claude-multi-session 1.0.0 → 2.2.0

package/src/mcp-server.js

@@ -29,6 +29,23 @@ const readline = require('readline');
 const SessionManager = require('./manager');
 const Delegate = require('./delegate');
 
+// Team Hub imports — all the new Layer 1, 2, 3 modules
+const TeamHub = require('./team-hub');
+const ArtifactStore = require('./artifact-store');
+const ContractStore = require('./contract-store');
+const DependencyResolver = require('./dependency-resolver');
+const LineageGraph = require('./lineage-graph');
+const PipelineEngine = require('./pipeline-engine');
+const SnapshotEngine = require('./snapshot-engine');
+
+// Layer 0: Session Continuity Engine
+const SessionSnapshot = require('./session-snapshot');
+const DiffEngine = require('./diff-engine');
+const BriefingGenerator = require('./briefing-generator');
+const DecisionJournal = require('./decision-journal');
+const PatternRegistry = require('./pattern-registry');
+const StaleDetector = require('./stale-detector');
+
 // =============================================================================
 // Server State — persists across all tool calls
 // =============================================================================
@@ -41,6 +58,46 @@ const manager = new SessionManager();
 // Track delegates per session (for continue/finish/abort)
 const delegates = new Map();
 
+// Team Hub instances (created lazily on first team tool call)
+// These are cached per team name to avoid recreating them on every call
+let teamHub = null;
+let artifactStore = null;
+let contractStore = null;
+let resolver = null;
+let lineageGraph = null;
+let pipelineEngine = null;
+let snapshotEngine = null;
+let currentTeamName = null;
+
+/**
+ * Get or create Team Hub instances for a given team
+ * This function lazily creates the instances on first use
+ * and caches them for subsequent calls to the same team
+ *
+ * @param {string} teamName - Name of the team (default: 'default')
+ * @returns {Object} Object with all team instances
+ */
+function getTeamInstances(teamName = 'default') {
+  // If team name changed or instances not yet created, recreate them
+  if (!teamHub || currentTeamName !== teamName) {
+    teamHub = new TeamHub(teamName);
+    artifactStore = new ArtifactStore(teamName);
+    contractStore = new ContractStore(teamName);
+    resolver = new DependencyResolver(teamName);
+    lineageGraph = new LineageGraph(teamName);
+    pipelineEngine = new PipelineEngine(teamName);
+    snapshotEngine = new SnapshotEngine(teamName);
+
+    // Set pipeline engine reference in resolver (avoid circular dependency)
+    resolver.setPipelineEngine(pipelineEngine);
+
+    // Update the current team name
+    currentTeamName = teamName;
+  }
+
+  return { teamHub, artifactStore, contractStore, resolver, lineageGraph, pipelineEngine, snapshotEngine };
+}
+
 // =============================================================================
 // Tool Definitions — these appear in Claude's tool list
 // =============================================================================
@@ -311,155 +368,1002 @@ const TOOLS = [
       required: ['sessions'],
     },
   },
-];
-
-// =============================================================================
-// Tool Handlers — execute each tool and return result
-// =============================================================================
 
-/**
- * Execute a tool by name with given arguments.
- * Returns { content: [{ type: "text", text: "..." }], isError?: true }
- */
-async function executeTool(toolName, args) {
-  try {
-    switch (toolName) {
-      // ── Session Management ────────────────────────────────────────────
-      case 'spawn_session':
-        return await handleSpawn(args);
-      case 'send_message':
-        return await handleSend(args);
-      case 'resume_session':
-        return await handleResume(args);
-      case 'pause_session':
-        return handlePause(args);
-      case 'fork_session':
-        return await handleFork(args);
-      case 'stop_session':
-        return handleStop(args);
-      case 'kill_session':
-        return handleKill(args);
+  // ══════════════════════════════════════════════════════════════════════════
+  // TEAM HUB v2 — 32 new tools for team collaboration
+  // ══════════════════════════════════════════════════════════════════════════
 
-      // ── Information ───────────────────────────────────────────────────
-      case 'get_session_status':
-        return handleStatus(args);
-      case 'get_last_output':
-        return handleLastOutput(args);
-      case 'list_sessions':
-        return handleList(args);
-      case 'get_history':
-        return handleHistory(args);
-      case 'delete_session':
-        return handleDelete(args);
+  // ── Layer 1: Team Chat (8 tools) ────────────────────────────────────────
+  {
+    name: 'team_spawn',
+    description:
+      'Spawn a session with team system prompt injected. The session joins the team roster and ' +
+      'receives context about teammates, communication tools, and collaboration rules.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name:   { type: 'string', description: 'Unique session name (e.g. "db-dev", "api-dev")' },
+        prompt: { type: 'string', description: 'Initial prompt to send' },
+        role:   { type: 'string', description: 'Role in the team (e.g. "database", "backend", "QA")' },
+        task:   { type: 'string', description: 'Current task description' },
+        model:  { type: 'string', enum: ['sonnet', 'opus', 'haiku'], description: 'Model to use (default: sonnet)' },
+        team:   { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['name', 'prompt'],
+    },
+  },
 
-      // ── Delegate ──────────────────────────────────────────────────────
-      case 'delegate_task':
-        return await handleDelegate(args);
-      case 'continue_task':
-        return await handleContinue(args);
-      case 'finish_task':
-        return handleFinish(args);
-      case 'abort_task':
-        return handleAbort(args);
+  {
+    name: 'team_send_message',
+    description:
+      'Send a direct message to a specific teammate. The message appears in their inbox.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        from:     { type: 'string', description: 'Sender session name' },
+        to:       { type: 'string', description: 'Recipient session name' },
+        content:  { type: 'string', description: 'Message content' },
+        priority: { type: 'string', enum: ['low', 'normal', 'high', 'urgent'], description: 'Message priority (default: normal)' },
+        team:     { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['from', 'to', 'content'],
+    },
+  },
 
-      // ── Batch ─────────────────────────────────────────────────────────
-      case 'batch_spawn':
-        return await handleBatch(args);
+  {
+    name: 'team_broadcast',
+    description:
+      'Send a message to all team members. Appears in everyone\'s inbox.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        from:     { type: 'string', description: 'Sender session name' },
+        content:  { type: 'string', description: 'Message content' },
+        priority: { type: 'string', enum: ['low', 'normal', 'high', 'urgent'], description: 'Message priority (default: normal)' },
+        team:     { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['from', 'content'],
+    },
+  },
 
-      default:
-        return errorResult(`Unknown tool: ${toolName}`);
-    }
-  } catch (err) {
-    return errorResult(err.message);
-  }
-}
+  {
+    name: 'team_check_inbox',
+    description:
+      'Check inbox for unread messages. Sessions should check their inbox before starting work ' +
+      'and after major steps to stay coordinated with the team.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name:      { type: 'string', description: 'Session name whose inbox to check' },
+        mark_read: { type: 'boolean', description: 'Mark messages as read after retrieving (default: true)' },
+        limit:     { type: 'number', description: 'Max messages to return (default: 20)' },
+        team:      { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['name'],
+    },
+  },
 
-// ── Session Handlers ──────────────────────────────────────────────────────
+  {
+    name: 'team_ask',
+    description:
+      'Ask a teammate a question and WAIT for their reply. This is a blocking operation that polls ' +
+      'until the recipient replies or the timeout expires.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        from:     { type: 'string', description: 'Sender session name' },
+        to:       { type: 'string', description: 'Recipient session name' },
+        question: { type: 'string', description: 'Question to ask' },
+        timeout:  { type: 'number', description: 'Timeout in milliseconds (default: 60000 = 1 minute)' },
+        team:     { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['from', 'to', 'question'],
+    },
+  },
 
