claude-multi-session 1.0.0 → 2.2.0

package/bin/cli.js

@@ -9,27 +9,52 @@
  *     or: npx claude-multi-session <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
- *   setup    Register MCP server with Claude Code
- *   help     Show this help
+ *   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');
 
@@ -488,6 +513,922 @@ function cmdCleanup(mgr, flags) {
   }
 }
 
+// ============================================================================
+// 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: ~/.claude-multi-session/continuity/{hash}/
+  const continuityDir = path.join(
+    os.homedir(),
+    '.claude-multi-session',
+    '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(`
 ╔══════════════════════════════════════════════════════════════╗
@@ -558,6 +1499,103 @@ COMMANDS:
             [--global]  [--local]  [--uninstall]
             [--guide]  [--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
@@ -659,6 +1697,31 @@ async function main() {
     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(),
   };