@shipers-dev/multi 0.12.0 → 0.13.0

package/src/index.ts

@@ -1,1784 +0,0 @@
-#!/usr/bin/env bun
-
-import { detectAgents } from './detect';
-import { apiClient, setAuthToken } from './client';
-import { Database } from 'bun:sqlite';
-import { runAcp } from './acp-runner';
-import { runAcpx } from './acpx-runner';
-import { STREAM_SCHEMA_VERSION, type StreamEventType, type CliStreamEmit } from '@multi/lib';
-import { ensureWorktree } from './worktree';
-import { materializeBundle, lastMaterializedRevision } from './materializer';
-import { parseArgs } from 'util';
-import { mkdirSync, existsSync, writeFileSync, readFileSync, appendFileSync, unlinkSync, readdirSync, statSync } from 'fs';
-import { join, dirname } from 'path';
-import pkg from '../package.json' with { type: 'json' };
-
-const HOME = process.env.HOME || process.env.USERPROFILE || '.';
-const MULTI_DIR = join(HOME, '.multi');
-const CONFIG_PATH = join(MULTI_DIR, 'config.json');
-const PID_PATH = join(MULTI_DIR, 'agent.pid');
-const PORT_PATH = join(MULTI_DIR, 'agent.port');
-const LOG_PATH = join(MULTI_DIR, 'logs', 'agent.log');
-const SKILLS_DIR = join(MULTI_DIR, 'skills');
-const STOP_PATH = join(MULTI_DIR, 'stop.flag');
-const TASKS_DB_PATH = join(MULTI_DIR, 'tasks.db');
-const VERSION = (pkg as { version: string }).version;
-
-const COMMANDS = {
-  setup: 'Register this device with a workspace',
-  connect: 'Connect device to realtime hub and execute assigned tasks',
-  link: 'Link this device to an agent (agent_id required)',
-  status: 'Show current status',
-  stop: 'Stop the running daemon',
-  restart: 'Stop and relaunch the daemon in background',
-  logs: 'View execution logs',
-  reset: 'Reset acpx session for an issue (--issue <id>)',
-} as const;
-
-type Command = keyof typeof COMMANDS;
-
-function ensureDirs() {
-  for (const d of [MULTI_DIR, join(MULTI_DIR, 'logs'), SKILLS_DIR]) {
-    if (!existsSync(d)) mkdirSync(d, { recursive: true });
-  }
-}
-
-function log(msg: string) {
-  ensureDirs();
-  const line = `[${new Date().toISOString()}] ${msg}\n`;
-  appendFileSync(LOG_PATH, line);
-  process.stdout.write(line);
-}
-
-async function main() {
-  const rawArgs = Bun.argv.slice(2);
-  if (rawArgs.includes('--version') || rawArgs.includes('-v')) {
-    console.log(VERSION);
-    process.exit(0);
-  }
-
-  const args = parseArgs({
-    args: Bun.argv,
-    options: {
-      help: { type: 'boolean', default: false, short: 'h' },
-      version: { type: 'boolean', default: false },
-      detach: { type: 'boolean', default: false, short: 'd' },
-      name: { type: 'string' },
-      workspace: { type: 'string' },
-      agent: { type: 'string' },
-      api: { type: 'string' },
-      issue: { type: 'string' },
-    },
-    allowPositionals: true,
-    strict: false,
-  });
-
-  const [command] = args.positionals.slice(2) as Command[];
-
-  if (args.values.help || !command) {
-    printHelp();
-    process.exit(0);
-  }
-
-  const apiUrl = args.values.api || process.env.MULTI_API_URL || 'https://multi-api.adnb3r.workers.dev';
-  const config = loadConfig();
-  if (config.token) setAuthToken(config.token);
-
-  switch (command) {
-    case 'setup':
-      await cmdSetup(args.values.name, apiUrl);
-      break;
-    case 'connect':
-    case 'start':
-      if (args.values.detach) {
-        await cmdConnectDetached(apiUrl);
-      } else {
-        await cmdConnect(apiUrl, config);
-      }
-      break;
-    case 'link':
-      await cmdLink(apiUrl, config, args.values.agent);
-      break;
-    case 'status':
-      await cmdStatus(apiUrl, config);
-      break;
-    case 'stop':
-      await cmdStop();
-      break;
-    case 'restart':
-      await cmdRestart(apiUrl);
-      break;
-    case 'logs':
-      await cmdLogs();
-      break;
-    case 'reset':
-      await cmdReset(args.values.issue);
-      break;
-    default:
-      console.error(`Unknown command: ${command}`);
-      printHelp();
-      process.exit(1);
-  }
-}
-
-function printHelp() {
-  console.log(`
-multi-agent v${VERSION} - Device CLI for Multi platform
-
-Usage: multi-agent <command> [options]
-
-Commands:
-  setup     ${COMMANDS.setup}
-  link      ${COMMANDS.link}
-  connect   ${COMMANDS.connect}
-  status    ${COMMANDS.status}
-  stop      ${COMMANDS.stop}
-  restart   ${COMMANDS.restart}
-  logs      ${COMMANDS.logs}
-  reset     ${COMMANDS.reset}
-
-Options:
-  --name <name>       Device name
-  --agent <id>        Agent ID (for link)
-  --api <url>         API URL
-  -d, --detach        Run connect in background (daemon)
-  -v, --version       Print version
-  -h, --help          Show this help
-
-Examples:
-  multi-agent setup --name "My Mac" --workspace ws_xxx
-  multi-agent link --agent agent_xxx
-  multi-agent connect
-`);
-}
-
-async function cmdSetup(name?: string, apiUrl?: string) {
-  ensureDirs();
-
-  console.log('🔍 Detecting local agent runtimes...');
-  const detected = await detectAgents();
-  for (const a of detected) console.log(`  ✓ ${a.type} at ${a.path}`);
-  if (!detected.length) console.log('  (none detected — stub runtime will be used)');
-
-  const deviceName = name || process.env.HOSTNAME || 'Unknown Device';
-  console.log(`\n📡 Requesting pairing code for "${deviceName}"...`);
-
-  const start = await apiClient.post<{ code: string; expires_at: number }>(`${apiUrl}/api/pair/start`, {
-    name: deviceName,
-    platform: process.platform,
-    arch: process.arch,
-    os_version: process.version,
-    detected_runtimes: detected.map(a => a.type),
-  });
-  if (!start.success || !start.data) {
-    console.log('\n❌ Failed to start pairing:', start.error);
-    process.exit(1);
-  }
-
-  const { code } = start.data;
-  const pairUrl = `${apiUrl}/pair/${code}`;
-  console.log(`\n👉 Open this URL in your browser to approve:\n\n   ${pairUrl}\n`);
-  console.log(`   Or enter code manually: ${code}`);
-  console.log('\n⏳ Waiting for approval (10 min timeout)...');
-
-  const deadline = Date.now() + 10 * 60 * 1000;
-  let approved: { device_id: string; token: string; dispatch_secret: string } | null = null;
-  while (Date.now() < deadline) {
-    await sleep(3000);
-    const poll = await apiClient.get<any>(`${apiUrl}/api/pair/poll/${code}`);
-    if (!poll.success) {
-      if (poll.status === 410) { console.log('\n❌ Pairing expired. Run setup again.'); process.exit(1); }
-      continue;
-    }
-    if (poll.data?.status === 'approved') {
-      approved = { device_id: poll.data.device_id, token: poll.data.token, dispatch_secret: poll.data.dispatch_secret };
-      break;
-    }
-  }
-  if (!approved) { console.log('\n❌ Timed out.'); process.exit(1); }
-
-  console.log(`\n✅ Device paired. ID: ${approved.device_id}`);
-  saveConfig({ deviceId: approved.device_id, token: approved.token, dispatchSecret: approved.dispatch_secret, apiUrl });
-  setAuthToken(approved.token);
-
-  // Fetch workspace_id from device (now authed)
-  const dev = await apiClient.get<any>(`${apiUrl}/api/devices/${approved.device_id}`);
-  const workspaceId = dev.data?.workspace_id;
-  if (workspaceId) {
-    saveConfig({ deviceId: approved.device_id, token: approved.token, dispatchSecret: approved.dispatch_secret, workspaceId, apiUrl });
-    try { await materializeBundle(apiUrl!, approved.device_id, (m) => console.log(`   ${m}`)); } catch (e) { console.log(`   materialize failed: ${String(e)}`); }
-  }
-  console.log('\nNext: link to an agent with: multi-agent link --agent <agentId>');
-  console.log('Then: multi-agent connect');
-}
-
-async function cmdLink(apiUrl: string, config: Config, agentId?: string) {
-  if (!config.deviceId) {
-    console.log('❌ Not registered. Run "multi-agent setup" first.');
-    process.exit(1);
-  }
-  if (!agentId) {
-    console.log('❌ Agent ID required: multi-agent link --agent <id>');
-    process.exit(1);
-  }
-  const res = await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/link`, { agent_id: agentId });
-  if (!res.success) {
-    console.log('❌ Link failed:', res.error);
-    process.exit(1);
-  }
-  console.log(`✅ Linked agent ${agentId} ↔ device ${config.deviceId}`);
-}
-
-async function cmdConnect(apiUrl: string, config: Config) {
-  if (!config.deviceId || !config.token) {
-    console.log('❌ Not registered. Run "multi-agent setup" first.');
-    process.exit(1);
-  }
-  if (!config.dispatchSecret) {
-    console.log('❌ Missing dispatch secret. Re-pair via "multi-agent setup".');
-    process.exit(1);
-  }
-
-  if (existsSync(PID_PATH)) {
-    const pid = Number(readFileSync(PID_PATH, 'utf8').trim());
-    if (pid && isRunning(pid)) {
-      console.log(`❌ Daemon already running (pid ${pid}).`);
-      process.exit(1);
-    }
-    unlinkSync(PID_PATH);
-  }
-  ensureDirs();
-  writeFileSync(PID_PATH, String(process.pid));
-  if (existsSync(STOP_PATH)) unlinkSync(STOP_PATH);
-
-  const detected = await detectAgents();
-  log(`🚀 Starting daemon for device ${config.deviceId} (pid ${process.pid})`);
-  log(`   runtimes: ${detected.map(d => d.type).join(', ') || 'stub'}`);
-
-  const db = openTasksDb();
-
-  // Requeue orphaned 'running' tasks from previous crash
-  db.run("UPDATE tasks SET status = 'queued' WHERE status = 'running'");
-
-  const MAX_DEVICE = Math.max(1, parseInt(process.env.MULTI_MAX_CONCURRENT ?? '3', 10) || 3);
-  // Keyed by task row id — unique per dispatch. Duplicate issue_id / agent_id still
-  // serialize via busyAgents/busyIssues filters.
-  const running = new Map<string, RunEntry>();
-
-  function resolvePayloadIds(row: { payload: string; agent_id: string | null; issue_id: string | null }): { agent_id: string | null; issue_id: string | null } {
-    let agent_id = row.agent_id;
-    let issue_id = row.issue_id;
-    if (!agent_id || !issue_id) {
-      try {
-        const p = JSON.parse(row.payload) as any;
-        agent_id ??= p?.agent_id ?? null;
-        issue_id ??= p?.issue_id ?? null;
-      } catch {}
-    }
-    return { agent_id, issue_id };
-  }
-
-  function pickNext(): { id: string; payload: string; agent_id: string | null; issue_id: string | null } | null {
-    const busyAgents = Array.from(running.values()).map((e) => e.agentId).filter((v): v is string => !!v);
-    const busyIssues = Array.from(running.values()).map((e) => e.issueId).filter((v): v is string => !!v);
-    const clauses: string[] = [];
-    const binds: string[] = [];
-    if (busyAgents.length) {
-      clauses.push(`(agent_id IS NULL OR agent_id NOT IN (${busyAgents.map(() => '?').join(',')}))`);
-      binds.push(...busyAgents);
-    }
-    if (busyIssues.length) {
-      clauses.push(`(issue_id IS NULL OR issue_id NOT IN (${busyIssues.map(() => '?').join(',')}))`);
-      binds.push(...busyIssues);
-    }
-    const where = clauses.length ? `AND ${clauses.join(' AND ')}` : '';
-    const sql = `SELECT id, payload, agent_id, issue_id FROM tasks WHERE status = 'queued' ${where} ORDER BY created_at ASC LIMIT 1`;
-    return db.query(sql).get(...binds) as any;
-  }
-
-  function schedule() {
-    while (running.size < MAX_DEVICE) {
-      const row = pickNext();
-      if (!row) return;
-      const ids = resolvePayloadIds(row);
-      // Defensive: if DB saw NULL agent/issue but payload has them, skip if busy.
-      if (ids.agent_id && Array.from(running.values()).some((e) => e.agentId === ids.agent_id)) return;
-      if (ids.issue_id && Array.from(running.values()).some((e) => e.issueId === ids.issue_id)) return;
-      db.run("UPDATE tasks SET status = 'running', started_at = unixepoch(), attempts = attempts + 1 WHERE id = ?", [row.id]);
-      const entry: RunEntry = { agentId: ids.agent_id || '', issueId: ids.issue_id, startedAt: Date.now(), child: null, worktreePath: '' };
-      running.set(row.id, entry);
-      void (async () => {
-        try {
-          const task = JSON.parse(row.payload);
-          await handleRunTask(apiUrl, config.deviceId!, task, detected, { runEntry: entry });
-          db.run("UPDATE tasks SET status = 'done', finished_at = unixepoch() WHERE id = ?", [row.id]);
-        } catch (e) {
-          log(`task ${row.id} error: ${String(e)}`);
-          db.run("UPDATE tasks SET status = 'failed', finished_at = unixepoch(), error = ? WHERE id = ?", [String(e), row.id]);
-        } finally {
-          running.delete(row.id);
-          queueMicrotask(() => schedule());
-        }
-      })();
-    }
-  }
-
-
-  // Local HTTP server on a free port
-  const port = await pickFreePort();
-  const expectedAuth = `Bearer ${config.dispatchSecret}`;
-  const server = Bun.serve({
-    port, hostname: '127.0.0.1',
-    fetch(req) {
-      const url = new URL(req.url);
-      if (url.pathname === '/health') return Response.json({ ok: true, device_id: config.deviceId });
-      if (url.pathname === '/run' && req.method === 'POST') {
-        if (req.headers.get('authorization') !== expectedAuth) return new Response('unauthorized', { status: 401 });
-        return (async () => {
-          try {
-            const body = await req.json() as { task: any };
-            const t = body?.task || {};
-            const taskId = t.issue_id ? `${t.issue_id}-${Date.now()}` : crypto.randomUUID();
-            db.run(
-              "INSERT INTO tasks (id, status, payload, agent_id, issue_id) VALUES (?, 'queued', ?, ?, ?)",
-              [taskId, JSON.stringify(t), t.agent_id ?? null, t.issue_id ?? null],
-            );
-            const pos = (db.query("SELECT COUNT(*) AS c FROM tasks WHERE status = 'queued' AND created_at <= (SELECT created_at FROM tasks WHERE id = ?)").get(taskId) as any)?.c ?? 1;
-            if (t.issue_id) {
-              void postStream(apiUrl, t.issue_id, 'queued', { queue_position: pos });
-            }
-            // Ack dispatch back to worker so UI flips from queued → acked. Fire-and-forget:
-            // missing/failed ack is fine, stall-sweep covers it.
-            if (t.dispatch_id) {
-              void ackDispatch(apiUrl, t.dispatch_id, config.dispatchSecret!);
-            }
-            queueMicrotask(() => schedule());
-            return Response.json({ accepted: true, task_id: taskId }, { status: 202 });
-          } catch (e) {
-            return Response.json({ error: String(e) }, { status: 400 });
-          }
-        })();
-      }
-      if (url.pathname === '/reset_session' && req.method === 'POST') {
-        if (req.headers.get('authorization') !== expectedAuth) return new Response('unauthorized', { status: 401 });
-        return (async () => {
-          try {
-            const { issue_id, agent_type } = await req.json() as { issue_id: string; agent_type?: string };
-            if (!issue_id) return Response.json({ error: 'issue_id required' }, { status: 400 });
-
-            // Kill any running acpx child for this issue.
-            const entries = Array.from(running.values()).filter((e) => e.issueId === issue_id);
-            for (const entry of entries) {
-              entry.stopped = true;
-              entry.stopReason = 'session reset';
-              try { entry.child?.kill('SIGTERM'); } catch {}
-              setTimeout(() => { try { entry.child?.kill('SIGKILL'); } catch {} }, 3000);
-            }
-
-            // Close acpx session so next dispatch creates fresh. Only known acpx types.
-            const acpxTypes = agent_type ? [agent_type] : ['pi', 'codex', 'openclaw'];
-            const sessionName = `issue-${issue_id}`;
-            const cwd = process.env.HOME || process.cwd();
-            const results: { agent: string; exit: number; stderr: string }[] = [];
-            for (const t of acpxTypes) {
-              try {
-                const rm = Bun.spawn(['acpx', '--ttl', '0', '--cwd', cwd, t, 'sessions', 'close', sessionName], {
-                  stdout: 'pipe', stderr: 'pipe', stdin: 'ignore',
-                });
-                const err = await new Response(rm.stderr as any).text();
-                const exit = await rm.exited;
-                results.push({ agent: t, exit, stderr: err.slice(0, 200) });
-              } catch (e) {
-                results.push({ agent: t, exit: -1, stderr: String(e).slice(0, 200) });
-              }
-            }
-            log(`🔄 reset_session ${issue_id} (killed=${entries.length}) ${results.map(r => `${r.agent}:${r.exit}`).join(' ')}`);
-            return Response.json({ ok: true, killed: entries.length, sessions: results });
-          } catch (e) {
-            return Response.json({ error: String(e) }, { status: 400 });
-          }
-        })();
-      }
-      if (url.pathname === '/stop' && req.method === 'POST') {
-        if (req.headers.get('authorization') !== expectedAuth) return new Response('unauthorized', { status: 401 });
-        return (async () => {
-          try {
-            const { issue_id } = await req.json() as { issue_id: string };
-            if (!issue_id) return Response.json({ error: 'issue_id required' }, { status: 400 });
-            const entries = Array.from(running.values()).filter((e) => e.issueId === issue_id);
-            if (!entries.length) {
-              db.run("UPDATE tasks SET status = 'failed', error = 'stopped before start', finished_at = unixepoch() WHERE issue_id = ? AND status = 'queued'", [issue_id]);
-              await markStopped(apiUrl, issue_id, 'stopped before start');
-              return Response.json({ ok: true, state: 'queued-cancelled' });
-            }
-            for (const entry of entries) {
-              entry.stopped = true;
-              entry.stopReason = 'user requested';
-              try { entry.child?.kill('SIGTERM'); } catch {}
-              setTimeout(() => { try { entry.child?.kill('SIGKILL'); } catch {} }, 5000);
-            }
-            return Response.json({ ok: true, state: 'running-signalled' });
-          } catch (e) {
-            return Response.json({ error: String(e) }, { status: 400 });
-          }
-        })();
-      }
-      return new Response('not found', { status: 404 });
-    },
-  });
-  log(`🌐 Local server: http://127.0.0.1:${port}`);
-  try { writeFileSync(PORT_PATH, String(port)); } catch {}
-
-  // Spawn cloudflared quick tunnel (with self-healing on death)
-  let tunnel = await startTunnel(port);
-  if (!tunnel) {
-    log('❌ cloudflared did not emit a tunnel URL — is `cloudflared` installed? (`brew install cloudflared`)');
-    try { server.stop(); } catch {}
-    process.exit(1);
-  }
-  log(`☁️  Tunnel up: ${tunnel.url}`);
-
-  const heartbeat = async (): Promise<number> => {
-    const res = await apiClient.post<{ pending_dispatches?: number; agent_skill_revision?: number }>(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online', tunnel_url: tunnel?.url });
-    if (res.success && res.data) {
-      const remoteRev = Number(res.data.agent_skill_revision ?? 0);
-      if (remoteRev > 0 && remoteRev !== lastMaterializedRevision()) {
-        try { await materializeBundle(apiUrl, config.deviceId!, log); }
-        catch (e) { log(`materialize error: ${String(e)}`); }
-      }
-    }
-    return (res.success && res.data?.pending_dispatches) || 0;
-  };
-  {
-    const pending = await heartbeat();
-    if (pending > 0) void drainOfflineDispatches(apiUrl, config.deviceId!, config.dispatchSecret!, db, () => schedule());
-  }
-  // Always attempt one drain on fresh startup, covering the case where worker
-  // couldn't reach the previous daemon instance right before restart.
-  void drainOfflineDispatches(apiUrl, config.deviceId!, config.dispatchSecret!, db, () => schedule());
-
-  let alive = true;
-
-  const shutdown = async (reason: string) => {
-    if (!alive) return;
-    alive = false;
-    log(`🛑 Shutting down (${reason})`);
-    try { server.stop(); } catch {}
-    try { tunnel?.child.kill(); } catch {}
-    try { await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'offline', tunnel_url: null }); } catch {}
-    if (existsSync(PID_PATH)) unlinkSync(PID_PATH);
-    if (existsSync(STOP_PATH)) unlinkSync(STOP_PATH);
-    if (existsSync(PORT_PATH)) unlinkSync(PORT_PATH);
-    db.close();
-    log('👋 Disconnected');
-    process.exit(0);
-  };
-  process.on('SIGINT', () => shutdown('SIGINT'));
-  process.on('SIGTERM', () => shutdown('SIGTERM'));
-
-  // Kick the scheduler on startup to drain any leftover queued rows.
-  schedule();
-
-  // Tunnel self-heal: relaunch cloudflared if child exits or DNS stops resolving.
-  // `restarting` guards against two entries racing (probe-failure + exit-watcher
-  // both firing when we kill the child as part of our own restart).
-  let restarting = false;
-  const restartTunnel = async (reason: string) => {
-    if (!alive || restarting) return;
-    restarting = true;
-    try {
-      log(`🔁 Restarting tunnel (${reason})`);
-      const old = tunnel;
-      tunnel = null; // null first so the exit-watcher's `tunnel === t` check skips our own kill
-      try { old?.child.kill(); } catch {}
-      for (let attempt = 1; alive; attempt++) {
-        const next = await startTunnel(port);
-        if (next) {
-          tunnel = next;
-          log(`☁️  Tunnel up: ${tunnel.url}`);
-          try {
-            const pending = await heartbeat();
-            if (pending > 0) void drainOfflineDispatches(apiUrl, config.deviceId!, config.dispatchSecret!, db, () => schedule());
-          } catch (e) {
-            log(`heartbeat error after tunnel restart: ${String(e)}`);
-          }
-          return;
-        }
-        const wait = Math.min(30000, 2000 * attempt);
-        log(`tunnel restart failed, retry in ${wait}ms`);
-        await sleep(wait);
-      }
-    } finally {
-      restarting = false;
-    }
-  };
-
-  // Watch for cloudflared process exit.
-  (async () => {
-    while (alive) {
-      const t = tunnel;
-      if (!t) { await sleep(1000); continue; }
-      const code = await t.child.exited;
-      if (!alive) return;
-      // If `tunnel` was nulled by restartTunnel, we killed it ourselves — skip.
-      if (tunnel === t) await restartTunnel(`cloudflared exited code=${code}`);
-    }
-  })();
-
-  // Heartbeat (20s) + tunnel liveness probe (every 6 ticks = ~2min).
-  let probeFailures = 0;
-  let tick = 0;
-  const PROBE_EVERY = 6;
-  while (alive) {
-    await sleep(20000);
-    if (existsSync(STOP_PATH)) { await shutdown('stop flag'); break; }
-    tick++;
-    const currentUrl = tunnel?.url;
-    if (currentUrl && tick % PROBE_EVERY === 0) {
-      const ok = await probeTunnel(currentUrl);
-      if (!ok) {
-        probeFailures++;
-        log(`tunnel probe failed (${probeFailures}/2): ${currentUrl}`);
-        if (probeFailures >= 2) {
-          probeFailures = 0;
-          await restartTunnel('probe failed 2x');
-          continue;
-        }
-      } else {
-        probeFailures = 0;
-      }
-    }
-    try {
-      const pending = await heartbeat();
-      if (pending > 0) void drainOfflineDispatches(apiUrl, config.deviceId!, config.dispatchSecret!, db, () => schedule());
-    } catch (e) {
-      log(`heartbeat error: ${String(e)}`);
-    }
-  }
-}
-
-async function startTunnel(port: number): Promise<{ child: ReturnType<typeof Bun.spawn>; url: string } | null> {
-  const child = Bun.spawn(['cloudflared', 'tunnel', '--no-autoupdate', '--url', `http://127.0.0.1:${port}`], {
-    stdout: 'pipe', stderr: 'pipe', stdin: 'ignore',
-  });
-  const url = await parseTunnelUrl(child.stderr as ReadableStream<Uint8Array>);
-  if (!url) {
-    try { child.kill(); } catch {}
-    return null;
-  }
-  return { child, url };
-}
-
-async function probeTunnel(url: string): Promise<boolean> {
-  try {
-    const ctrl = new AbortController();
-    const t = setTimeout(() => ctrl.abort(), 8000);
-    // Any HTTP response — even 404 — proves the tunnel edge is routing.
-    const res = await fetch(url, { method: 'GET', signal: ctrl.signal });
-    clearTimeout(t);
-    return res.status > 0;
-  } catch {
-    return false;
-  }
-}
-
-async function cmdConnectDetached(apiUrl: string) {
-  if (existsSync(PID_PATH)) {
-    const pid = Number(readFileSync(PID_PATH, 'utf8').trim());
-    if (pid && isRunning(pid)) {
-      console.log(`❌ Daemon already running (pid ${pid}).`);
-      process.exit(1);
-    }
-  }
-  ensureDirs();
-  const logFd = Bun.file(LOG_PATH);
-  // Re-exec ourselves with same args minus --detach
-  const args = Bun.argv.slice(1).filter(a => a !== '-d' && a !== '--detach');
-  const proc = Bun.spawn([process.execPath, ...args, '--api', apiUrl], {
-    stdio: ['ignore', 'ignore', 'ignore'],
-    env: { ...process.env, MULTI_DETACHED: '1' },
-  });
-  (proc as any).unref?.();
-  // Give daemon a moment to write pidfile
-  await sleep(500);
-  console.log(`✅ Daemon started in background (pid ${proc.pid}).`);
-  console.log(`   Tail logs: multi-agent logs`);
-  console.log(`   Stop: multi-agent stop`);
-  process.exit(0);
-}
-
-async function pickFreePort(): Promise<number> {
-  // Bind to 0, read assigned port, close immediately.
-  for (let i = 0; i < 10; i++) {
-    const p = 40000 + Math.floor(Math.random() * 20000);
-    try {
-      const s = Bun.serve({ port: p, hostname: '127.0.0.1', fetch: () => new Response('ok') });
-      s.stop();
-      return p;
-    } catch {}
-  }
-  return 47832;
-}
-
-async function parseTunnelUrl(stream: ReadableStream<Uint8Array>): Promise<string | null> {
-  const reader = stream.getReader();
-  const dec = new TextDecoder();
-  const deadline = Date.now() + 30000;
-  let buf = '';
-  while (Date.now() < deadline) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    buf += dec.decode(value, { stream: true });
-    const m = buf.match(/(https:\/\/[a-z0-9-]+\.trycloudflare\.com)/i);
-    if (m) {
-      // Keep draining in background so pipe doesn't block
-      (async () => { try { while (true) { const { done } = await reader.read(); if (done) break; } } catch {} })();
-      return m[1];
-    }
-  }
-  return null;
-}
-
-interface RunEntry {
-  agentId: string;
-  issueId: string | null;
-  startedAt: number;
-  child: any | null;
-  worktreePath: string;
-  stopped?: boolean;
-  stopReason?: string;
-}
-
-interface RuntimeCtx {
-  runEntry?: RunEntry;
-  refreshLocalAgents?: () => Promise<void>;
-}
-
-async function markStopped(apiUrl: string, issueId: string, reason: string) {
-  try {
-    await apiClient.patch(`${apiUrl}/api/issues/${issueId}`, { status: 'stopped' });
-  } catch {}
-  try {
-    await apiClient.post(`${apiUrl}/api/issues/${issueId}/comments`, {
-      author_type: 'agent', author_id: 'daemon', author_name: 'daemon', body: `⏹ Stopped: ${reason}`,
-    });
-  } catch {}
-  await postStream(apiUrl, issueId, 'stopped', { reason });
-}
-
-async function handleRunTask(apiUrl: string, deviceId: string, task: any, detected: { type: string; path: string }[], ctx?: RuntimeCtx) {
-  const issueId = task.issue_id;
-  const isFollowup = !!task.followup;
-  const baseWorkingDir = task.working_dir && existsSync(task.working_dir) ? task.working_dir : undefined;
-
-  // Per-issue worktree isolation. Falls back to baseWorkingDir on failure or non-git.
-  let workingDir = baseWorkingDir;
-  let worktreeBranch = '';
-  if (baseWorkingDir) {
-    try {
-      const wt = await ensureWorktree(baseWorkingDir, task.key || issueId);
-      workingDir = wt.path;
-      worktreeBranch = wt.branch;
-      await postStream(apiUrl, issueId, 'worktree_created', { path: wt.path, branch: wt.branch, reused: !wt.created });
-    } catch (e) {
-      await postStream(apiUrl, issueId, 'worktree_error', { message: fmtError(e) });
-    }
-  }
-
-  log(`▶ run_task ${task.key}: ${isFollowup ? '(follow-up) ' : ''}${task.title}${workingDir ? ` [cwd: ${workingDir}${worktreeBranch ? ` @${worktreeBranch}` : ''}]` : ''}`);
-
-  await apiClient.patch(`${apiUrl}/api/issues/${issueId}`, { status: 'in_progress' });
-  await postStream(apiUrl, issueId, 'progress', { message: `Device ${deviceId} picked up ${isFollowup ? 'follow-up' : 'task'}` });
-
-  // Fetch attachments from originating comment into a scratch dir under working_dir (or tmp)
-  let attachmentRefs: { filename: string; path: string }[] = [];
-  if (task.from_comment_id) {
-    const baseDir = workingDir || join(MULTI_DIR, 'tmp', issueId);
-    const inDir = join(baseDir, '.multi-in', task.from_comment_id);
-    attachmentRefs = await downloadCommentAttachments(apiUrl, task.from_comment_id, inDir);
-    if (attachmentRefs.length) log(`  fetched ${attachmentRefs.length} attachment(s) → ${inDir}`);
-  }
-  const outDir = join(workingDir || join(MULTI_DIR, 'tmp', issueId), '.multi-out');
-
-  let liveCommentId: string | undefined;
-  let liveBody = '';
-  let hadError = false;
-  let hasAssistantText = false;
-  let liveCommentPromise: Promise<void> | null = null;
-
-  const ensureLiveComment = (): Promise<void> => {
-    if (liveCommentId) return Promise.resolve();
-    if (!liveCommentPromise) {
-      liveCommentPromise = apiClient.post<any>(`${apiUrl}/api/issues/${issueId}/comments`, {
-        author_type: 'agent', author_id: task.agent_id, author_name: 'agent', body: '…',
-      }).then(res => { liveCommentId = res.data?.id; });
-    }
-    return liveCommentPromise;
-  };
-  const patchLive = async (body: string) => {
-    if (!liveCommentId) return;
-    try { await apiClient.patch(`${apiUrl}/api/issues/${issueId}/comments/${liveCommentId}`, { body: body || '…' }); } catch {}
-  };
-  const postComment = async (body: string) => {
-    try { await apiClient.post(`${apiUrl}/api/issues/${issueId}/comments`, { author_type: 'agent', author_id: task.agent_id, author_name: 'agent', body }); } catch {}
-  };
-
-  type ToolEntry = { id: string; tool: string; kind?: string; status?: string; input?: any; results: string[] };
-  type Block = { kind: 'text'; text: string } | { kind: 'tool'; id: string };
-  const turn = {
-    blocks: [] as Block[],
-    tools: new Map<string, ToolEntry>(),
-    plans: [] as string[],
-    progress: [] as string[],
-    result: null as null | { duration_ms?: number; total_cost_usd?: number; stopReason?: string; is_error?: boolean },
-    error: null as null | string,
-  };
-
-  const appendText = (text: string) => {
-    const last = turn.blocks[turn.blocks.length - 1];
-    if (last && last.kind === 'text') last.text += text;
-    else turn.blocks.push({ kind: 'text', text });
-  };
-
-  const upsertTool = (id: string, patch: Partial<ToolEntry>) => {
-    const existing = turn.tools.get(id);
-    if (existing) {
-      if (patch.tool && patch.tool !== 'tool') existing.tool = patch.tool;
-      if (patch.kind) existing.kind = patch.kind;
-      if (patch.status) existing.status = patch.status;
-      if (patch.input !== undefined) existing.input = patch.input;
-    } else {
-      turn.tools.set(id, { id, tool: patch.tool || 'tool', kind: patch.kind, status: patch.status, input: patch.input, results: [] });
-      turn.blocks.push({ kind: 'tool', id });
-    }
-  };
-
-  const toolLabel = (t: ToolEntry): string => {
-    const clean = stripMd(t.tool);
-    if (clean && clean !== 'tool') return clean;
-    // Fallback from input shape
-    if (t.input && typeof t.input === 'object') {
-      if (t.input.command) return `Bash: ${String(t.input.command).split('\n')[0].slice(0, 60)}`;
-      if (t.input.file_path) return `${t.kind === 'edit' ? 'Edit' : 'Read'}: ${t.input.file_path}`;
-      if (t.input.pattern) return `Grep: ${t.input.pattern}`;
-      if (t.input.url) return `Fetch: ${t.input.url}`;
-    }
-    return (t.kind ? `${t.kind}` : 'tool');
-  };
-
-  const render = (): string => {
-    const parts: string[] = [];
-    for (const b of turn.blocks) {
-      if (b.kind === 'text') {
-        if (b.text) parts.push(b.text);
-        continue;
-      }
-      const t = turn.tools.get(b.id);
-      if (!t) continue;
-      const icon = statusIcon(t.status);
-      const label = toolLabel(t);
-      const head = `${icon} ${label}${t.status && t.status !== 'completed' ? ` · ${t.status}` : ''}`;
-      const body: string[] = [];
-      if (t.input !== undefined && t.input !== null) {
-        const inputStr = typeof t.input === 'object' ? JSON.stringify(t.input, null, 2) : String(t.input);
-        body.push('```json\n' + inputStr.slice(0, 2000) + '\n```');
-      }
-      if (t.results.length) {
-        const joined = t.results.join('\n').slice(-2000);
-        body.push('**Output**\n\n```\n' + joined + '\n```');
-      }
-      parts.push(`<details>\n<summary>${head}</summary>\n\n${body.join('\n\n')}\n</details>`);
-    }
-
-    if (turn.plans.length) parts.push('**Plan**\n\n' + turn.plans[turn.plans.length - 1]);
-    if (turn.error) parts.push(`> ❌ ${turn.error}`);
-
-    if (turn.result) {
-      const bits: string[] = [];
-      if (turn.result.duration_ms) bits.push(`${Math.round(turn.result.duration_ms)}ms`);
-      if (turn.result.total_cost_usd) bits.push(`$${Number(turn.result.total_cost_usd).toFixed(4)}`);
-      if (turn.result.stopReason) bits.push(turn.result.stopReason);
-      if (bits.length) parts.push(`---\n_${bits.join(' · ')}_`);
-    }
-
-    return parts.join('\n\n') || '…';
-  };
-
-  let renderScheduled = false;
-  const schedulePatch = () => {
-    if (renderScheduled) return;
-    renderScheduled = true;
-    queueMicrotask(async () => {
-      renderScheduled = false;
-      try { await patchLive(render()); } catch {}
-    });
-  };
-
-  const eventHandler = async (event: any) => {
-    if (event.event_type === 'error') hadError = true;
-    await postStream(apiUrl, issueId, event.event_type, event.payload);
-
-    const p: any = event.payload || {};
-    switch (event.event_type) {
-      case 'progress': {
-        if (p.message) turn.progress.push(p.message);
-        break;
-      }
-      case 'assistant_text': {
-        await ensureLiveComment();
-        appendText(p.text);
-        hasAssistantText = true;
-        schedulePatch();
-        break;
-      }
-      case 'stdout': {
-        if (p.line) {
-          await ensureLiveComment();
-          appendText((turn.blocks.length ? '\n' : '') + p.line);
-          hasAssistantText = true;
-          schedulePatch();
-        }
-        break;
-      }
-      case 'tool_call': {
-        await ensureLiveComment();
-        const id = p.id || `anon-${turn.tools.size}`;
-        upsertTool(id, { tool: p.tool, kind: p.kind, status: p.status, input: p.input });
-        schedulePatch();
-        break;
-      }
-      case 'tool_result': {
-        await ensureLiveComment();
-        const lastToolId = [...turn.blocks].reverse().find(b => b.kind === 'tool')?.id;
-        const id = p.tool_use_id || lastToolId;
-        const entry = id ? turn.tools.get(id) : undefined;
-        const content = String(p.content ?? '').trim();
-        if (entry && content) {
-          entry.results.push(content);
-          schedulePatch();
-        } else if (content) {
-          const pid = `result-${turn.tools.size}`;
-          upsertTool(pid, { tool: 'tool result' });
-          turn.tools.get(pid)!.results.push(content);
-          schedulePatch();
-        }
-        break;
-      }
-      case 'result': {
-        await ensureLiveComment();
-        if (p.is_error) hadError = true;
-        if (!hasAssistantText && p.result) {
-          appendText(p.result);
-          hasAssistantText = true;
-        }
-        turn.result = { duration_ms: p.duration_ms, total_cost_usd: p.total_cost_usd, stopReason: p.stopReason, is_error: p.is_error };
-        schedulePatch();
-        break;
-      }
-      case 'error': {
-        await ensureLiveComment();
-        turn.error = p.message || 'error';
-        schedulePatch();
-        break;
-      }
-    }
-  };
-
-  // Pick per-agent-type path: claude-code → ACP; pi/others → legacy stdout runner.
-  let preferType: string | undefined;
-  try {
-    const a = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
-    if (a.data?.type) preferType = a.data.type;
-  } catch {}
-  const acpCapable = detected.filter(d => d.type === 'claude-code');
-  const useAcp = preferType !== 'pi' && acpCapable.length > 0 && process.env.MULTI_LEGACY !== '1';
-  // Route pi/codex/openclaw through acpx (handles these agent types natively)
-  const useAcpx = !useAcp && preferType && ['pi', 'codex', 'openclaw'].includes(preferType) && process.env.MULTI_LEGACY !== '1';
-
-  try {
-    if (useAcp) {
-      const issueContext = `## Issue ${task.key}: ${task.title}${task.description ? `\n\n${task.description}` : ''}`;
-      let userPart: string;
-      if (task.followup) {
-        const cleanFollowup = stripSelfMention(task.followup, preferType);
-        userPart = `${issueContext}\n\n---\n\n## New user message — current request\n\n${cleanFollowup}`;
-      } else {
-        userPart = stripSelfMention(issueContext, preferType);
-      }
-      if (attachmentRefs.length) {
-        const lines = attachmentRefs.map(a => `- ${a.filename}: ${a.path}`).join('\n');
-        userPart += `\n\n---\nAttached input files (read them with your tools if useful):\n${lines}\n\nNote: if (and only if) you produce binary or large artifact outputs (screenshots, data exports, generated source files), write them under ${outDir}. Always put your human-facing reply in the chat response itself — do NOT write your answer as a file.`;
-      } else {
-        userPart += `\n\n---\nRespond in the chat. Only if you produce large artifact files (screenshots, data exports, generated source code), write them under ${outDir}. Do not put your answer in a file.`;
-      }
-
-      // Pull agent + linked skills to construct system/context preamble
-      let preamble = '';
-      try {
-        const agentRes = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
-        const agent = agentRes.data;
-        if (agent?.prompt) preamble += `# Agent instructions\n\n${agent.prompt}\n\n`;
-
-        const skillsRes = await apiClient.get<any[]>(`${apiUrl}/api/agents/${task.agent_id}/skills`);
-        const skillList = Array.isArray(skillsRes.data) ? skillsRes.data : [];
-        if (skillList.length) {
-          preamble += `# Attached skills (${skillList.length})\n\n`;
-          for (const s of skillList) {
-            const body = String(s.body || s.description || '').trim();
-            if (!body) continue;
-            preamble += `## ${s.name}${s.version ? ` v${s.version}` : ''}\n\n${body}\n\n`;
-          }
-        }
-      } catch (e) {
-        log(`preamble fetch failed: ${String(e)}`);
-      }
-
-      preamble += await buildPlanningPreamble(apiUrl, task);
-
-      const prompt = preamble ? `${preamble}\n---\n\n${userPart}` : userPart;
-
-      // Pick adapter for the agent's declared type if we have it, else first ACP-capable
-      let preferredType: string = 'claude-code';
-      try {
-        const a = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
-        if (a.data?.type) preferredType = a.data.type;
-      } catch {}
-      const chosen = acpCapable.find(d => d.type === preferredType) || acpCapable[0];
-      const adapterBin = await resolveAcpAdapter(chosen.type, chosen.path);
-      if (!adapterBin) throw new Error(`ACP adapter for ${chosen.type} not found`);
-      log(`  adapter: ${chosen.type} → ${adapterBin.join(' ')}`);
-
-      const startedAt = Date.now();
-      const { sessionId } = await runAcp({
-        apiUrl, issueId, deviceId, prompt,
-        sessionId: task.session_id || null,
-        adapterBin,
-        autonomy: task.autonomy_level,
-        cwd: workingDir,
-        onEvent: eventHandler,
-        onSession: async (sid) => {
-          try { await apiClient.post(`${apiUrl}/api/issues/${issueId}/session`, { session_id: sid }); } catch {}
-        },
-        onSpawn: (child) => {
-          if (ctx?.runEntry) {
-            ctx.runEntry.child = child;
-            ctx.runEntry.worktreePath = workingDir || '';
-          }
-          void postStream(apiUrl, issueId, 'run_started', { pid: child?.pid, worktree_path: workingDir, branch: worktreeBranch, adapter: chosen.type });
-        },
-      });
-      void postStream(apiUrl, issueId, 'run_finished', { stopReason: (typeof sessionId === 'string' ? 'ok' : 'unknown'), duration_ms: Date.now() - startedAt });
-      log(`  acp session ${sessionId.slice(0, 8)}`);
-    } else if (useAcpx) {
-      // Build prompt with preamble (same logic as ACP path, but as one string)
-      let preamble = '';
-      try {
-        const agentRes = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
-        const agent = agentRes.data;
-        if (agent?.prompt) preamble += `# Agent instructions\n\n${agent.prompt}\n\n`;
-        const skillsRes = await apiClient.get<any[]>(`${apiUrl}/api/agents/${task.agent_id}/skills`);
-        const skillList = Array.isArray(skillsRes.data) ? skillsRes.data : [];
-        if (skillList.length) {
-          preamble += `# Attached skills (${skillList.length})\n\n`;
-          for (const s of skillList) {
-            const body = String(s.body || s.description || '').trim();
-            if (body) preamble += `## ${s.name}${s.version ? ` v${s.version}` : ''}\n\n${body}\n\n`;
-          }
-        }
-      } catch {}
-      preamble += await buildPlanningPreamble(apiUrl, task);
-      const issueContext = `## Issue ${task.key}: ${task.title}${task.description ? `\n\n${task.description}` : ''}`;
-      let userPart: string;
-      if (task.followup) {
-        const cleanFollowup = stripSelfMention(task.followup, preferType);
-        userPart = `${issueContext}\n\n---\n\n## New user message — current request\n\n${cleanFollowup}`;
-      } else {
-        userPart = stripSelfMention(issueContext, preferType);
-      }
-      if (attachmentRefs.length) {
-        const lines = attachmentRefs.map(a => `- ${a.filename}: ${a.path}`).join('\n');
-        userPart += `\n\n---\nAttached files:\n${lines}\n\nWrite generated files to: ${outDir}`;
-      } else {
-        userPart += `\n\n---\nWrite generated files to: ${outDir}`;
-      }
-      const full = preamble ? `${preamble}\n---\n\n${userPart}` : userPart;
-      log(`  acpx runner: ${preferType}`);
-      const acpxStartedAt = Date.now();
-      await runAcpx({
-        agentType: preferType!,
-        prompt: full,
-        cwd: workingDir,
-        sessionName: `issue-${issueId}`,
-        onEvent: eventHandler,
-        onSpawn: (child) => {
-          if (ctx?.runEntry) {
-            ctx.runEntry.child = child;
-            ctx.runEntry.worktreePath = workingDir || '';
-          }
-          void postStream(apiUrl, issueId, 'run_started', { pid: child?.pid, worktree_path: workingDir, branch: worktreeBranch, adapter: preferType });
-        },
-      });
-      void postStream(apiUrl, issueId, 'run_finished', { stopReason: 'ok', duration_ms: Date.now() - acpxStartedAt });
-    } else {
-      const runner = pickRunner(detected, preferType);
-      for await (const event of runner(task)) await eventHandler(event);
-    }
-
-    // Upload any files the agent wrote to .multi-out as attachments on the live comment
-    if (liveCommentId) {
-      const n = await uploadOutputDir(apiUrl, liveCommentId, outDir);
-      if (n > 0) log(`  📎 uploaded ${n} output file(s)`);
-    }
-
-    // Post-turn: scan agent text for `multi-plan` fenced blocks and execute mutations.
-    if (ctx) {
-      const fullText = turn.blocks.filter(b => b.kind === 'text').map(b => (b as any).text).join('\n');
-      const actions = extractPlanActions(fullText);
-      if (actions.length) {
-        const summary = await executePlanActions(apiUrl, task, actions, ctx);
-        if (summary) {
-          try { await apiClient.post(`${apiUrl}/api/issues/${issueId}/comments`, { author_type: 'agent', author_id: task.agent_id, author_name: 'agent', body: summary }); } catch {}
-        }
-      }
-    }
-
-    // Visible fallback: agent ran but emitted nothing user-facing
-    if (!hasAssistantText && !hadError) {
-      const stopReason = turn.result?.stopReason || 'unknown';
-      await postComment(`⚠️ Agent returned no output (stopReason=${stopReason}). Adapter may be stuck on a stale session — try starting a new issue or clearing session_id.`);
-      log(`  ⚠ ${task.key} produced no assistant output (stopReason=${stopReason})`);
-    }
-
-    if (ctx?.runEntry?.stopped) {
-      await markStopped(apiUrl, issueId, ctx.runEntry.stopReason || 'stopped');
-      log(`  ⏹ ${task.key} stopped`);
-    } else if (hadError) { await apiClient.post(`${apiUrl}/api/issues/${issueId}/fail`, {}); log(`  ✗ ${task.key} failed`); }
-    else { await apiClient.post(`${apiUrl}/api/issues/${issueId}/complete`, {}); log(`  ✓ ${task.key} complete`); }
-  } catch (e) {
-    const msg = fmtError(e);
-    if (ctx?.runEntry?.stopped) {
-      await markStopped(apiUrl, issueId, ctx.runEntry.stopReason || 'stopped');
-      log(`  ⏹ ${task.key} stopped (${msg})`);
-    } else {
-      await postStream(apiUrl, issueId, 'error', { message: msg });
-      await postComment(`❌ spawn error: ${msg}`);
-      await apiClient.post(`${apiUrl}/api/issues/${issueId}/fail`, {});
-      log(`  ✗ ${task.key} failed: ${msg}`);
-    }
-  }
-}
-
-// Appended to agent prompt. Teaches the agent how to emit planning actions the
-// daemon will execute after the turn: create sub-issues, update any issue in
-// the project, or delegate to other agents.
-async function buildPlanningPreamble(apiUrl: string, task: any): Promise<string> {
-  const depth = typeof task.planning_depth === 'number' ? task.planning_depth : 0;
-  if (depth >= PLANNING_DEPTH_LIMIT) {
-    return `# Planning (sub-task context)
-
-You are acting on a sub-issue spawned by another agent. You MAY emit a \`multi-plan\` block to update your own issue's status (e.g. mark done/failed) but CANNOT create child issues or delegate further.
-
-\`\`\`multi-plan
-{"actions":[{"type":"update","id":"<this issue id>","status":"done"}]}
-\`\`\`
-
-`;
-  }
-  let projectId = '';
-  let agentsBlock = '';
-  try {
-    const issueRes = await apiClient.get<any>(`${apiUrl}/api/issues/${task.issue_id}`);
-    projectId = issueRes.data?.project_id || '';
-    const agentRes = await apiClient.get<any>(`${apiUrl}/api/agents/${task.agent_id}`);
-    const workspaceId = agentRes.data?.workspace_id;
-    if (workspaceId) {
-      const ag = await apiClient.get<any[]>(`${apiUrl}/api/agents?workspace_id=${workspaceId}`);
-      const list = Array.isArray(ag.data) ? ag.data : [];
-      const others = list.filter(a => a.id !== task.agent_id);
-      if (others.length) {
-        agentsBlock = others.map(a => `- \`${a.id}\` (${a.name}${a.type ? `, ${a.type}` : ''})`).join('\n');
-      }
-    }
-  } catch {}
-
-  return `# Planning, delegation, and self-service
-
-After finishing your reply, you may append ONE fenced \`multi-plan\` block. The daemon parses it and executes after your turn.
-
-Issue actions:
-
-\`\`\`multi-plan
-{"actions":[
-  {"type":"create","title":"...","description":"...","assignee_type":"agent","assignee_id":"<agent id>"},
-  {"type":"update","id":"<issue id>","status":"done"},
-  {"type":"delegate","id":"<issue id>","assignee_id":"<agent id>"}
-]}
-\`\`\`
-
-Agent + skill self-service (use sparingly — only when you genuinely need a new capability that isn't covered by an existing agent or skill):
-
-\`\`\`multi-plan
-{"actions":[
-  {"type":"agent.create","name":"refactor-bot","agent_type":"claude-code","prompt":"You refactor TS code...","skill_ids":["sk_xxx"],"allowed_tools":["Read","Edit","Bash"]},
-  {"type":"agent.update","id":"ag_xxx","prompt":"new prompt..."},
-  {"type":"skill.create","name":"run-tests","description":"Run the test suite","body":"---\\nname: run-tests\\n---\\n\\n# Run tests\\n..."},
-  {"type":"skill.attach","agent_id":"ag_xxx","skill_id":"sk_yyy"},
-  {"type":"skill.detach","agent_id":"ag_xxx","skill_id":"sk_yyy"}
-]}
-\`\`\`
-
-Rules:
-- Omit the block if no actions are needed.
-- Max 10 actions per turn. Sub-caps: agent.create=2, skill.create=3 per turn.
-- Planning depth capped at ${PLANNING_DEPTH_LIMIT}. At depth ≥ 1 you can only \`update\` your own issue — no creates, no agents, no skills.
-- \`agent.create\` is auto-approved on auto-autonomy issues. Caps + rate limits prevent abuse.
-- \`skill.create\` ALWAYS waits for human review (skill bodies become future system prompts).
-- \`allowed_tools\` on a new agent must be a subset of your own tools.
-- \`create\` / \`update\` / \`delegate\` target issues only in the current project (${projectId || 'this project'}).
-
-${agentsBlock ? `Available agents you can delegate to:\n${agentsBlock}\n` : ''}`;
-}
-
-type PlanAction =
-  | { type: 'create'; project_id?: string; title: string; description?: string; priority?: string; assignee_type?: string; assignee_id?: string; parent_id?: string }
-  | { type: 'update'; id: string; title?: string; description?: string; status?: string; priority?: string; assignee_type?: string; assignee_id?: string }
-  | { type: 'delegate'; id: string; assignee_id: string }
-  | { type: 'agent.create'; name: string; agent_type: string; prompt?: string; skill_ids?: string[]; allowed_tools?: string[] }
-  | { type: 'agent.update'; id: string; name?: string; prompt?: string | null; allowed_tools?: string[] | null }
-  | { type: 'skill.create'; name: string; version?: string; description?: string; body: string; files?: { path: string; content: string }[] }
-  | { type: 'skill.attach'; agent_id: string; skill_id: string }
-  | { type: 'skill.detach'; agent_id: string; skill_id: string };
-
-// Extract JSON action blocks fenced as ```multi-plan ... ```
-function extractPlanActions(text: string): PlanAction[] {
-  const out: PlanAction[] = [];
-  if (!text) return out;
-  const re = /```multi-plan\s*\n([\s\S]*?)\n```/g;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(text)) !== null) {
-    try {
-      const parsed = JSON.parse(m[1]);
-      const actions = Array.isArray(parsed?.actions) ? parsed.actions : Array.isArray(parsed) ? parsed : [parsed];
-      for (const a of actions) if (a && typeof a === 'object' && typeof a.type === 'string') out.push(a as PlanAction);
-    } catch {}
-  }
-  return out;
-}
-
-const PLAN_ACTION_LIMIT = 10;
-const PLANNING_DEPTH_LIMIT = 10;
-
-async function executePlanActions(apiUrl: string, parentTask: any, actions: PlanAction[], ctx: RuntimeCtx): Promise<string> {
-  const lines: string[] = [];
-  let truncated = false;
-  if (actions.length > PLAN_ACTION_LIMIT) {
-    truncated = true;
-    actions = actions.slice(0, PLAN_ACTION_LIMIT);
-  }
-  // Prevent agent recursion: a child turn's plan cannot itself spawn more children.
-  // `planning_depth` is carried on each dispatched task (set server-side from issue row).
-  const depth = typeof parentTask.planning_depth === 'number' ? parentTask.planning_depth : 0;
-  if (depth >= PLANNING_DEPTH_LIMIT) {
-    const blocked = actions.filter(a => a.type !== 'update').length;
-    actions = actions.filter(a => a.type === 'update');
-    if (blocked) lines.push(`- ⚠ ${blocked} non-update action(s) blocked (planning depth limit ${PLANNING_DEPTH_LIMIT})`);
-  }
-  // Sub-caps: agent/skill creation is rare, prevent runaway turns.
-  const SUBCAPS = { 'agent.create': 2, 'skill.create': 3, 'skill.attach': 5, 'skill.detach': 5, 'agent.update': 5 } as Record<string, number>;
-  const counts: Record<string, number> = {};
-  actions = actions.filter(a => {
-    const cap = SUBCAPS[a.type];
-    if (cap === undefined) return true;
-    counts[a.type] = (counts[a.type] || 0) + 1;
-    if (counts[a.type] > cap) {
-      lines.push(`- ⚠ ${a.type} sub-cap ${cap} hit, dropping extra`);
-      return false;
-    }
-    return true;
-  });
-  const parentId = parentTask.issue_id;
-  const parentProjectId = await (async () => {
-    try {
-      const r = await apiClient.get<any>(`${apiUrl}/api/issues/${parentId}`);
-      return r.data?.project_id;
-    } catch { return null; }
-  })();
-  const headers: Record<string, string> = { 'x-agent-id': parentTask.agent_id, 'x-origin-issue-id': parentTask.issue_id };
-
-  // Refresh the set of agents linked to this device once per plan execution.
-  if (typeof ctx.refreshLocalAgents === 'function') {
-    try { await ctx.refreshLocalAgents(); } catch {}
-  }
-
-  for (const a of actions) {
-    try {
-      if (a.type === 'create') {
-        const body = {
-          action: 'create' as const,
-          project_id: a.project_id || parentProjectId,
-          title: a.title, description: a.description,
-          priority: a.priority, assignee_type: a.assignee_type, assignee_id: a.assignee_id,
-          parent_id: a.parent_id || parentId,
-        };
-        const res = await apiClient.post<any>(`${apiUrl}/api/issues/agent/mutate`, body, { headers });
-        if (!res.success) { lines.push(`- ❌ create "${a.title}": ${res.error || res.status}`); continue; }
-        const created = res.data;
-        lines.push(`- ✓ created **${created.key}** — ${created.title}${created.assignee_id ? ` → @${created.assignee_id}` : ''} (autonomy=${created.autonomy_level || 'auto'})`);
-      } else if (a.type === 'update') {
-        const res = await apiClient.post<any>(`${apiUrl}/api/issues/agent/mutate`, { action: 'update', ...a }, { headers });
-        if (!res.success) { lines.push(`- ❌ update ${a.id}: ${res.error || res.status}`); continue; }
-        lines.push(`- ✓ updated ${res.data.key}`);
-      } else if (a.type === 'delegate') {
-        const res = await apiClient.post<any>(`${apiUrl}/api/issues/agent/mutate`, { action: 'update', id: a.id, assignee_type: 'agent', assignee_id: a.assignee_id, status: 'todo' }, { headers });
-        if (!res.success) { lines.push(`- ❌ delegate ${a.id}: ${res.error || res.status}`); continue; }
-        lines.push(`- ✓ delegated ${res.data.key} → ${a.assignee_id}`);
-      } else if (a.type === 'agent.create') {
-        const res = await apiClient.post<any>(`${apiUrl}/api/agent_ops/agents/mutate`, { action: 'create', name: a.name, type: a.agent_type, prompt: a.prompt, skill_ids: a.skill_ids, allowed_tools: a.allowed_tools }, { headers });
-        if (!res.success) { lines.push(`- ❌ agent.create "${a.name}": ${res.error || res.status}`); continue; }
-        if (res.data?.queued) lines.push(`- ⏳ agent.create "${a.name}" queued for human approval (op ${res.data.pending_op_id})`);
-        else lines.push(`- ✓ agent.create "${a.name}" → ${res.data?.agent_id}`);
-      } else if (a.type === 'agent.update') {
-        const res = await apiClient.post<any>(`${apiUrl}/api/agent_ops/agents/mutate`, { action: 'update', ...a }, { headers });
-        if (!res.success) { lines.push(`- ❌ agent.update ${a.id}: ${res.error || res.status}`); continue; }
-        if (res.data?.queued) lines.push(`- ⏳ agent.update ${a.id} queued`);
-        else lines.push(`- ✓ agent.update ${a.id}`);
-      } else if (a.type === 'skill.create') {
-        const res = await apiClient.post<any>(`${apiUrl}/api/agent_ops/skills/mutate`, { action: 'create', name: a.name, version: a.version, description: a.description, body: a.body, files: a.files }, { headers });
-        if (!res.success) { lines.push(`- ❌ skill.create "${a.name}": ${res.error || res.status}`); continue; }
-        lines.push(`- ⏳ skill.create "${a.name}" queued for human review (op ${res.data?.pending_op_id})`);
-      } else if (a.type === 'skill.attach' || a.type === 'skill.detach') {
-        const action = a.type === 'skill.attach' ? 'attach_skill' : 'detach_skill';
-        const res = await apiClient.post<any>(`${apiUrl}/api/agent_ops/agents/mutate`, { action, agent_id: a.agent_id, skill_id: a.skill_id }, { headers });
-        if (!res.success) { lines.push(`- ❌ ${a.type} ${a.skill_id}→${a.agent_id}: ${res.error || res.status}`); continue; }
-        if (res.data?.queued) lines.push(`- ⏳ ${a.type} queued`);
-        else lines.push(`- ✓ ${a.type} ${a.skill_id} ↔ ${a.agent_id}`);
-      }
-    } catch (e) {
-      lines.push(`- ❌ ${a.type} failed: ${String(e)}`);
-    }
-  }
-  if (truncated) lines.push(`- ⚠ action list truncated at ${PLAN_ACTION_LIMIT}`);
-  if (!lines.length) return '';
-  return `**Planning actions**\n\n${lines.join('\n')}`;
-}
-
-function stripMd(s: string): string {
-  return s.replace(/[`*_]/g, '').trim();
-}
-
-// Strip leading "@agent_name" so the agent CLI doesn't treat it as a file ref (pi)
-// or get confused by self-address. Universally safe across runners.
-function stripSelfMention(prompt: string, _agentType?: string): string {
-  return prompt.replace(/^@[A-Za-z0-9_\-]+\s*/, '').trim();
-}
-
-// Best-effort error → string. Plain Error, ACP error envelopes ({error:{message,code,data}}),
-// fetch Response-shaped rejections, and arbitrary objects all stringify to something readable
-// instead of "[object Object]".
-function fmtError(e: any): string {
-  if (e == null) return 'unknown error';
-  if (typeof e === 'string') return e;
-  if (e instanceof Error) return e.stack ? `${e.message}` : String(e);
-  if (typeof e === 'object') {
-    const inner = e.error ?? e.cause ?? e;
-    const msg = inner?.message ?? e.message ?? e.reason ?? e.statusText;
-    const code = inner?.code ?? e.code ?? e.status;
-    if (msg) return code ? `${msg} (code ${code})` : String(msg);
-    try { return JSON.stringify(e).slice(0, 500); } catch {}
-  }
-  return String(e);
-}
-
-function statusIcon(status?: string): string {
-  switch (status) {
-    case 'pending': return '⏳';
-    case 'in_progress': return '🔧';
-    case 'completed': return '✓';
-    case 'failed': return '✗';
-    default: return '🔧';
-  }
-}
-
-async function resolveAcpAdapter(agentType: string, detectedPath?: string): Promise<string[] | null> {
-  // Native ACP agents (like `pi`) — invoke directly with ACP mode flag
-  if (agentType === 'pi' && detectedPath && existsSync(detectedPath)) {
-    return [detectedPath, '--mode', 'rpc'];
-  }
-
-  // claude-code → claude-agent-acp adapter wrapper (stdio ACP)
-  const adapterName = 'claude-agent-acp';
-  const candidates = [
-    join(HOME, '.bun', 'install', 'global', 'node_modules', '.bin', adapterName),
-  ];
-  try {
-    const here = new URL(import.meta.url).pathname;
-    let dir = here;
-    for (let i = 0; i < 8; i++) {
-      dir = dirname(dir);
-      const bin = join(dir, 'node_modules', '.bin', adapterName);
-      if (existsSync(bin)) return [bin];
-    }
-  } catch {}
-  for (const c of candidates) if (existsSync(c)) return [c];
-  return null;
-}
-
-// Ack a dispatch so the worker flips its status from dispatched → acked.
-// Uses dispatch_secret (Bearer) so the daemon can call an unauthenticated-by-user endpoint.
-async function ackDispatch(apiUrl: string, dispatchId: string, secret: string) {
-  try {
-    await fetch(`${apiUrl}/api/issues/dispatches/${dispatchId}/ack`, {
-      method: 'POST',
-      headers: { 'authorization': `Bearer ${secret}` },
-    });
-  } catch (e) {
-    log(`ack dispatch ${dispatchId} failed: ${String(e)}`);
-  }
-}
-
-// On reconnect, pull dispatches the worker couldn't deliver and enqueue them.
-// Each call claims the row (offline → dispatched) atomically so parallel daemons
-// don't double-run the same task.
-async function drainOfflineDispatches(apiUrl: string, deviceId: string, secret: string, db: Database, onEnqueued: () => void) {
-  let list: any;
-  try {
-    list = await apiClient.get<any>(`${apiUrl}/api/devices/${deviceId}/dispatches/pending`);
-  } catch (e) {
-    log(`drain list failed: ${String(e)}`);
-    return;
-  }
-  const rows = (list?.data?.results || list?.data || list?.results || list || []) as any[];
-  if (!Array.isArray(rows) || rows.length === 0) return;
-  log(`🪣 draining ${rows.length} offline dispatch(es)`);
-  for (const r of rows) {
-    try {
-      const res = await fetch(`${apiUrl}/api/issues/dispatches/${r.id}/claim`, {
-        method: 'POST',
-        headers: { 'authorization': `Bearer ${secret}` },
-      });
-      if (!res.ok) { log(`claim ${r.id} skipped: ${res.status}`); continue; }
-      const { task } = await res.json() as { task: any };
-      const taskId = task.issue_id ? `${task.issue_id}-${Date.now()}` : crypto.randomUUID();
-      db.run(
-        "INSERT INTO tasks (id, status, payload, agent_id, issue_id) VALUES (?, 'queued', ?, ?, ?)",
-        [taskId, JSON.stringify(task), task.agent_id ?? null, task.issue_id ?? null],
-      );
-      if (task.issue_id) void postStream(apiUrl, task.issue_id, 'queued', { drained: true });
-      void ackDispatch(apiUrl, r.id, secret);
-    } catch (e) {
-      log(`drain ${r.id} failed: ${String(e)}`);
-    }
-  }
-  onEnqueued();
-}
-
-async function postStream(apiUrl: string, issueId: string, event_type: StreamEventType, payload: unknown) {
-  // Local ndjson sink for tail -f debugging.
-  try {
-    ensureDirs();
-    const date = new Date().toISOString().slice(0, 10);
-    const path = join(MULTI_DIR, 'logs', `events-${date}.ndjson`);
-    appendFileSync(path, JSON.stringify({ ts: Date.now(), issue_id: issueId, event_type, payload }) + '\n');
-  } catch {}
-  await apiClient.post(`${apiUrl}/api/streams/${issueId}`, { event_type, payload }, {
-    headers: { 'X-Stream-Version': String(STREAM_SCHEMA_VERSION) },
-  });
-}
-
-// Download attachments of a comment to a local dir. Returns list of absolute paths.
-async function downloadCommentAttachments(apiUrl: string, commentId: string, destDir: string): Promise<{ filename: string; path: string }[]> {
-  try {
-    const list = await apiClient.get<any>(`${apiUrl}/api/attachments/comments/${commentId}`);
-    const items = list.data?.results || list.data || [];
-    if (!Array.isArray(items) || items.length === 0) return [];
-    mkdirSync(destDir, { recursive: true });
-    const token = authTokenHeader();
-    const out: { filename: string; path: string }[] = [];
-    for (const it of items) {
-      const res = await fetch(`${apiUrl}/api/attachments/${it.id}`, { headers: token ? { Authorization: token } : {} });
-      if (!res.ok) continue;
-      const buf = new Uint8Array(await res.arrayBuffer());
-      const safe = it.filename.replace(/[^A-Za-z0-9._-]/g, '_');
-      const p = join(destDir, safe);
-      writeFileSync(p, buf);
-      out.push({ filename: it.filename, path: p });
-    }
-    return out;
-  } catch { return []; }
-}
-
-function authTokenHeader(): string | null {
-  const cfg = loadConfig();
-  return cfg.token ? `Bearer ${cfg.token}` : null;
-}
-
-// Scan a directory for files (recursive, shallow cap) and upload each as an attachment to a comment.
-async function uploadOutputDir(apiUrl: string, commentId: string, dir: string): Promise<number> {
-  if (!existsSync(dir)) return 0;
-  const files: string[] = [];
-  const walk = (d: string, depth = 0) => {
-    if (depth > 3) return;
-    for (const name of readdirSync(d)) {
-      const p = join(d, name);
-      try {
-        const st = statSync(p);
-        if (st.isDirectory()) walk(p, depth + 1);
-        else if (st.isFile()) files.push(p);
-      } catch {}
-    }
-  };
-  walk(dir);
-  if (!files.length) return 0;
-  const token = authTokenHeader();
-  let uploaded = 0;
-  for (const f of files) {
-    try {
-      const data = readFileSync(f);
-      const form = new FormData();
-      const blob = new Blob([data]);
-      form.append('file', blob, f.split('/').pop() || 'file');
-      const res = await fetch(`${apiUrl}/api/attachments/comments/${commentId}`, {
-        method: 'POST',
-        body: form,
-        headers: token ? { Authorization: token } : {},
-      });
-      if (res.ok) { uploaded++; try { unlinkSync(f); } catch {} }
-    } catch (e) { log(`upload failed for ${f}: ${String(e)}`); }
-  }
-  return uploaded;
-}
-
-type StreamEvent = CliStreamEmit;
-type Runner = (task: any) => AsyncGenerator<StreamEvent>;
-
-function pickRunner(detected: { type: string; path: string }[], preferType?: string): Runner {
-  const forceStub = process.env.MULTI_STUB === '1';
-  if (forceStub || !detected.length) return stubRunner;
-  const preferred = (preferType && detected.find(d => d.type === preferType)) || detected.find(d => d.type === 'claude-code') || detected[0];
-  return makeCliRunner(preferred);
-}
-
-async function* stubRunner(task: any): AsyncGenerator<StreamEvent> {
-  yield { event_type: 'stdout', payload: { line: `# ${task.key}: ${task.title}` } };
-  await sleep(600);
-  yield { event_type: 'stdout', payload: { line: 'Analyzing task...' } };
-  await sleep(800);
-  yield { event_type: 'progress', payload: { message: 'Generating solution' } };
-  await sleep(800);
-  yield { event_type: 'stdout', payload: { line: 'Solution ready.' } };
-  yield { event_type: 'done', payload: { code: 0 } };
-}
-
-function makeCliRunner(agent: { type: string; path: string }): Runner {
-  return async function* (task: any): AsyncGenerator<StreamEvent> {
-    const base = `${task.title}\n\n${task.description || ''}`.trim();
-    let prompt = task.followup
-      ? `${task.followup}\n\n---\nContext (original task ${task.key}): ${task.title}`
-      : (base || task.title);
-    prompt = stripSelfMention(prompt, agent.type);
-    const args = buildArgs(agent.type, prompt);
-    yield { event_type: 'progress', payload: { message: `spawning ${agent.type}`, cmd: `${agent.path} ${args.slice(0, 2).join(' ')} …` } };
-
-    let proc: ReturnType<typeof Bun.spawn>;
-    try {
-      proc = Bun.spawn([agent.path, ...args], { stdout: 'pipe', stderr: 'pipe', stdin: 'ignore', cwd: (task as any)?.working_dir || undefined });
-    } catch (e) {
-      yield { event_type: 'error', payload: { message: `spawn failed: ${fmtError(e)}` } };
-      return;
-    }
-
-    const queue: StreamEvent[] = [];
-    let stdoutDone = false, stderrDone = false;
-    let notify: (() => void) | null = null;
-    const pushWaiter = () => new Promise<void>((r) => { notify = r; });
-
-    const drainStderr = (stream: ReadableStream<Uint8Array>) => {
-      const reader = stream.getReader();
-      const dec = new TextDecoder();
-      let buf = '';
-      (async () => {
-        try {
-          while (true) {
-            const { value, done } = await reader.read();
-            if (done) break;
-            buf += dec.decode(value, { stream: true });
-            let nl: number;
-            while ((nl = buf.indexOf('\n')) !== -1) {
-              const line = buf.slice(0, nl);
-              buf = buf.slice(nl + 1);
-              if (line.trim()) queue.push({ event_type: 'stderr', payload: { line } });
-              notify?.();
-            }
-          }
-          if (buf.trim()) { queue.push({ event_type: 'stderr', payload: { line: buf } }); notify?.(); }
-        } finally { stderrDone = true; notify?.(); }
-      })();
-    };
-
-    const drainStdout = (stream: ReadableStream<Uint8Array>) => {
-      const reader = stream.getReader();
-      const dec = new TextDecoder();
-      let buf = '';
-      (async () => {
-        try {
-          while (true) {
-            const { value, done } = await reader.read();
-            if (done) break;
-            buf += dec.decode(value, { stream: true });
-            let nl: number;
-            while ((nl = buf.indexOf('\n')) !== -1) {
-              const line = buf.slice(0, nl); buf = buf.slice(nl + 1);
-              if (!line.trim()) continue;
-              if (agent.type === 'claude-code') {
-                const events = parseClaudeStreamJson(line);
-                for (const ev of events) queue.push(ev);
-              } else {
-                queue.push({ event_type: 'stdout', payload: { line } });
-              }
-              notify?.();
-            }
-          }
-          if (buf.trim()) {
-            if (agent.type === 'claude-code') {
-              for (const ev of parseClaudeStreamJson(buf)) queue.push(ev);
-            } else queue.push({ event_type: 'stdout', payload: { line: buf } });
-            notify?.();
-          }
-        } finally { stdoutDone = true; notify?.(); }
-      })();
-    };
-
-    drainStderr(proc.stderr as ReadableStream<Uint8Array>);
-    drainStdout(proc.stdout as ReadableStream<Uint8Array>);
-
-    while (!stdoutDone || !stderrDone || queue.length) {
-      if (queue.length) yield queue.shift()!;
-      else await pushWaiter();
-    }
-
-    const code = await proc.exited;
-    if (code === 0) yield { event_type: 'done', payload: { code } };
-    else yield { event_type: 'error', payload: { code, message: `exited with code ${code}` } };
-  };
-}
-
-function parseClaudeStreamJson(line: string): StreamEvent[] {
-  let msg: any;
-  try { msg = JSON.parse(line); } catch { return [{ event_type: 'stdout', payload: { line } }]; }
-  const out: StreamEvent[] = [];
-  const t = msg.type;
-  if (t === 'system') {
-    if (msg.subtype === 'init') {
-      out.push({ event_type: 'progress', payload: { message: `session ${msg.session_id?.slice(0, 8)} started`, model: msg.model } });
-    }
-    // skip hook chatter
-    return out;
-  }
-  if (t === 'assistant') {
-    const content = msg.message?.content || [];
-    for (const c of content) {
-      if (c.type === 'text' && c.text) {
-        out.push({ event_type: 'assistant_text', payload: { text: c.text } });
-      } else if (c.type === 'tool_use') {
-        out.push({ event_type: 'tool_call', payload: { tool: c.name, input: c.input, id: c.id } });
-      }
-    }
-    return out;
-  }
-  if (t === 'user') {
-    const content = msg.message?.content || [];
-    for (const c of content) {
-      if (c.type === 'tool_result') {
-        const preview = typeof c.content === 'string' ? c.content : JSON.stringify(c.content);
-        out.push({ event_type: 'tool_result', payload: { tool_use_id: c.tool_use_id, content: preview.slice(0, 2000), truncated: preview.length > 2000 } });
-      }
-    }
-    return out;
-  }
-  if (t === 'result') {
-    out.push({ event_type: 'result', payload: {
-      result: msg.result, duration_ms: msg.duration_ms,
-      num_turns: msg.num_turns, total_cost_usd: msg.total_cost_usd,
-      usage: msg.usage, is_error: !!msg.is_error,
-    }});
-    return out;
-  }
-  return out;
-}
-
-function buildArgs(type: string, prompt: string): string[] {
-  switch (type) {
-    case 'claude-code':
-      return ['-p', prompt, '--output-format', 'stream-json', '--verbose'];
-    case 'pi':
-      // pi: non-interactive, plain text mode, no session saved
-      return ['-p', '--mode', 'text', '--no-session', prompt];
-    case 'codex':
-      return ['-q', prompt];
-    case 'opencode':
-      return ['run', prompt];
-    case 'gemini-cli':
-      return ['-p', prompt];
-    default:
-      return [prompt];
-  }
-}
-
-async function cmdStatus(apiUrl: string, config: Config) {
-  if (!config.deviceId) {
-    console.log('❌ Not registered.');
-    process.exit(1);
-  }
-  const res = await apiClient.get<any>(`${apiUrl}/api/devices/${config.deviceId}`);
-  if (!res.success) { console.log('❌', res.error); process.exit(1); }
-  const d = res.data;
-  const pid = existsSync(PID_PATH) ? readFileSync(PID_PATH, 'utf8').trim() : null;
-  const daemon = pid && isRunning(Number(pid)) ? `running (pid ${pid})` : 'stopped';
-  console.log(`
-Device Status
-=============
-ID:        ${d.id}
-Name:      ${d.name}
-Platform:  ${d.platform} ${d.arch}
-Runtimes:  ${JSON.parse(d.detected_runtimes || '[]').join(', ') || 'none'}
-Status:    ${d.status}
-Daemon:    ${daemon}
-`);
-}
-
-async function cmdStop() {
-  if (!existsSync(PID_PATH)) { console.log('No daemon running.'); return; }
-  const pid = Number(readFileSync(PID_PATH, 'utf8').trim());
-  if (!pid || !isRunning(pid)) {
-    unlinkSync(PID_PATH);
-    console.log('Cleaned stale pidfile.');
-    return;
-  }
-  ensureDirs();
-  writeFileSync(STOP_PATH, '1');
-  try { process.kill(pid, 'SIGTERM'); console.log(`Sent SIGTERM to ${pid}`); } catch {}
-}
-
-async function cmdReset(issueId?: string) {
-  if (!issueId) { console.error('Usage: multi-agent reset --issue <issue_id>'); process.exit(2); }
-  if (!existsSync(PORT_PATH)) { console.error('Daemon not running (no port file).'); process.exit(1); }
-  const port = Number(readFileSync(PORT_PATH, 'utf8').trim());
-  const config = loadConfig();
-  if (!config.dispatchSecret) { console.error('No dispatchSecret in config — run `multi-agent setup` first.'); process.exit(1); }
-  const res = await fetch(`http://127.0.0.1:${port}/reset_session`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', 'authorization': `Bearer ${config.dispatchSecret}` },
-    body: JSON.stringify({ issue_id: issueId }),
-  });
-  const body = await res.text();
-  if (!res.ok) { console.error(`Reset failed (${res.status}): ${body}`); process.exit(1); }
-  console.log(body);
-}
-
-async function cmdRestart(apiUrl: string) {
-  if (existsSync(PID_PATH)) {
-    const pid = Number(readFileSync(PID_PATH, 'utf8').trim());
-    if (pid && isRunning(pid)) {
-      ensureDirs();
-      writeFileSync(STOP_PATH, '1');
-      try { process.kill(pid, 'SIGTERM'); } catch {}
-      console.log(`⏹  Stopping daemon (pid ${pid})...`);
-      const deadline = Date.now() + 10_000;
-      while (Date.now() < deadline && isRunning(pid)) await sleep(200);
-      if (isRunning(pid)) {
-        try { process.kill(pid, 'SIGKILL'); } catch {}
-        await sleep(300);
-      }
-    }
-    try { if (existsSync(PID_PATH)) unlinkSync(PID_PATH); } catch {}
-  }
-  try { if (existsSync(STOP_PATH)) unlinkSync(STOP_PATH); } catch {}
-  console.log('🔄 Relaunching daemon...');
-  ensureDirs();
-  // Spawn `connect` detached (don't re-exec `restart` — would loop).
-  const args = Bun.argv.slice(1).filter(a => a !== '-d' && a !== '--detach' && a !== 'restart');
-  if (!args.includes('connect')) args.splice(1, 0, 'connect');
-  const proc = Bun.spawn([process.execPath, ...args, '--api', apiUrl], {
-    stdio: ['ignore', 'ignore', 'ignore'],
-    env: { ...process.env, MULTI_DETACHED: '1' },
-  });
-  (proc as any).unref?.();
-  await sleep(500);
-  console.log(`✅ Daemon restarted (pid ${proc.pid}).`);
-  console.log(`   Tail logs: multi-agent logs`);
-  process.exit(0);
-}
-
-async function cmdLogs() {
-  if (!existsSync(LOG_PATH)) { console.log('No logs yet.'); return; }
-  const content = readFileSync(LOG_PATH, 'utf8');
-  console.log(content.split('\n').slice(-100).join('\n'));
-}
-
-function isRunning(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-interface Config {
-  deviceId?: string;
-  workspaceId?: string;
-  apiUrl?: string;
-  token?: string;
-  dispatchSecret?: string;
-  // legacy
-  agentId?: string;
-}
-
-function openTasksDb(): Database {
-  ensureDirs();
-  const db = new Database(TASKS_DB_PATH);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS tasks (
-      id TEXT PRIMARY KEY,
-      status TEXT NOT NULL DEFAULT 'queued',
-      payload TEXT NOT NULL,
-      attempts INTEGER NOT NULL DEFAULT 0,
-      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
-      started_at INTEGER,
-      finished_at INTEGER,
-      error TEXT
-    );
-    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
-  `);
-  // Idempotent migrations: add agent_id/issue_id columns if missing.
-  const cols = db.query("PRAGMA table_info(tasks)").all() as { name: string }[];
-  const have = new Set(cols.map((c) => c.name));
-  if (!have.has('agent_id')) db.exec('ALTER TABLE tasks ADD COLUMN agent_id TEXT');
-  if (!have.has('issue_id')) db.exec('ALTER TABLE tasks ADD COLUMN issue_id TEXT');
-  db.exec(`
-    CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_id, status);
-    CREATE INDEX IF NOT EXISTS idx_tasks_issue ON tasks(issue_id);
-  `);
-  // Old rows used 'pending'; normalize to 'queued'.
-  db.run("UPDATE tasks SET status = 'queued' WHERE status = 'pending'");
-  // Backfill agent_id/issue_id from payload JSON for rows predating the columns.
-  // Without this, the scheduler cannot serialize per-agent / per-issue and fires
-  // concurrent dispatches for the same agent on the same issue.
-  db.run("UPDATE tasks SET agent_id = json_extract(payload, '$.agent_id') WHERE agent_id IS NULL AND payload IS NOT NULL AND json_valid(payload)");
-  db.run("UPDATE tasks SET issue_id = json_extract(payload, '$.issue_id') WHERE issue_id IS NULL AND payload IS NOT NULL AND json_valid(payload)");
-  return db;
-}
-
-function loadConfig(): Config {
-  try {
-    if (!existsSync(CONFIG_PATH)) return {};
-    return JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
-  } catch { return {}; }
-}
-
-function saveConfig(config: Config) {
-  ensureDirs();
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
-}
-
-function sleep(ms: number) { return new Promise(r => setTimeout(r, ms)); }
-
-main().catch((err) => {
-  log(`Fatal: ${String(err)}`);
-  process.exit(1);
-});