SDK Documentation

const { loop_id } = await claw.registerOpenLoop({
  action_id: 'act_abc123',
  loop_type: 'approval',
  description: 'Needs manager approval for prod deploy',
  priority: 'high',
  owner: 'ops-team',
});

await claw.resolveOpenLoop('loop_xyz789', 'resolved', 'Manager approved via Slack');

const { assumption_id } = await claw.registerAssumption({
  action_id: 'act_abc123',
  assumption: 'Database schema is unchanged since last deploy',
  basis: 'No migration files found in latest commits',
});

const { assumption } = await claw.getAssumption('asm_abc123');

// Validate
await claw.validateAssumption('asm_abc123', true);

// Invalidate
await claw.validateAssumption('asm_abc123', false, 'Schema was altered by migration #47');

const { loops } = await claw.getOpenLoops({
  status: 'open',
  priority: 'critical',
});

const { assumptions, drift_summary } = await claw.getDriftReport();
console.log(drift_summary);
// { total, validated, invalidated, unvalidated, drift_score }

const { signals, counts } = await claw.getSignals();
console.log(`${counts.red} red, ${counts.amber} amber signals`);

for (const signal of signals) {
  console.log(`[${signal.severity}] ${signal.signal_type}: ${signal.help}`);
}

const result = await claw.guard({
  action_type: 'deploy',
  risk_score: 85,
  systems_touched: ['production-api'],
  reversible: false,
  declared_goal: 'Deploy auth service v2',
});

if (result.decision === 'block') {
  console.log('Blocked:', result.reasons);
  return; // abort the action
}

if (result.decision === 'warn') {
  console.log('Warnings:', result.warnings);
}

// proceed with the action
await claw.createAction({ action_type: 'deploy', ... });

const { decisions, stats } = await claw.getGuardDecisions({
  decision: 'block',
  limit: 10,
});

console.log(`${stats.blocks_24h} blocks in last 24h`);

await claw.recordDecision({
  decision: 'Use Redis for session caching',
  reasoning: 'Lower latency than Postgres for read-heavy access pattern',
  confidence: 85,
});

await claw.createGoal({
  title: 'Complete API migration',
  category: 'engineering',
  target_date: '2025-03-01T00:00:00.000Z',
  progress: 30,
});

await claw.recordContent({
  title: 'How We Migrated to Edge Functions',
  platform: 'linkedin',
  status: 'published',
  url: 'https://linkedin.com/posts/...',
});

await claw.recordInteraction({
  contact_name: 'Jane Smith',
  summary: 'Discussed Q1 roadmap and timeline',
  type: 'meeting',
  direction: 'outbound',
});

await claw.reportConnections([
  { provider: 'anthropic', authType: 'subscription', planName: 'Pro Max', status: 'active' },
  { provider: 'github', authType: 'oauth', status: 'active' },
  { provider: 'slack', authType: 'api_key', status: 'active', metadata: { workspace: 'eng-team' } },
]);

await claw.createCalendarEvent({
  summary: 'Deploy review',
  start_time: '2025-02-10T14:00:00.000Z',
  end_time: '2025-02-10T14:30:00.000Z',
  description: 'Review prod deploy results',
});

await claw.recordIdea({
  title: 'Auto-summarize daily agent activity',
  category: 'feature',
  score: 75,
  source: 'User feedback in Slack #agents',
});

await claw.reportMemoryHealth({
  health: {
    score: 82,
    total_files: 15,
    total_lines: 340,
    duplicates: 3,
    stale_count: 7,
  },
  entities: [
    { name: 'PostgreSQL', type: 'service', mentions: 12 },
    { name: 'auth-service', type: 'service', mentions: 8 },
  ],
  topics: [
    { name: 'deployment', mentions: 15 },
    { name: 'authentication', mentions: 9 },
  ],
});

