@aion0/forge 0.5.25 → 0.5.26

package/.forge/worktrees/pipeline-d6a6ef23/lib/usage-scanner.ts

@@ -0,0 +1,249 @@
+/**
+ * Usage Scanner — scans Claude Code JSONL session files for token usage data.
+ * Stores per-day aggregated results in SQLite for accurate daily breakdown.
+ */
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+import { getClaudeDir } from './dirs';
+
+function db() { return getDb(getDbPath()); }
+
+const PRICING: Record<string, { input: number; output: number }> = {
+  'claude-opus-4': { input: 15, output: 75 },
+  'claude-sonnet-4': { input: 3, output: 15 },
+  'claude-haiku-4': { input: 0.80, output: 4 },
+  'default': { input: 3, output: 15 },
+};
+
+function getModelFamily(model: string): string {
+  if (!model) return 'unknown';
+  if (model.includes('opus')) return 'claude-opus-4';
+  if (model.includes('haiku')) return 'claude-haiku-4';
+  if (model.includes('sonnet')) return 'claude-sonnet-4';
+  return 'unknown';
+}
+
+function calcCost(family: string, input: number, output: number): number {
+  const p = PRICING[family] || PRICING['default'];
+  // Only count input + output tokens. Cache tokens excluded from cost estimate
+  // because subscriptions (Max/Pro) don't charge per-token for cache.
+  return (input * p.input / 1_000_000) + (output * p.output / 1_000_000);
+}
+
+function dirToProjectPath(dirName: string): string {
+  return dirName.replace(/^-/, '/').replace(/-/g, '/');
+}
+
+function dirToProjectName(dirName: string): string {
+  return dirToProjectPath(dirName).split('/').pop() || dirName;
+}
+
+/** Get local date string from UTC timestamp */
+function toLocalDate(ts: string): string {
+  if (!ts) return 'unknown';
+  try {
+    const d = new Date(ts);
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+  } catch {
+    return ts.slice(0, 10) || 'unknown';
+  }
+}
+
+interface DayModelBucket {
+  input: number; output: number; cacheRead: number; cacheCreate: number; count: number;
+}
+
+/** Parse JSONL and aggregate by day + model */
+function parseByDayModel(content: string): Map<string, DayModelBucket> {
+  // key: "day|model"
+  const buckets = new Map<string, DayModelBucket>();
+
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === 'assistant' && obj.message?.usage) {
+        const u = obj.message.usage;
+        const model = getModelFamily(obj.message.model || '');
+        const day = toLocalDate(obj.timestamp || '');
+        const key = `${day}|${model}`;
+
+        let b = buckets.get(key);
+        if (!b) { b = { input: 0, output: 0, cacheRead: 0, cacheCreate: 0, count: 0 }; buckets.set(key, b); }
+        b.input += u.input_tokens || 0;
+        b.output += u.output_tokens || 0;
+        b.cacheRead += u.cache_read_input_tokens || 0;
+        b.cacheCreate += u.cache_creation_input_tokens || 0;
+        b.count++;
+      }
+    } catch {}
+  }
+  return buckets;
+}
+
+/** Scan all JSONL files */
+export function scanUsage(): { scanned: number; updated: number; errors: number } {
+  const projectsDir = join(getClaudeDir(), 'projects');
+  let scanned = 0, updated = 0, errors = 0;
+
+  let projectDirs: string[];
+  try { projectDirs = readdirSync(projectsDir); } catch { return { scanned: 0, updated: 0, errors: 0 }; }
+
+  const upsert = db().prepare(`
+    INSERT INTO token_usage (session_id, source, project_path, project_name, model, day, input_tokens, output_tokens, cache_read_tokens, cache_create_tokens, cost_usd, message_count)
+    VALUES (?, 'terminal', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(session_id, source, model, day) DO UPDATE SET
+      input_tokens = excluded.input_tokens, output_tokens = excluded.output_tokens,
+      cache_read_tokens = excluded.cache_read_tokens, cache_create_tokens = excluded.cache_create_tokens,
+      cost_usd = excluded.cost_usd, message_count = excluded.message_count
+  `);
+
+  const getScanState = db().prepare('SELECT last_size FROM usage_scan_state WHERE file_path = ?');
+  const setScanState = db().prepare(`
+    INSERT INTO usage_scan_state (file_path, last_size) VALUES (?, ?)
+    ON CONFLICT(file_path) DO UPDATE SET last_size = excluded.last_size, last_scan = datetime('now')
+  `);
+
+  for (const projDir of projectDirs) {
+    const projPath = join(projectsDir, projDir);
+    try { if (!statSync(projPath).isDirectory()) continue; } catch { continue; }
+
+    const projectPath = dirToProjectPath(projDir);
+    const projectName = dirToProjectName(projDir);
+    let files: string[];
+    try { files = readdirSync(projPath).filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-')); } catch { continue; }
+
+    for (const file of files) {
+      const filePath = join(projPath, file);
+      const sessionId = basename(file, '.jsonl');
+      scanned++;
+
+      try {
+        const currentSize = statSync(filePath).size;
+        const scanState = getScanState.get(filePath) as { last_size: number } | undefined;
+        if (currentSize === (scanState?.last_size || 0)) continue;
+
+        const content = readFileSync(filePath, 'utf-8');
+        const buckets = parseByDayModel(content);
+
+        if (buckets.size === 0) { setScanState.run(filePath, currentSize); continue; }
+
+        for (const [key, b] of buckets) {
+          const [day, model] = key.split('|');
+          const cost = calcCost(model, b.input, b.output);
+          upsert.run(sessionId, projectPath, projectName, model, day, b.input, b.output, b.cacheRead, b.cacheCreate, cost, b.count);
+        }
+
+        setScanState.run(filePath, currentSize);
+        updated++;
+      } catch { errors++; }
+    }
+  }
+  return { scanned, updated, errors };
+}
+
+/** Record usage from task/mobile/pipeline */
+export function recordUsage(opts: {
+  sessionId: string;
+  source: 'task' | 'mobile' | 'pipeline';
+  projectPath: string;
+  projectName: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens?: number;
+  cacheCreateTokens?: number;
+  taskId?: string;
+}): void {
+  const family = getModelFamily(opts.model);
+  const cost = calcCost(family, opts.inputTokens, opts.outputTokens);
+  const day = toLocalDate(new Date().toISOString());
+
+  db().prepare(`
+    INSERT INTO token_usage (session_id, source, project_path, project_name, model, day, input_tokens, output_tokens, cache_read_tokens, cache_create_tokens, cost_usd, message_count, task_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)
+    ON CONFLICT(session_id, source, model, day) DO UPDATE SET
+      input_tokens = token_usage.input_tokens + excluded.input_tokens,
+      output_tokens = token_usage.output_tokens + excluded.output_tokens,
+      cost_usd = token_usage.cost_usd + excluded.cost_usd,
+      message_count = token_usage.message_count + 1
+  `).run(opts.sessionId, opts.source, opts.projectPath, opts.projectName, family, day, opts.inputTokens, opts.outputTokens, opts.cacheReadTokens || 0, opts.cacheCreateTokens || 0, cost, opts.taskId || null);
+}
+
+/** Query usage data */
+export function queryUsage(opts: {
+  days?: number;
+  projectName?: string;
+  source?: string;
+  model?: string;
+}): {
+  total: { input: number; output: number; cost: number; sessions: number; messages: number };
+  byProject: { name: string; input: number; output: number; cost: number; sessions: number }[];
+  byModel: { model: string; input: number; output: number; cost: number; messages: number }[];
+  byDay: { date: string; input: number; output: number; cost: number }[];
+  bySource: { source: string; input: number; output: number; cost: number; messages: number }[];
+} {
+  let where = '1=1';
+  const params: any[] = [];
+
+  if (opts.days) {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - opts.days);
+    const cutoffDay = `${cutoff.getFullYear()}-${String(cutoff.getMonth() + 1).padStart(2, '0')}-${String(cutoff.getDate()).padStart(2, '0')}`;
+    where += ' AND day >= ?';
+    params.push(cutoffDay);
+  }
+  if (opts.projectName) { where += ' AND project_name = ?'; params.push(opts.projectName); }
+  if (opts.source) { where += ' AND source = ?'; params.push(opts.source); }
+  if (opts.model) { where += ' AND model = ?'; params.push(opts.model); }
+
+  const totalRow = db().prepare(`
+    SELECT COALESCE(SUM(input_tokens), 0) as input, COALESCE(SUM(output_tokens), 0) as output,
+           COALESCE(SUM(cost_usd), 0) as cost, COUNT(DISTINCT session_id) as sessions,
+           COALESCE(SUM(message_count), 0) as messages
+    FROM token_usage WHERE ${where}
+  `).get(...params) as any;
+
+  const byProject = (db().prepare(`
+    SELECT project_name as name, SUM(input_tokens) as input, SUM(output_tokens) as output,
+           SUM(cost_usd) as cost, COUNT(DISTINCT session_id) as sessions
+    FROM token_usage WHERE ${where}
+    GROUP BY project_name ORDER BY cost DESC LIMIT 20
+  `).all(...params) as any[]).map(r => ({
+    name: r.name, input: r.input, output: r.output, cost: +r.cost.toFixed(4), sessions: r.sessions,
+  }));
+
+  const byModel = (db().prepare(`
+    SELECT model, SUM(input_tokens) as input, SUM(output_tokens) as output,
+           SUM(cost_usd) as cost, SUM(message_count) as messages
+    FROM token_usage WHERE ${where}
+    GROUP BY model ORDER BY cost DESC
+  `).all(...params) as any[]).map(r => ({
+    model: r.model, input: r.input, output: r.output, cost: +r.cost.toFixed(4), messages: r.messages,
+  }));
+
+  const byDay = (db().prepare(`
+    SELECT day as date, SUM(input_tokens) as input, SUM(output_tokens) as output, SUM(cost_usd) as cost
+    FROM token_usage WHERE ${where} AND day != 'unknown'
+    GROUP BY day ORDER BY day DESC LIMIT 30
+  `).all(...params) as any[]).map(r => ({
+    date: r.date, input: r.input, output: r.output, cost: +r.cost.toFixed(4),
+  }));
+
+  const bySource = (db().prepare(`
+    SELECT source, SUM(input_tokens) as input, SUM(output_tokens) as output,
+           SUM(cost_usd) as cost, SUM(message_count) as messages
+    FROM token_usage WHERE ${where}
+    GROUP BY source ORDER BY cost DESC
+  `).all(...params) as any[]).map(r => ({
+    source: r.source, input: r.input, output: r.output, cost: +r.cost.toFixed(4), messages: r.messages,
+  }));
+
+  return {
+    total: { input: totalRow.input, output: totalRow.output, cost: +totalRow.cost.toFixed(4), sessions: totalRow.sessions, messages: totalRow.messages },
+    byProject, byModel, byDay, bySource,
+  };
+}