-async function handleSpawn(args) {
-  const { session, response } = await manager.spawn(args.name, {
-    prompt: args.prompt,
-    model: args.model,
-    workDir: args.work_dir,
-    permissionMode: args.permission_mode,
-    allowedTools: args.allowed_tools,
-    systemPrompt: args.system_prompt,
-    maxBudget: args.max_budget,
-    agent: args.agent,
-  });
+  {
+    name: 'team_reply',
+    description:
+      'Reply to a question you received. Use the message_id from the ask message in your inbox.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        from:       { type: 'string', description: 'Your session name' },
+        message_id: { type: 'string', description: 'ID of the ask message you\'re replying to' },
+        answer:     { type: 'string', description: 'Your answer to the question' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['from', 'message_id', 'answer'],
+    },
+  },
 
-  const result = {
-    session_name: session.name,
-    status: session.status,
-    model: session.model,
-    session_id: session.id,
-  };
+  {
+    name: 'team_roster',
+    description:
+      'View the current team roster with all members, their roles, status, and lastSeen times.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        team: { type: 'string', description: 'Team name (default: "default")' },
+      },
+    },
+  },
 
-  if (response) {
-    result.response = response.text;
-    result.cost = response.cost;
-    result.turns = response.turns;
-    result.duration_ms = response.duration;
-  } else {
-    result.message = 'Session started (idle). Send a message with send_message.';
-  }
+  {
+    name: 'team_update_status',
+    description:
+      'Update your own status in the team roster. Use this to keep teammates informed of what you\'re doing.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name:   { type: 'string', description: 'Your session name' },
+        status: { type: 'string', enum: ['active', 'busy', 'idle', 'offline'], description: 'Your current status' },
+        task:   { type: 'string', description: 'What you\'re currently working on' },
+        role:   { type: 'string', description: 'Your role (if it changed)' },
+        team:   { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['name'],
+    },
+  },
 
-  return textResult(JSON.stringify(result, null, 2));
-}
+  // ── Layer 2: Artifacts (4 tools) ─────────────────────────────────────────
+  {
+    name: 'artifact_publish',
+    description:
+      'Publish a structured artifact (versioned, immutable). This is how sessions exchange structured ' +
+      'data like API contracts, schemas, test results. Publishing triggers dependency resolution and pipelines.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        artifactId:   { type: 'string', description: 'Unique artifact ID (e.g. "api-contract-user-auth")' },
+        type:         { type: 'string', description: 'Artifact type (e.g. "api-contract", "schema-change", "test-results", "custom")' },
+        name:         { type: 'string', description: 'Human-readable name' },
+        data:         { type: 'object', description: 'The artifact data payload (validated against schema for well-known types)' },
+        summary:      { type: 'string', description: 'Brief summary of this version' },
+        tags:         { type: 'array', items: { type: 'string' }, description: 'Tags for filtering (e.g. ["auth", "v1"])' },
+        publisher:    { type: 'string', description: 'Session name publishing this artifact' },
+        derivedFrom:  { type: 'array', items: { type: 'string' }, description: 'Array of artifact IDs this was derived from (for lineage)' },
+        team:         { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['artifactId', 'type', 'name', 'data'],
+    },
+  },
 
-async function handleSend(args) {
-  // Auto-resume if session is not alive
-  if (!manager.sessions.has(args.name)) {
-    log(`Session "${args.name}" not alive. Auto-resuming...`);
-    const response = await manager.resume(args.name, args.message);
-    return textResult(JSON.stringify({
-      session_name: args.name,
-      auto_resumed: true,
-      response: response?.text || '',
-      cost: response?.cost || 0,
-      turns: response?.turns || 0,
-      duration_ms: response?.duration || 0,
-    }, null, 2));
-  }
+  {
+    name: 'artifact_get',
+    description:
+      'Read an artifact (latest version or specific version).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        artifactId: { type: 'string', description: 'Artifact ID to retrieve' },
+        version:    { type: 'number', description: 'Specific version number (omit for latest)' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['artifactId'],
+    },
+  },
 
-  const response = await manager.send(args.name, args.message);
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    response: response.text,
-    cost: response.cost,
-    turns: response.turns,
-    duration_ms: response.duration,
-  }, null, 2));
-}
+  {
+    name: 'artifact_list',
+    description:
+      'List all artifacts with optional filters by type, publisher, or tag.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type:      { type: 'string', description: 'Filter by artifact type' },
+        publisher: { type: 'string', description: 'Filter by publisher session name' },
+        tag:       { type: 'string', description: 'Filter by tag' },
+        team:      { type: 'string', description: 'Team name (default: "default")' },
+      },
+    },
+  },
 
-async function handleResume(args) {
-  const response = await manager.resume(args.name, args.message);
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    status: 'resumed',
-    response: response?.text || null,
-    cost: response?.cost || 0,
-    turns: response?.turns || 0,
-  }, null, 2));
-}
+  {
+    name: 'artifact_history',
+    description:
+      'View the version history of an artifact.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        artifactId: { type: 'string', description: 'Artifact ID' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['artifactId'],
+    },
+  },
 
-function handlePause(args) {
-  manager.pause(args.name);
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    status: 'paused',
-  }, null, 2));
-}
+  // ── Layer 2: Contracts (8 tools) ─────────────────────────────────────────
+  {
+    name: 'contract_create',
+    description:
+      'Create a task contract and assign it to ANY teammate (peer-to-peer). Contracts define work with ' +
+      'inputs, outputs, dependencies, and acceptance criteria. The dependency resolver automatically advances ' +
+      'contracts when their dependencies are satisfied.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        contractId:         { type: 'string', description: 'Unique contract ID (e.g. "build-auth-api")' },
+        title:              { type: 'string', description: 'Human-readable title' },
+        assignee:           { type: 'string', description: 'Session name who will do the work' },
+        assigner:           { type: 'string', description: 'Session name who created the contract' },
+        description:        { type: 'string', description: 'Detailed description of the work' },
+        inputs:             { type: 'object', description: 'Input artifacts and context for the assignee' },
+        expectedOutputs:    { type: 'array', description: 'What the assignee should produce' },
+        dependencies:       { type: 'array', description: 'Contract/artifact dependencies that must be satisfied first' },
+        acceptanceCriteria: { type: 'array', description: 'How we know the work is done' },
+        autoComplete:       { type: 'boolean', description: 'Auto-complete when criteria met (default: true)' },
+        timeoutMs:          { type: 'number', description: 'Timeout in milliseconds (null = no timeout)' },
+        maxRetries:         { type: 'number', description: 'Maximum reopen attempts (default: 3)' },
+        priority:           { type: 'string', enum: ['low', 'normal', 'high', 'urgent'], description: 'Priority level (default: normal)' },
+        team:               { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['contractId', 'title', 'assignee', 'assigner'],
+    },
+  },
 
-async function handleFork(args) {
-  const { session, response } = await manager.fork(args.name, args.new_name, {
-    message: args.message,
-    model: args.model,
-  });
+  {
+    name: 'contract_start',
+    description:
+      'Start working on a contract. Transitions status from ready to in_progress and returns the contract ' +
+      'details with resolved input artifacts.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        contractId: { type: 'string', description: 'Contract ID to start' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['contractId'],
+    },
+  },
 
