@inneranimalmedia/agentsam-sdk 2.0.0 → 2.2.0

package/src/agent/capability-adapter.js

@@ -0,0 +1,50 @@
+import { getCapability, listCapabilities } from '../capabilities/manifest.js';
+import { repositorySnapshot } from '../capabilities/repository-snapshot.js';
+import { runRepositoryAudit } from './repository-audit.js';
+
+export function createCapabilityAdapter({ handlers = {}, reasoner } = {}) {
+  const executable = new Map([
+    ['repository.snapshot', (input) => repositorySnapshot(input)],
+    ...Object.entries(handlers),
+  ]);
+  if (typeof reasoner === 'function') {
+    executable.set('repository.audit', (input = {}) => runRepositoryAudit({ ...input, reasoner }));
+  }
+
+  function describe(id) {
+    const capability = getCapability(id);
+    if (!capability) throw new Error(`unknown_capability:${id}`);
+    return capability;
+  }
+
+  return Object.freeze({
+    list(options = {}) {
+      return listCapabilities(options);
+    },
+    describe,
+    toolDescriptors({ domain, kind, includeUnavailable = false } = {}) {
+      return listCapabilities({ domain, kind }).filter((row) => includeUnavailable || executable.has(row.id)).map((row) => ({
+        name: row.id,
+        description: row.description,
+        input_schema: row.input_schema || null,
+        side_effects: row.side_effects,
+        deterministic: row.deterministic,
+        model_required: row.model_required,
+      }));
+    },
+    canInvoke(id) {
+      return executable.has(String(id || '').trim());
+    },
+    async invoke(id, input = {}) {
+      const capability = describe(id);
+      const handler = executable.get(capability.id);
+      if (!handler) throw new Error(`capability_handler_unavailable:${capability.id}`);
+      const value = await handler(input);
+      return {
+        capability_id: capability.id,
+        capability_version: capability.version,
+        result: value,
+      };
+    },
+  });
+}

package/src/agent/index.js

@@ -0,0 +1,2 @@
+export { createCapabilityAdapter } from './capability-adapter.js';
+export { buildRepositoryAuditPacket, renderRepositoryAuditMarkdown, runRepositoryAudit } from './repository-audit.js';

package/src/agent/repository-audit.js

