SDK Documentation

await claw.createScorer({
  name: 'JSON Validator',
  scorerType: 'regex',
  config: { pattern: '^\{.*\}$' },
});

const profile = await dc.createScoringProfile({
  name: 'deploy-quality',
  action_type: 'deploy',
  composite_method: 'weighted_average',
  dimensions: [
    { name: 'Speed', data_source: 'duration_ms', weight: 0.3,
      scale: [
        { label: 'excellent', operator: 'lt', value: 30000, score: 100 },
        { label: 'good', operator: 'lt', value: 60000, score: 75 },
        { label: 'poor', operator: 'gte', value: 60000, score: 20 },
      ]},
    { name: 'Reliability', data_source: 'confidence', weight: 0.7,
      scale: [
        { label: 'excellent', operator: 'gte', value: 0.9, score: 100 },
        { label: 'poor', operator: 'lt', value: 0.7, score: 25 },
      ]},
  ],
});

const result = await dc.scoreWithProfile('sp_abc123', {
  duration_ms: 25000, confidence: 0.95, cost_estimate: 0.008,
});
// result.composite_score = 92.5
// result.dimensions = [{ dimension_name: 'Speed', score: 100, label: 'excellent' }, ...]

const batch = await dc.batchScoreWithProfile('sp_abc123', [
  { duration_ms: 500, confidence: 0.98 },
  { duration_ms: 10000, confidence: 0.5 },
]);
// batch.summary = { total: 2, scored: 2, avg_score: 72.3 }

const stats = await dc.getProfileScoreStats('sp_abc123');
// { total_scores: 142, avg_score: 78.3, min_score: 23, max_score: 99, stddev_score: 12.5 }

const template = await dc.createRiskTemplate({
  name: 'Production Safety',
  base_risk: 20,
  rules: [
    { condition: "metadata.environment == 'production'", add: 25 },
    { condition: "metadata.modifies_data == true", add: 15 },
    { condition: "metadata.irreversible == true", add: 30 },
  ],
});

const cal = await dc.autoCalibrate({ lookback_days: 30, action_type: 'deploy' });
// cal.suggestions[0] = { metric: 'duration_ms', sample_size: 480,
//   distribution: { p25: 3000, p50: 8000, p75: 20000 },
//   suggested_scale: [...] }

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.reportTokenUsage({
  tokens_in: 1234,
  tokens_out: 980,
  context_used: 2214,
  context_max: 128000,
  model: 'gpt-4o',
});

import Anthropic from '@anthropic-ai/sdk';

const anthropic = claw.wrapClient(new Anthropic());
const msg = await anthropic.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Hello' }],
});
// Token usage auto-reported to DashClaw

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' });

const { snippet } = await claw.getSnippet('sn_abc123');
console.log(snippet.name, snippet.language);

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');

const result = await claw.scanPromptInjection(userMessage, { source: 'user_input' });
if (result.recommendation === 'block') {
  console.error(`Blocked: ${result.findings_count} injection patterns detected`);
} else if (result.recommendation === 'warn') {
  console.warn(`Warning: ${result.categories.join(', ')} detected`);
}

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`);

const { messages } = await claw.getSentMessages({ type: 'action' });

const { messages } = await claw.getMessages({ direction: 'all', type: 'question' });

const { message } = await claw.getMessage('msg_abc123');

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 url = claw.getAttachmentUrl('att_abc123');
console.log(url); // https://dashclaw.example.com/api/attachments/att_abc123

const { data, filename, mimeType } = await claw.getAttachment('att_abc123');
fs.writeFileSync(filename, data);

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`);

const result = await claw.testPolicies();
console.log(`${result.passed}/${result.totals} policies passed`);
if (!result.success) {
  console.warn(`${result.failed} policies failed validation`);
}

// JSON format (default)
const { report } = await claw.getProofReport();

// Markdown format for sharing
const { report: mdReport } = await claw.getProofReport({ format: 'md' });

// Import a named pack
const result = await claw.importPolicies({ pack: 'enterprise-strict' });
console.log(`Imported ${result.imported}, skipped ${result.skipped}`);

// Import raw YAML
const yaml = `
- name: block-high-risk
  type: risk_threshold
  threshold: 80
  action: block
`;
await claw.importPolicies({ yaml });

const { compliance_map } = await claw.mapCompliance('nist-ai-rmf');
console.log('Covered controls:', compliance_map.covered);
console.log('Uncovered controls:', compliance_map.uncovered);

const { gap_analysis } = await claw.analyzeGaps('eu-ai-act');
console.log('Gaps found:', gap_analysis.gaps.length);
for (const gap of gap_analysis.gaps) {
  console.log(`[${gap.severity}] ${gap.control}: ${gap.remediation}`);
}

const { report } = await claw.getComplianceReport('iso-42001');
console.log('Overall score:', report.score);
console.log('Status:', report.status);

const { frameworks } = await claw.listFrameworks();
for (const fw of frameworks) {
  console.log(`${fw.id}: ${fw.name} (${fw.controls_count} controls)`);
}

const { evidence } = await claw.getComplianceEvidence({ window: '7d' });
console.log('Evidence items:', evidence.items.length);
console.log('Coverage:', evidence.coverage_pct + '%');

const { agents } = await claw.listRoutingAgents({ status: 'available' });
console.log(`${agents.length} agents available for tasks`);

const { agent } = await claw.registerRoutingAgent({
  name: 'deploy-agent',
  capabilities: ['deploy', 'rollback', 'health-check'],
  maxConcurrent: 3,
  endpoint: 'https://my-agent.example.com/tasks',
});

const { agent } = await claw.getRoutingAgent('ra_abc123');
console.log(agent.name, agent.status, agent.active_tasks);

await claw.updateRoutingAgentStatus('ra_abc123', 'busy');

await claw.deleteRoutingAgent('ra_abc123');

const { tasks } = await claw.listRoutingTasks({
  status: 'pending',
  limit: 10,
});

const { task, routing } = await claw.submitRoutingTask({
  title: 'Deploy auth service v2',
  description: 'Deploy the latest auth service build to production',
  requiredSkills: ['deploy', 'kubernetes'],
  urgency: 'high',
  timeoutSeconds: 600,
  callbackUrl: 'https://my-app.example.com/hooks/task-done',
});
console.log(`Task ${task.id} assigned to ${routing.assigned_to}`);

// Success
await claw.completeRoutingTask('rt_abc123', {
  success: true,
  result: { deployed_version: '2.1.0', pods: 3 },
});

// Failure
await claw.completeRoutingTask('rt_abc123', {
  success: false,
  error: 'Health check failed after deploy',
});

const stats = await claw.getRoutingStats();
console.log(`Agents: ${stats.agents.total} (${stats.agents.available} available)`);
console.log(`Tasks: ${stats.tasks.total} (${stats.tasks.pending} pending)`);

const health = await claw.getRoutingHealth();
console.log('Routing status:', health.status);
console.log('Available agents:', health.agents.available);
console.log('Queued tasks:', health.tasks.queued);

const { schedules } = await claw.listAgentSchedules({ agent_id: 'forge' });
schedules.forEach(s => console.log(s.name, s.cron_expression));

const { schedule } = await claw.createAgentSchedule({
  agent_id: 'forge',
  name: 'Build projects',
  cron_expression: '0 */6 * * *',
  description: 'Check for pending builds every 6 hours'
});

await claw.approveAction('act_abc123', 'allow', 'Reviewed and safe to proceed');

const { actions } = await claw.getPendingApprovals({ limit: 10 });