package/.forge/worktrees/pipeline-d6a6ef23/lib/workspace/__tests__/state-machine.test.ts

@@ -0,0 +1,388 @@
+/**
+ * State Machine Tests — verify smith/task status transitions and message flow.
+ *
+ * Usage: npx tsx lib/workspace/__tests__/state-machine.test.ts
+ */
+
+import assert from 'node:assert';
+import { WorkspaceOrchestrator } from '../orchestrator';
+import { AgentBus } from '../agent-bus';
+import type { WorkspaceAgentConfig, AgentState, BusMessage, WorkerEvent } from '../types';
+
+const TEST_WS = 'test-sm-' + Date.now();
+const TEST_PATH = '/tmp/test-sm';
+
+// ─── Helpers ─────────────────────────────────────────────
+
+function createOrch(): WorkspaceOrchestrator {
+  return new WorkspaceOrchestrator(TEST_WS, TEST_PATH, 'test');
+}
+
+function addInput(orch: WorkspaceOrchestrator, id = 'input-1'): void {
+  orch.addAgent({
+    id, label: 'Requirements', icon: '📝', type: 'input',
+    content: '', entries: [], role: '', backend: 'cli',
+    dependsOn: [], outputs: [], steps: [],
+  });
+}
+
+function addAgent(orch: WorkspaceOrchestrator, id: string, label: string, dependsOn: string[]): void {
+  orch.addAgent({
+    id, label, icon: '🤖', role: 'test', backend: 'cli',
+    dependsOn, outputs: [], workDir: id, // unique workDir to avoid conflicts
+    steps: [{ id: 's1', label: 'Step 1', prompt: 'do something' }],
+  });
+}
+
+function getState(orch: WorkspaceOrchestrator, id: string): AgentState {
+  return orch.getAllAgentStates()[id];
+}
+
+function collectEvents(orch: WorkspaceOrchestrator): any[] {
+  const events: any[] = [];
+  orch.on('event', (e: any) => events.push(e));
+  return events;
+}
+
+let passed = 0;
+let failed = 0;
+let testNum = 0;
+
+function ok(condition: boolean, msg: string) {
+  if (condition) {
+    console.log(`  ✅ ${msg}`);
+    passed++;
+  } else {
+    console.log(`  ❌ ${msg}`);
+    failed++;
+  }
+}
+
+function test(name: string, fn: () => void | Promise<void>) {
+  testNum++;
+  console.log(`\n📋 Test ${testNum}: ${name}`);
+  try {
+    const result = fn();
+    if (result instanceof Promise) {
+      return result.catch(e => {
+        console.log(`  💥 Crashed: ${e.message}`);
+        failed++;
+      });
+    }
+  } catch (e: any) {
+    console.log(`  💥 Crashed: ${e.message}`);
+    failed++;
+  }
+}
+
+// ─── Tests ───────────────────────────────────────────────
+
+async function runAll() {
+  console.log('🧪 State Machine Tests\n');
+
+  // Test 1: Initial state
+  await test('Initial agent state', () => {
+    const orch = createOrch();
+    addAgent(orch, 'a1', 'Agent1', []);
+    const s = getState(orch, 'a1');
+    ok(s.smithStatus === 'down', `smithStatus = down (got ${s.smithStatus})`);
+    ok(s.taskStatus === 'idle', `taskStatus = idle (got ${s.taskStatus})`);
+    // mode field removed — execution method determined by tmuxSession presence
+  });
+
+  // Test 2: startDaemon sets all smiths to active
+  await test('startDaemon sets smithStatus=active', async () => {
+    const orch = createOrch();
+    addInput(orch);
+    addAgent(orch, 'pm', 'PM', ['input-1']);
+    addAgent(orch, 'eng', 'Engineer', ['pm']);
+
+    ok(getState(orch, 'pm').smithStatus === 'down', 'PM starts down');
+    ok(getState(orch, 'eng').smithStatus === 'down', 'Engineer starts down');
+
+    await orch.startDaemon();
+
+    ok(getState(orch, 'pm').smithStatus === 'active', 'PM active after startDaemon');
+    ok(getState(orch, 'eng').smithStatus === 'active', 'Engineer active after startDaemon');
+    ok(orch.isDaemonActive(), 'daemonActive = true');
+
+    orch.stopDaemon();
+    ok(getState(orch, 'pm').smithStatus === 'down', 'PM down after stopDaemon');
+    ok(getState(orch, 'eng').smithStatus === 'down', 'Engineer down after stopDaemon');
+    ok(!orch.isDaemonActive(), 'daemonActive = false');
+  });
+
+  // Test 3: stopDaemon preserves taskStatus
+  await test('stopDaemon preserves taskStatus', async () => {
+    const orch = createOrch();
+    addAgent(orch, 'a1', 'Agent1', []);
+
+    // Manually set to done to simulate completed agent
+    const states = orch.getAllAgentStates();
+    (states['a1'] as any).taskStatus = 'done';
+    // Hack: directly modify internal state for testing
+    (orch as any).agents.get('a1').state.taskStatus = 'done';
+
+    await orch.startDaemon();
+    ok(getState(orch, 'a1').taskStatus === 'done', 'taskStatus stays done after startDaemon');
+
+    orch.stopDaemon();
+    ok(getState(orch, 'a1').taskStatus === 'done', 'taskStatus stays done after stopDaemon');
+  });
+
+  // Test 4: loadSnapshot resets smith to down and pending messages to failed
+  await test('loadSnapshot resets state correctly', () => {
+    const orch = createOrch();
+
+    const busLog: BusMessage[] = [
+      { id: 'm1', from: 'a', to: 'b', type: 'notify', payload: { action: 'test' }, timestamp: Date.now(), status: 'pending' },
+      { id: 'm2', from: 'a', to: 'b', type: 'notify', payload: { action: 'test2' }, timestamp: Date.now(), status: 'done' },
+      { id: 'm3', from: 'a', to: 'b', type: 'notify', payload: { action: 'test3' }, timestamp: Date.now(), status: 'pending' },
+    ];
+
+    orch.loadSnapshot({
+      agents: [{
+        id: 'a1', label: 'Agent1', icon: '🤖', role: '', backend: 'cli',
+        dependsOn: [], outputs: [], workDir: 'a1',
+        steps: [{ id: 's1', label: 'Step1', prompt: 'test' }],
+      }],
+      agentStates: {
+        'a1': {
+          smithStatus: 'active', taskStatus: 'running',
+          history: [], artifacts: [],
+        } as AgentState,
+      },
+      busLog,
+    });
+
+    const s = getState(orch, 'a1');
+    ok(s.smithStatus === 'down', 'smithStatus reset to down after load');
+    ok(s.taskStatus === 'failed', 'running taskStatus becomes failed after load');
+
+    // Check bus messages
+    const log = orch.getBusLog();
+    const m1 = log.find(m => m.id === 'm1');
+    const m2 = log.find(m => m.id === 'm2');
+    const m3 = log.find(m => m.id === 'm3');
+    ok(m1?.status === 'failed', 'pending message m1 marked failed');
+    ok(m2?.status === 'done', 'acked message m2 unchanged');
+    ok(m3?.status === 'failed', 'pending message m3 marked failed');
+  });
+
+  // Test 5: completeInput sends input_updated messages (no daemon to avoid CLI spawn)
+  await test('completeInput sends bus messages to downstream', () => {
+    const orch = createOrch();
+    addInput(orch);
+    addAgent(orch, 'pm', 'PM', ['input-1']);
+
+    // Don't start daemon — just test that completeInput sends bus messages
+    const busLog = orch.getBusLog();
+    const before = busLog.length;
+
+    orch.completeInput('input-1', 'Build a todo app');
+
+    const after = busLog.length;
+    ok(after > before, `New bus messages sent (${before} → ${after})`);
+
+    const inputMsgs = busLog.filter(m => m.payload.action === 'input_updated');
+    ok(inputMsgs.length > 0, 'input_updated message found');
+    ok(inputMsgs[0].from === 'input-1', 'from = input-1');
+    ok(inputMsgs[0].to === 'pm', 'to = pm');
+    // Smith is down so message stays pending (not acked)
+    ok(inputMsgs[0].status === 'pending', `message pending (smith down) — got ${inputMsgs[0].status}`);
+  });
+
+  // Test 6: broadcastCompletion sends upstream_complete (no daemon)
+  await test('broadcastCompletion sends upstream_complete', () => {
+    const orch = createOrch();
+    addInput(orch);
+    addAgent(orch, 'pm', 'PM', ['input-1']);
+    addAgent(orch, 'eng', 'Engineer', ['pm']);
+
+    // Set PM to done with artifacts
+    (orch as any).agents.get('pm').state.taskStatus = 'done';
+    (orch as any).agents.get('pm').state.artifacts = [{ type: 'file', path: 'docs/prd.md' }];
+    (orch as any).agents.get('pm').state.history = [
+      { type: 'result', subtype: 'final_summary', content: 'PRD completed', timestamp: new Date().toISOString() }
+    ];
+
+    (orch as any).broadcastCompletion('pm');
+
+    const busLog = orch.getBusLog();
+    const upstreamMsgs = busLog.filter(m => m.payload.action === 'upstream_complete' && m.from === 'pm');
+    ok(upstreamMsgs.length > 0, 'upstream_complete message sent');
+    ok(upstreamMsgs[0].to === 'eng', 'sent to Engineer');
+    ok(upstreamMsgs[0].payload.files?.includes('docs/prd.md') === true, 'includes file path');
+  });
+
+  // Test 7: Bus message ACK flow
+  await test('Bus message ACK: pending → acked on success, pending → failed on error', () => {
+    const bus = new AgentBus();
+    bus.setAgentStatus('a', 'alive');
+    bus.setAgentStatus('b', 'alive');
+
+    const msg = bus.send('a', 'b', 'notify', { action: 'test', content: 'hello' });
+    ok(msg.status === 'pending', 'starts as pending');
+
+    // Simulate ack
+    msg.status = 'done';
+    ok(msg.status === 'done', 'acked after processing');
+
+    // Test failed path
+    const msg2 = bus.send('a', 'b', 'notify', { action: 'test2', content: 'world' });
+    msg2.status = 'failed';
+    ok(msg2.status === 'failed', 'failed on error');
+
+    // Test retry
+    const retried = bus.retryMessage(msg2.id);
+    ok(retried !== null, 'retryMessage returns message');
+    ok(retried!.status === 'pending', 'retried message back to pending');
+  });
+
+  // Test 8: markAllPendingAsFailed
+  await test('markAllPendingAsFailed on restart', () => {
+    const bus = new AgentBus();
+    bus.setAgentStatus('a', 'alive');
+    bus.setAgentStatus('b', 'alive');
+
+    const m1 = bus.send('a', 'b', 'notify', { action: 'test1' });
+    const m2 = bus.send('a', 'b', 'notify', { action: 'test2' });
+    m1.status = 'done'; // already processed
+    // m2 stays pending
+
+    bus.markAllPendingAsFailed();
+
+    ok(m1.status === 'done', 'acked message unchanged');
+    ok(m2.status === 'failed', 'pending message marked failed');
+  });
+
+  // Test 9: Manual run (force) dep check logic — test validateCanRun vs force dep check
+  await test('Force run checks smith active, normal run checks taskStatus done', () => {
+    const orch = createOrch();
+    addInput(orch);
+    addAgent(orch, 'pm', 'PM', ['input-1']);
+    addAgent(orch, 'eng', 'Engineer', ['pm']);
+
+    // Normal validateCanRun: PM idle → should fail
+    let error1 = '';
+    try { orch.validateCanRun('eng'); } catch (e: any) { error1 = e.message; }
+    ok(error1.includes('not completed'), `Normal: rejects when PM idle`);
+
+    // PM done → should pass
+    (orch as any).agents.get('pm').state.taskStatus = 'done';
+    let error2 = '';
+    try { orch.validateCanRun('eng'); } catch (e: any) { error2 = e.message; }
+    ok(!error2, `Normal: passes when PM done`);
+
+    // Force dep check: PM smith down → should fail
+    (orch as any).agents.get('pm').state.taskStatus = 'idle';
+    (orch as any).agents.get('pm').state.smithStatus = 'down';
+    // Simulate the force dep check from runAgentDaemon
+    const config = (orch as any).agents.get('eng').config;
+    let forceError = '';
+    for (const depId of config.dependsOn) {
+      const dep = (orch as any).agents.get(depId);
+      if (dep && dep.config.type !== 'input' && dep.state.smithStatus !== 'active') {
+        forceError = `${dep.config.label} smith not active`;
+      }
+    }
+    ok(forceError.includes('not active'), `Force: rejects when PM smith down`);
+
+    // PM smith active → should pass
+    (orch as any).agents.get('pm').state.smithStatus = 'active';
+    forceError = '';
+    for (const depId of config.dependsOn) {
+      const dep = (orch as any).agents.get(depId);
+      if (dep && dep.config.type !== 'input' && dep.state.smithStatus !== 'active') {
+        forceError = `${dep.config.label} smith not active`;
+      }
+    }
+    ok(!forceError, `Force: passes when PM smith active`);
+  });
+
+  // Test 10: Auto trigger requires taskStatus=done (check via validateCanRun)
+  await test('Auto trigger requires dep taskStatus=done', () => {
+    const orch = createOrch();
+    addInput(orch);
+    addAgent(orch, 'pm', 'PM', ['input-1']);
+    addAgent(orch, 'eng', 'Engineer', ['pm']);
+
+    // PM is idle — validateCanRun for Engineer should fail
+    let error = '';
+    try {
+      orch.validateCanRun('eng');
+    } catch (e: any) {
+      error = e.message;
+    }
+    ok(error.includes('not completed'), `validateCanRun rejects when PM idle: ${error}`);
+
+    // Set PM to done — should pass
+    (orch as any).agents.get('pm').state.taskStatus = 'done';
+    let error2 = '';
+    try {
+      orch.validateCanRun('eng');
+    } catch (e: any) {
+      error2 = e.message;
+    }
+    ok(!error2, `validateCanRun passes when PM done (got: ${error2 || 'no error'})`);
+  });
+
+  // Test 11: taskStatus transitions - never goes from done to idle
+  await test('taskStatus never goes from done→idle', async () => {
+    const orch = createOrch();
+    addAgent(orch, 'a1', 'Agent1', []);
+
+    // Set to done
+    (orch as any).agents.get('a1').state.taskStatus = 'done';
+    (orch as any).agents.get('a1').state.smithStatus = 'active';
+
+    // Stop daemon should NOT change taskStatus
+    await orch.startDaemon();
+    orch.stopDaemon();
+
+    ok(getState(orch, 'a1').taskStatus === 'done',
+      `taskStatus stays done after stop (got ${getState(orch, 'a1').taskStatus})`);
+  });
+
+  // Test 12: startDaemon doesn't re-send input messages
+  await test('startDaemon does NOT broadcast existing input', async () => {
+    const orch = createOrch();
+    addInput(orch);
+    addAgent(orch, 'pm', 'PM', ['input-1']);
+
+    // Complete input first
+    orch.completeInput('input-1', 'test content');
+
+    const busLogBefore = orch.getBusLog().length;
+
+    await orch.startDaemon();
+
+    const busLogAfter = orch.getBusLog().length;
+    const newMsgs = orch.getBusLog().slice(busLogBefore);
+    const inputMsgs = newMsgs.filter(m => m.payload.action === 'input_updated');
+
+    ok(inputMsgs.length === 0, `No input_updated sent by startDaemon (got ${inputMsgs.length})`);
+
+    orch.stopDaemon();
+  });
+
+  // ─── Summary ──────────────────────────────────────────
+
+  console.log('\n' + '═'.repeat(40));
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  console.log('═'.repeat(40));
+
+  console.log('');
+  if (failed > 0) {
+    process.exit(1);
+  } else {
+    process.exit(0);
+  }
+}
+
+// Force exit after 8s in case of dangling timers/workers
+setTimeout(() => {
+  console.log('\n(Force exit due to dangling timers)');
+  process.exit(passed > 0 && failed === 0 ? 0 : 1);
+}, 8000);
+runAll();