@@ -0,0 +1,188 @@
+import { repositorySnapshot } from '../capabilities/repository-snapshot.js';
+
+const DEPTHS = new Set(['quick', 'standard', 'deep']);
+const FORBIDDEN_OUTPUT_KEYS = new Set(['jobs', 'executions', 'commits', 'deployments', 'mutations', 'patches']);
+const ARRAY_FIELDS = [
+  'packages',
+  'binaries',
+  'commands',
+  'capabilities',
+  'services',
+  'protocols',
+  'notable_combinations',
+  'findings',
+  'cleanup_candidates',
+  'recommended_routes',
+  'evidence_refs',
+  'artifacts',
+];
+
+function boundedStrings(values = [], max = 32, field = 'value') {
+  if (!Array.isArray(values)) throw new TypeError(`${field} must be an array`);
+  return values.slice(0, max).map((value) => String(value).trim()).filter(Boolean);
+}
+
+function shrinkEvidence(evidence, characterBudget) {
+  const out = structuredClone(evidence);
+  const shrinkable = [
+    ['pressure_points', 12, 6, 3],
+    ['top_level', 20, 10, 5],
+    ['file_paths', 400, 200, 100],
+    ['packages', 40, 20, 10],
+    ['languages', 30, 15, 8],
+    ['manifests', 40, 20, 10],
+  ];
+  for (const [key, ...limits] of shrinkable) {
+    const original = Array.isArray(out[key]) ? out[key] : [];
+    for (const limit of limits) {
+      if (JSON.stringify(out).length <= characterBudget) break;
+      out[key] = original.slice(0, limit);
+    }
+  }
+  if (JSON.stringify(out).length > characterBudget) {
+    out.top_level = [];
+    out.pressure_points = [];
+  }
+  if (JSON.stringify(out).length > characterBudget) {
+    out.file_paths = [];
+    out.packages = [];
+    out.languages = [];
+    out.manifests = [];
+  }
+  return out;
+}
+
+export function buildRepositoryAuditPacket({
+  snapshot,
+  focus = [],
+  depth = 'standard',
+  requestedSections = [],
+  evidenceBudget = 8000,
+} = {}) {
+  if (snapshot?.capability !== 'repository.snapshot' || !snapshot.snapshot_id) {
+    throw new TypeError('repository.audit requires a repository.snapshot result');
+  }
+  if (!DEPTHS.has(depth)) throw new RangeError(`depth must be one of: ${[...DEPTHS].join(', ')}`);
+  if (!Number.isInteger(evidenceBudget) || evidenceBudget < 1000 || evidenceBudget > 64000) {
+    throw new RangeError('evidenceBudget must be an integer from 1000..64000');
+  }
+
+  const evidence = shrinkEvidence({
+    repository: snapshot.repository,
+    tree: { merkle_root: snapshot.tree?.merkle_root, stats: snapshot.tree?.stats },
+    file_paths: snapshot.tree?.paths || [],
+    summary: snapshot.intelligence?.summary || {},
+    languages: snapshot.intelligence?.languages || [],
+    manifests: snapshot.intelligence?.manifests || [],
+    top_level: snapshot.intelligence?.top_level || [],
+    pressure_points: snapshot.intelligence?.pressure_points || [],
+    packages: snapshot.packages || [],
+    knowledge: snapshot.knowledge || { configured: false },
+    deploy: snapshot.deploy || null,
+  }, evidenceBudget * 4);
+
+  const prefix = `snapshot:${snapshot.snapshot_id}`;
+  return Object.freeze({
+    schema_version: 1,
+    primitive: 'repository.audit',
+    snapshot_id: snapshot.snapshot_id,
+    snapshot_content_hash: snapshot.content_hash,
+    focus: boundedStrings(focus, 24, 'focus'),
+    depth,
+    requested_sections: boundedStrings(requestedSections, 24, 'requestedSections'),
+    evidence_budget: evidenceBudget,
+    evidence,
+    evidence_index: Object.freeze({
+      repository: `${prefix}#repository`,
+      tree: `${prefix}#tree`,
+      file_paths: `${prefix}#tree.paths`,
+      summary: `${prefix}#intelligence.summary`,
+      languages: `${prefix}#intelligence.languages`,
+      manifests: `${prefix}#intelligence.manifests`,
+      packages: `${prefix}#packages`,
+      knowledge: `${prefix}#knowledge`,
+      deploy: `${prefix}#deploy`,
+    }),
+    rules: Object.freeze({
+      read_only: true,
+      may_edit: false,
+      may_deploy: false,
+      may_create_jobs: false,
+      evidence_must_come_from_packet: true,
+    }),
+  });
+}
+
+function normalizeAnalysis(value, snapshotId) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError('repository.audit reasoner must return an object');
+  for (const key of FORBIDDEN_OUTPUT_KEYS) {
+    if (Object.hasOwn(value, key)) throw new Error(`repository.audit output may not contain mutation field: ${key}`);
+  }
+  if (typeof value.summary !== 'string' || !value.summary.trim()) throw new TypeError('repository.audit output requires summary');
+  const prefix = `snapshot:${snapshotId}#`;
+  const result = {
+    summary: value.summary.trim(),
+    repository_map: value.repository_map ?? null,
+    file_tree: value.file_tree ?? null,
+  };
+  for (const field of ARRAY_FIELDS) result[field] = Array.isArray(value[field]) ? structuredClone(value[field]) : [];
+  const validateRef = (ref) => {
+    if (typeof ref !== 'string' || !ref.startsWith(prefix)) throw new Error(`repository.audit invalid evidence ref: ${ref}`);
+  };
+  for (const ref of result.evidence_refs) validateRef(ref);
+  for (const finding of result.findings) {
+    if (finding && typeof finding === 'object' && Array.isArray(finding.evidence_refs)) {
+      for (const ref of finding.evidence_refs) validateRef(ref);
+    }
+  }
+  return result;
+}
+
+/**
+ * Optional AgentSam/LLM layer over deterministic repository evidence.
+ * The SDK owns evidence collection and output validation; the caller injects reasoning.
+ */
+export async function runRepositoryAudit({
+  cwd = process.cwd(),
+  snapshot,
+  focus = [],
+  depth = 'standard',
+  requestedSections = [],
+  evidenceBudget = 8000,
+  reasoner,
+} = {}) {
+  if (typeof reasoner !== 'function') throw new TypeError('repository.audit requires an injected reasoner(packet) function');
+  const resolvedSnapshot = snapshot || await repositorySnapshot({ cwd });
+  const packet = buildRepositoryAuditPacket({ snapshot: resolvedSnapshot, focus, depth, requestedSections, evidenceBudget });
+  const analysis = normalizeAnalysis(await reasoner(structuredClone(packet)), resolvedSnapshot.snapshot_id);
+  return {
+    schema_version: 1,
+    primitive: 'repository.audit',
+    snapshot_id: resolvedSnapshot.snapshot_id,
+    snapshot_content_hash: resolvedSnapshot.content_hash,
+    generated_at: new Date().toISOString(),
+    ...analysis,
+  };
+}
+
+export function renderRepositoryAuditMarkdown(audit) {
+  if (audit?.primitive !== 'repository.audit') throw new TypeError('repository.audit result required');
+  const lines = [`# Repository audit`, '', audit.summary, '', `Snapshot: \`${audit.snapshot_id}\``];
+  const sections = [
+    ['Packages', audit.packages],
+    ['Commands', audit.commands],
+    ['Capabilities', audit.capabilities],
+    ['Services', audit.services],
+    ['Protocols', audit.protocols],
+    ['Notable combinations', audit.notable_combinations],
+    ['Findings', audit.findings],
+    ['Cleanup candidates', audit.cleanup_candidates],
+    ['Recommended routes', audit.recommended_routes],
+  ];
+  for (const [title, rows] of sections) {
+    if (!Array.isArray(rows) || rows.length === 0) continue;
+    lines.push('', `## ${title}`, '');
+    for (const row of rows) lines.push(`- ${typeof row === 'string' ? row : JSON.stringify(row)}`);
+  }
+  return `${lines.join('\n')}\n`;
+}

