agileflow 3.4.0 → 3.4.1

package/scripts/spawn-audit-sessions.js

@@ -70,8 +70,11 @@ function parseArgs() {
     traceId: null,
     timeout: 30,
     dryRun: false,
+    json: false,
     stagger: null,
     concurrency: null,
+    depth: null,
+    partitions: null,
   };
 
   for (const arg of args) {
@@ -89,7 +92,11 @@ function parseArgs() {
     } else if (arg.startsWith('--concurrency=')) {
       const parsed = parseInt(arg.split('=')[1], 10);
       options.concurrency = isNaN(parsed) ? null : parsed;
-    } else if (arg === '--dry-run') options.dryRun = true;
+    } else if (arg.startsWith('--depth=')) options.depth = arg.split('=')[1];
+    else if (arg.startsWith('--partitions='))
+      options.partitions = arg.split('=')[1].split(',').filter(Boolean);
+    else if (arg === '--dry-run') options.dryRun = true;
+    else if (arg === '--json') options.json = true;
   }
 
   if (!options.traceId) {
@@ -133,7 +140,7 @@ function createSentinelDir(rootDir, traceId) {
  * @param {number} [staggerMs] - Stagger delay in milliseconds
  * @param {number} [maxConcurrent] - Max concurrent sessions (0 = unlimited)
  */
-function writeStatusFile(sentinelDir, auditType, analyzers, staggerMs, maxConcurrent) {
+function writeStatusFile(sentinelDir, auditType, analyzers, staggerMs, maxConcurrent, extra) {
   const status = {
     started_at: new Date().toISOString(),
     audit_type: auditType,
@@ -143,6 +150,12 @@ function writeStatusFile(sentinelDir, auditType, analyzers, staggerMs, maxConcur
     stagger_ms: staggerMs != null ? staggerMs : null,
     max_concurrent: maxConcurrent || null,
   };
+  // Store extra fields for retry support
+  if (extra) {
+    if (extra.target != null) status.target = extra.target;
+    if (extra.model != null) status.model = extra.model;
+    if (extra.timeout_minutes != null) status.timeout_minutes = extra.timeout_minutes;
+  }
   fs.writeFileSync(path.join(sentinelDir, '_status.json'), JSON.stringify(status, null, 2) + '\n');
 }
 
@@ -153,32 +166,47 @@ function writeStatusFile(sentinelDir, auditType, analyzers, staggerMs, maxConcur
  * @param {string} traceId - Trace ID
  * @param {string} sentinelDir - Sentinel directory for output
  * @param {string} auditType - Audit type key
+ * @param {string} [model] - Resolved model name for sub-agent
  * @returns {string} Prompt text
  */
-function buildAnalyzerPrompt(analyzer, target, traceId, sentinelDir, auditType) {
+function buildAnalyzerPrompt(analyzer, target, traceId, sentinelDir, auditType, model) {
   const findingsFile = path.join(sentinelDir, `${analyzer.key}.findings.json`);
 
-  return `You are the ${analyzer.label} analyzer for an ULTRADEEP ${auditType} audit.
+  // Sanitize fields that get interpolated into double-quoted prompt sections
+  const safeLabel = String(analyzer.label || '').replace(/["\\]/g, '');
+  const safeTarget = String(target || '').replace(/["\\]/g, '');
+  const safeSubagentType = String(analyzer.subagent_type || '').replace(/["\\]/g, '');
+
+  return `You are an ULTRADEEP audit session coordinator.
+
+## Task
 
-TARGET: ${target}
-TRACE_ID: ${traceId}
-ANALYZER: ${analyzer.key} (${analyzer.label})
+1. Use the Agent tool to spawn a sub-agent for analysis
+2. After the sub-agent completes, parse its output and write findings as JSON to the sentinel file
 
-## Instructions
+## Agent Configuration
 
-1. Analyze the target path thoroughly for ${analyzer.label}-related issues
-2. Search all relevant files recursively
-3. Document every finding with: file path, line number, severity (P0-P3), description, and evidence
-4. When complete, write your findings as JSON to: ${findingsFile}
+Use the Agent tool with these parameters:
+- subagent_type: "${safeSubagentType}"
+- description: "${safeLabel} analysis of ${safeTarget}"${model ? `\n- model: "${model}"` : ''}
+- prompt: |
+    Analyze the target path ${safeTarget} thoroughly for ${safeLabel}-related issues.
+    Search all relevant files recursively. Be thorough.
+    Return a JSON object with this structure:
+    {"findings": [{"id": "${analyzer.key}-NNN", "severity": "P0|P1|P2|P3", "title": "Short description", "file": "path/to/file.js", "line": 42, "description": "Detailed explanation", "evidence": "Code snippet or reasoning", "recommendation": "How to fix"}], "summary": {"files_scanned": 0, "total_findings": 0, "by_severity": {"P0": 0, "P1": 0, "P2": 0, "P3": 0}}}
+    TRACE_ID: ${traceId}
+    ANALYZER: ${analyzer.key}
 
-## Output Format
+## Output
 
-Write a JSON file with this structure:
+After the Agent tool returns its analysis, write a JSON file to: ${findingsFile}
+
+Use this structure:
 {
   "analyzer": "${analyzer.key}",
   "audit_type": "${auditType}",
   "trace_id": "${traceId}",
-  "target": "${target}",
+  "target": "${safeTarget}",
   "completed_at": "<ISO timestamp>",
   "findings": [
     {
@@ -200,7 +228,107 @@ Write a JSON file with this structure:
 }
 
 IMPORTANT: You MUST write the findings JSON file when complete. This is how the orchestrator knows you're done.
-Start analyzing now.`;
+If the Agent tool is unavailable or returns an error, perform the analysis directly using Read, Glob, and Grep tools.
+Start by spawning the Agent now.`;
+}
+
+/**
+ * Create a slug from a partition path for use in window names and filenames.
+ * Only allows alphanumeric, hyphens, and underscores — safe for tmux window
+ * names, shell interpolation, and filesystem paths.
+ * @param {string} partition - Partition path (e.g. 'src/auth')
+ * @returns {string} Slug (e.g. 'src-auth')
+ */
+function partitionSlug(partition) {
+  return (
+    partition
+      .replace(/^\.?\/?/, '')
+      .replace(/\/+$/g, '')
+      .replace(/[/\\]/g, '-')
+      .replace(/[^a-zA-Z0-9_-]/g, '_') || 'root'
+  );
+}
+
+/**
+ * Build the prompt for an extreme-mode partition coordinator session.
+ * This coordinator runs ALL analyzers on a single partition using the Agent tool.
+ * @param {string} partition - Partition path to analyze
+ * @param {Array<{ key: string, subagent_type: string, label: string }>} analyzers - All analyzers to run
+ * @param {string} traceId - Trace ID
+ * @param {string} sentinelDir - Sentinel directory for output
+ * @param {string} auditType - Audit type key
+ * @param {string} [model] - Resolved model name for sub-agents
+ * @returns {string} Prompt text
+ */
+function buildExtremePrompt(partition, analyzers, traceId, sentinelDir, auditType, model) {
+  const slug = partitionSlug(partition);
+  const findingsFile = path.join(sentinelDir, `${slug}.findings.json`);
+
+  const safePartition = String(partition || '').replace(/["\\]/g, '');
+
+  const analyzerList = analyzers
+    .map((a, i) => `${i + 1}. subagent_type: "${a.subagent_type}" — ${a.label} (key: ${a.key})`)
+    .join('\n');
+
+  const modelLine = model ? `\n- model: "${model}"` : '';
+
+  return `You are an EXTREME audit session coordinator for partition: ${safePartition}
+
+## Task
+
+Run ALL of the following analyzers on your partition using the Agent tool.
+Deploy them in parallel (multiple Agent calls in one message) where possible.
+
+## Analyzers to Run
+${analyzerList}
+
+## Agent Configuration for Each Analyzer
+
+Use the Agent tool with these parameters for each analyzer:
+- subagent_type: (from the list above)
+- description: "[Analyzer label] analysis of ${safePartition}"${modelLine}
+- prompt: |
+    Analyze the target path ${safePartition} thoroughly for issues relevant to your analyzer domain.
+    Search all relevant files recursively. Be thorough.
+    Use the analyzer key from your subagent_type as the ID prefix (e.g., for "security-analyzer-injection" use "injection").
+    Return a JSON object with this structure:
+    {"findings": [{"id": "<analyzer-key>-NNN", "severity": "P0|P1|P2|P3", "title": "Short description", "file": "path/to/file.js", "line": 42, "description": "Detailed explanation", "evidence": "Code snippet or reasoning", "recommendation": "How to fix"}], "summary": {"files_scanned": 0, "total_findings": 0, "by_severity": {"P0": 0, "P1": 0, "P2": 0, "P3": 0}}}
+    TRACE_ID: ${traceId}
+
+## After All Analyzers Complete
+
+Combine ALL findings from ALL analyzers into a single JSON file: ${findingsFile}
+
+Use this structure:
+{
+  "partition": "${safePartition}",
+  "audit_type": "${auditType}",
+  "trace_id": "${traceId}",
+  "completed_at": "<ISO timestamp>",
+  "analyzer_count": ${analyzers.length},
+  "analyzers_run": [${analyzers.map(a => `"${a.key}"`).join(', ')}],
+  "findings": [
+    {
+      "id": "<analyzer_key>-001",
+      "analyzer": "<analyzer_key>",
+      "severity": "P0|P1|P2|P3",
+      "title": "Short description",
+      "file": "path/to/file.js",
+      "line": 42,
+      "description": "Detailed explanation",
+      "evidence": "Code snippet or reasoning",
+      "recommendation": "How to fix"
+    }
+  ],
+  "summary": {
+    "files_scanned": 0,
+    "total_findings": 0,
+    "by_severity": { "P0": 0, "P1": 0, "P2": 0, "P3": 0 }
+  }
+}
+
+IMPORTANT: You MUST write the findings JSON file when complete. This is how the orchestrator knows you're done.
+Start by spawning ALL ${analyzers.length} analyzers now, in parallel.`;
 }
 
 /**
@@ -225,7 +353,8 @@ function spawnOneSession({
     options.target,
     options.traceId,
     sentinelDir,
-    options.audit
+    options.audit,
+    model
   );
   const escapedPrompt = prompt.replace(/'/g, "'\\''");
 
@@ -248,7 +377,7 @@ function spawnOneSession({
       { stdio: 'pipe' }
     );
 
-    const claudeCmd = `echo '${escapedPrompt}' | claude --model ${model} --allowedTools 'Read Glob Grep Write' 2>&1; echo "AUDIT_COMPLETE: ${analyzer.key}"`;
+    const claudeCmd = `echo '${escapedPrompt}' | claude --model ${model} --allowedTools 'Read Glob Grep Write Agent' 2>&1; echo "AUDIT_COMPLETE: ${analyzer.key}"`;
     execFileSync('tmux', ['send-keys', '-t', `${sessionName}:${windowName}`, claudeCmd, 'Enter'], {
       stdio: 'pipe',
     });
@@ -295,44 +424,202 @@ async function spawnAuditInTmux(options) {
     process.exit(1);
   }
 
-  const result = getAnalyzersForAudit(options.audit, 'ultradeep', options.focus);
+  const isExtreme = options.depth === 'extreme';
+  const depthForRegistry = isExtreme ? 'extreme' : 'ultradeep';
+  const result = getAnalyzersForAudit(options.audit, depthForRegistry, options.focus);
   if (!result || result.analyzers.length === 0) {
     console.error(`No analyzers found for ${options.audit} with focus: ${options.focus.join(',')}`);
     process.exit(1);
   }
 
+  const sentinelDir = createSentinelDir(rootDir, options.traceId);
+
+  // Use stderr for human output when --json mode is active
+  const log = options.json ? console.error : console.log;
+
+  // --- EXTREME MODE: partition-based multi-agent ---
+  if (isExtreme) {
+    if (!options.partitions || options.partitions.length === 0) {
+      console.error('EXTREME mode requires --partitions=dir1,dir2,...');
+      process.exit(1);
+    }
+
+    const partitions = options.partitions;
+    const partitionSlugs = partitions.map(p => partitionSlug(p));
+
+    // Write status file with partition info
+    const statusData = {
+      started_at: new Date().toISOString(),
+      audit_type: options.audit,
+      mode: 'extreme',
+      partitions: partitions,
+      analyzers: partitionSlugs,
+      analyzers_per_partition: result.analyzers.map(a => a.key),
+      completed: [],
+      failed: [],
+      target: options.target,
+      model: options.model,
+      timeout_minutes: options.timeout,
+    };
+    fs.writeFileSync(
+      path.join(sentinelDir, '_status.json'),
+      JSON.stringify(statusData, null, 2) + '\n'
+    );
+
+    const groupColor = getColorForAudit(options.audit);
+    const totalSessions = partitions.length * result.analyzers.length;
+
+    if (options.dryRun) {
+      log(`\nDry run - EXTREME mode would spawn ${partitions.length} partition coordinators:`);
+      log(`  Partitions: ${partitions.join(', ')}`);
+      log(`  Analyzers per partition: ${result.analyzers.length}`);
+      log(`  Total agent sessions: ${totalSessions}`);
+      const model = resolveModel(options.model, 'haiku');
+      for (const p of partitions) {
+        const slug = partitionSlug(p);
+        log(
+          `  ${auditType.prefix}:${slug} (${model}) → ALL ${result.analyzers.length} analyzers on ${p}`
+        );
+      }
+      log(`\nSentinel dir: ${sentinelDir}`);
+      log(`Group color: ${groupColor}`);
+      return {
+        ok: true,
+        traceId: options.traceId,
+        sentinelDir,
+        sessions: [],
+        dryRun: true,
+        mode: 'extreme',
+        partitions,
+      };
+    }
+
+    const tmux = checkTmux();
+    if (!tmux.available) {
+      console.error('tmux is not available. EXTREME mode requires tmux.');
+      console.error('Falling back to DEPTH=deep mode.');
+      return { ok: false, traceId: options.traceId, sentinelDir, sessions: [], fallback: 'deep' };
+    }
+
+    const sessionName = `audit-${options.audit}-${options.traceId.slice(0, 8)}`;
+    const sessions = [];
+    const config = getUltradeepConfig();
+    const staggerMs =
+      ((options.stagger != null ? options.stagger : config.stagger_seconds) || 0) * 1000;
+
+    for (let i = 0; i < partitions.length; i++) {
+      if (i > 0 && staggerMs > 0) await sleep(staggerMs);
+
+      const partition = partitions[i];
+      const slug = partitionSlug(partition);
+      const windowName = `${auditType.prefix}:${slug}`;
+      const model = resolveModel(options.model, 'haiku');
+      const prompt = buildExtremePrompt(
+        partition,
+        result.analyzers,
+        options.traceId,
+        sentinelDir,
+        options.audit,
+        model
+      );
+      const escapedPrompt = prompt.replace(/'/g, "'\\''");
+
+      try {
+        if (i === 0) {
+          execFileSync(
+            'tmux',
+            ['new-session', '-d', '-s', sessionName, '-n', windowName, '-c', rootDir],
+            { stdio: 'pipe' }
+          );
+        } else {
+          execFileSync('tmux', ['new-window', '-t', sessionName, '-n', windowName, '-c', rootDir], {
+            stdio: 'pipe',
+          });
+        }
+
+        execFileSync(
+          'tmux',
+          ['set-option', '-w', '-t', `${sessionName}:${windowName}`, '@group_color', groupColor],
+          { stdio: 'pipe' }
+        );
+
+        const claudeCmd = `echo '${escapedPrompt}' | claude --model ${model} --allowedTools 'Read Glob Grep Write Agent' 2>&1; echo "AUDIT_COMPLETE: ${slug}"`;
+        execFileSync(
+          'tmux',
+          ['send-keys', '-t', `${sessionName}:${windowName}`, claudeCmd, 'Enter'],
+          {
+            stdio: 'pipe',
+          }
+        );
+
+        sessions.push(windowName);
+      } catch (err) {
+        console.error(`Failed to spawn ${windowName}: ${err.message}`);
+      }
+    }
+
+    // Apply status bar theme
+    try {
+      const tmuxScript = path.join(__dirname, 'claude-tmux.sh');
+      execFileSync(tmuxScript, [`--configure-session=${sessionName}`], { stdio: 'pipe' });
+    } catch (_) {
+      // Non-critical
+    }
+
+    log(`\nSpawned ${sessions.length} partition coordinators in tmux session: ${sessionName}`);
+    log(`  Partitions: ${partitions.join(', ')}`);
+    log(`  Analyzers per partition: ${result.analyzers.length}`);
+    log(`  Total agent sessions: ${totalSessions}`);
+    log(`Sentinel dir: ${sentinelDir}`);
+    log(`Attach with: tmux attach -t ${sessionName}`);
+
+    return {
+      ok: true,
+      traceId: options.traceId,
+      sentinelDir,
+      sessions,
+      sessionName,
+      mode: 'extreme',
+      partitions,
+    };
+  }
+
+  // --- ULTRADEEP MODE (existing behavior) ---
+
   // Enforce session limit
   if (result.analyzers.length > 20) {
     console.error(`Too many analyzers (${result.analyzers.length}). Maximum is 20.`);
     process.exit(1);
   }
 
-  const sentinelDir = createSentinelDir(rootDir, options.traceId);
-
   // Resolve stagger and concurrency from CLI flags or config
   const config = getUltradeepConfig();
   const staggerMs =
     ((options.stagger != null ? options.stagger : config.stagger_seconds) || 0) * 1000;
   const maxConcurrent = options.concurrency != null ? options.concurrency : config.max_concurrent;
 
-  writeStatusFile(sentinelDir, options.audit, result.analyzers, staggerMs, maxConcurrent);
+  writeStatusFile(sentinelDir, options.audit, result.analyzers, staggerMs, maxConcurrent, {
+    target: options.target,
+    model: options.model,
+    timeout_minutes: options.timeout,
+  });
 
   const groupColor = getColorForAudit(options.audit);
   const sessions = [];
 
   if (options.dryRun) {
-    console.log(`\nDry run - would spawn ${result.analyzers.length} sessions:`);
-    console.log(`  Stagger: ${staggerMs / 1000}s between launches`);
+    log(`\nDry run - would spawn ${result.analyzers.length} sessions:`);
+    log(`  Stagger: ${staggerMs / 1000}s between launches`);
     if (maxConcurrent > 0) {
       const waveCount = Math.ceil(result.analyzers.length / maxConcurrent);
-      console.log(`  Concurrency: ${maxConcurrent}/wave (${waveCount} waves)`);
+      log(`  Concurrency: ${maxConcurrent}/wave (${waveCount} waves)`);
     }
     for (const analyzer of result.analyzers) {
       const model = resolveModel(options.model, 'haiku');
-      console.log(`  ${auditType.prefix}:${analyzer.key} (${model}) → ${analyzer.label}`);
+      log(`  ${auditType.prefix}:${analyzer.key} (${model}) → ${analyzer.label}`);
     }
-    console.log(`\nSentinel dir: ${sentinelDir}`);
-    console.log(`Group color: ${groupColor}`);
+    log(`\nSentinel dir: ${sentinelDir}`);
+    log(`Group color: ${groupColor}`);
     return { ok: true, traceId: options.traceId, sentinelDir, sessions: [], dryRun: true };
   }
 
@@ -400,9 +687,9 @@ async function spawnAuditInTmux(options) {
     // Non-critical styling failure — audit session still works with default theme
   }
 
-  console.log(`\nSpawned ${sessions.length} analyzer sessions in tmux session: ${sessionName}`);
-  console.log(`Sentinel dir: ${sentinelDir}`);
-  console.log(`Attach with: tmux attach -t ${sessionName}`);
+  log(`\nSpawned ${sessions.length} analyzer sessions in tmux session: ${sessionName}`);
+  log(`Sentinel dir: ${sentinelDir}`);
+  log(`Attach with: tmux attach -t ${sessionName}`);
 
   return { ok: true, traceId: options.traceId, sentinelDir, sessions, sessionName };
 }
@@ -460,7 +747,9 @@ async function pollForCompletion(sentinelDir, expected, timeoutMinutes) {
 /**
  * Collect all findings from sentinel directory.
  * @param {string} sentinelDir - Sentinel directory path
- * @param {string[]} expected - Expected analyzer keys
+ * @param {string[]} expected - Expected keys. In ultradeep mode these are analyzer keys
+ *   (e.g. 'injection', 'auth'). In extreme mode these are partition slugs
+ *   (e.g. 'src-auth', 'src-api') — matches the `analyzers` array in `_status.json`.
  * @returns {object[]} Array of parsed findings
  */
 function collectResults(sentinelDir, expected) {
@@ -490,18 +779,34 @@ function collectResults(sentinelDir, expected) {
  * @param {string} auditType - Audit type key
  * @param {number} analyzerCount - Number of analyzers to spawn
  * @param {string} [model] - Explicit model override
+ * @param {object} [opts] - Options
+ * @param {boolean} [opts.json] - If true, route output to stderr to keep stdout clean for JSON
+ * @param {number} [opts.partitions] - Number of partitions (extreme mode)
  */
-function showCostEstimate(auditType, analyzerCount, model) {
+function showCostEstimate(auditType, analyzerCount, model, opts) {
   const resolved = resolveModel(model, 'haiku');
-  const estimate = estimateCost(resolved, analyzerCount);
-
-  console.log(`\nCost estimate for ULTRADEEP ${auditType} audit:`);
-  console.log(`  Model: ${estimate.model}`);
-  console.log(`  Analyzers: ${analyzerCount}`);
-  console.log(`  Cost multiplier vs haiku: ${estimate.multiplier}x`);
-  console.log(`  Per-analyzer estimate: ${estimate.perAnalyzerCost}`);
-  console.log(`  Total estimate: ${estimate.totalEstimate}`);
-  console.log(`  Each analyzer runs as a full Claude Code session`);
+  const partCount =
+    opts && typeof opts.partitions === 'number' && opts.partitions > 1 ? opts.partitions : 1;
+  const estimate = estimateCost(resolved, analyzerCount, partCount);
+  const log = opts && opts.json ? console.error : console.log;
+
+  if (partCount > 1) {
+    log(`\nCost estimate for EXTREME ${auditType} audit:`);
+    log(`  Model: ${estimate.model}`);
+    log(`  Partitions: ${partCount}`);
+    log(`  Analyzers per partition: ${analyzerCount}`);
+    log(`  Total agent sessions: ${estimate.totalSessions}`);
+    log(`  Per-agent estimate: ${estimate.perAnalyzerCost}`);
+    log(`  Total estimate: ${estimate.totalEstimate}`);
+  } else {
+    log(`\nCost estimate for ULTRADEEP ${auditType} audit:`);
+    log(`  Model: ${estimate.model}`);
+    log(`  Analyzers: ${analyzerCount}`);
+    log(`  Cost multiplier vs haiku: ${estimate.multiplier}x`);
+    log(`  Per-analyzer estimate: ${estimate.perAnalyzerCost}`);
+    log(`  Total estimate: ${estimate.totalEstimate}`);
+    log(`  Each analyzer runs as a full Claude Code session`);
+  }
 }
 
 // Main
@@ -517,12 +822,33 @@ if (require.main === module) {
       process.exit(1);
     }
 
-    const result = getAnalyzersForAudit(options.audit, 'ultradeep', options.focus);
+    const isExtreme = options.depth === 'extreme';
+    const depthForCost = isExtreme ? 'extreme' : 'ultradeep';
+    const result = getAnalyzersForAudit(options.audit, depthForCost, options.focus);
     if (result) {
-      showCostEstimate(options.audit, result.analyzers.length, options.model);
+      showCostEstimate(options.audit, result.analyzers.length, options.model, {
+        json: options.json,
+        partitions: isExtreme && options.partitions ? options.partitions.length : 1,
+      });
     }
 
     const spawnResult = await spawnAuditInTmux(options);
+
+    if (options.json) {
+      const jsonOut = {
+        ok: spawnResult.ok,
+        traceId: spawnResult.traceId,
+        sentinelDir: spawnResult.sentinelDir,
+        sessionName: spawnResult.sessionName || null,
+        sessions: spawnResult.sessions,
+        dryRun: spawnResult.dryRun || false,
+        fallback: spawnResult.fallback || null,
+        mode: spawnResult.mode || 'ultradeep',
+        partitions: spawnResult.partitions || null,
+      };
+      console.log(JSON.stringify(jsonOut));
+    }
+
     if (!spawnResult.ok && spawnResult.fallback) {
       process.exit(2); // Signal fallback to caller
     }
@@ -538,6 +864,8 @@ module.exports = {
   createSentinelDir,
   writeStatusFile,
   buildAnalyzerPrompt,
+  buildExtremePrompt,
+  partitionSlug,
   spawnOneSession,
   spawnAuditInTmux,
   pollForCompletion,

package/scripts/team-manager.js

@@ -492,6 +492,25 @@ function stopTeam(rootDir) {
       // Non-critical - metrics aggregation is best-effort
     }
 
+    // Reconcile teammate final states to status.json (AC2/AC3)
+    try {
+      const taskSync = require('./lib/task-sync');
+      const nativeTasks = (team.teammates || [])
+        .filter(t => t.status === 'completed' || t.status === 'done')
+        .map(t => ({
+          id: t.agent,
+          status: 'completed',
+          metadata: { story_id: t.story_id },
+        }))
+        .filter(t => t.metadata.story_id);
+
+      if (nativeTasks.length > 0) {
+        taskSync.reconcile(rootDir, nativeTasks);
+      }
+    } catch (e) {
+      // Non-critical - reconciliation is best-effort
+    }
+
     return {
       ok: true,
       template: team.template,