@aion0/forge 0.6.1 → 0.6.3

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

@@ -1,249 +0,0 @@
-/**
- * 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-d59c2fe2/lib/workspace/__tests__/state-machine.test.ts

@@ -1,388 +0,0 @@
-/**
- * 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();