package/src/capabilities/index.js

@@ -0,0 +1,7 @@
+export {
+  CAPABILITY_MANIFEST_VERSION,
+  getCapability,
+  getCapabilityManifest,
+  listCapabilities,
+} from './manifest.js';
+export { repositorySnapshot } from './repository-snapshot.js';

package/src/capabilities/manifest.js

@@ -0,0 +1,22 @@
+import manifest from '../../protocol/capabilities/manifest.json' with { type: 'json' };
+
+export const CAPABILITY_MANIFEST_VERSION = manifest.schema_version;
+
+function rows() {
+  return Object.values(manifest.capabilities);
+}
+
+export function listCapabilities({ domain, status = 'stable', kind } = {}) {
+  return rows()
+    .filter((row) => (!domain || row.domain === domain) && (!status || row.status === status) && (!kind || row.kind === kind))
+    .map((row) => structuredClone(row));
+}
+
+export function getCapability(id) {
+  const row = manifest.capabilities[String(id || '').trim()];
+  return row ? structuredClone(row) : null;
+}
+
+export function getCapabilityManifest() {
+  return structuredClone(manifest);
+}

package/src/capabilities/repository-snapshot.js

@@ -0,0 +1,180 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { resolveGitContext } from '../lib/git-context.js';
+import { buildMerkleTree } from '../lib/merkle/index.js';
+import { showLatestDeployReceipt } from '../lib/deploy-receipt/index.js';
+import { CONFIG_PATH, canonical, readConfig, scopeKey } from '../knowledge/config.js';
+import { openSqliteStore } from '../knowledge/stores/sqlite.js';
+
+const execute = promisify(execFile);
+
+function sha256(value) {
+  return createHash('sha256').update(JSON.stringify(canonical(value))).digest('hex');
+}
+
+function providerForHost(host) {
+  const value = String(host || '').toLowerCase();
+  if (value === 'github.com') return 'github';
+  if (value === 'gitlab.com') return 'gitlab';
+  if (value === 'bitbucket.org') return 'bitbucket';
+  return value ? 'git' : null;
+}
+
+async function gitIgnoredPaths(root) {
+  const result = await execute('git', ['status', '--porcelain=v1', '--ignored=matching'], {
+    cwd: root,
+    maxBuffer: 16 * 1024 * 1024,
+  });
+  return [...new Set(result.stdout.split('\n')
+    .filter((line) => line.startsWith('!! '))
+    .map((line) => line.slice(3).trim().replace(/\/$/, ''))
+    .filter((value) => value && !value.includes('\\') && !value.split('/').includes('..')))];
+}
+
+async function runRepositoryIntelligence(root, churnDays) {
+  const pythonRoot = fileURLToPath(new URL('../../python', import.meta.url));
+  const result = await execute(process.platform === 'win32' ? 'python' : 'python3', [
+    '-B', '-m', 'agentsam_sdk.repository.intelligence', '--repo-root', root,
+    '--churn-days', String(churnDays), '--json',
+  ], {
+    env: { ...process.env, PYTHONPATH: [pythonRoot, process.env.PYTHONPATH].filter(Boolean).join(path.delimiter) },
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  return JSON.parse(result.stdout);
+}
+
+function readPackageInventory(root, manifests = []) {
+  const packages = [];
+  for (const row of manifests) {
+    if (row.kind !== 'node' || path.basename(row.path) !== 'package.json') continue;
+    const filename = path.join(root, row.path);
+    try {
+      const parsed = JSON.parse(fs.readFileSync(filename, 'utf8'));
+      packages.push({
+        path: row.path,
+        name: parsed.name || null,
+        version: parsed.version || null,
+        private: parsed.private === true,
+        type: parsed.type || null,
+        bins: parsed.bin || null,
+        exports: parsed.exports && typeof parsed.exports === 'object' ? Object.keys(parsed.exports) : [],
+        scripts: parsed.scripts && typeof parsed.scripts === 'object' ? Object.keys(parsed.scripts).sort() : [],
+        dependencies: parsed.dependencies && typeof parsed.dependencies === 'object' ? Object.keys(parsed.dependencies).sort() : [],
+        dev_dependencies: parsed.devDependencies && typeof parsed.devDependencies === 'object' ? Object.keys(parsed.devDependencies).sort() : [],
+        workspaces: parsed.workspaces || null,
+      });
+    } catch {
+      packages.push({ path: row.path, invalid: true });
+    }
+  }
+  return packages.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+async function readKnowledgeState(root) {
+  const filename = path.join(root, CONFIG_PATH);
+  if (!fs.existsSync(filename)) return { configured: false };
+  try {
+    const config = readConfig(root);
+    const state = {
+      configured: true,
+      repository_id: config.repository_id,
+      scope: config.scope,
+      storage: config.storage.driver,
+      embedding_profile: config.embedding,
+      legacy_workspace_id: config.workspace_id || null,
+    };
+    if (config.storage.driver !== 'sqlite') return state;
+    const store = await openSqliteStore(path.join(root, '.agentsam', 'knowledge', 'index.sqlite'), { readOnly: true });
+    if (!store) return { ...state, indexed: false };
+    try {
+      const generation = await store.active(scopeKey(config));
+      if (!generation) return { ...state, indexed: false };
+      return {
+        ...state,
+        indexed: true,
+        generation_id: generation.id,
+        created_at: generation.created_at,
+        source_hash: generation.source_hash,
+        profile_id: generation.profile_id || null,
+        receipt: generation.receipt || null,
+      };
+    } finally {
+      await store.close();
+    }
+  } catch (error) {
+    return { configured: true, error: error?.message || String(error) };
+  }
+}
+
+/**
+ * Canonical deterministic repository evidence snapshot.
+ * Read-only: no source/config/index/deploy state is created or modified.
+ */
+export async function repositorySnapshot({ cwd = process.cwd(), churnDays = 30 } = {}) {
+  if (!Number.isInteger(churnDays) || churnDays < 1 || churnDays > 3650) {
+    throw new RangeError('churnDays must be an integer from 1..3650');
+  }
+  const git = resolveGitContext({ cwd });
+  const root = git.root;
+  const ignored = await gitIgnoredPaths(root);
+  const [intelligence, merkle, knowledge, deployReceipt] = await Promise.all([
+    runRepositoryIntelligence(root, churnDays),
+    buildMerkleTree(root, { exclude: ignored }),
+    readKnowledgeState(root),
+    showLatestDeployReceipt({ root }),
+  ]);
+  const provider = providerForHost(git.remoteHost);
+  const portableRepositoryId = provider && git.repoFullName ? `${provider}:${git.repoFullName}` : null;
+  const repositoryId = knowledge.repository_id || portableRepositoryId;
+  const packages = readPackageInventory(root, intelligence.manifests || []);
+
+  const evidence = {
+    repository: {
+      repository_id: repositoryId,
+      identity_source: knowledge.repository_id ? 'knowledge-config' : portableRepositoryId ? 'git-remote' : 'unresolved',
+      provider,
+      full_name: git.repoFullName,
+      remote_url: git.remoteUrl || null,
+      branch: git.branch,
+      revision_sha: git.revisionSha,
+      dirty: git.dirty,
+    },
+    tree: {
+      merkle_root: merkle.rootHash,
+      stats: merkle.stats,
+      paths: merkle.entries
+        .filter((entry) => entry.type === 'file' || entry.type === 'symlink')
+        .map((entry) => entry.path),
+    },
+    intelligence: {
+      summary: intelligence.summary,
+      languages: intelligence.languages || [],
+      manifests: intelligence.manifests || [],
+      top_level: intelligence.top_level || [],
+      pressure_points: intelligence.pressure_points || [],
+    },
+    packages,
+    knowledge,
+    deploy: deployReceipt ? {
+      status: deployReceipt.status,
+      root_hash: deployReceipt.root_hash,
+      git_sha: deployReceipt.git_sha,
+      deployment_id: deployReceipt.deployment_id || null,
+      worker_version_id: deployReceipt.worker_version_id || null,
+      completed_at: deployReceipt.completed_at || null,
+    } : null,
+  };
+  const contentHash = sha256(evidence);
+  return {
+    schema_version: 1,
+    capability: 'repository.snapshot',
+    snapshot_id: `rsnap_${contentHash.slice(0, 24)}`,
+    created_at: new Date().toISOString(),
+    content_hash: `sha256:${contentHash}`,
+    ...evidence,
+  };
+}

package/src/cli.js

@@ -21,7 +21,11 @@ import { runTui } from './commands/tui.js';
 import { runDockerize } from './commands/dockerize.js';
 import { runMini } from './commands/mini.js';
 import { runMerkle } from './commands/merkle.js';
+import { runDeployReceipt } from './commands/deploy-receipt.js';
 import { runSecurity } from './commands/security.js';
+import { runRecon } from './commands/recon.js';
+import { applyPresetSelection, runAdd, runCapabilities, runDev, runInspect } from './commands/product.js';
+import { listPresets, resolvePreset } from './presets/index.js';
 import { SLASH_COMMANDS, SHELL_PHASES } from './lib/slash-commands.js';
 import fs from 'node:fs';
 import { repositoryRoot } from './knowledge/config.js';
@@ -40,7 +44,17 @@ function printHelp() {
   console.log(`
   Agent Sam SDK — CLI v${VERSION}
 
-  Usage:
+  Product UX:
+    agentsam create <name> --preset <fullstack|cms|prototype|data>
+    agentsam add <auth|cms|knowledge|agent|deploy-cloudflare>
+    agentsam dev               Run this project's existing npm dev script
+    agentsam inspect [--json]  Canonical deterministic repository.snapshot
+    agentsam deploy            Graduate an AgentSam project intentionally
+
+  Capability discovery:
+    agentsam capabilities [capability-id] [--json]
+
+  Power-user UX:
     agentsam context [--json]  Git repo/revision + bridge configuration from any repo
     agentsam init              Configure knowledge in this repo; --name scaffolds a new project
     agentsam index             Plan/run incremental AST and optional embeddings (--help)
@@ -48,6 +62,8 @@ function printHelp() {
     agentsam repo snapshot     Git composition/churn; --save retains observations
     agentsam mini <name>       Create and preview a small local gadget (--help for options)
     agentsam merkle            File integrity, snapshots, comparisons, and TUI (--help)
+    agentsam deploy-receipt    Merkle deploy/checkpoint capture + promote/failure receipts (--help)
+    agentsam recon             Bounded-worker task packets + finding-report validation (--help)
     agentsam security          Dependency scan, log triage, and verified repair (--help)
     agentsam status [--json]   Live local Git + DB + API + PTY status
     agentsam db init|status    Manage the project-local SQLite database
@@ -112,6 +128,21 @@ function parseDeployArgs(argv) {
   return opts;
 }
 
+function parseCreateArgs(argv) {
+  const opts = { projectName: '', preset: 'fullstack', runTarget: 'local', help: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') opts.help = true;
+    else if (arg === '--preset') opts.preset = argv[++i] || 'fullstack';
+    else if (arg === '--run-target' || arg === '--target') opts.runTarget = argv[++i] || 'local';
+    else if (arg === '--yes' || arg === '-y') continue;
+    else if (arg.startsWith('-')) throw new Error(`unknown create option: ${arg}`);
+    else if (!opts.projectName) opts.projectName = arg;
+    else throw new Error(`unexpected create argument: ${arg}`);
+  }
+  return opts;
+}
+
 async function runLocalInit(config) {
   const { projectName, lane, runTarget, prompt } = config;
 
@@ -121,13 +152,13 @@ async function runLocalInit(config) {
   );
 
   console.log(`
-  ┌─────────────────────────────────────┐
+  ┌──────────────────────────────────────┐
   │  Agent Sam — local-first scaffold   │
-  ├─────────────────────────────────────┤
+  ├──────────────────────────────────────┤
   │  Name:     ${meta.projectName.padEnd(25)}│
   │  Lane:     ${meta.laneKey.padEnd(25)}│
   │  Run:      ${meta.runTarget.padEnd(25)}│
-  └─────────────────────────────────────┘
+  └──────────────────────────────────────┘
   `);
 
   const dir = writeScaffoldFiles(meta.projectName, meta.files);
@@ -159,16 +190,17 @@ async function runLocalInit(config) {
   console.log(`
   Local means local: no Worker, tunnel, IAM login, or cloud database is required.
   `);
+  return { dir, meta };
 }
 
 async function initInteractive(partial = {}) {
   const prompt = createPrompt();
 
   console.log(`
-  ╔═══════════════════════════════════╗
+  ╔════════════════════════════════╗
   ║   Agent Sam SDK — Init            ║
   ║   Local-first · Node only         ║
-  ╚═══════════════════════════════════╝
+  ╚════════════════════════════════╝
   `);
 
   const projectName =
@@ -241,9 +273,9 @@ async function runShellInfo(argv = []) {
 
   const next = SHELL_PHASES.find((p) => p.status === 'next' || p.status === 'current');
   console.log(`
-  ╔═══════════════════════════════════╗
+  ╔═══════════════════════════════╗
   ║        Agent Sam Terminal         ║
-  ╚═══════════════════════════════════╝
+  ╚════════════════════════════════╝
 
   Local PTY   agentsam start-local     ws://127.0.0.1:3099
   ANSI TUI    agentsam tui             zero-dependency Node UI
@@ -267,6 +299,30 @@ if (command === '--version' || command === '-v') {
   console.log(VERSION);
 } else if (command === '--help' || command === '-h' || !command) {
   printHelp();
+} else if (command === 'create') {
+  try {
+    const opts = parseCreateArgs(rest);
+    if (opts.help || !opts.projectName) {
+      console.log(`agentsam create <name> --preset <${listPresets().map((row) => row.id).join('|')}> [--target local|cloudflare|gcp]`);
+    } else {
+      const preset = resolvePreset(opts.preset);
+      const created = await runLocalInit({ projectName: opts.projectName, lane: preset.lane, runTarget: opts.runTarget, prompt: null });
+      applyPresetSelection(created.dir, preset);
+      console.log(`  ✓ Preset      ${preset.id}\n  ✓ Features    ${preset.features.join(', ') || 'none'}\n  ✓ Capabilities ${preset.capabilities.length}\n`);
+    }
+  } catch (e) { console.error(`\n  ✗ ${e?.message || e}\n`); process.exitCode = 1; }
+} else if (command === 'add') {
+  try { await runAdd(rest); }
+  catch (e) { console.error(`\n  ✗ ${e?.message || e}\n`); process.exitCode = 1; }
+} else if (command === 'dev') {
+  try { await runDev(rest); }
+  catch (e) { console.error(`\n  ✗ ${e?.message || e}\n`); process.exitCode = 1; }
+} else if (command === 'inspect') {
+  try { await runInspect(rest); }
+  catch (e) { console.error(`\n  ✗ ${e?.message || e}\n`); process.exitCode = 1; }
+} else if (command === 'capabilities') {
+  try { await runCapabilities(rest); }
+  catch (e) { console.error(`\n  ✗ ${e?.message || e}\n`); process.exitCode = 1; }
 } else if (command === 'context') {
   try {
     await runContext(rest);
@@ -329,6 +385,10 @@ if (command === '--version' || command === '-v') {
   await runSecurity(rest);
 } else if (command === 'merkle') {
   await runMerkle(rest);
+} else if (command === 'deploy-receipt') {
+  await runDeployReceipt(rest);
+} else if (command === 'recon') {
+  await runRecon(rest);
 } else if (command === 'mini') {
   try {
     await runMini(rest);