await claw.createHandoff({
  summary: 'Completed auth system overhaul',
  key_decisions: ['JWT over sessions', 'Added refresh tokens'],
  open_tasks: ['Write migration guide', 'Load test'],
  next_priorities: ['Deploy to staging'],
});

const { handoffs } = await claw.getHandoffs({ limit: 5 });

const { handoff } = await claw.getLatestHandoff();
if (handoff) {
  console.log('Last session:', handoff.summary);
  console.log('Open tasks:', JSON.parse(handoff.open_tasks));
}

await claw.captureKeyPoint({
  content: 'User wants dark mode as the default theme',
  category: 'decision',
  importance: 8,
});

const { points } = await claw.getKeyPoints({ category: 'decision' });

const { thread_id } = await claw.createThread({ name: 'Auth System', summary: 'Tracking auth decisions' });

await claw.addThreadEntry(threadId, 'Decided on JWT strategy');

await claw.closeThread(threadId, 'Auth complete: JWT + refresh tokens');

const { threads } = await claw.getThreads({ status: 'active' });

const { points, threads } = await claw.getContextSummary();

await claw.saveSnippet({
  name: 'fetch-with-retry',
  code: 'async function fetchRetry(url, n = 3) { ... }',
  language: 'javascript',
  tags: ['fetch', 'retry'],
});

const { snippets } = await claw.getSnippets({ language: 'javascript' });

await claw.useSnippet('sn_abc123');

await claw.deleteSnippet('sn_abc123');

await claw.logObservation({ observation: 'Prefers tabs over spaces', category: 'coding', importance: 6 });

await claw.setPreference({ preference: 'Prefers concise responses', confidence: 90 });

await claw.logMood({ mood: 'focused', energy: 'high' });

await claw.trackApproach({ approach: 'Show code before explanation', success: true });

const { summary } = await claw.getPreferenceSummary();

const { approaches } = await claw.getApproaches({ limit: 10 });

const { digest, summary } = await claw.getDailyDigest();
console.log(`Today: ${summary.action_count} actions, ${summary.decision_count} decisions`);

const result = await claw.scanContent(messageText, 'slack');
if (!result.clean) {
  console.warn(`Found ${result.findings_count} issues`);
  messageText = result.redacted_text; // Use redacted version
}

await claw.reportSecurityFinding(outboundMessage, 'email');

await claw.sendMessage({
  to: 'ops-agent',
  type: 'question',
  subject: 'Deploy approval needed',
  body: 'Auth service ready for prod. Please review.',
  urgent: true,
});

const { messages, unread_count } = await claw.getInbox({ unread: true });
console.log(`${unread_count} unread messages`);

await claw.markRead(['msg_abc123', 'msg_def456']);

await claw.archiveMessages(['msg_abc123']);

await claw.broadcast({
  type: 'status',
  subject: 'Deployment complete',
  body: 'Auth service v2.1 deployed to production.',
});

const { thread_id } = await claw.createMessageThread({
  name: 'Auth Service Migration',
  participants: ['ops-agent', 'security-agent'],
});

const { threads } = await claw.getMessageThreads({ status: 'open' });

await claw.resolveMessageThread('mt_abc123', 'Migration completed successfully.');

await claw.saveSharedDoc({
  name: 'runbook/auth-deploy',
  content: '# Auth Deploy Runbook\n\n1. Run migrations...',
});

const result = await claw.syncState({
  connections: [
    { provider: 'github', auth_type: 'oauth', status: 'active' },
    { provider: 'neon', auth_type: 'api_key', status: 'active' },
  ],
  goals: [
    { title: 'Deploy v2', status: 'active' },
  ],
  learning: [
    { decision: 'Used JWT for Edge compat', reasoning: 'NextAuth on Vercel Edge' },
  ],
  context_points: [
    { content: 'Dark-only theme', category: 'insight', importance: 7 },
  ],
});
console.log(`Synced ${result.total_synced} items in ${result.duration_ms}ms`);