-  return textResult(JSON.stringify({
-    source: args.name,
-    forked_as: args.new_name,
+  {
+    name: 'contract_complete',
+    description:
+      'Mark a contract as completed. This triggers dependency resolution for downstream contracts and ' +
+      'evaluates reactive pipelines.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        contractId:         { type: 'string', description: 'Contract ID to complete' },
+        summary:            { type: 'string', description: 'Summary of what was done' },
+        publishedArtifacts: { type: 'array', items: { type: 'string' }, description: 'Artifact IDs that were published' },
+        team:               { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['contractId'],
+    },
+  },
+
+  {
+    name: 'contract_fail',
+    description:
+      'Mark a contract as failed. Notifies the assigner and triggers dependency resolution.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        contractId: { type: 'string', description: 'Contract ID to fail' },
+        reason:     { type: 'string', description: 'Why the contract failed' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['contractId', 'reason'],
+    },
+  },
+
+  {
+    name: 'contract_reopen',
+    description:
+      'Reopen a failed or completed contract for retry. Increments retryCount and transitions back to ready. ' +
+      'Rejects if retryCount >= maxRetries.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        contractId: { type: 'string', description: 'Contract ID to reopen' },
+        reason:     { type: 'string', description: 'Why we are reopening' },
+        newInputs:  { type: 'object', description: 'Optional updated inputs' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['contractId'],
+    },
+  },
+
+  {
+    name: 'contract_get',
+    description:
+      'Get full details of a contract including status, inputs, outputs, dependencies, and acceptance criteria.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        contractId: { type: 'string', description: 'Contract ID' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['contractId'],
+    },
+  },
+
+  {
+    name: 'contract_list',
+    description:
+      'List all contracts with optional filters by status, assignee, or assigner.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status:   { type: 'string', enum: ['pending', 'ready', 'in_progress', 'completed', 'failed'], description: 'Filter by status' },
+        assignee: { type: 'string', description: 'Filter by assignee session name' },
+        assigner: { type: 'string', description: 'Filter by assigner session name' },
+        team:     { type: 'string', description: 'Team name (default: "default")' },
+      },
+    },
+  },
+
+  {
+    name: 'contract_reassign',
+    description:
+      'Reassign a contract to a different session.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        contractId:  { type: 'string', description: 'Contract ID' },
+        newAssignee: { type: 'string', description: 'New assignee session name' },
+        team:        { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['contractId', 'newAssignee'],
+    },
+  },
+
+  // ── Layer 3: Lineage (4 tools) ───────────────────────────────────────────
+  {
+    name: 'artifact_lineage',
+    description:
+      'Query the artifact lineage graph. Upstream shows what this was derived from. Downstream shows what ' +
+      'depends on this. Returns the full chain recursively.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        artifactId: { type: 'string', description: 'Artifact ID' },
+        direction:  { type: 'string', enum: ['upstream', 'downstream'], description: 'Which direction to traverse' },
+        version:    { type: 'number', description: 'Specific version (omit for latest)' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['artifactId', 'direction'],
+    },
+  },
+
+  {
+    name: 'artifact_impact',
+    description:
+      'Analyze the impact radius: "If I change this artifact, what downstream artifacts and contracts break?" ' +
+      'Returns all affected artifacts and contracts with impact depth.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        artifactId: { type: 'string', description: 'Artifact ID to analyze' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['artifactId'],
+    },
+  },
+
+  {
+    name: 'artifact_stale',
+    description:
+      'Find all stale artifacts — artifacts derived from sources that have been updated to newer versions. ' +
+      'This helps identify what needs to be regenerated after changes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        team: { type: 'string', description: 'Team name (default: "default")' },
+      },
+    },
+  },
+
+  {
+    name: 'team_audit',
+    description:
+      'Get the full audit trail for an artifact: who created it, from what inputs, under which contract, ' +
+      'at what time. Follows the provenance chain upstream to the root.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        artifactId: { type: 'string', description: 'Artifact ID' },
+        version:    { type: 'number', description: 'Specific version (omit for latest)' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['artifactId'],
+    },
+  },
+
+  // ── Layer 3: Pipelines (4 tools) ─────────────────────────────────────────
+  {
+    name: 'pipeline_create',
+    description:
+      'Create a reactive pipeline: "When X happens, automatically do Y." Pipelines contain trigger/condition/action ' +
+      'rules that fire when artifacts are published or contracts change status. This enables self-healing CI loops.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pipelineId: { type: 'string', description: 'Unique pipeline ID (e.g. "ci-loop")' },
+        rules:      { type: 'array', description: 'Array of trigger/condition/action rules' },
+        owner:      { type: 'string', description: 'Session name who owns this pipeline' },
+        enabled:    { type: 'boolean', description: 'Whether pipeline is active (default: true)' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['pipelineId', 'rules'],
+    },
+  },
+
+  {
+    name: 'pipeline_list',
+    description:
+      'List all pipelines with optional filter by owner. Shows execution counts and last fired times.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        owner: { type: 'string', description: 'Filter by owner session name' },
+        team:  { type: 'string', description: 'Team name (default: "default")' },
+      },
+    },
+  },
+
+  {
+    name: 'pipeline_pause',
+    description:
+      'Pause a pipeline (disable without deleting). The pipeline stops evaluating rules.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pipelineId: { type: 'string', description: 'Pipeline ID to pause' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['pipelineId'],
+    },
+  },
+
+  {
+    name: 'pipeline_resume',
+    description:
+      'Resume a paused pipeline. It will start evaluating rules again on new events.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pipelineId: { type: 'string', description: 'Pipeline ID to resume' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['pipelineId'],
+    },
+  },
+
+  // ── Layer 3: Snapshots (4 tools) ─────────────────────────────────────────
+  {
+    name: 'team_snapshot',
+    description:
+      'Capture a snapshot of the entire team state (contracts, artifacts, pipelines). Use this before ' +
+      'risky operations or at major milestones.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        snapshotId:  { type: 'string', description: 'Unique snapshot ID (e.g. "pre-work", "all-complete")' },
+        label:       { type: 'string', description: 'Short label for this snapshot' },
+        description: { type: 'string', description: 'Longer description' },
+        team:        { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['snapshotId'],
+    },
+  },
+
+  {
+    name: 'team_snapshot_list',
+    description:
+      'List all snapshots with timestamp, label, and summary of what was captured.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        team: { type: 'string', description: 'Team name (default: "default")' },
+      },
+    },
+  },
+
+  {
+    name: 'team_rollback',
+    description:
+      'Rollback to a previous snapshot. Resets contract and pipeline state. Artifact version files are ' +
+      'preserved on disk but can be marked as rolled-back in the index.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        snapshotId:        { type: 'string', description: 'Snapshot ID to rollback to' },
+        preserveArtifacts: { type: 'boolean', description: 'Keep artifact index entries (default: true)' },
+        team:              { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['snapshotId'],
+    },
+  },
+
+  {
+    name: 'team_replay',
+    description:
+      'Replay from a snapshot with optional overrides to contract inputs. Rollbacks to the snapshot, ' +
+      'applies modifications, then re-triggers dependency resolution. Use this to test "what if" scenarios.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        snapshotId: { type: 'string', description: 'Snapshot ID to replay from' },
+        overrides:  { type: 'object', description: 'Map of contractId -> { inputs: {...} } to override' },
+        team:       { type: 'string', description: 'Team name (default: "default")' },
+      },
+      required: ['snapshotId'],
+    },
+  },
+
+  // ── Session Continuity (Layer 0) ──────────────────────────────────────
+  {
+    name: 'continuity_snapshot',
+    description: 'Capture a lightweight snapshot of the current project state (git state, file tree, working context). Use on session end.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        sessionName: { type: 'string', description: 'Name of the session capturing this snapshot' },
+        taskSummary: { type: 'string', description: 'What you were working on' },
+        activeFiles: { type: 'array', items: { type: 'string' }, description: 'Files read/edited this session' },
+        openQuestions: { type: 'array', items: { type: 'string' }, description: 'Unresolved questions' }
+      },
+      required: ['projectPath', 'sessionName']
+    }
+  },
+  {
+    name: 'continuity_briefing',
+    description: 'Generate a diff-aware session briefing. Shows what changed since last session, previous context, decisions, patterns. Use on session start.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        maxTokens: { type: 'number', description: 'Max briefing length in characters (default: 4000)' },
+        includeDecisions: { type: 'boolean', description: 'Include recent decisions (default: true)' },
+        includePatterns: { type: 'boolean', description: 'Include pattern rules (default: true)' }
+      },
+      required: ['projectPath']
+    }
+  },
+  {
+    name: 'continuity_status',
+    description: 'Quick status check: what changed since the last snapshot. Lighter than a full briefing.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' }
+      },
+      required: ['projectPath']
+    }
+  },
+  {
+    name: 'continuity_diff',
+    description: 'Detailed diff between two snapshots or between latest snapshot and current state.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        fromSnapshot: { type: 'string', description: 'Source snapshot ID (default: latest)' },
+        toSnapshot: { type: 'string', description: 'Target snapshot ID (default: current state)' }
+      },
+      required: ['projectPath']
+    }
+  },
+  {
+    name: 'continuity_history',
+    description: 'List all snapshots for a project, newest first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        limit: { type: 'number', description: 'Max snapshots to return (default: 20)' }
+      },
+      required: ['projectPath']
+    }
+  },
+  {
+    name: 'continuity_stale_check',
+    description: 'Check if your previous session context is stale. Shows warnings about changed files, branch switches, etc.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' }
+      },
+      required: ['projectPath']
+    }
+  },
+  {
+    name: 'decision_add',
+    description: 'Record an architectural or design decision in the project decision journal.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        decision: { type: 'string', description: 'The decision made (e.g., "Use bcrypt over argon2")' },
+        reason: { type: 'string', description: 'Why this decision was made' },
+        files: { type: 'array', items: { type: 'string' }, description: 'Related file paths' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Tags for categorization' }
+      },
+      required: ['projectPath', 'decision']
+    }
+  },
+  {
+    name: 'decision_list',
+    description: 'List recent decisions from the project decision journal.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        limit: { type: 'number', description: 'Max decisions to return (default: 50)' },
+        tag: { type: 'string', description: 'Filter by tag' }
+      },
+      required: ['projectPath']
+    }
+  },
+  {
+    name: 'decision_search',
+    description: 'Search decisions by keyword across decision text, reasoning, and context.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        keyword: { type: 'string', description: 'Search keyword (case-insensitive)' }
+      },
+      required: ['projectPath', 'keyword']
+    }
+  },
+  {
+    name: 'pattern_add',
+    description: 'Add a coding pattern rule. Patterns are corrections that persist across sessions (e.g., "Always use enum constants for status comparisons").',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        rule: { type: 'string', description: 'The pattern rule' },
+        context: { type: 'string', description: 'Where this pattern applies (e.g., "auth module")' },
+        example: { type: 'string', description: 'Code example or explanation' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Tags for categorization' }
+      },
+      required: ['projectPath', 'rule']
+    }
+  },
+  {
+    name: 'pattern_list',
+    description: 'List all coding patterns for a project.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        tag: { type: 'string', description: 'Filter by tag' }
+      },
+      required: ['projectPath']
+    }
+  },
+  {
+    name: 'pattern_remove',
+    description: 'Remove a coding pattern by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Absolute path to the project directory' },
+        patternId: { type: 'string', description: 'Pattern ID to remove' }
+      },
+      required: ['projectPath', 'patternId']
+    }
+  }
+];
+
+// =============================================================================
+// Tool Handlers — execute each tool and return result
+// =============================================================================
+
+/**
+ * Execute a tool by name with given arguments.
+ * Returns { content: [{ type: "text", text: "..." }], isError?: true }
+ */
+async function executeTool(toolName, args) {
+  try {
+    switch (toolName) {
+      // ── Session Management ────────────────────────────────────────────
+      case 'spawn_session':
+        return await handleSpawn(args);
+      case 'send_message':
+        return await handleSend(args);
+      case 'resume_session':
+        return await handleResume(args);
+      case 'pause_session':
+        return handlePause(args);
+      case 'fork_session':
+        return await handleFork(args);
+      case 'stop_session':
+        return handleStop(args);
+      case 'kill_session':
+        return handleKill(args);
+
+      // ── Information ───────────────────────────────────────────────────
+      case 'get_session_status':
+        return handleStatus(args);
+      case 'get_last_output':
+        return handleLastOutput(args);
+      case 'list_sessions':
+        return handleList(args);
+      case 'get_history':
+        return handleHistory(args);
+      case 'delete_session':
+        return handleDelete(args);
+
+      // ── Delegate ──────────────────────────────────────────────────────
+      case 'delegate_task':
+        return await handleDelegate(args);
+      case 'continue_task':
+        return await handleContinue(args);
+      case 'finish_task':
+        return handleFinish(args);
+      case 'abort_task':
+        return handleAbort(args);
+
+      // ── Batch ─────────────────────────────────────────────────────────
+      case 'batch_spawn':
+        return await handleBatch(args);
+
+      // ══════════════════════════════════════════════════════════════════
+      // Team Hub Tools
+      // ══════════════════════════════════════════════════════════════════
+
+      // ── Layer 1: Chat ─────────────────────────────────────────────────
+      case 'team_spawn':
+        return await handleTeamSpawn(args);
+      case 'team_send_message':
+        return handleTeamSendMessage(args);
+      case 'team_broadcast':
+        return handleTeamBroadcast(args);
+      case 'team_check_inbox':
+        return handleTeamCheckInbox(args);
+      case 'team_ask':
+        return await handleTeamAsk(args);
+      case 'team_reply':
+        return handleTeamReply(args);
+      case 'team_roster':
+        return handleTeamRoster(args);
+      case 'team_update_status':
+        return handleTeamUpdateStatus(args);
+
+      // ── Layer 2: Artifacts ────────────────────────────────────────────
+      case 'artifact_publish':
+        return await handleArtifactPublish(args);
+      case 'artifact_get':
+        return handleArtifactGet(args);
+      case 'artifact_list':
+        return handleArtifactList(args);
+      case 'artifact_history':
+        return handleArtifactHistory(args);
+
+      // ── Layer 2: Contracts ────────────────────────────────────────────
+      case 'contract_create':
+        return await handleContractCreate(args);
+      case 'contract_start':
+        return handleContractStart(args);
+      case 'contract_complete':
+        return await handleContractComplete(args);
+      case 'contract_fail':
+        return await handleContractFail(args);
+      case 'contract_reopen':
+        return await handleContractReopen(args);
+      case 'contract_get':
+        return handleContractGet(args);
+      case 'contract_list':
+        return handleContractList(args);
+      case 'contract_reassign':
+        return handleContractReassign(args);
+
+      // ── Layer 3: Lineage ──────────────────────────────────────────────
+      case 'artifact_lineage':
+        return handleArtifactLineage(args);
+      case 'artifact_impact':
+        return handleArtifactImpact(args);
+      case 'artifact_stale':
+        return handleArtifactStale(args);
+      case 'team_audit':
+        return handleTeamAudit(args);
+
+      // ── Layer 3: Pipelines ────────────────────────────────────────────
+      case 'pipeline_create':
+        return handlePipelineCreate(args);
+      case 'pipeline_list':
+        return handlePipelineList(args);
+      case 'pipeline_pause':
+        return handlePipelinePause(args);
+      case 'pipeline_resume':
+        return handlePipelineResume(args);
+
+      // ── Layer 3: Snapshots ────────────────────────────────────────────
+      case 'team_snapshot':
+        return handleTeamSnapshot(args);
+      case 'team_snapshot_list':
+        return handleTeamSnapshotList(args);
+      case 'team_rollback':
+        return handleTeamRollback(args);
+      case 'team_replay':
+        return await handleTeamReplay(args);
+
+      // ── Session Continuity (Layer 0) handlers ──
+      case 'continuity_snapshot': {
+        const snap = new SessionSnapshot(args.projectPath);
+        const result = snap.capture(args.sessionName, {
+          activeFiles: args.activeFiles,
+          taskSummary: args.taskSummary,
+          openQuestions: args.openQuestions
+        });
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'continuity_briefing': {
+        const gen = new BriefingGenerator(args.projectPath);
+        const result = gen.generate({
+          maxTokens: args.maxTokens,
+          includeDecisions: args.includeDecisions,
+          includePatterns: args.includePatterns
+        });
+        return textResult(result.markdown);
+      }
+      case 'continuity_status': {
+        const diff = new DiffEngine(args.projectPath);
+        const result = diff.diffFromLatest();
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'continuity_diff': {
+        const diff = new DiffEngine(args.projectPath);
+        let result;
+        if (args.fromSnapshot && args.toSnapshot) {
+          result = diff.diffBetween(args.fromSnapshot, args.toSnapshot);
+        } else {
+          result = diff.diffFromLatest();
+        }
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'continuity_history': {
+        const snap = new SessionSnapshot(args.projectPath);
+        const result = snap.list(args.limit || 20);
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'continuity_stale_check': {
+        const detector = new StaleDetector(args.projectPath);
+        const result = detector.check();
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'decision_add': {
+        const journal = new DecisionJournal(args.projectPath);
+        const result = journal.add({
+          decision: args.decision,
+          reason: args.reason,
+          files: args.files,
+          tags: args.tags
+        });
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'decision_list': {
+        const journal = new DecisionJournal(args.projectPath);
+        const result = journal.list({ limit: args.limit, tag: args.tag });
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'decision_search': {
+        const journal = new DecisionJournal(args.projectPath);
+        const result = journal.search(args.keyword);
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'pattern_add': {
+        const registry = new PatternRegistry(args.projectPath);
+        const result = registry.add({
+          rule: args.rule,
+          context: args.context,
+          example: args.example,
+          tags: args.tags
+        });
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'pattern_list': {
+        const registry = new PatternRegistry(args.projectPath);
+        const result = registry.list({ tag: args.tag });
+        return textResult(JSON.stringify(result, null, 2));
+      }
+      case 'pattern_remove': {
+        const registry = new PatternRegistry(args.projectPath);
+        const result = registry.remove(args.patternId);
+        return textResult(JSON.stringify(result, null, 2));
+      }
+
+      default:
+        return errorResult(`Unknown tool: ${toolName}`);
+    }
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+// ── Session Handlers ──────────────────────────────────────────────────────
+
+async function handleSpawn(args) {
+  const { session, response } = await manager.spawn(args.name, {
+    prompt: args.prompt,
+    model: args.model,
+    workDir: args.work_dir,
+    permissionMode: args.permission_mode,
+    allowedTools: args.allowed_tools,
+    systemPrompt: args.system_prompt,
+    maxBudget: args.max_budget,
+    agent: args.agent,
+  });
+
+  const result = {
+    session_name: session.name,
+    status: session.status,
+    model: session.model,
+    session_id: session.id,
+  };
+
+  if (response) {
+    result.response = response.text;
+    result.cost = response.cost;
+    result.turns = response.turns;
+    result.duration_ms = response.duration;
+  } else {
+    result.message = 'Session started (idle). Send a message with send_message.';
+  }
+
+  return textResult(JSON.stringify(result, null, 2));
+}
+
+async function handleSend(args) {
+  // Auto-resume if session is not alive
+  if (!manager.sessions.has(args.name)) {
+    log(`Session "${args.name}" not alive. Auto-resuming...`);
+    const response = await manager.resume(args.name, args.message);
+    return textResult(JSON.stringify({
+      session_name: args.name,
+      auto_resumed: true,
+      response: response?.text || '',
+      cost: response?.cost || 0,
+      turns: response?.turns || 0,
+      duration_ms: response?.duration || 0,
+    }, null, 2));
+  }
+
+  const response = await manager.send(args.name, args.message);
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    response: response.text,
+    cost: response.cost,
+    turns: response.turns,
+    duration_ms: response.duration,
+  }, null, 2));
+}
+
+async function handleResume(args) {
+  const response = await manager.resume(args.name, args.message);
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    status: 'resumed',
+    response: response?.text || null,
+    cost: response?.cost || 0,
+    turns: response?.turns || 0,
+  }, null, 2));
+}
+
+function handlePause(args) {
+  manager.pause(args.name);
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    status: 'paused',
+  }, null, 2));
+}
+
+async function handleFork(args) {
+  const { session, response } = await manager.fork(args.name, args.new_name, {
+    message: args.message,
+    model: args.model,
+  });
+
+  return textResult(JSON.stringify({
+    source: args.name,
+    forked_as: args.new_name,
     status: session.status,
     response: response?.text || '',
     cost: response?.cost || 0,
@@ -467,174 +1371,1064 @@ async function handleFork(args) {
   }, null, 2));
 }
 
-function handleStop(args) {
-  manager.stop(args.name);
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    status: 'stopped',
-    message: 'Session stopped. Can be resumed later with resume_session.',
-  }, null, 2));
+function handleStop(args) {
+  manager.stop(args.name);
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    status: 'stopped',
+    message: 'Session stopped. Can be resumed later with resume_session.',
+  }, null, 2));
+}
+
+function handleKill(args) {
+  manager.kill(args.name);
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    status: 'killed',
+  }, null, 2));
+}
+
+// ── Information Handlers ──────────────────────────────────────────────────
+
+function handleStatus(args) {
+  const info = manager.status(args.name);
+  return textResult(JSON.stringify({
+    name: info.name,
+    status: info.status,
+    model: info.model,
+    session_id: info.claudeSessionId || info.id,
+    work_dir: info.workDir,
+    total_cost: info.totalCostUsd || 0,
+    total_turns: info.totalTurns || 0,
+    interactions: info.interactionCount || (info.interactions || []).length,
+    pid: info.pid || null,
+  }, null, 2));
+}
+
+function handleLastOutput(args) {
+  const last = manager.lastOutput(args.name);
+  if (!last) {
+    return textResult(JSON.stringify({ session_name: args.name, output: null, message: 'No output yet.' }, null, 2));
+  }
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    prompt: last.prompt,
+    response: last.response,
+    cost: last.cost,
+    timestamp: last.timestamp,
+  }, null, 2));
+}
+
+function handleList(args) {
+  const sessions = manager.list(args.status);
+  const summary = sessions.map(s => ({
+    name: s.name,
+    status: s.status,
+    model: s.model,
+    total_cost: s.totalCostUsd || 0,
+    total_turns: s.totalTurns || 0,
+    interactions: s.interactionCount || (s.interactions || []).length,
+  }));
+  return textResult(JSON.stringify({ total: summary.length, sessions: summary }, null, 2));
+}
+
+function handleHistory(args) {
+  const hist = manager.history(args.name);
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    interaction_count: hist.length,
+    interactions: hist.map((h, i) => ({
+      index: i,
+      prompt: h.prompt,
+      response: h.response,
+      cost: h.cost,
+      turns: h.turns,
+      duration_ms: h.duration,
+      timestamp: h.timestamp,
+    })),
+  }, null, 2));
+}
+
+function handleDelete(args) {
+  manager.delete(args.name);
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    status: 'deleted',
+    message: 'Session permanently deleted.',
+  }, null, 2));
+}
+
+// ── Delegate Handlers ─────────────────────────────────────────────────────
+
+async function handleDelegate(args) {
+  // Create or reuse a delegate instance for this session
+  let delegate = delegates.get(args.name);
+  if (!delegate) {
+    delegate = new Delegate(manager);
+    delegates.set(args.name, delegate);
+  }
+
+  const result = await delegate.run(args.name, {
+    task: args.task,
+    model: args.model,
+    preset: args.preset,
+    workDir: args.work_dir,
+    maxCost: args.max_cost,
+    maxTurns: args.max_turns,
+    context: args.context,
+    systemPrompt: args.system_prompt,
+    agent: args.agent,
+    safety: args.safety,
+  });
+
+  return textResult(JSON.stringify(result, null, 2));
+}
+
+async function handleContinue(args) {
+  // Get or create delegate for this session
+  let delegate = delegates.get(args.name);
+  if (!delegate) {
+    delegate = new Delegate(manager);
+    delegates.set(args.name, delegate);
+  }
+
+  const result = await delegate.continue(args.name, args.message);
+  return textResult(JSON.stringify(result, null, 2));
+}
+
+function handleFinish(args) {
+  const delegate = delegates.get(args.name);
+  if (delegate) {
+    delegate.finish(args.name);
+    delegates.delete(args.name);
+  } else {
+    // No delegate — just stop the session
+    try { manager.stop(args.name); } catch (e) {}
+  }
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    status: 'finished',
+    message: 'Task finished. Session stopped.',
+  }, null, 2));
+}
+
+function handleAbort(args) {
+  const delegate = delegates.get(args.name);
+  if (delegate) {
+    delegate.abort(args.name);
+    delegates.delete(args.name);
+  } else {
+    try { manager.kill(args.name); } catch (e) {}
+  }
+  return textResult(JSON.stringify({
+    session_name: args.name,
+    status: 'aborted',
+    message: 'Task aborted. Session killed.',
+  }, null, 2));
+}
+
+// ── Batch Handler ─────────────────────────────────────────────────────────
+
+async function handleBatch(args) {
+  const results = await manager.batch(args.sessions);
+  const summary = results.map(r => ({
+    name: r.session?.name || 'unknown',
+    status: r.error ? 'failed' : 'completed',
+    response: r.response?.text || null,
+    cost: r.response?.cost || 0,
+    error: r.error || null,
+  }));
+  return textResult(JSON.stringify({ total: summary.length, results: summary }, null, 2));
+}
+
+// =============================================================================
+// Team Hub Handlers — Layer 1, 2, 3
+// =============================================================================
+
+// ── Layer 1: Team Chat Handlers ───────────────────────────────────────────
+
+/**
+ * Build team system prompt from roster
+ * This gets injected into team_spawn sessions to teach them about collaboration
+ */
+function buildTeamSystemPrompt(name, role, roster) {
+  const teammates = roster
+    .filter(m => m.name !== name)
+    .map(m => `- ${m.name}: ${m.role} (${m.status}) — ${m.task || 'no task'}`)
+    .join('\n');
+
+  return `
+## TEAM COLLABORATION
+
+You are "${name}" — part of a team. Your role: ${role || 'team member'}.
+
+Your teammates:
+${teammates || '(No other teammates yet)'}
+
+Communication tools:
+- team_check_inbox — Check BEFORE starting work and AFTER major steps
+- team_send_message / team_broadcast — Send updates
+- team_ask / team_reply — Ask questions, reply to questions
+- team_roster / team_update_status — View/update team state
+
+Artifact tools (structured data exchange):
+- artifact_publish — Publish structured outputs (API contracts, schemas, test results)
+- artifact_get / artifact_list — Read artifacts from teammates
+- artifact_lineage / artifact_impact — Query data provenance and impact radius
+- contract_create — Create a contract and assign it to ANY teammate (not just orchestrator)
+- contract_start — Start working on assigned contracts
+- contract_complete / contract_fail — Report results
+
+Rules:
+- Check inbox before starting work
+- When you finish something, publish it as an artifact (not a chat message)
+- When you receive a question (type: "ask"), reply IMMEDIATELY
+- If you discover work that another session should do, CREATE A CONTRACT for them — don't just send a chat message
+- Be specific (include file paths, function names, exact schemas)
+`;
+}
+
+async function handleTeamSpawn(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { teamHub } = getTeamInstances(teamName);
+
+    // Join the team roster
+    teamHub.joinTeam(args.name, {
+      role: args.role || 'team member',
+      task: args.task || 'Starting up',
+      model: args.model || 'sonnet',
+    });
+
+    // Get roster to build system prompt
+    const roster = teamHub.getRoster();
+
+    // Build team system prompt
+    const teamSystemPrompt = buildTeamSystemPrompt(args.name, args.role, roster);
+
+    // Spawn the session with team system prompt appended
+    const { session, response } = await manager.spawn(args.name, {
+      prompt: args.prompt,
+      model: args.model,
+      systemPrompt: teamSystemPrompt,
+    });
+
+    const result = {
+      session_name: session.name,
+      status: session.status,
+      model: session.model,
+      team: teamName,
+      role: args.role,
+      roster_size: roster.length,
+    };
+
+    if (response) {
+      result.response = response.text;
+      result.cost = response.cost;
+      result.turns = response.turns;
+    }
+
+    return textResult(JSON.stringify(result, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleTeamSendMessage(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { teamHub } = getTeamInstances(teamName);
+
+    teamHub.sendDirect(args.from, args.to, args.content, {
+      priority: args.priority || 'normal',
+    });
+
+    return textResult(JSON.stringify({
+      status: 'sent',
+      from: args.from,
+      to: args.to,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleTeamBroadcast(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { teamHub } = getTeamInstances(teamName);
+
+    const count = teamHub.sendBroadcast(args.from, args.content, {
+      priority: args.priority || 'normal',
+    });
+
+    return textResult(JSON.stringify({
+      status: 'broadcast',
+      from: args.from,
+      recipients: count,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleTeamCheckInbox(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { teamHub } = getTeamInstances(teamName);
+
+    const messages = teamHub.getInbox(args.name, {
+      markRead: args.mark_read !== false,
+      limit: args.limit || 20,
+    });
+
+    return textResult(JSON.stringify({
+      session: args.name,
+      team: teamName,
+      count: messages.length,
+      messages: messages.map(m => ({
+        id: m.id,
+        from: m.from,
+        type: m.type,
+        content: m.content,
+        timestamp: m.timestamp,
+        priority: m.priority,
+        replyTo: m.replyTo,
+      })),
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+async function handleTeamAsk(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { teamHub } = getTeamInstances(teamName);
+
+    // Create the ask
+    const askId = teamHub.createAsk(
+      args.from,
+      args.to,
+      args.question,
+      args.timeout || 60000
+    );
+
+    // Poll for reply
+    const reply = await teamHub.pollForReply(askId, args.timeout || 60000);
+
+    if (reply) {
+      return textResult(JSON.stringify({
+        status: 'answered',
+        question: args.question,
+        answer: reply.answer,
+        from: args.from,
+        to: args.to,
+        team: teamName,
+      }, null, 2));
+    } else {
+      return textResult(JSON.stringify({
+        status: 'timeout',
+        question: args.question,
+        message: 'No reply received within timeout period',
+        team: teamName,
+      }, null, 2));
+    }
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleTeamReply(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { teamHub } = getTeamInstances(teamName);
+
+    teamHub.submitReply(args.from, args.message_id, args.answer);
+
+    return textResult(JSON.stringify({
+      status: 'replied',
+      message_id: args.message_id,
+      from: args.from,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleTeamRoster(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { teamHub } = getTeamInstances(teamName);
+
+    const roster = teamHub.getRoster();
+
+    return textResult(JSON.stringify({
+      team: teamName,
+      count: roster.length,
+      members: roster.map(m => ({
+        name: m.name,
+        role: m.role,
+        status: m.status,
+        task: m.task,
+        model: m.model,
+        joinedAt: m.joinedAt,
+        lastSeen: m.lastSeen,
+      })),
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleTeamUpdateStatus(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { teamHub } = getTeamInstances(teamName);
+
+    const updates = {};
+    if (args.status) updates.status = args.status;
+    if (args.task) updates.task = args.task;
+    if (args.role) updates.role = args.role;
+
+    teamHub.updateMember(args.name, updates);
+
+    return textResult(JSON.stringify({
+      status: 'updated',
+      name: args.name,
+      updates,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+// ── Layer 2: Artifact Handlers ────────────────────────────────────────────
+
+async function handleArtifactPublish(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { artifactStore, resolver } = getTeamInstances(teamName);
+
+    // Publish the artifact
+    const result = artifactStore.publish(args.artifactId, {
+      type: args.type,
+      name: args.name,
+      data: args.data,
+      summary: args.summary,
+      tags: args.tags,
+      publisher: args.publisher,
+      derivedFrom: args.derivedFrom,
+    });
+
+    // Trigger dependency resolution and pipeline evaluation
+    await resolver.resolve({
+      type: 'artifact_published',
+      artifactId: args.artifactId,
+      artifactType: args.type,
+      version: result.version,
+      data: args.data,
+    });
+
+    return textResult(JSON.stringify({
+      status: 'published',
+      artifactId: result.artifactId,
+      version: result.version,
+      type: result.type,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleArtifactGet(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { artifactStore } = getTeamInstances(teamName);
+
+    const artifact = artifactStore.get(args.artifactId, args.version);
+
+    if (!artifact) {
+      return errorResult(`Artifact ${args.artifactId} not found`);
+    }
+
+    return textResult(JSON.stringify({
+      artifactId: artifact.artifactId,
+      version: artifact.version,
+      type: artifact.type,
+      name: artifact.name,
+      data: artifact.data,
+      publisher: artifact.publisher,
+      publishedAt: artifact.publishedAt,
+      summary: artifact.summary,
+      lineage: artifact.lineage,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleArtifactList(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { artifactStore } = getTeamInstances(teamName);
+
+    const filters = {};
+    if (args.type) filters.type = args.type;
+    if (args.publisher) filters.publisher = args.publisher;
+    if (args.tag) filters.tag = args.tag;
+
+    const artifacts = artifactStore.list(filters);
+
+    return textResult(JSON.stringify({
+      team: teamName,
+      count: artifacts.length,
+      artifacts: artifacts.map(a => ({
+        artifactId: a.artifactId,
+        type: a.type,
+        name: a.name,
+        publisher: a.publisher,
+        latestVersion: a.latestVersion,
+        createdAt: a.createdAt,
+        updatedAt: a.updatedAt,
+        tags: a.tags,
+      })),
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleArtifactHistory(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { artifactStore } = getTeamInstances(teamName);
+
+    const history = artifactStore.history(args.artifactId);
+
+    return textResult(JSON.stringify({
+      artifactId: args.artifactId,
+      team: teamName,
+      versions: history.length,
+      history: history.map(v => ({
+        version: v.version,
+        publishedAt: v.publishedAt,
+        publisher: v.publisher,
+        summary: v.summary,
+        derivedFrom: v.lineage?.derivedFrom || [],
+      })),
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+// ── Layer 2: Contract Handlers ────────────────────────────────────────────
+
+async function handleContractCreate(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { contractStore, resolver, teamHub } = getTeamInstances(teamName);
+
+    // Create the contract
+    const contract = contractStore.create(args.contractId, {
+      title: args.title,
+      description: args.description,
+      assignee: args.assignee,
+      assigner: args.assigner,
+      inputs: args.inputs,
+      expectedOutputs: args.expectedOutputs,
+      dependencies: args.dependencies,
+      acceptanceCriteria: args.acceptanceCriteria,
+      autoComplete: args.autoComplete !== false,
+      timeoutMs: args.timeoutMs,
+      maxRetries: args.maxRetries,
+      priority: args.priority,
+    });
+
+    // Trigger dependency resolution to check if contract is immediately ready
+    await resolver.resolve({
+      type: 'contract_created',
+      contractId: args.contractId,
+    });
+
+    // If contract became ready, send inbox notification to assignee
+    const updatedContract = contractStore.get(args.contractId);
+    if (updatedContract.status === 'ready') {
+      teamHub.sendDirect(
+        'system',
+        args.assignee,
+        `Contract ready: ${args.title} (${args.contractId})`,
+        { priority: args.priority || 'normal' }
+      );
+    }
+
+    return textResult(JSON.stringify({
+      status: 'created',
+      contractId: contract.contractId,
+      initialStatus: updatedContract.status,
+      assignee: contract.assignee,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleContractStart(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { contractStore } = getTeamInstances(teamName);
+
+    const contract = contractStore.start(args.contractId);
+
+    return textResult(JSON.stringify({
+      status: 'started',
+      contractId: contract.contractId,
+      title: contract.title,
+      inputs: contract.inputs,
+      expectedOutputs: contract.expectedOutputs,
+      acceptanceCriteria: contract.acceptanceCriteria,
+      startedAt: contract.startedAt,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+async function handleContractComplete(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { contractStore, resolver } = getTeamInstances(teamName);
+
+    // Complete the contract
+    contractStore.complete(args.contractId, {
+      summary: args.summary,
+      publishedArtifacts: args.publishedArtifacts,
+    });
+
+    // Trigger dependency resolution for cascade
+    await resolver.resolve({
+      type: 'contract_completed',
+      contractId: args.contractId,
+    });
+
+    return textResult(JSON.stringify({
+      status: 'completed',
+      contractId: args.contractId,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+async function handleContractFail(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { contractStore, resolver } = getTeamInstances(teamName);
+
+    // Fail the contract
+    contractStore.fail(args.contractId, args.reason);
+
+    // Trigger dependency resolution
+    await resolver.resolve({
+      type: 'contract_failed',
+      contractId: args.contractId,
+      reason: args.reason,
+    });
+
+    return textResult(JSON.stringify({
+      status: 'failed',
+      contractId: args.contractId,
+      reason: args.reason,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+async function handleContractReopen(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { contractStore, resolver } = getTeamInstances(teamName);
+
+    // Reopen the contract
+    const contract = contractStore.reopen(args.contractId, {
+      reason: args.reason,
+      newInputs: args.newInputs,
+    });
+
+    // Trigger dependency resolution
+    await resolver.resolve({
+      type: 'contract_reopened',
+      contractId: args.contractId,
+    });
+
+    return textResult(JSON.stringify({
+      status: 'reopened',
+      contractId: contract.contractId,
+      retryCount: contract.retryCount,
+      currentStatus: contract.status,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleContractGet(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { contractStore } = getTeamInstances(teamName);
+
+    const contract = contractStore.get(args.contractId);
+
+    if (!contract) {
+      return errorResult(`Contract ${args.contractId} not found`);
+    }
+
+    return textResult(JSON.stringify({
+      contractId: contract.contractId,
+      title: contract.title,
+      status: contract.status,
+      assignee: contract.assignee,
+      assigner: contract.assigner,
+      inputs: contract.inputs,
+      expectedOutputs: contract.expectedOutputs,
+      dependencies: contract.dependencies,
+      acceptanceCriteria: contract.acceptanceCriteria,
+      retryCount: contract.retryCount,
+      maxRetries: contract.maxRetries,
+      createdAt: contract.createdAt,
+      startedAt: contract.startedAt,
+      completedAt: contract.completedAt,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
+}
+
+function handleContractList(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { contractStore } = getTeamInstances(teamName);
+
+    const filters = {};
+    if (args.status) filters.status = args.status;
+    if (args.assignee) filters.assignee = args.assignee;
+    if (args.assigner) filters.assigner = args.assigner;
+
+    const contracts = contractStore.list(filters);
+
+    return textResult(JSON.stringify({
+      team: teamName,
+      count: contracts.length,
+      contracts: contracts.map(c => ({
+        contractId: c.contractId,
+        title: c.title,
+        status: c.status,
+        assignee: c.assignee,
+        assigner: c.assigner,
+        priority: c.priority,
+        retryCount: c.retryCount,
+        createdAt: c.createdAt,
+      })),
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
 }
 
-function handleKill(args) {
-  manager.kill(args.name);
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    status: 'killed',
-  }, null, 2));
+function handleContractReassign(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { contractStore } = getTeamInstances(teamName);
+
+    contractStore.reassign(args.contractId, args.newAssignee);
+
+    return textResult(JSON.stringify({
+      status: 'reassigned',
+      contractId: args.contractId,
+      newAssignee: args.newAssignee,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
 }
 
-// ── Information Handlers ──────────────────────────────────────────────────
+// ── Layer 3: Lineage Handlers ─────────────────────────────────────────────
 
-function handleStatus(args) {
-  const info = manager.status(args.name);
-  return textResult(JSON.stringify({
-    name: info.name,
-    status: info.status,
-    model: info.model,
-    session_id: info.claudeSessionId || info.id,
-    work_dir: info.workDir,
-    total_cost: info.totalCostUsd || 0,
-    total_turns: info.totalTurns || 0,
-    interactions: info.interactionCount || (info.interactions || []).length,
-    pid: info.pid || null,
-  }, null, 2));
+function handleArtifactLineage(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { lineageGraph } = getTeamInstances(teamName);
+
+    let result;
+    if (args.direction === 'upstream') {
+      result = lineageGraph.getUpstream(args.artifactId, args.version);
+    } else {
+      result = lineageGraph.getDownstream(args.artifactId, args.version);
+    }
+
+    return textResult(JSON.stringify({
+      artifactId: args.artifactId,
+      direction: args.direction,
+      chain: result,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
 }
 
-function handleLastOutput(args) {
-  const last = manager.lastOutput(args.name);
-  if (!last) {
-    return textResult(JSON.stringify({ session_name: args.name, output: null, message: 'No output yet.' }, null, 2));
+function handleArtifactImpact(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { lineageGraph } = getTeamInstances(teamName);
+
+    const impact = lineageGraph.getImpact(args.artifactId);
+
+    return textResult(JSON.stringify({
+      artifactId: args.artifactId,
+      impactRadius: impact.impactRadius,
+      affectedArtifacts: impact.affectedArtifacts,
+      affectedContracts: impact.affectedContracts,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
   }
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    prompt: last.prompt,
-    response: last.response,
-    cost: last.cost,
-    timestamp: last.timestamp,
-  }, null, 2));
 }
 
-function handleList(args) {
-  const sessions = manager.list(args.status);
-  const summary = sessions.map(s => ({
-    name: s.name,
-    status: s.status,
-    model: s.model,
-    total_cost: s.totalCostUsd || 0,
-    total_turns: s.totalTurns || 0,
-    interactions: s.interactionCount || (s.interactions || []).length,
-  }));
-  return textResult(JSON.stringify({ total: summary.length, sessions: summary }, null, 2));
+function handleArtifactStale(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { lineageGraph } = getTeamInstances(teamName);
+
+    const staleArtifacts = lineageGraph.findStale();
+
+    return textResult(JSON.stringify({
+      team: teamName,
+      count: staleArtifacts.length,
+      staleArtifacts: staleArtifacts,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
 }
 
-function handleHistory(args) {
-  const hist = manager.history(args.name);
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    interaction_count: hist.length,
-    interactions: hist.map((h, i) => ({
-      index: i,
-      prompt: h.prompt,
-      response: h.response,
-      cost: h.cost,
-      turns: h.turns,
-      duration_ms: h.duration,
-      timestamp: h.timestamp,
-    })),
-  }, null, 2));
+function handleTeamAudit(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { lineageGraph } = getTeamInstances(teamName);
+
+    const trail = lineageGraph.getAuditTrail(args.artifactId, args.version);
+
+    return textResult(JSON.stringify({
+      artifactId: args.artifactId,
+      auditTrail: trail,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
 }
 
-function handleDelete(args) {
-  manager.delete(args.name);
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    status: 'deleted',
-    message: 'Session permanently deleted.',
-  }, null, 2));
+// ── Layer 3: Pipeline Handlers ────────────────────────────────────────────
+
+function handlePipelineCreate(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { pipelineEngine } = getTeamInstances(teamName);
+
+    const pipeline = pipelineEngine.create(args.pipelineId, {
+      rules: args.rules,
+      owner: args.owner,
+      enabled: args.enabled !== false,
+    });
+
+    return textResult(JSON.stringify({
+      status: 'created',
+      pipelineId: pipeline.pipelineId,
+      rulesCount: pipeline.rules.length,
+      enabled: pipeline.enabled,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
 }
 
-// ── Delegate Handlers ─────────────────────────────────────────────────────
+function handlePipelineList(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { pipelineEngine } = getTeamInstances(teamName);
 
-async function handleDelegate(args) {
-  // Create or reuse a delegate instance for this session
-  let delegate = delegates.get(args.name);
-  if (!delegate) {
-    delegate = new Delegate(manager);
-    delegates.set(args.name, delegate);
+    const filters = {};
+    if (args.owner) filters.owner = args.owner;
+
+    const pipelines = pipelineEngine.list(filters);
+
+    return textResult(JSON.stringify({
+      team: teamName,
+      count: pipelines.length,
+      pipelines: pipelines.map(p => ({
+        pipelineId: p.pipelineId,
+        owner: p.owner,
+        enabled: p.enabled,
+        rulesCount: p.rules.length,
+        executionCount: p.executionCount,
+        lastExecutedAt: p.lastExecutedAt,
+      })),
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
   }
+}
 
-  const result = await delegate.run(args.name, {
-    task: args.task,
-    model: args.model,
-    preset: args.preset,
-    workDir: args.work_dir,
-    maxCost: args.max_cost,
-    maxTurns: args.max_turns,
-    context: args.context,
-    systemPrompt: args.system_prompt,
-    agent: args.agent,
-    safety: args.safety,
-  });
+function handlePipelinePause(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { pipelineEngine } = getTeamInstances(teamName);
 
-  return textResult(JSON.stringify(result, null, 2));
+    pipelineEngine.pause(args.pipelineId);
+
+    return textResult(JSON.stringify({
+      status: 'paused',
+      pipelineId: args.pipelineId,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
 }
 
-async function handleContinue(args) {
-  // Get or create delegate for this session
-  let delegate = delegates.get(args.name);
-  if (!delegate) {
-    delegate = new Delegate(manager);
-    delegates.set(args.name, delegate);
+function handlePipelineResume(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { pipelineEngine } = getTeamInstances(teamName);
+
+    pipelineEngine.resume(args.pipelineId);
+
+    return textResult(JSON.stringify({
+      status: 'resumed',
+      pipelineId: args.pipelineId,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
   }
+}
 
-  const result = await delegate.continue(args.name, args.message);
-  return textResult(JSON.stringify(result, null, 2));
+// ── Layer 3: Snapshot Handlers ────────────────────────────────────────────
+
+function handleTeamSnapshot(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { snapshotEngine } = getTeamInstances(teamName);
+
+    const snapshot = snapshotEngine.createSnapshot(args.snapshotId, {
+      label: args.label,
+      description: args.description,
+    });
+
+    return textResult(JSON.stringify({
+      status: 'created',
+      snapshotId: snapshot.snapshotId,
+      label: snapshot.label,
+      createdAt: snapshot.createdAt,
+      contractsCount: snapshot.contractsCount,
+      artifactsCount: snapshot.artifactsCount,
+      pipelinesCount: snapshot.pipelinesCount,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
 }
 
-function handleFinish(args) {
-  const delegate = delegates.get(args.name);
-  if (delegate) {
-    delegate.finish(args.name);
-    delegates.delete(args.name);
-  } else {
-    // No delegate — just stop the session
-    try { manager.stop(args.name); } catch (e) {}
+function handleTeamSnapshotList(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { snapshotEngine } = getTeamInstances(teamName);
+
+    const snapshots = snapshotEngine.listSnapshots();
+
+    return textResult(JSON.stringify({
+      team: teamName,
+      count: snapshots.length,
+      snapshots: snapshots.map(s => ({
+        snapshotId: s.snapshotId,
+        label: s.label,
+        description: s.description,
+        createdAt: s.createdAt,
+        contractsCount: s.contractsCount,
+        artifactsCount: s.artifactsCount,
+      })),
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
   }
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    status: 'finished',
-    message: 'Task finished. Session stopped.',
-  }, null, 2));
 }
 
-function handleAbort(args) {
-  const delegate = delegates.get(args.name);
-  if (delegate) {
-    delegate.abort(args.name);
-    delegates.delete(args.name);
-  } else {
-    try { manager.kill(args.name); } catch (e) {}
+function handleTeamRollback(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { snapshotEngine } = getTeamInstances(teamName);
+
+    const result = snapshotEngine.rollback(args.snapshotId, {
+      preserveArtifacts: args.preserveArtifacts !== false,
+    });
+
+    return textResult(JSON.stringify({
+      status: 'rolled_back',
+      snapshotId: args.snapshotId,
+      restoredContracts: result.restoredContracts,
+      restoredPipelines: result.restoredPipelines,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
   }
-  return textResult(JSON.stringify({
-    session_name: args.name,
-    status: 'aborted',
-    message: 'Task aborted. Session killed.',
-  }, null, 2));
 }
 
-// ── Batch Handler ─────────────────────────────────────────────────────────
+async function handleTeamReplay(args) {
+  try {
+    const teamName = args.team || 'default';
+    const { snapshotEngine, resolver } = getTeamInstances(teamName);
 
-async function handleBatch(args) {
-  const results = await manager.batch(args.sessions);
-  const summary = results.map(r => ({
-    name: r.session?.name || 'unknown',
-    status: r.error ? 'failed' : 'completed',
-    response: r.response?.text || null,
-    cost: r.response?.cost || 0,
-    error: r.error || null,
-  }));
-  return textResult(JSON.stringify({ total: summary.length, results: summary }, null, 2));
+    // Replay from snapshot with overrides
+    const result = snapshotEngine.replay(args.snapshotId, {
+      overrides: args.overrides,
+    });
+
+    // Re-trigger dependency resolution to execute the workflow
+    await resolver.resolve({
+      type: 'replay_triggered',
+      snapshotId: args.snapshotId,
+    });
+
+    return textResult(JSON.stringify({
+      status: 'replayed',
+      snapshotId: args.snapshotId,
+      appliedOverrides: Object.keys(args.overrides || {}).length,
+      restoredContracts: result.restoredContracts,
+      team: teamName,
+    }, null, 2));
+  } catch (err) {
+    return errorResult(err.message);
+  }
 }
 
 // =============================================================================