clearctx 3.0.0

package/bin/cli.js

@@ -0,0 +1,1756 @@
+#!/usr/bin/env node
+
+/**
+ * ╔══════════════════════════════════════════════════════════════╗
+ * ║  clearctx (cms) — CLI for multi-session control  ║
+ * ╚══════════════════════════════════════════════════════════════╝
+ *
+ * Usage:  clearctx <command> [options]
+ *     or: npx clearctx <command> [options]
+ *
+ * Commands:
+ *   spawn              Start a new streaming session
+ *   send               Send a message to an existing session
+ *   resume             Restore and resume a stopped/paused session
+ *   pause              Pause a session (keeps process alive)
+ *   fork               Branch off a session into a new one
+ *   stop               Gracefully stop a session
+ *   kill               Force kill a session
+ *   status             Show detailed session info
+ *   output             Get last response text
+ *   list               List all sessions
+ *   history            Show full interaction history
+ *   delete             Permanently remove a session
+ *   batch              Spawn multiple sessions from JSON file
+ *   cleanup            Remove old sessions
+ *   delegate           Smart task delegation with safety + control loop
+ *   continue           Send follow-up to a delegated session
+ *   team-roster        Show team members
+ *   team-send          Send message to teammate
+ *   team-broadcast     Send to all teammates
+ *   team-inbox         Check inbox
+ *   artifact-publish   Publish artifact
+ *   artifact-get       Read artifact
+ *   artifact-list      List artifacts
+ *   contract-create    Create contract
+ *   contract-list      List contracts
+ *   contract-start     Start contract
+ *   pipeline-create    Create pipeline
+ *   pipeline-list      List pipelines
+ *   snapshot-create    Create snapshot
+ *   snapshot-list      List snapshots
+ *   snapshot-rollback  Rollback to snapshot
+ *   setup              Register MCP server with Claude Code
+ *   help               Show this help
+ */
+
+const { SessionManager, Delegate } = require('../src/index');
+const TeamHub = require('../src/team-hub');
+const ArtifactStore = require('../src/artifact-store');
+const ContractStore = require('../src/contract-store');
+const PipelineEngine = require('../src/pipeline-engine');
+const SnapshotEngine = require('../src/snapshot-engine');
+const SessionSnapshot = require('../src/session-snapshot');
+const BriefingGenerator = require('../src/briefing-generator');
+const StaleDetector = require('../src/stale-detector');
+const DecisionJournal = require('../src/decision-journal');
+const PatternRegistry = require('../src/pattern-registry');
+const fs = require('fs');
+const path = require('path');
+
+// ============================================================================
+// Argument Parser
+// ============================================================================
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  if (args.length === 0) return { command: 'help', flags: {} };
+
+  const command = args[0];
+  const flags = {};
+  let i = 1;
+
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      if (key.includes('=')) {
+        const [k, ...v] = key.split('=');
+        flags[k] = v.join('=');
+      } else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+        flags[key] = args[i + 1];
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    }
+    i++;
+  }
+
+  return { command, flags };
+}
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+function truncate(str, maxLen) {
+  if (!str) return '';
+  const single = str.replace(/\n/g, ' ').trim();
+  return single.length <= maxLen ? single : single.slice(0, maxLen - 3) + '...';
+}
+
+function timeAgo(iso) {
+  if (!iso) return 'unknown';
+  const diff = Date.now() - new Date(iso).getTime();
+  if (diff < 60000) return 'just now';
+  if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`;
+  if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`;
+  return `${Math.floor(diff / 86400000)}d ago`;
+}
+
+function statusIcon(status) {
+  return {
+    created: '○', starting: '◐', ready: '●', busy: '⟳',
+    paused: '⏸', stopped: '□', killed: '⊘', failed: '✗', error: '✗',
+    completed: '✓',
+  }[status] || '?';
+}
+
+function printResponse(name, response) {
+  console.log(`\n=== ${name} ===`);
+  if (response.isError) console.log('Status: ERROR');
+  if (response.cost) console.log(`Cost: $${response.cost.toFixed(4)}`);
+  if (response.turns) console.log(`Turns: ${response.turns}`);
+  if (response.duration) console.log(`Duration: ${(response.duration / 1000).toFixed(1)}s`);
+  console.log('---');
+  console.log(response.text || '(no output)');
+  console.log('');
+}
+
+// ============================================================================
+// Command Handlers
+// ============================================================================
+async function cmdSpawn(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags.prompt) { console.error('Error: --prompt required'); process.exit(1); }
+
+  console.log(`Spawning "${flags.name}" (model: ${flags.model || 'sonnet'})...`);
+
+  const { session, response } = await mgr.spawn(flags.name, {
+    prompt: flags.prompt,
+    model: flags.model,
+    workDir: flags['work-dir'],
+    permissionMode: flags['permission-mode'],
+    allowedTools: flags['allowed-tools'] ? flags['allowed-tools'].split(',') : undefined,
+    systemPrompt: flags['system-prompt'],
+    maxBudget: flags['max-budget'] ? parseFloat(flags['max-budget']) : undefined,
+    agent: flags.agent,
+  });
+
+  if (response) {
+    printResponse(flags.name, response);
+  }
+
+  console.log(`Session "${flags.name}" is ready (ID: ${session.id})`);
+
+  // If --stop flag, stop session after first response (one-shot mode)
+  if (flags.stop) {
+    mgr.stop(flags.name);
+    console.log(`Session stopped. Resume later: clearctx resume --name ${flags.name}`);
+  } else {
+    console.log(`Send follow-up: clearctx send --name ${flags.name} --message "..."`);
+    console.log(`Session is alive and waiting. Stop with: clearctx stop --name ${flags.name}`);
+  }
+}
+
+async function cmdSend(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags.message) { console.error('Error: --message required'); process.exit(1); }
+
+  // Check if session is alive — if not, auto-resume
+  const sessions = mgr.sessions;
+  if (!sessions.has(flags.name)) {
+    console.log(`Session "${flags.name}" not alive. Auto-resuming...`);
+    const response = await mgr.resume(flags.name, flags.message);
+    if (response) {
+      printResponse(flags.name, response);
+    }
+
+    // Stop after if requested
+    if (flags.stop) {
+      mgr.stop(flags.name);
+      console.log(`Session stopped.`);
+    }
+    return;
+  }
+
+  console.log(`Sending to "${flags.name}"...`);
+  const response = await mgr.send(flags.name, flags.message);
+  printResponse(flags.name, response);
+
+  if (flags.stop) {
+    mgr.stop(flags.name);
+    console.log(`Session stopped.`);
+  }
+}
+
+async function cmdResume(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+
+  console.log(`Resuming "${flags.name}"...`);
+  const response = await mgr.resume(flags.name, flags.message);
+
+  if (response) {
+    printResponse(flags.name, response);
+  }
+
+  console.log(`Session "${flags.name}" is alive.`);
+  console.log(`Send: clearctx send --name ${flags.name} --message "..."`);
+}
+
+function cmdPause(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  mgr.pause(flags.name);
+  console.log(`Session "${flags.name}" paused.`);
+}
+
+async function cmdFork(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags['new-name']) { console.error('Error: --new-name required'); process.exit(1); }
+
+  console.log(`Forking "${flags.name}" -> "${flags['new-name']}"...`);
+  const { session, response } = await mgr.fork(flags.name, flags['new-name'], {
+    message: flags.message || 'Continue from the forked conversation.',
+    model: flags.model,
+  });
+
+  if (response) {
+    printResponse(flags['new-name'], response);
+  }
+
+  console.log(`Forked session "${flags['new-name']}" is ready.`);
+}
+
+function cmdStop(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  mgr.stop(flags.name);
+  console.log(`Session "${flags.name}" stopped. Resume: clearctx resume --name ${flags.name}`);
+}
+
+function cmdKill(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  mgr.kill(flags.name);
+  console.log(`Session "${flags.name}" killed.`);
+}
+
+function cmdStatus(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+
+  const info = mgr.status(flags.name);
+  console.log(`\n=== Session: ${info.name} ===`);
+  console.log(`Status:        ${statusIcon(info.status)} ${info.status}`);
+  console.log(`Model:         ${info.model}`);
+  console.log(`Session ID:    ${info.claudeSessionId || info.id || 'unknown'}`);
+  console.log(`Work Dir:      ${info.workDir}`);
+  console.log(`Cost:          $${(info.totalCostUsd || 0).toFixed(4)}`);
+  console.log(`Turns:         ${info.totalTurns || 0}`);
+  console.log(`Interactions:  ${info.interactionCount || (info.interactions || []).length}`);
+  if (info.pid) console.log(`PID:           ${info.pid}`);
+  console.log('');
+}
+
+function cmdOutput(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+
+  const last = mgr.lastOutput(flags.name);
+  if (!last) {
+    console.log(`No output for "${flags.name}" yet.`);
+    return;
+  }
+
+  if (flags.full) {
+    console.log(last.response || '(no output)');
+  } else {
+    console.log(`\n[${flags.name}] (${last.timestamp || 'unknown'})`);
+    console.log(`Prompt: ${truncate(last.prompt, 100)}`);
+    console.log('---');
+    console.log(last.response || '(no output)');
+    console.log('');
+  }
+}
+
+function cmdList(mgr, flags) {
+  const sessions = mgr.list(flags.status);
+
+  if (sessions.length === 0) {
+    console.log(flags.status ? `No sessions with status "${flags.status}".` : 'No sessions.');
+    return;
+  }
+
+  sessions.sort((a, b) => (b.lastSaved || b.created || '') > (a.lastSaved || a.created || '') ? 1 : -1);
+
+  console.log(`\n${'Name'.padEnd(25)} ${'Status'.padEnd(12)} ${'Model'.padEnd(8)} ${'Turns'.padEnd(6)} ${'Cost'.padEnd(10)} ${'Interactions'}`);
+  console.log('-'.repeat(80));
+
+  for (const s of sessions) {
+    const icon = statusIcon(s.status);
+    const interactions = s.interactionCount || (s.interactions || []).length;
+    console.log(
+      `${truncate(s.name, 24).padEnd(25)} ` +
+      `${(icon + ' ' + s.status).padEnd(12)} ` +
+      `${(s.model || '?').padEnd(8)} ` +
+      `${String(s.totalTurns || 0).padEnd(6)} ` +
+      `${'$' + (s.totalCostUsd || 0).toFixed(4).padEnd(9)} ` +
+      `${interactions}`
+    );
+  }
+
+  console.log(`\nTotal: ${sessions.length}`);
+  console.log('');
+}
+
+function cmdHistory(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+
+  const hist = mgr.history(flags.name);
+  if (hist.length === 0) {
+    console.log(`No history for "${flags.name}".`);
+    return;
+  }
+
+  console.log(`\n=== History: ${flags.name} (${hist.length} interactions) ===\n`);
+
+  hist.forEach((h, i) => {
+    console.log(`--- #${i} ${h.type || 'send'} — ${h.timestamp || 'unknown'} ---`);
+    console.log(`PROMPT:   ${flags.full ? h.prompt : truncate(h.prompt, 200)}`);
+    console.log(`RESPONSE: ${flags.full ? h.response : truncate(h.response, 300)}`);
+    if (h.cost) console.log(`COST:     $${h.cost.toFixed(4)}`);
+    if (h.duration) console.log(`DURATION: ${(h.duration / 1000).toFixed(1)}s`);
+    console.log('');
+  });
+}
+
+function cmdDelete(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  mgr.delete(flags.name);
+  console.log(`Session "${flags.name}" deleted permanently.`);
+}
+
+async function cmdBatch(mgr, flags) {
+  if (!flags.file) { console.error('Error: --file required (JSON file path)'); process.exit(1); }
+
+  const filePath = path.resolve(flags.file);
+  if (!fs.existsSync(filePath)) {
+    console.error(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  let specs;
+  try { specs = JSON.parse(fs.readFileSync(filePath, 'utf-8')); } catch (e) {
+    console.error(`Invalid JSON: ${e.message}`);
+    process.exit(1);
+  }
+
+  if (!Array.isArray(specs)) {
+    console.error('JSON must be an array of session specs.');
+    process.exit(1);
+  }
+
+  console.log(`Spawning ${specs.length} sessions in parallel...`);
+  const results = await mgr.batch(specs);
+
+  for (const r of results) {
+    if (r.error) {
+      console.log(`  ✗ ${r.session?.name || 'unknown'}: ${r.error}`);
+    } else {
+      const resp = r.response;
+      console.log(`  ✓ ${r.session.name}: ${resp ? truncate(resp.text, 80) : 'started (no prompt)'}`);
+    }
+  }
+
+  console.log(`\nDone. List all: clearctx list`);
+
+  // Stop all after batch unless --keep-alive
+  if (!flags['keep-alive']) {
+    mgr.stopAll();
+    console.log('All sessions stopped. Resume individually: clearctx resume --name <name>');
+  }
+}
+
+// ============================================================================
+// Delegate Commands (Control Loop + Safety Net)
+// ============================================================================
+
+/**
+ * DELEGATE — Smart task delegation with safety limits and auto-permission handling.
+ *
+ * Required: --name, --task
+ * Optional: --model, --preset, --max-cost, --max-turns, --context, --work-dir, --json
+ */
+async function cmdDelegate(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags.task) { console.error('Error: --task required'); process.exit(1); }
+
+  const delegate = new Delegate(mgr);
+
+  const preset = flags.preset || 'edit';
+  const maxCost = flags['max-cost'] ? parseFloat(flags['max-cost']) : 2.00;
+  const maxTurns = flags['max-turns'] ? parseInt(flags['max-turns']) : 50;
+
+  if (!flags.json) {
+    console.log(`Delegating to "${flags.name}" (model: ${flags.model || 'sonnet'}, preset: ${preset}, max: $${maxCost.toFixed(2)})...`);
+  }
+
+  // --no-safety flag disables the safety net entirely
+  const useSafety = !flags['no-safety'];
+
+  const result = await delegate.run(flags.name, {
+    task: flags.task,
+    model: flags.model,
+    preset: preset,
+    workDir: flags['work-dir'],
+    maxCost: maxCost,
+    maxTurns: maxTurns,
+    context: flags.context,
+    systemPrompt: flags['system-prompt'],
+    agent: flags.agent,
+    safety: useSafety,
+  });
+
+  // Stop session after delegation (can be resumed)
+  delegate.finish(flags.name);
+
+  if (flags.json) {
+    // Output as JSON for programmatic consumption by parent Claude
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    printDelegateResult(result);
+  }
+}
+
+/**
+ * CONTINUE — Send follow-up to a delegated session with safety limits.
+ *
+ * Required: --name, --message
+ * Optional: --json
+ */
+async function cmdContinue(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags.message) { console.error('Error: --message required'); process.exit(1); }
+
+  const delegate = new Delegate(mgr);
+
+  if (!flags.json) {
+    console.log(`Continuing "${flags.name}"...`);
+  }
+
+  const result = await delegate.continue(flags.name, flags.message);
+
+  // Stop after
+  delegate.finish(flags.name);
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    printDelegateResult(result);
+  }
+}
+
+/**
+ * Print a DelegateResult in human-readable format.
+ */
+function printDelegateResult(result) {
+  const statusEmoji = {
+    completed: '✓',
+    needs_input: '?',
+    failed: '✗',
+    cost_exceeded: '$',
+    turns_exceeded: '#',
+    protected_path: '!',
+  }[result.status] || '?';
+
+  console.log(`\n${statusEmoji} Status: ${result.status.toUpperCase()}`);
+  if (result.error) console.log(`  Error: ${result.error}`);
+  if (result.cost) console.log(`  Cost: $${result.cost.toFixed(4)}`);
+  if (result.turns) console.log(`  Turns: ${result.turns}`);
+  if (result.duration) console.log(`  Duration: ${(result.duration / 1000).toFixed(1)}s`);
+  if (result.toolsUsed.length > 0) console.log(`  Tools: ${[...new Set(result.toolsUsed)].join(', ')}`);
+  console.log(`  Can continue: ${result.canContinue ? 'yes' : 'no'}`);
+
+  if (result.safety && result.safety.totalViolations > 0) {
+    console.log(`  Safety violations: ${result.safety.totalViolations}`);
+    result.safety.violations.forEach(v => console.log(`    - ${v.message}`));
+  }
+
+  console.log(`\n--- Response ---`);
+  console.log(result.response || '(no output)');
+  console.log('');
+
+  if (result.canContinue) {
+    console.log(`Continue: clearctx continue --name ${result.name} --message "..."`);
+  }
+}
+
+// ============================================================================
+// Setup Command
+// ============================================================================
+
+/**
+ * SETUP — Register the MCP server with Claude Code settings.
+ * Delegates to bin/setup.js which handles the interactive wizard.
+ */
+async function cmdSetup(flags) {
+  const { run } = require('./setup');
+  await run(flags);
+}
+
+function cmdCleanup(mgr, flags) {
+  const days = flags.days ? parseInt(flags.days) : 7;
+  const removed = mgr.cleanup(days);
+  if (removed.length === 0) {
+    console.log(`No sessions older than ${days} days to clean.`);
+  } else {
+    console.log(`Removed ${removed.length} sessions: ${removed.join(', ')}`);
+  }
+}
+
+// ============================================================================
+// Team/Artifact/Contract/Pipeline/Snapshot Commands
+// ============================================================================
+
+/**
+ * TEAM-ROSTER — Show team members
+ */
+function cmdTeamRoster(flags) {
+  const team = flags.team || 'default';
+  const hub = new TeamHub(team);
+  const roster = hub.getRoster();
+
+  console.log(`\n=== Team Roster: ${team} ===\n`);
+  console.log(`${'Name'.padEnd(25)} ${'Role'.padEnd(20)} ${'Status'.padEnd(12)} ${'Task'.padEnd(30)} ${'Last Seen'}`);
+  console.log('-'.repeat(120));
+
+  for (const member of roster) {
+    console.log(
+      `${truncate(member.name, 24).padEnd(25)} ` +
+      `${truncate(member.role || '-', 19).padEnd(20)} ` +
+      `${(member.status || 'offline').padEnd(12)} ` +
+      `${truncate(member.task || '-', 29).padEnd(30)} ` +
+      `${timeAgo(member.lastSeen)}`
+    );
+  }
+
+  console.log(`\nTotal: ${roster.length}\n`);
+}
+
+/**
+ * TEAM-SEND — Send message to teammate
+ */
+function cmdTeamSend(flags) {
+  if (!flags.from) { console.error('Error: --from required'); process.exit(1); }
+  if (!flags.to) { console.error('Error: --to required'); process.exit(1); }
+  if (!flags.message) { console.error('Error: --message required'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const hub = new TeamHub(team);
+
+  hub.sendDirect(flags.from, flags.to, flags.message, flags.priority || 'normal');
+  console.log(`Message sent from "${flags.from}" to "${flags.to}".`);
+}
+
+/**
+ * TEAM-BROADCAST — Send to all teammates
+ */
+function cmdTeamBroadcast(flags) {
+  if (!flags.from) { console.error('Error: --from required'); process.exit(1); }
+  if (!flags.message) { console.error('Error: --message required'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const hub = new TeamHub(team);
+
+  hub.sendBroadcast(flags.from, flags.message, flags.priority || 'normal');
+  console.log(`Broadcast sent from "${flags.from}" to all team members.`);
+}
+
+/**
+ * TEAM-INBOX — Check inbox
+ */
+function cmdTeamInbox(flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const hub = new TeamHub(team);
+  const markRead = flags['mark-read'] !== undefined ? flags['mark-read'] : true;
+  const limit = flags.limit ? parseInt(flags.limit) : 20;
+
+  const messages = hub.getInbox(flags.name, markRead, limit);
+
+  console.log(`\n=== Inbox: ${flags.name} (${messages.length} messages) ===\n`);
+
+  if (messages.length === 0) {
+    console.log('No messages.\n');
+    return;
+  }
+
+  for (const msg of messages) {
+    console.log(`[${msg.priority || 'normal'}] From: ${msg.from} | ${timeAgo(msg.timestamp)}`);
+    console.log(`  ${msg.content}`);
+    if (msg.messageId) console.log(`  ID: ${msg.messageId}`);
+    console.log('');
+  }
+}
+
+/**
+ * ARTIFACT-PUBLISH — Publish artifact
+ */
+function cmdArtifactPublish(flags) {
+  if (!flags.id) { console.error('Error: --id required'); process.exit(1); }
+  if (!flags.type) { console.error('Error: --type required'); process.exit(1); }
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags.data) { console.error('Error: --data required (JSON string)'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const store = new ArtifactStore(team);
+
+  let data;
+  try {
+    data = JSON.parse(flags.data);
+  } catch (e) {
+    console.error(`Invalid JSON in --data: ${e.message}`);
+    process.exit(1);
+  }
+
+  const artifact = store.publish(flags.id, {
+    type: flags.type,
+    name: flags.name,
+    data: data,
+    publisher: flags.publisher,
+    summary: flags.summary,
+    tags: flags.tags ? flags.tags.split(',') : [],
+    derivedFrom: flags['derived-from'] ? flags['derived-from'].split(',') : [],
+  });
+
+  console.log(`Artifact published: ${flags.id} (version ${artifact.version})`);
+}
+
+/**
+ * ARTIFACT-GET — Read artifact
+ */
+function cmdArtifactGet(flags) {
+  if (!flags.id) { console.error('Error: --id required'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const store = new ArtifactStore(team);
+
+  const artifact = store.get(flags.id, flags.version ? parseInt(flags.version) : undefined);
+
+  if (!artifact) {
+    console.log(`Artifact "${flags.id}" not found.`);
+    return;
+  }
+
+  console.log(`\n=== Artifact: ${artifact.artifactId} (v${artifact.version}) ===\n`);
+  console.log(`Type:      ${artifact.type}`);
+  console.log(`Name:      ${artifact.name}`);
+  console.log(`Publisher: ${artifact.publisher || 'unknown'}`);
+  console.log(`Published: ${artifact.timestamp}`);
+  if (artifact.summary) console.log(`Summary:   ${artifact.summary}`);
+  if (artifact.tags && artifact.tags.length > 0) console.log(`Tags:      ${artifact.tags.join(', ')}`);
+  console.log('\nData:');
+  console.log(JSON.stringify(artifact.data, null, 2));
+  console.log('');
+}
+
+/**
+ * ARTIFACT-LIST — List artifacts
+ */
+function cmdArtifactList(flags) {
+  const team = flags.team || 'default';
+  const store = new ArtifactStore(team);
+
+  const artifacts = store.list(flags.type, flags.publisher, flags.tag);
+
+  console.log(`\n=== Artifacts (${artifacts.length}) ===\n`);
+
+  if (artifacts.length === 0) {
+    console.log('No artifacts.\n');
+    return;
+  }
+
+  console.log(`${'ID'.padEnd(30)} ${'Type'.padEnd(20)} ${'Version'.padEnd(8)} ${'Publisher'.padEnd(15)} ${'Published'}`);
+  console.log('-'.repeat(100));
+
+  for (const a of artifacts) {
+    console.log(
+      `${truncate(a.artifactId, 29).padEnd(30)} ` +
+      `${truncate(a.type, 19).padEnd(20)} ` +
+      `${String(a.version).padEnd(8)} ` +
+      `${truncate(a.publisher || '-', 14).padEnd(15)} ` +
+      `${timeAgo(a.timestamp)}`
+    );
+  }
+
+  console.log('');
+}
+
+/**
+ * CONTRACT-CREATE — Create contract
+ */
+function cmdContractCreate(flags) {
+  if (!flags.id) { console.error('Error: --id required'); process.exit(1); }
+  if (!flags.title) { console.error('Error: --title required'); process.exit(1); }
+  if (!flags.assignee) { console.error('Error: --assignee required'); process.exit(1); }
+  if (!flags.assigner) { console.error('Error: --assigner required'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const store = new ContractStore(team);
+
+  const contract = store.create(flags.id, {
+    title: flags.title,
+    assignee: flags.assignee,
+    assigner: flags.assigner,
+    description: flags.description,
+    inputs: flags.inputs ? JSON.parse(flags.inputs) : {},
+    expectedOutputs: flags['expected-outputs'] ? JSON.parse(flags['expected-outputs']) : [],
+    acceptanceCriteria: flags['acceptance-criteria'] ? JSON.parse(flags['acceptance-criteria']) : [],
+    dependencies: flags.dependencies ? flags.dependencies.split(',') : [],
+    priority: flags.priority || 'normal',
+    timeoutMs: flags['timeout-ms'] ? parseInt(flags['timeout-ms']) : null,
+  });
+
+  console.log(`Contract created: ${flags.id} (status: ${contract.status})`);
+}
+
+/**
+ * CONTRACT-LIST — List contracts
+ */
+function cmdContractList(flags) {
+  const team = flags.team || 'default';
+  const store = new ContractStore(team);
+
+  const contracts = store.list(flags.status, flags.assignee, flags.assigner);
+
+  console.log(`\n=== Contracts (${contracts.length}) ===\n`);
+
+  if (contracts.length === 0) {
+    console.log('No contracts.\n');
+    return;
+  }
+
+  console.log(`${'ID'.padEnd(25)} ${'Title'.padEnd(30)} ${'Status'.padEnd(15)} ${'Assignee'.padEnd(15)} ${'Created'}`);
+  console.log('-'.repeat(110));
+
+  for (const c of contracts) {
+    console.log(
+      `${truncate(c.contractId, 24).padEnd(25)} ` +
+      `${truncate(c.title, 29).padEnd(30)} ` +
+      `${(c.status || 'pending').padEnd(15)} ` +
+      `${truncate(c.assignee, 14).padEnd(15)} ` +
+      `${timeAgo(c.created)}`
+    );
+  }
+
+  console.log('');
+}
+
+/**
+ * CONTRACT-START — Start contract
+ */
+function cmdContractStart(flags) {
+  if (!flags.id) { console.error('Error: --id required'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const store = new ContractStore(team);
+
+  const contract = store.start(flags.id);
+  console.log(`Contract "${flags.id}" started (status: ${contract.status})`);
+}
+
+/**
+ * PIPELINE-CREATE — Create pipeline
+ */
+function cmdPipelineCreate(flags) {
+  if (!flags.id) { console.error('Error: --id required'); process.exit(1); }
+  if (!flags.rules) { console.error('Error: --rules required (JSON string)'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const engine = new PipelineEngine(team);
+
+  let rules;
+  try {
+    rules = JSON.parse(flags.rules);
+  } catch (e) {
+    console.error(`Invalid JSON in --rules: ${e.message}`);
+    process.exit(1);
+  }
+
+  const pipeline = engine.create(flags.id, rules, flags.owner);
+  console.log(`Pipeline created: ${flags.id} (enabled: ${pipeline.enabled})`);
+}
+
+/**
+ * PIPELINE-LIST — List pipelines
+ */
+function cmdPipelineList(flags) {
+  const team = flags.team || 'default';
+  const engine = new PipelineEngine(team);
+
+  const pipelines = engine.list(flags.owner);
+
+  console.log(`\n=== Pipelines (${pipelines.length}) ===\n`);
+
+  if (pipelines.length === 0) {
+    console.log('No pipelines.\n');
+    return;
+  }
+
+  console.log(`${'ID'.padEnd(25)} ${'Enabled'.padEnd(10)} ${'Rules'.padEnd(8)} ${'Executed'.padEnd(10)} ${'Owner'}`);
+  console.log('-'.repeat(80));
+
+  for (const p of pipelines) {
+    console.log(
+      `${truncate(p.pipelineId, 24).padEnd(25)} ` +
+      `${(p.enabled ? 'yes' : 'no').padEnd(10)} ` +
+      `${String(p.rules.length).padEnd(8)} ` +
+      `${String(p.executionCount || 0).padEnd(10)} ` +
+      `${p.owner || '-'}`
+    );
+  }
+
+  console.log('');
+}
+
+/**
+ * SNAPSHOT-CREATE — Create snapshot
+ */
+function cmdSnapshotCreate(flags) {
+  if (!flags.id) { console.error('Error: --id required'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const engine = new SnapshotEngine(team);
+
+  const snapshot = engine.createSnapshot(flags.id, flags.label, flags.description);
+  console.log(`Snapshot created: ${flags.id} at ${snapshot.timestamp}`);
+}
+
+/**
+ * SNAPSHOT-LIST — List snapshots
+ */
+function cmdSnapshotList(flags) {
+  const team = flags.team || 'default';
+  const engine = new SnapshotEngine(team);
+
+  const snapshots = engine.listSnapshots();
+
+  console.log(`\n=== Snapshots (${snapshots.length}) ===\n`);
+
+  if (snapshots.length === 0) {
+    console.log('No snapshots.\n');
+    return;
+  }
+
+  console.log(`${'ID'.padEnd(25)} ${'Label'.padEnd(30)} ${'Created'}`);
+  console.log('-'.repeat(70));
+
+  for (const s of snapshots) {
+    console.log(
+      `${truncate(s.snapshotId, 24).padEnd(25)} ` +
+      `${truncate(s.label || '-', 29).padEnd(30)} ` +
+      `${timeAgo(s.timestamp)}`
+    );
+  }
+
+  console.log('');
+}
+
+/**
+ * SNAPSHOT-ROLLBACK — Rollback to snapshot
+ */
+function cmdSnapshotRollback(flags) {
+  if (!flags.id) { console.error('Error: --id required'); process.exit(1); }
+
+  const team = flags.team || 'default';
+  const engine = new SnapshotEngine(team);
+
+  engine.rollback(flags.id, flags['preserve-artifacts'] !== false);
+  console.log(`Rolled back to snapshot: ${flags.id}`);
+}
+
+// ============================================================================
+// Session Continuity Commands (Layer 0)
+// ============================================================================
+
+/**
+ * SNAPSHOT — Capture a session snapshot
+ */
+function cmdSnapshot(flags) {
+  if (!flags['project-path']) { console.error('Error: --project-path required'); process.exit(1); }
+
+  const snap = new SessionSnapshot(flags['project-path']);
+  const sessionName = flags.session || 'cli-session';
+  const taskSummary = flags.task || 'Work in progress';
+
+  const result = snap.capture(sessionName, {
+    taskSummary: taskSummary,
+    activeFiles: flags.files ? flags.files.split(',') : [],
+    openQuestions: flags.questions ? flags.questions.split(',') : []
+  });
+
+  console.log(`Snapshot captured: ${result.snapshotId}`);
+  console.log(`  Session: ${sessionName}`);
+  console.log(`  Captured at: ${result.capturedAt}`);
+  console.log(`  Files tracked: ${result.workingContext?.activeFiles?.length || 0}`);
+}
+
+/**
+ * BRIEFING — Generate session briefing
+ */
+function cmdBriefing(flags) {
+  if (!flags['project-path']) { console.error('Error: --project-path required'); process.exit(1); }
+
+  const gen = new BriefingGenerator(flags['project-path']);
+  const maxTokens = flags['max-tokens'] ? parseInt(flags['max-tokens']) : 4000;
+  const includeDecisions = flags['include-decisions'] !== false;
+  const includePatterns = flags['include-patterns'] !== false;
+
+  const result = gen.generate({
+    maxTokens: maxTokens,
+    includeDecisions: includeDecisions,
+    includePatterns: includePatterns
+  });
+
+  console.log('\n' + result.markdown);
+}
+
+/**
+ * STALE-CHECK — Check if context is stale
+ */
+function cmdStaleCheck(flags) {
+  if (!flags['project-path']) { console.error('Error: --project-path required'); process.exit(1); }
+
+  const detector = new StaleDetector(flags['project-path']);
+  const result = detector.check();
+
+  console.log(`\n=== Stale Context Check ===\n`);
+  console.log(`Status: ${result.isStale ? 'STALE' : 'FRESH'}`);
+
+  if (result.warnings && result.warnings.length > 0) {
+    console.log(`\nWarnings:`);
+    result.warnings.forEach(w => console.log(`  - ${w}`));
+  }
+
+  if (result.changedFiles && result.changedFiles.length > 0) {
+    console.log(`\nChanged files since last snapshot: ${result.changedFiles.length}`);
+  }
+
+  console.log('');
+}
+
+/**
+ * DECISIONS — List decisions
+ */
+function cmdDecisions(flags) {
+  if (!flags['project-path']) { console.error('Error: --project-path required'); process.exit(1); }
+
+  const journal = new DecisionJournal(flags['project-path']);
+  const limit = flags.limit ? parseInt(flags.limit) : 50;
+  const tag = flags.tag;
+
+  const decisions = journal.list({ limit: limit, tag: tag });
+
+  console.log(`\n=== Decisions (${decisions.length}) ===\n`);
+
+  if (decisions.length === 0) {
+    console.log('No decisions recorded.\n');
+    return;
+  }
+
+  for (const d of decisions) {
+    console.log(`[${d.createdAt || 'unknown'}]`);
+    console.log(`  Decision: ${d.decision}`);
+    if (d.reason) console.log(`  Reason: ${d.reason}`);
+    if (d.tags && d.tags.length > 0) console.log(`  Tags: ${d.tags.join(', ')}`);
+    console.log('');
+  }
+}
+
+/**
+ * PATTERNS — List patterns
+ */
+function cmdPatterns(flags) {
+  if (!flags['project-path']) { console.error('Error: --project-path required'); process.exit(1); }
+
+  const registry = new PatternRegistry(flags['project-path']);
+  const tag = flags.tag;
+
+  const patterns = registry.list({ tag: tag });
+
+  console.log(`\n=== Patterns (${patterns.length}) ===\n`);
+
+  if (patterns.length === 0) {
+    console.log('No patterns recorded.\n');
+    return;
+  }
+
+  for (const p of patterns) {
+    console.log(`[${p.id}] ${p.rule}`);
+    if (p.context) console.log(`  Context: ${p.context}`);
+    if (p.example) console.log(`  Example: ${p.example}`);
+    if (p.tags && p.tags.length > 0) console.log(`  Tags: ${p.tags.join(', ')}`);
+    console.log('');
+  }
+}
+
+// ============================================================================
+// Session Continuity Automation Commands
+// ============================================================================
+
+/**
+ * CONTINUITY-SETUP — Install Claude Code hooks for automatic session continuity.
+ *
+ * Writes 4 hook entries to ~/.claude/settings.json so that:
+ *   - SessionStart automatically injects a diff-aware briefing
+ *   - Stop quietly checkpoints in the background
+ *   - PreCompact saves context before compaction
+ *   - SessionEnd captures a final snapshot on exit
+ */
+function cmdContinuitySetup() {
+  const os = require('os');
+  const crypto = require('crypto');
+
+  // Resolve the absolute path to our hook entry point script
+  const hookScript = path.resolve(__dirname, 'continuity-hook.js');
+
+  // Path to Claude Code's settings file
+  const claudeDir = path.join(os.homedir(), '.claude');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+
+  // Create ~/.claude/ directory if it doesn't exist
+  if (!fs.existsSync(claudeDir)) {
+    fs.mkdirSync(claudeDir, { recursive: true });
+  }
+
+  // Read existing settings (or start fresh)
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    } catch (e) {
+      // If settings file is corrupted, start fresh
+      settings = {};
+    }
+  }
+
+  // Make sure hooks object exists
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  // The hook command uses the absolute path to our entry point
+  // On Windows, we need forward slashes in the JSON string for safety
+  const hookScriptEscaped = hookScript.replace(/\\/g, '\\\\');
+  const hookCmd = `node "${hookScriptEscaped}"`;
+
+  // Define the 4 hook configurations we need to install
+  const hookConfigs = {
+    SessionStart: {
+      matcher: '',
+      hooks: [{
+        type: 'command',
+        command: `${hookCmd} SessionStart`,
+        timeout: 5
+      }]
+    },
+    Stop: {
+      matcher: '',
+      hooks: [{
+        type: 'command',
+        command: `${hookCmd} Stop`,
+        async: true,
+        timeout: 10
+      }]
+    },
+    PreCompact: {
+      matcher: '',
+      hooks: [{
+        type: 'command',
+        command: `${hookCmd} PreCompact`,
+        timeout: 10
+      }]
+    },
+    SessionEnd: {
+      matcher: '',
+      hooks: [{
+        type: 'command',
+        command: `${hookCmd} SessionEnd`,
+        async: true,
+        timeout: 15
+      }]
+    }
+  };
+
+  // Check if we're updating existing hooks (contains continuity-hook.js)
+  let isUpdate = false;
+
+  // Merge hooks into settings — don't overwrite existing hooks from other tools
+  for (const [eventName, newHookEntry] of Object.entries(hookConfigs)) {
+    if (!settings.hooks[eventName]) {
+      // No existing hooks for this event — create the array
+      settings.hooks[eventName] = [newHookEntry];
+    } else {
+      // Existing hooks — check if our hook is already installed
+      const existingArray = settings.hooks[eventName];
+      let found = false;
+
+      for (let i = 0; i < existingArray.length; i++) {
+        const entry = existingArray[i];
+        // Check if any hook command in this entry contains our script
+        if (entry.hooks && Array.isArray(entry.hooks)) {
+          for (let j = 0; j < entry.hooks.length; j++) {
+            if (entry.hooks[j].command && entry.hooks[j].command.includes('continuity-hook')) {
+              // Update the existing hook with new path
+              existingArray[i] = newHookEntry;
+              found = true;
+              isUpdate = true;
+              break;
+            }
+          }
+        }
+        if (found) break;
+      }
+
+      if (!found) {
+        // Our hook isn't installed yet — add it to the array
+        existingArray.push(newHookEntry);
+      }
+    }
+  }
+
+  // Write the settings back using atomic write (write to temp, then rename)
+  const tmpPath = settingsPath + '.tmp.' + Date.now();
+  fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2), 'utf-8');
+  fs.renameSync(tmpPath, settingsPath);
+
+  // Print success output
+  if (isUpdate) {
+    console.log(`\n  Session Continuity hooks updated in ~/.claude/settings.json`);
+    console.log(`  (Hook script path updated to: ${hookScript})\n`);
+  } else {
+    console.log(`\n  Session Continuity hooks installed to ~/.claude/settings.json\n`);
+    console.log(`  Hooks configured:`);
+    console.log(`    SessionStart  -> Auto-inject session briefing (timeout: 5s)`);
+    console.log(`    Stop          -> Background checkpoint (async, timeout: 10s)`);
+    console.log(`    PreCompact    -> Critical save before compaction (timeout: 10s)`);
+    console.log(`    SessionEnd    -> Final snapshot on exit (async, timeout: 15s)`);
+    console.log(`\n  Hook script: ${hookScript}`);
+    console.log(`\n  Continuity is now active for ALL projects.`);
+    console.log(`  Start a Claude Code session, do some work, exit, and start again.`);
+    console.log(`  The next session will automatically receive a briefing about what changed.\n`);
+  }
+}
+
+/**
+ * CONTINUITY-UNSETUP — Remove continuity hooks from ~/.claude/settings.json.
+ */
+function cmdContinuityUnsetup() {
+  const os = require('os');
+  const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+
+  // If settings file doesn't exist, nothing to remove
+  if (!fs.existsSync(settingsPath)) {
+    console.log('No settings file found at ~/.claude/settings.json — nothing to remove.');
+    return;
+  }
+
+  // Read existing settings
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+  } catch (e) {
+    console.error('Error reading settings file:', e.message);
+    return;
+  }
+
+  if (!settings.hooks) {
+    console.log('No hooks found in settings — nothing to remove.');
+    return;
+  }
+
+  let removedCount = 0;
+
+  // Remove any hook entries that contain 'continuity-hook' in their command
+  for (const eventName of Object.keys(settings.hooks)) {
+    const entries = settings.hooks[eventName];
+    if (!Array.isArray(entries)) continue;
+
+    // Filter out entries that have continuity-hook commands
+    settings.hooks[eventName] = entries.filter(entry => {
+      if (entry.hooks && Array.isArray(entry.hooks)) {
+        const hasContinuity = entry.hooks.some(h =>
+          h.command && h.command.includes('continuity-hook')
+        );
+        if (hasContinuity) {
+          removedCount++;
+          return false; // Remove this entry
+        }
+      }
+      return true; // Keep this entry
+    });
+
+    // Clean up empty arrays
+    if (settings.hooks[eventName].length === 0) {
+      delete settings.hooks[eventName];
+    }
+  }
+
+  // Clean up empty hooks object
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  // Write back
+  const tmpPath = settingsPath + '.tmp.' + Date.now();
+  fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2), 'utf-8');
+  fs.renameSync(tmpPath, settingsPath);
+
+  if (removedCount > 0) {
+    console.log(`\n  Removed ${removedCount} continuity hook(s) from ~/.claude/settings.json`);
+    console.log(`  Session Continuity automation is now disabled.\n`);
+  } else {
+    console.log('No continuity hooks found in settings — nothing to remove.');
+  }
+}
+
+/**
+ * CONTINUITY-RESET — Delete ALL continuity data for a project.
+ */
+function cmdContinuityReset(flags) {
+  if (!flags['project-path']) {
+    console.error('Error: --project-path required');
+    process.exit(1);
+  }
+
+  const os = require('os');
+  const crypto = require('crypto');
+
+  const projectPath = flags['project-path'];
+
+  // Compute the same project hash used by all continuity modules
+  const projectHash = crypto
+    .createHash('sha256')
+    .update(projectPath)
+    .digest('hex')
+    .slice(0, 16);
+
+  // Primary storage location: ~/.clearctx/continuity/{hash}/
+  const continuityDir = path.join(
+    os.homedir(),
+    '.clearctx',
+    'continuity',
+    projectHash
+  );
+
+  let deleted = false;
+
+  // Delete the primary continuity directory recursively
+  if (fs.existsSync(continuityDir)) {
+    fs.rmSync(continuityDir, { recursive: true, force: true });
+    deleted = true;
+  }
+
+  // Also check the old BriefingGenerator path (in case data was stored there before the fix)
+  const oldBriefingsDir = path.join(
+    os.homedir(),
+    '.claude',
+    'multi-session',
+    projectHash,
+    'briefings'
+  );
+  if (fs.existsSync(oldBriefingsDir)) {
+    fs.rmSync(oldBriefingsDir, { recursive: true, force: true });
+    deleted = true;
+
+    // Clean up the parent directory if it's now empty
+    const oldParent = path.join(os.homedir(), '.claude', 'multi-session', projectHash);
+    try {
+      const remaining = fs.readdirSync(oldParent);
+      if (remaining.length === 0) {
+        fs.rmdirSync(oldParent);
+      }
+    } catch (e) {
+      // Ignore — parent might not exist
+    }
+  }
+
+  if (deleted) {
+    console.log(`\n  Continuity data cleared for ${projectPath}`);
+    console.log(`  Project hash: ${projectHash}\n`);
+  } else {
+    console.log(`\n  No continuity data found for ${projectPath}`);
+    console.log(`  Project hash: ${projectHash}\n`);
+  }
+}
+
+/**
+ * CONTINUITY-PRUNE — Keep only the N most recent snapshots for a project.
+ */
+function cmdContinuityPrune(flags) {
+  if (!flags['project-path']) {
+    console.error('Error: --project-path required');
+    process.exit(1);
+  }
+
+  const projectPath = flags['project-path'];
+  const keep = flags.keep ? parseInt(flags.keep) : 10;
+
+  // Instantiate SessionSnapshot to get the snapshots directory
+  const snap = new SessionSnapshot(projectPath);
+  const snapshotsDir = path.join(snap.getProjectDir(), 'snapshots');
+
+  if (!fs.existsSync(snapshotsDir)) {
+    console.log('No snapshots directory found — nothing to prune.');
+    return;
+  }
+
+  // Read all snapshot files
+  const files = fs.readdirSync(snapshotsDir)
+    .filter(f => f.startsWith('snap_') && f.endsWith('.json'));
+
+  if (files.length <= keep) {
+    console.log(`\n  Only ${files.length} snapshot(s) found — nothing to prune (keeping ${keep}).\n`);
+    return;
+  }
+
+  // Sort ascending by filename (contains timestamp) — oldest first
+  files.sort();
+
+  // Delete the oldest files, keep the most recent
+  const toDelete = files.slice(0, files.length - keep);
+  let deletedCount = 0;
+
+  for (const file of toDelete) {
+    try {
+      fs.unlinkSync(path.join(snapshotsDir, file));
+      deletedCount++;
+    } catch (e) {
+      console.error(`  Warning: could not delete ${file}: ${e.message}`);
+    }
+  }
+
+  console.log(`\n  Pruned ${deletedCount} snapshot(s), kept ${keep} most recent.\n`);
+}
+
+/**
+ * CONTINUITY-STATUS — Show continuity status at a glance.
+ */
+function cmdContinuityStatus(flags) {
+  if (!flags['project-path']) {
+    console.error('Error: --project-path required');
+    process.exit(1);
+  }
+
+  const os = require('os');
+
+  const projectPath = flags['project-path'];
+
+  // Get snapshot info
+  const snap = new SessionSnapshot(projectPath);
+  const latest = snap.getLatest();
+  const allSnapshots = snap.list(100);
+  const projectHash = snap.getProjectHash();
+
+  // Get decision count
+  const journal = new DecisionJournal(projectPath);
+  const decisions = journal.list({});
+
+  // Get pattern count
+  const registry = new PatternRegistry(projectPath);
+  const patterns = registry.list({});
+
+  // Check staleness
+  let staleStatus = 'N/A';
+  let changedCount = 0;
+  if (latest) {
+    try {
+      const detector = new StaleDetector(projectPath);
+      const staleResult = detector.check();
+      if (staleResult.isStale) {
+        changedCount = staleResult.totalFileChanges || 0;
+        staleStatus = `STALE -- ${staleResult.warnings.length} warning(s), ${changedCount} file change(s)`;
+      } else {
+        staleStatus = 'FRESH';
+      }
+    } catch (e) {
+      staleStatus = 'Error checking: ' + e.message;
+    }
+  }
+
+  // Check if hooks are installed
+  let hooksInstalled = false;
+  const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+      if (settings.hooks) {
+        // Check if any hook command contains continuity-hook
+        const hookStr = JSON.stringify(settings.hooks);
+        hooksInstalled = hookStr.includes('continuity-hook');
+      }
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  // Format last snapshot time
+  let lastSnapshotStr = 'None';
+  let lastTrigger = 'N/A';
+  let oldestStr = 'N/A';
+  if (latest) {
+    const capturedAt = new Date(latest.capturedAt);
+    const ago = timeAgo(latest.capturedAt);
+    lastSnapshotStr = `${capturedAt.toISOString()} (${ago})`;
+    lastTrigger = latest.capturedBy || 'unknown';
+  }
+  if (allSnapshots.length > 0) {
+    const oldest = allSnapshots[allSnapshots.length - 1];
+    oldestStr = timeAgo(oldest.capturedAt);
+  }
+
+  // Print the status
+  console.log(`\n=== Session Continuity Status ===\n`);
+  console.log(`Project:          ${projectPath}`);
+  console.log(`Project hash:     ${projectHash}`);
+  console.log(`Last snapshot:    ${lastSnapshotStr}`);
+  console.log(`Trigger:          ${lastTrigger}`);
+  console.log(`Snapshots stored: ${allSnapshots.length} (oldest: ${oldestStr})`);
+  console.log(`Decisions logged: ${decisions.length}`);
+  console.log(`Patterns saved:   ${patterns.length}`);
+  console.log(`Context status:   ${staleStatus}`);
+  console.log(`Hooks installed:  ${hooksInstalled ? 'Yes (in ~/.claude/settings.json)' : 'No'}`);
+  console.log('');
+}
+
+function cmdHelp() {
+  console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║  clearctx (cms) — Multi-Session Orchestrator     ║
+║  Streaming-powered session management for Claude Code CLI    ║
+╚══════════════════════════════════════════════════════════════╝
+
+COMMANDS:
+
+  spawn     Start a new streaming session (keeps process alive)
+            --name <name>  --prompt <text>
+            [--model sonnet|opus|haiku]  [--stop]
+            [--work-dir <path>]  [--permission-mode <mode>]
+            [--allowed-tools <t1,t2>]  [--system-prompt <text>]
+            [--max-budget <usd>]  [--agent <name>]
+
+  send      Send a follow-up message (auto-resumes if stopped)
+            --name <name>  --message <text>  [--stop]
+
+  resume    Restore a stopped/paused session
+            --name <name>  [--message <text>]
+
+  pause     Pause session (process stays alive, no messages accepted)
+            --name <name>
+
+  fork      Branch off a session into a new one
+            --name <source>  --new-name <target>
+            [--message <text>]  [--model <model>]
+
+  stop      Gracefully stop (saves state, can resume later)
+            --name <name>
+
+  kill      Force kill a session
+            --name <name>
+
+  status    Show detailed session info
+            --name <name>
+
+  output    Get last response text
+            --name <name>  [--full]
+
+  list      List all sessions
+            [--status ready|paused|stopped|killed]
+
+  history   Show full interaction history
+            --name <name>  [--full]
+
+  delete    Permanently remove a session
+            --name <name>
+
+  batch     Spawn multiple sessions from JSON file
+            --file <path>  [--keep-alive]
+
+  cleanup   Remove old sessions
+            [--days <n>]
+
+  delegate  Smart task delegation with safety limits & auto-permission
+            --name <name>  --task <text>
+            [--model sonnet|opus|haiku]  [--preset read-only|review|edit|full|plan]
+            [--max-cost <usd>]  [--max-turns <n>]  [--no-safety]
+            [--context <text>]  [--work-dir <path>]
+            [--system-prompt <text>]  [--agent <name>]  [--json]
+
+  continue  Send follow-up to a delegated session
+            --name <name>  --message <text>  [--json]
+
+  setup     Register MCP server with Claude Code
+            [--global]  [--local]  [--uninstall]  [--migrate]
+            [--yes]  [--no-guide]
+
+TEAM COMMANDS:
+
+  team-roster      Show team members
+                   [--team <name>]
+
+  team-send        Send message to teammate
+                   --from <name>  --to <name>  --message <text>
+                   [--priority low|normal|high|urgent]  [--team <name>]
+
+  team-broadcast   Send to all teammates
+                   --from <name>  --message <text>
+                   [--priority low|normal|high|urgent]  [--team <name>]
+
+  team-inbox       Check inbox
+                   --name <name>  [--mark-read]  [--limit <n>]  [--team <name>]
+
+ARTIFACT COMMANDS:
+
+  artifact-publish Publish artifact
+                   --id <id>  --type <type>  --name <name>  --data <json>
+                   [--publisher <name>]  [--summary <text>]  [--tags <t1,t2>]
+                   [--derived-from <id1,id2>]  [--team <name>]
+
+  artifact-get     Read artifact
+                   --id <id>  [--version <n>]  [--team <name>]
+
+  artifact-list    List artifacts
+                   [--type <type>]  [--publisher <name>]  [--tag <tag>]  [--team <name>]
+
+CONTRACT COMMANDS:
+
+  contract-create  Create contract
+                   --id <id>  --title <text>  --assignee <name>  --assigner <name>
+                   [--description <text>]  [--priority low|normal|high|urgent]
+                   [--team <name>]
+
+  contract-list    List contracts
+                   [--status pending|ready|in_progress|completed|failed]
+                   [--assignee <name>]  [--assigner <name>]  [--team <name>]
+
+  contract-start   Start contract
+                   --id <id>  [--team <name>]
+
+PIPELINE COMMANDS:
+
+  pipeline-create  Create pipeline
+                   --id <id>  --rules <json>  [--owner <name>]  [--team <name>]
+
+  pipeline-list    List pipelines
+                   [--owner <name>]  [--team <name>]
+
+SNAPSHOT COMMANDS:
+
+  snapshot-create  Create snapshot
+                   --id <id>  [--label <text>]  [--description <text>]  [--team <name>]
+
+  snapshot-list    List snapshots
+                   [--team <name>]
+
+  snapshot-rollback Rollback to snapshot
+                    --id <id>  [--preserve-artifacts]  [--team <name>]
+
+SESSION CONTINUITY COMMANDS (Layer 0):
+
+  snapshot         Capture session snapshot
+                   --project-path <path>  [--session <name>]  [--task <summary>]
+                   [--files <file1,file2>]  [--questions <q1,q2>]
+
+  briefing         Generate session briefing
+                   --project-path <path>  [--max-tokens <n>]
+                   [--include-decisions]  [--include-patterns]
+
+  stale-check      Check if context is stale
+                   --project-path <path>
+
+  decisions        List decisions
+                   --project-path <path>  [--limit <n>]  [--tag <tag>]
+
+  patterns         List patterns
+                   --project-path <path>  [--tag <tag>]
+
+CONTINUITY AUTOMATION COMMANDS:
+
+  continuity-setup    Install hooks for automatic session continuity
+                      (writes to ~/.claude/settings.json)
+
+  continuity-unsetup  Remove continuity hooks from settings
+
+  continuity-reset    Delete ALL continuity data for a project
+                      --project-path <path>
+
+  continuity-prune    Keep only N most recent snapshots
+                      --project-path <path>  [--keep <n>]
+
+  continuity-status   Show continuity status at a glance
+                      --project-path <path>
+
+HOW IT WORKS:
+
+  Unlike the resume approach (new process per message), this system
+  uses Claude's stream-json protocol to keep ONE process alive per
+  session. Messages are piped in/out via stdin/stdout.
+
+  Benefits:
+    • No process restart overhead (~2-3s saved per message)
+    • No context reload (lower token cost)
+    • Instant follow-up responses
+    • True multi-turn conversations
+
+  Sessions are persisted to ~/.clearctx/ and can be
+  resumed even after the manager process exits (using --resume).
+
+EXAMPLES:
+
+  # Start a session, send prompt, keep alive for follow-ups
+  clearctx spawn --name fix-auth --prompt "Fix the auth bug in auth.service.ts"
+  clearctx send --name fix-auth --message "Also add input validation"
+  clearctx send --name fix-auth --message "Now write tests"
+  clearctx stop --name fix-auth
+
+  # One-shot: spawn, get result, stop automatically
+  clearctx spawn --name quick-task --prompt "Count TypeScript files" --stop
+
+  # Resume a stopped session days later
+  clearctx resume --name fix-auth --message "Actually, also handle edge cases"
+
+  # Fork to try a different approach
+  clearctx fork --name fix-auth --new-name fix-auth-v2 --message "Try JWT instead"
+
+  # Parallel batch
+  clearctx batch --file tasks.json
+
+  # Send to stopped session (auto-resumes)
+  clearctx send --name fix-auth --message "Add error handling"
+
+DELEGATE (Control Loop + Safety Net):
+
+  # Delegate a task with $1 cost limit, auto-permission handling
+  clearctx delegate --name fix-bug --task "Fix auth bug in auth.service.ts" --max-cost 1.00
+
+  # Delegate with read-only preset (no file edits allowed)
+  clearctx delegate --name review --task "Review code quality" --preset read-only
+
+  # Get structured JSON output (for programmatic use by parent Claude)
+  clearctx delegate --name task-1 --task "Count files" --model haiku --json
+
+  # Send follow-up to a delegated session
+  clearctx continue --name fix-bug --message "Also add input validation"
+
+  # Full control: delegate with context and custom limits
+  clearctx delegate --name big-task --task "Refactor auth" --model opus \\
+    --preset full --max-cost 5.00 --max-turns 100 \\
+    --context "Use JWT, not sessions"
+
+PRESETS (for delegate):
+
+  read-only   Can search/read files, no edits
+  review      Same as read-only (code review mode)
+  edit        Can read and edit files (default)
+  full        Full access (use with caution)
+  plan        Explore only, no execution
+
+INSTALL:
+
+  npm install -g clearctx
+  clearctx setup              # Register MCP server with Claude Code
+  # Then use: clearctx <command>
+  # Or: npx clearctx <command>
+`);
+}
+
+// ============================================================================
+// Main
+// ============================================================================
+async function main() {
+  const { command, flags } = parseArgs(process.argv);
+
+  // Create manager (shared across commands)
+  const mgr = new SessionManager();
+
+  const commands = {
+    spawn: () => cmdSpawn(mgr, flags),
+    send: () => cmdSend(mgr, flags),
+    input: () => cmdSend(mgr, flags), // Alias
+    resume: () => cmdResume(mgr, flags),
+    pause: () => cmdPause(mgr, flags),
+    fork: () => cmdFork(mgr, flags),
+    stop: () => cmdStop(mgr, flags),
+    kill: () => cmdKill(mgr, flags),
+    status: () => cmdStatus(mgr, flags),
+    output: () => cmdOutput(mgr, flags),
+    list: () => cmdList(mgr, flags),
+    history: () => cmdHistory(mgr, flags),
+    delete: () => cmdDelete(mgr, flags),
+    batch: () => cmdBatch(mgr, flags),
+    cleanup: () => cmdCleanup(mgr, flags),
+    delegate: () => cmdDelegate(mgr, flags),
+    continue: () => cmdContinue(mgr, flags),
+    'team-roster': () => cmdTeamRoster(flags),
+    'team-send': () => cmdTeamSend(flags),
+    'team-broadcast': () => cmdTeamBroadcast(flags),
+    'team-inbox': () => cmdTeamInbox(flags),
+    'artifact-publish': () => cmdArtifactPublish(flags),
+    'artifact-get': () => cmdArtifactGet(flags),
+    'artifact-list': () => cmdArtifactList(flags),
+    'contract-create': () => cmdContractCreate(flags),
+    'contract-list': () => cmdContractList(flags),
+    'contract-start': () => cmdContractStart(flags),
+    'pipeline-create': () => cmdPipelineCreate(flags),
+    'pipeline-list': () => cmdPipelineList(flags),
+    'snapshot-create': () => cmdSnapshotCreate(flags),
+    'snapshot-list': () => cmdSnapshotList(flags),
+    'snapshot-rollback': () => cmdSnapshotRollback(flags),
+    snapshot: () => cmdSnapshot(flags),
+    briefing: () => cmdBriefing(flags),
+    'stale-check': () => cmdStaleCheck(flags),
+    decisions: () => cmdDecisions(flags),
+    patterns: () => cmdPatterns(flags),
+    'continuity-setup': () => cmdContinuitySetup(),
+    'continuity-unsetup': () => cmdContinuityUnsetup(),
+    'continuity-reset': () => cmdContinuityReset(flags),
+    'continuity-prune': () => cmdContinuityPrune(flags),
+    'continuity-status': () => cmdContinuityStatus(flags),
+    setup: () => cmdSetup(flags),
+    help: () => cmdHelp(),
+  };
+
+  if (!commands[command]) {
+    console.error(`Unknown command: "${command}". Run "clearctx help" for usage.`);
+    process.exit(1);
+  }
+
+  try {
+    await commands[command]();
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+
+  // If any sessions are still alive, keep the process running
+  // so streaming sessions don't get killed
+  if (mgr.sessions.size > 0 && !['list', 'status', 'output', 'history', 'help', 'cleanup'].includes(command)) {
+    // Keep process alive until stopped
+    if (['spawn', 'send', 'resume', 'fork'].includes(command) && !flags.stop) {
+      // Don't hold the process — sessions survive in background
+      // We stop them gracefully and they can be resumed
+      mgr.stopAll();
+    }
+  }
+}
+
+main().catch(err => {
+  console.error(`Fatal: ${err.message}`);
+  process.exit(1);
+});