ai-whisper 0.2.0 → 0.2.1

package/dist/bin/whisper.js

@@ -1105,6 +1105,7 @@ function rowToRecord(row) {
     clipSample: row.clip_sample,
     turnSample: row.turn_sample,
     abortedByRaceGuard: row.aborted_by_race_guard === 1,
+    interferenceDetected: row.interference_detected === 1,
     createdAt: row.created_at
   };
 }
@@ -1112,8 +1113,9 @@ function insertCaptureDiagnostic(db, input) {
   db.prepare(`INSERT INTO relay_capture_diagnostics
 		 (capture_id, handoff_id, collab_id, chain_id, workflow_id, target_provider,
 		  capture_status, clip_len, turn_len, turn_confidence, jaccard_score,
-		  containment_score, clip_sample, turn_sample, aborted_by_race_guard, created_at)
-		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.captureId, input.handoffId, input.collabId, input.chainId, input.workflowId, input.targetProvider, input.captureStatus, input.clipLen, input.turnLen, input.turnConfidence, input.jaccardScore, input.containmentScore, input.clipSample, input.turnSample, input.abortedByRaceGuard ? 1 : 0, input.createdAt);
+		  containment_score, clip_sample, turn_sample, aborted_by_race_guard,
+		  interference_detected, created_at)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.captureId, input.handoffId, input.collabId, input.chainId, input.workflowId, input.targetProvider, input.captureStatus, input.clipLen, input.turnLen, input.turnConfidence, input.jaccardScore, input.containmentScore, input.clipSample, input.turnSample, input.abortedByRaceGuard ? 1 : 0, input.interferenceDetected ? 1 : 0, input.createdAt);
 }
 function listCaptureDiagnosticsByCollab(db, collabId, limit, opts) {
   const filter = opts?.workflowFilter;
@@ -3939,6 +3941,7 @@ function createControlService(db, events) {
         clipSample: input.clipSample,
         turnSample: input.turnSample,
         abortedByRaceGuard: input.abortedByRaceGuard,
+        interferenceDetected: input.interferenceDetected ?? false,
         createdAt: input.now
       });
       return { captureId };
@@ -4015,8 +4018,153 @@ function createBrokerApp(input) {
   return app;
 }
 
+// ../broker/dist/storage/enforce-one-active-collab.js
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function dedupeActiveCollabs(db, opts) {
+  const rows = db.prepare(`SELECT c.collab_id, c.workspace_id, c.created_at, d.pid AS pid,
+			        (SELECT COUNT(*) FROM workflows w
+			           WHERE w.collab_id = c.collab_id AND w.status = 'running') AS running_workflows
+			   FROM collab c
+			   LEFT JOIN broker_daemon d ON d.collab_id = c.collab_id
+			  WHERE c.status = 'active' AND c.workspace_id IS NOT NULL`).all();
+  const byWorkspace = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = row.workspace_id;
+    const list = byWorkspace.get(key);
+    if (list)
+      list.push(row);
+    else
+      byWorkspace.set(key, [row]);
+  }
+  const conflicted = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const stop = db.prepare("UPDATE collab SET status = 'stopped', stopped_at = ?, updated_at = ? WHERE collab_id = ?");
+  for (const [workspaceId, group] of byWorkspace) {
+    if (group.length < 2)
+      continue;
+    const workflowOwners = group.filter((r) => r.running_workflows > 0);
+    if (workflowOwners.length >= 2) {
+      conflicted.push(workspaceId);
+      opts.warn(`Workspace ${workspaceId} has ${workflowOwners.length} active collabs that each own a running workflow: ${workflowOwners.map((r) => r.collab_id).join(", ")}. Refusing to auto-stop any (that would orphan a live run). Stop the extra collab(s) manually with \`whisper collab stop --collab <id>\`. The one-active-collab-per-workspace index will be created automatically once only one remains.`);
+      continue;
+    }
+    let survivor;
+    if (workflowOwners.length === 1) {
+      survivor = workflowOwners[0];
+    } else {
+      const live = group.filter((r) => r.pid !== null && opts.isPidAlive(r.pid));
+      if (live.length >= 1) {
+        survivor = live.reduce((a, b) => a.created_at >= b.created_at ? a : b);
+      } else {
+        survivor = group.reduce((a, b) => a.created_at >= b.created_at ? a : b);
+      }
+    }
+    for (const row of group) {
+      if (row.collab_id === survivor.collab_id)
+        continue;
+      stop.run(now, now, row.collab_id);
+    }
+  }
+  return conflicted;
+}
+var CREATE_INDEX_SQL = "CREATE UNIQUE INDEX IF NOT EXISTS idx_collab_one_active_per_workspace ON collab(workspace_id) WHERE status = 'active'";
+function residualDuplicateCount(db) {
+  const row = db.prepare(`SELECT COUNT(*) AS n FROM (
+			   SELECT workspace_id FROM collab
+			    WHERE status = 'active' AND workspace_id IS NOT NULL
+			    GROUP BY workspace_id HAVING COUNT(*) > 1
+			 )`).get();
+  return row.n;
+}
+function enforceOneActiveCollabPerWorkspace(db, options = {}) {
+  const opts = {
+    isPidAlive: options.isPidAlive ?? defaultIsPidAlive,
+    warn: options.warn ?? ((m) => console.error(m))
+  };
+  const tx = db.transaction(() => {
+    dedupeActiveCollabs(db, opts);
+    if (residualDuplicateCount(db) === 0) {
+      db.exec(CREATE_INDEX_SQL);
+    } else {
+      opts.warn("Skipping idx_collab_one_active_per_workspace: an irreducible duplicate active collab remains. The index will be created on a later startup once only one active collab per workspace exists.");
+    }
+  });
+  tx();
+}
+
+// ../broker/dist/storage/clipboard-capture-lease.js
+var LEASE_ID = 1;
+var DEFAULT_LEASE_TTL_MS = 5e3;
+function defaultIsPidAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function resolveOptions(options) {
+  return {
+    isPidAlive: options.isPidAlive ?? defaultIsPidAlive2,
+    ttlMs: options.ttlMs ?? DEFAULT_LEASE_TTL_MS,
+    now: options.now ?? Date.now
+  };
+}
+function isStale(row, opts) {
+  if (row.holder_collab_id === null)
+    return true;
+  if (row.holder_pid === null || !opts.isPidAlive(row.holder_pid))
+    return true;
+  if (row.acquired_at === null)
+    return true;
+  const age = opts.now() - Date.parse(row.acquired_at);
+  return age > opts.ttlMs;
+}
+function acquireCaptureLease(db, collabId, pid, options = {}) {
+  const opts = resolveOptions(options);
+  const tx = db.transaction(() => {
+    const row = db.prepare("SELECT holder_collab_id, holder_pid, acquired_at FROM clipboard_capture_lease WHERE id = ?").get(LEASE_ID);
+    if (row && !isStale(row, opts))
+      return false;
+    const acquiredAt = new Date(opts.now()).toISOString();
+    db.prepare(`INSERT INTO clipboard_capture_lease (id, holder_collab_id, holder_pid, acquired_at)
+			 VALUES (?, ?, ?, ?)
+			 ON CONFLICT(id) DO UPDATE SET
+			   holder_collab_id = excluded.holder_collab_id,
+			   holder_pid       = excluded.holder_pid,
+			   acquired_at      = excluded.acquired_at`).run(LEASE_ID, collabId, pid, acquiredAt);
+    return true;
+  });
+  return tx();
+}
+function releaseCaptureLease(db, collabId) {
+  const tx = db.transaction(() => {
+    db.prepare("UPDATE clipboard_capture_lease SET holder_collab_id = NULL, holder_pid = NULL, acquired_at = NULL WHERE id = ? AND holder_collab_id = ?").run(LEASE_ID, collabId);
+  });
+  tx();
+}
+function sweepStaleCaptureLease(db, options = {}) {
+  const opts = resolveOptions(options);
+  const tx = db.transaction(() => {
+    const row = db.prepare("SELECT holder_collab_id, holder_pid, acquired_at FROM clipboard_capture_lease WHERE id = ?").get(LEASE_ID);
+    if (!row || row.holder_collab_id === null)
+      return;
+    if (isStale(row, opts)) {
+      db.prepare("UPDATE clipboard_capture_lease SET holder_collab_id = NULL, holder_pid = NULL, acquired_at = NULL WHERE id = ?").run(LEASE_ID);
+    }
+  });
+  tx();
+}
+
 // ../broker/dist/storage/apply-migrations.js
-var CURRENT_SCHEMA_VERSION = 4;
+var CURRENT_SCHEMA_VERSION = 5;
 var initMigrationSql = `
 CREATE TABLE IF NOT EXISTS broker_state (
   id INTEGER PRIMARY KEY CHECK (id = 1),
@@ -4303,6 +4451,13 @@ CREATE TABLE IF NOT EXISTS recovery_state (
   recovered_at         TEXT
 );
 
+CREATE TABLE IF NOT EXISTS clipboard_capture_lease (
+  id                INTEGER PRIMARY KEY CHECK (id = 1),
+  holder_collab_id  TEXT,
+  holder_pid        INTEGER,
+  acquired_at       TEXT
+);
+
 `;
 function ensureBrokerStateRow(db) {
   db.prepare(`INSERT INTO broker_state (id, schema_version, migrated)
@@ -4313,20 +4468,20 @@ function ensureBrokerStateRow(db) {
 }
 function applyMigrations(db) {
   const current = db.pragma("user_version", { simple: true });
-  if (current >= CURRENT_SCHEMA_VERSION) {
-    ensureBrokerStateRow(db);
-    return;
-  }
-  db.exec("BEGIN EXCLUSIVE");
-  try {
-    runMigrationBody(db);
-    db.pragma(`user_version = ${CURRENT_SCHEMA_VERSION}`);
-    ensureBrokerStateRow(db);
-    db.exec("COMMIT");
-  } catch (err) {
-    db.exec("ROLLBACK");
-    throw err;
+  if (current < CURRENT_SCHEMA_VERSION) {
+    db.exec("BEGIN EXCLUSIVE");
+    try {
+      runMigrationBody(db);
+      db.pragma(`user_version = ${CURRENT_SCHEMA_VERSION}`);
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
   }
+  ensureBrokerStateRow(db);
+  enforceOneActiveCollabPerWorkspace(db);
+  sweepStaleCaptureLease(db);
 }
 function runMigrationBody(db) {
   db.exec(initMigrationSql);
@@ -4463,6 +4618,7 @@ function runMigrationBody(db) {
 			clip_sample TEXT,
 			turn_sample TEXT,
 			aborted_by_race_guard INTEGER NOT NULL DEFAULT 0,
+			interference_detected INTEGER NOT NULL DEFAULT 0,
 			created_at TEXT NOT NULL
 		);
 		CREATE INDEX IF NOT EXISTS idx_relay_capture_diagnostics_collab_created
@@ -4474,6 +4630,10 @@ function runMigrationBody(db) {
 		CREATE INDEX IF NOT EXISTS idx_relay_capture_diagnostics_status
 			ON relay_capture_diagnostics (capture_status);
 	`);
+  const captureDiagColumns = db.prepare("PRAGMA table_info(relay_capture_diagnostics)").all();
+  if (!captureDiagColumns.some((column) => column.name === "interference_detected")) {
+    db.exec("ALTER TABLE relay_capture_diagnostics ADD COLUMN interference_detected INTEGER NOT NULL DEFAULT 0");
+  }
   db.exec(`
 		CREATE TABLE IF NOT EXISTS relay_evaluator_diagnostics (
 			evaluator_id TEXT PRIMARY KEY,
@@ -7279,7 +7439,8 @@ ${hint}`,
       let composed = null;
       let initialValue = "";
       if (input.captureHandbackText) {
-        const captured = await input.captureHandbackText() ?? "";
+        const outcome = await input.captureHandbackText("") ?? "";
+        const captured = typeof outcome === "string" ? outcome : outcome.text ?? "";
         if (captured.trim().length > 0 && input.confirmHandbackCapture) {
           const accepted = await input.confirmHandbackCapture({
             target,
@@ -7341,14 +7502,29 @@ ${hint}`,
       input.turnCapture?.finishAssistantTurn();
       const turnResult = input.turnCapture?.extractLatestAssistantTurn() ?? { confidence: "low", text: null };
       let clipboardText = null;
+      let leaseDegraded = false;
+      let interferenceDetected = false;
       try {
-        clipboardText = await input.captureHandbackText?.() ?? null;
+        const captureResult = await input.captureHandbackText?.(turnResult.text ?? "") ?? null;
+        if (typeof captureResult === "string") {
+          clipboardText = captureResult;
+        } else if (captureResult !== null) {
+          interferenceDetected = captureResult.interferenceDetected;
+          if (captureResult.status === "captured") {
+            clipboardText = captureResult.text;
+          } else {
+            leaseDegraded = true;
+          }
+        }
       } catch {
         clipboardText = null;
       }
       const classification = classifyCapture(turnResult, clipboardText);
       const captureStatus = classification.status;
-      const requestText = captureStatus === "ok" ? clipboardText ?? "" : "";
+      let requestText = captureStatus === "ok" ? clipboardText ?? "" : "";
+      if (leaseDegraded && (turnResult.text ?? "").trim().length > 0) {
+        requestText = turnResult.text;
+      }
       const currentAcceptedId = getAcceptedHandoff()?.handoffId;
       const abortedByRaceGuard = currentAcceptedId !== accepted.handoffId;
       const handoffMeta = input.broker.control.getHandoffWithWorkflowMeta?.(accepted.handoffId) ?? null;
@@ -7375,6 +7551,7 @@ ${hint}`,
           clipSample: sampleOf(clipboardText),
           turnSample: sampleOf(turnResult.text),
           abortedByRaceGuard,
+          interferenceDetected,
           now
         });
       } catch (err) {
@@ -7679,6 +7856,107 @@ async function captureClipboardHandback(input) {
   return null;
 }
 
+// src/runtime/capture-handback-text.ts
+var defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+function contentMatches(turnText, clip) {
+  const t = turnText.trim();
+  const c = clip.trim();
+  if (c.length === 0) return false;
+  if (t === c) return true;
+  const jaccard = computeOrderedJaccard(t, c);
+  const containment = computeContainment(c, t);
+  return jaccard >= 0.6 || containment >= 0.8;
+}
+async function captureHandbackText(input) {
+  const sleep3 = input.sleep ?? defaultSleep;
+  const acquireMaxWaitMs = input.acquireMaxWaitMs ?? 4e3;
+  const acquireBackoffMs = input.acquireBackoffMs ?? 50;
+  const recaptureAttempts = input.recaptureAttempts ?? 2;
+  const recaptureBackoffMs = input.recaptureBackoffMs ?? 50;
+  let acquired = false;
+  const deadline = Date.now() + acquireMaxWaitMs;
+  for (; ; ) {
+    acquired = acquireCaptureLease(
+      input.db,
+      input.collabId,
+      input.pid,
+      input.leaseOptions
+    );
+    if (acquired) break;
+    if (Date.now() >= deadline) break;
+    await sleep3(acquireBackoffMs);
+  }
+  if (!acquired) {
+    return { status: "degraded_pty_only", text: null, interferenceDetected: false };
+  }
+  try {
+    let interferenceDetected = false;
+    for (let attempt = 0; attempt <= recaptureAttempts; attempt += 1) {
+      if (attempt > 0) await sleep3(recaptureBackoffMs);
+      const c0 = await input.readChangeCount();
+      const clip = await input.runCapture();
+      const cn = await input.readChangeCount();
+      const checkAvailable = c0 !== null && cn !== null;
+      const interfered = checkAvailable && cn - c0 > 1;
+      if (clip === null || clip.trim().length === 0) {
+        if (interfered) {
+          interferenceDetected = true;
+          continue;
+        }
+        return { status: "captured", text: null, interferenceDetected };
+      }
+      const clean = checkAvailable ? cn - c0 === 1 : true;
+      if (clean) {
+        return { status: "captured", text: clip, interferenceDetected };
+      }
+      interferenceDetected = true;
+      if (contentMatches(input.turnText, clip)) {
+        return { status: "captured", text: clip, interferenceDetected: true };
+      }
+    }
+    return { status: "degraded_pty_only", text: null, interferenceDetected: true };
+  } finally {
+    releaseCaptureLease(input.db, input.collabId);
+  }
+}
+
+// src/runtime/clipboard-change-count.ts
+import { execFile as execFile3 } from "node:child_process";
+import { existsSync as existsSync7 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname as dirname3, join as join7 } from "node:path";
+var HELPER_BIN_NAME = "clipboard-change-count";
+function execFileText2(command, args = []) {
+  return new Promise((resolve5, reject) => {
+    execFile3(command, args, { encoding: "utf8" }, (error, stdout) => {
+      if (error) {
+        reject(error instanceof Error ? error : new Error("helper failed"));
+        return;
+      }
+      resolve5(stdout);
+    });
+  });
+}
+function makeChangeCountReader(deps) {
+  const platform = deps?.platform ?? process.platform;
+  const runHelper = deps?.runHelper ?? (async () => {
+    const here = dirname3(fileURLToPath2(import.meta.url));
+    const bin = join7(here, "..", "native", HELPER_BIN_NAME);
+    if (!existsSync7(bin)) throw new Error("changeCount helper not built");
+    return execFileText2(bin);
+  });
+  return async () => {
+    if (platform !== "darwin") return null;
+    try {
+      const out = (await runHelper()).trim();
+      const n = Number.parseInt(out, 10);
+      return Number.isFinite(n) && String(n) === out ? n : null;
+    } catch {
+      return null;
+    }
+  };
+}
+
 // src/runtime/provider-submit-strategy.ts
 async function submitInjectedProviderInput(input) {
   const sleep3 = input.sleep ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
@@ -7723,6 +8001,7 @@ function createRuntimeDebugLogger(input) {
 }
 
 // src/runtime/mount-session-main.ts
+var readChangeCount = makeChangeCountReader();
 function safeReapSessions(input) {
   const reap = input.reap ?? ((collabId, agentType, keepSessionId) => {
     const db = openDatabase(getSharedSqlitePath());
@@ -7807,6 +8086,7 @@ function createMountSessionRuntime(input) {
                 agentType: input.target,
                 attachmentKind: "mounted"
               });
+              releaseCaptureLease(db, resolvedClaim.collabId);
             } finally {
               db.close();
             }
@@ -7966,17 +8246,30 @@ function createMountSessionRuntime(input) {
             }
             return runComposer();
           },
-          captureHandbackText: async () => {
-            return captureClipboardHandback({
-              triggerCopy: () => submitInjectedInput2("/copy"),
-              // Some provider versions show a picker after /copy (e.g. Claude Code's
-              // content-type picker). Send Enter to confirm the default selection
-              // if the clipboard has not changed yet after the trigger delay.
-              confirmPicker: () => {
-                writeInjectedInput("mounted-submit-picker", "\r");
-              },
-              triggerDelayMs: 300
-            });
+          captureHandbackText: async (turnText) => {
+            if (!resolvedClaim) return null;
+            const db = openDatabase(getSharedSqlitePath());
+            try {
+              return await captureHandbackText({
+                db,
+                collabId: resolvedClaim.collabId,
+                pid: process.pid,
+                turnText,
+                readChangeCount,
+                runCapture: () => captureClipboardHandback({
+                  triggerCopy: () => submitInjectedInput2("/copy"),
+                  // Some provider versions show a picker after /copy (e.g. Claude
+                  // Code's content-type picker). Send Enter to confirm the default
+                  // selection if the clipboard has not changed yet after the delay.
+                  confirmPicker: () => {
+                    writeInjectedInput("mounted-submit-picker", "\r");
+                  },
+                  triggerDelayMs: 300
+                })
+              });
+            } finally {
+              db.close();
+            }
           },
           confirmHandbackCapture: async () => {
             const runConfirm = async () => {
@@ -8088,30 +8381,53 @@ async function isPortFree(port, host = "127.0.0.1") {
   });
 }
 
-// src/commands/collab/start.ts
-import { mkdirSync as mkdirSync3 } from "node:fs";
-
 // src/runtime/port-allocator.ts
 var DEFAULT_PORT_RANGE = [4500, 4999];
 
-// src/commands/collab/start.ts
+// src/commands/collab/recover.ts
 var READY_TIMEOUT_DEFAULT = 3e4;
-async function runCollabStart(opts) {
-  const root = getStateRoot();
-  mkdirSync3(root, { recursive: true });
+var STALE_THRESHOLD_DEFAULT = 9e4;
+function defaultIsAliveImpl(pid) {
+  try {
+    process.kill(pid, 0);
+    return Promise.resolve({ alive: true, startTime: null });
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") return Promise.resolve({ alive: true, startTime: null });
+    return Promise.resolve({ alive: false, startTime: null });
+  }
+}
+async function runCollabRecover(opts) {
   const sqlitePath = getSharedSqlitePath();
   const db = openDatabase(sqlitePath);
   applyMigrations(db);
-  const workspaceRoot = canonicalWorkspaceRoot(opts.cwd);
-  const workspaceId = workspaceIdFromPath(opts.cwd);
-  const now = opts.now();
-  const collabId = createCliCollabId(now);
+  const isAlive = opts.isAlive ?? defaultIsAliveImpl;
+  const staleThresholdMs = opts.staleThresholdMs ?? STALE_THRESHOLD_DEFAULT;
+  const resolved = resolveCollab({
+    db,
+    cwd: opts.cwd,
+    ...opts.collabIdOverride ? { collabIdOverride: opts.collabIdOverride } : {},
+    requireActive: true
+  });
+  const collabId = resolved.collabId;
   const host = "127.0.0.1";
-  const orchestratorEnabled = process.env.AI_WHISPER_RELAY_ORCHESTRATOR_ENABLED !== "0";
-  const orchestratorMaxRounds = Math.max(
-    1,
-    Number(process.env.AI_WHISPER_RELAY_ORCHESTRATOR_MAX_ROUNDS ?? "3") || 3
-  );
+  const preCheckRow = getBrokerDaemonByCollab(db, collabId);
+  let preCheckPid = null;
+  let preCheckPidStartTime = null;
+  let preCheckHeartbeat = null;
+  if (preCheckRow && preCheckRow.pid !== null) {
+    preCheckPid = preCheckRow.pid;
+    preCheckPidStartTime = preCheckRow.pidStartTime;
+    preCheckHeartbeat = preCheckRow.lastHeartbeatAt;
+    const liveness = await isAlive(preCheckRow.pid);
+    const startTimeMatches = preCheckRow.pidStartTime === null || liveness.startTime === null || liveness.startTime === preCheckRow.pidStartTime;
+    if (liveness.alive && startTimeMatches) {
+      db.close();
+      throw new Error(
+        `daemon already running for collab ${collabId} (pid ${preCheckRow.pid})`
+      );
+    }
+  }
   const range = opts.portRange ?? DEFAULT_PORT_RANGE;
   const osFreeCandidates = [];
   if (opts.explicitPort !== void 0) {
@@ -8133,16 +8449,25 @@ async function runCollabStart(opts) {
       );
     }
   }
+  const now = opts.now();
   let allocatedPort = 0;
   const tx = db.transaction(() => {
-    upsertWorkspace(db, { id: workspaceId, workspaceRoot, now });
-    const active = db.prepare(
-      "SELECT collab_id FROM collab WHERE workspace_id = ? AND status = 'active' LIMIT 1"
-    ).get(workspaceId);
-    if (active) {
-      throw new Error(
-        `active collab ${active.collab_id} already exists for workspace ${workspaceRoot}`
-      );
+    const existing = getBrokerDaemonByCollab(db, collabId);
+    if (existing) {
+      if (existing.pid === null) {
+        const heartbeatMs = Date.parse(existing.lastHeartbeatAt);
+        const nowMs = Date.parse(now);
+        const ageMs = Number.isFinite(heartbeatMs) && Number.isFinite(nowMs) ? nowMs - heartbeatMs : Number.POSITIVE_INFINITY;
+        if (ageMs < staleThresholdMs) {
+          throw new Error("RECOVERY_ALREADY_IN_PROGRESS");
+        }
+        deleteBrokerDaemonByCollab(db, collabId);
+      } else {
+        if (preCheckPid === null || existing.pid !== preCheckPid || existing.pidStartTime !== preCheckPidStartTime || existing.lastHeartbeatAt !== preCheckHeartbeat) {
+          throw new Error("DAEMON_NOW_RUNNING");
+        }
+        deleteBrokerDaemonByCollab(db, collabId);
+      }
     }
     const takenPorts = new Set(
       db.prepare("SELECT port FROM broker_daemon").all().map((r) => r.port)
@@ -8155,20 +8480,6 @@ async function runCollabStart(opts) {
       );
     }
     allocatedPort = picked;
-    db.prepare(
-      "INSERT INTO collab (collab_id, workspace_root, display_name, status, workspace_id, launch_mode, tmux_session, created_at, updated_at, orchestrator_enabled, orchestrator_max_rounds) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?)"
-    ).run(
-      collabId,
-      workspaceRoot,
-      opts.displayName,
-      workspaceId,
-      opts.launchMode,
-      opts.tmuxSession ?? null,
-      now,
-      now,
-      orchestratorEnabled ? 1 : 0,
-      orchestratorMaxRounds
-    );
     insertBrokerDaemon(db, {
       collabId,
       host,
@@ -8176,23 +8487,27 @@ async function runCollabStart(opts) {
       startedAt: now,
       lastHeartbeatAt: now
     });
-    upsertRecoveryState(db, {
-      collabId,
-      state: "normal",
-      idleAfterRecovery: false,
-      recoveredAt: null
-    });
   });
   try {
     tx.immediate();
   } catch (err) {
-    if (err.message === "ALL_CANDIDATES_TAKEN") {
-      db.close();
+    const msg = err.message;
+    db.close();
+    if (msg === "RECOVERY_ALREADY_IN_PROGRESS") {
+      throw new Error(
+        `recovery already in progress for collab ${collabId}`
+      );
+    }
+    if (msg === "DAEMON_NOW_RUNNING") {
+      throw new Error(
+        `daemon already running for collab ${collabId}`
+      );
+    }
+    if (msg === "ALL_CANDIDATES_TAKEN") {
       throw new Error(
         `every OS-free port in [${range[0]}, ${range[1]}] is reserved in the registry`
       );
     }
-    db.close();
     throw err;
   }
   const childPid = opts.spawnBroker({
@@ -8204,9 +8519,6 @@ async function runCollabStart(opts) {
   const cleanupOnFailure = (msg) => {
     const cleanup = db.transaction(() => {
       deleteBrokerDaemonByCollab(db, collabId);
-      db.prepare(
-        "UPDATE collab SET status='stopped', stopped_at=?, updated_at=? WHERE collab_id = ?"
-      ).run(opts.now(), opts.now(), collabId);
     });
     cleanup.immediate();
     try {
@@ -8234,23 +8546,197 @@ async function runCollabStart(opts) {
     );
   }
   db.close();
-  return {
-    collabId,
-    port: allocatedPort,
-    host,
-    // biome-ignore lint/style/noNonNullAssertion: guarded by cleanupOnFailure
-    pid: finalRow.pid
-  };
-}
-function recordLaunchedSessions(input) {
-  const db = openDatabase(getSharedSqlitePath());
+  const recoveryBroker = createBrokerRuntime({
+    sqlitePath,
+    runWorkflowDriver: false,
+    runDiagnosticsSweep: false,
+    runDaemonHeartbeat: false,
+    runBrokerDaemonSweep: false
+  });
   try {
-    if (input.launch.tmuxSession) {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      db.prepare(
-        "UPDATE collab SET tmux_session = ?, updated_at = ? WHERE collab_id = ?"
-      ).run(input.launch.tmuxSession, now, input.collabId);
-    }
+    const prepared = recoveryBroker.control.prepareCollabRecovery({
+      collabId,
+      now
+    });
+    const hasRememberedBindings = prepared.bindings.some(
+      (b) => b.activeSessionId !== null
+    );
+    upsertRecoveryState(recoveryBroker.db, {
+      collabId,
+      state: hasRememberedBindings ? "recovered" : "normal",
+      idleAfterRecovery: hasRememberedBindings,
+      recoveredAt: hasRememberedBindings ? now : null
+    });
+  } finally {
+    await recoveryBroker.stop();
+  }
+  return {
+    collabId,
+    host,
+    port: allocatedPort,
+    // biome-ignore lint/style/noNonNullAssertion: guarded by cleanupOnFailure
+    pid: finalRow.pid
+  };
+}
+
+// src/commands/collab/start.ts
+import { mkdirSync as mkdirSync3 } from "node:fs";
+var READY_TIMEOUT_DEFAULT2 = 3e4;
+async function runCollabStart(opts) {
+  const root = getStateRoot();
+  mkdirSync3(root, { recursive: true });
+  const sqlitePath = getSharedSqlitePath();
+  const db = openDatabase(sqlitePath);
+  applyMigrations(db);
+  const workspaceRoot = canonicalWorkspaceRoot(opts.cwd);
+  const workspaceId = workspaceIdFromPath(opts.cwd);
+  const now = opts.now();
+  const collabId = createCliCollabId(now);
+  const host = "127.0.0.1";
+  const orchestratorEnabled = process.env.AI_WHISPER_RELAY_ORCHESTRATOR_ENABLED !== "0";
+  const orchestratorMaxRounds = Math.max(
+    1,
+    Number(process.env.AI_WHISPER_RELAY_ORCHESTRATOR_MAX_ROUNDS ?? "3") || 3
+  );
+  const range = opts.portRange ?? DEFAULT_PORT_RANGE;
+  const osFreeCandidates = [];
+  if (opts.explicitPort !== void 0) {
+    if (!await opts.isPortFreeOs(opts.explicitPort)) {
+      db.close();
+      throw new Error(
+        `port ${opts.explicitPort} is in use by another process`
+      );
+    }
+    osFreeCandidates.push(opts.explicitPort);
+  } else {
+    for (let p = range[0]; p <= range[1]; p++) {
+      if (await opts.isPortFreeOs(p)) osFreeCandidates.push(p);
+    }
+    if (osFreeCandidates.length === 0) {
+      db.close();
+      throw new Error(
+        `No OS-free port in range [${range[0]}, ${range[1]}]`
+      );
+    }
+  }
+  let allocatedPort = 0;
+  const tx = db.transaction(() => {
+    upsertWorkspace(db, { id: workspaceId, workspaceRoot, now });
+    const active = db.prepare(
+      "SELECT collab_id FROM collab WHERE workspace_id = ? AND status = 'active' LIMIT 1"
+    ).get(workspaceId);
+    if (active) {
+      throw new Error(
+        `active collab ${active.collab_id} already exists for workspace ${workspaceRoot}`
+      );
+    }
+    const takenPorts = new Set(
+      db.prepare("SELECT port FROM broker_daemon").all().map((r) => r.port)
+    );
+    const picked = osFreeCandidates.find((p) => !takenPorts.has(p));
+    if (picked === void 0) throw new Error("ALL_CANDIDATES_TAKEN");
+    if (opts.explicitPort !== void 0 && picked !== opts.explicitPort) {
+      throw new Error(
+        `port ${opts.explicitPort} already in use by another daemon`
+      );
+    }
+    allocatedPort = picked;
+    db.prepare(
+      "INSERT INTO collab (collab_id, workspace_root, display_name, status, workspace_id, launch_mode, tmux_session, created_at, updated_at, orchestrator_enabled, orchestrator_max_rounds) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?)"
+    ).run(
+      collabId,
+      workspaceRoot,
+      opts.displayName,
+      workspaceId,
+      opts.launchMode,
+      opts.tmuxSession ?? null,
+      now,
+      now,
+      orchestratorEnabled ? 1 : 0,
+      orchestratorMaxRounds
+    );
+    insertBrokerDaemon(db, {
+      collabId,
+      host,
+      port: allocatedPort,
+      startedAt: now,
+      lastHeartbeatAt: now
+    });
+    upsertRecoveryState(db, {
+      collabId,
+      state: "normal",
+      idleAfterRecovery: false,
+      recoveredAt: null
+    });
+  });
+  try {
+    tx.immediate();
+  } catch (err) {
+    if (err.message === "ALL_CANDIDATES_TAKEN") {
+      db.close();
+      throw new Error(
+        `every OS-free port in [${range[0]}, ${range[1]}] is reserved in the registry`
+      );
+    }
+    db.close();
+    throw err;
+  }
+  const childPid = opts.spawnBroker({
+    collabId,
+    host,
+    port: allocatedPort,
+    sqlitePath
+  });
+  const cleanupOnFailure = (msg) => {
+    const cleanup = db.transaction(() => {
+      deleteBrokerDaemonByCollab(db, collabId);
+      db.prepare(
+        "UPDATE collab SET status='stopped', stopped_at=?, updated_at=? WHERE collab_id = ?"
+      ).run(opts.now(), opts.now(), collabId);
+    });
+    cleanup.immediate();
+    try {
+      opts.signalProcess(childPid, "SIGTERM");
+    } catch {
+    }
+    db.close();
+    throw new Error(msg);
+  };
+  const ready = await opts.waitForReady({
+    host,
+    port: allocatedPort,
+    collabId,
+    timeoutMs: opts.readyTimeoutMs ?? READY_TIMEOUT_DEFAULT2
+  });
+  if (!ready) {
+    cleanupOnFailure(
+      `broker readiness check timed out for collab ${collabId}`
+    );
+  }
+  const finalRow = getBrokerDaemonByCollab(db, collabId);
+  if (!finalRow || finalRow.pid === null) {
+    cleanupOnFailure(
+      `daemon did not write its PID for collab ${collabId}`
+    );
+  }
+  db.close();
+  return {
+    collabId,
+    port: allocatedPort,
+    host,
+    // biome-ignore lint/style/noNonNullAssertion: guarded by cleanupOnFailure
+    pid: finalRow.pid
+  };
+}
+function recordLaunchedSessions(input) {
+  const db = openDatabase(getSharedSqlitePath());
+  try {
+    if (input.launch.tmuxSession) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      db.prepare(
+        "UPDATE collab SET tmux_session = ?, updated_at = ? WHERE collab_id = ?"
+      ).run(input.launch.tmuxSession, now, input.collabId);
+    }
     if (input.launchMode === "terminals") {
       const runtime = input.launch.runtime;
       const agents = [
@@ -8302,7 +8788,7 @@ function recordLaunchedSessions(input) {
 }
 
 // src/commands/collab/mount.ts
-function defaultIsPidAlive(pid) {
+function defaultIsPidAlive3(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -8358,10 +8844,46 @@ async function runCollabMount(input) {
       db.close();
     }
   };
+  const isDaemonAlive = input.isDaemonPidAlive ?? defaultIsPidAlive3;
+  const reviveViaRecover = async () => {
+    await (input.runRecoverFn ?? runCollabRecover)({
+      cwd: input.workspaceRoot,
+      now: () => (/* @__PURE__ */ new Date()).toISOString(),
+      isPortFreeOs: (port) => isPortFree(port),
+      spawnBroker: ({ collabId, host, port, sqlitePath }) => spawnBrokerDaemon(sqlitePath, host, port, collabId),
+      waitForReady: ({ host, port, collabId, timeoutMs }) => waitForBrokerReady({ host, port, collabId, timeoutMs }),
+      signalProcess: (pid, signal) => {
+        try {
+          process.kill(pid, signal);
+        } catch {
+        }
+      }
+    });
+    const db = openDatabase(getSharedSqlitePath());
+    try {
+      const r = resolveCollab({ db, cwd: input.workspaceRoot });
+      upsertRecoveryState(db, {
+        collabId: r.collabId,
+        state: "normal",
+        idleAfterRecovery: false,
+        recoveredAt: null
+      });
+    } finally {
+      db.close();
+    }
+    return tryResolve();
+  };
   const resolveOrCreate = async () => {
     try {
-      return tryResolve();
+      const resolved2 = tryResolve();
+      if (input.collabIdOverride === void 0 && resolved2.daemon !== null && !isDaemonAlive(resolved2.daemon.pid)) {
+        return await reviveViaRecover();
+      }
+      return resolved2;
     } catch (err) {
+      if (err instanceof CollabResolverError && err.kind === "NoLiveDaemonForCollab" && input.collabIdOverride === void 0) {
+        return await reviveViaRecover();
+      }
       if (!(err instanceof CollabResolverError && (err.kind === "NoCollabFoundForCwd" || err.kind === "CollabAlreadyStopped"))) {
         throw err;
       }
@@ -8429,7 +8951,7 @@ async function runCollabMount(input) {
   try {
     const current = broker.control.listSessionBindings(resolved.collabId).find((binding) => binding.agentType === input.target);
     if (current?.bindingState === "bound") {
-      const isAlive = input.isPidAlive ?? defaultIsPidAlive;
+      const isAlive = input.isPidAlive ?? defaultIsPidAlive3;
       const liveOwner = broker.control.listSessionAttachments(resolved.collabId).some(
         (a) => a.agentType === input.target && a.pid !== null && isAlive(a.pid)
       );
@@ -8873,201 +9395,6 @@ async function runCollabInspect(input) {
   }
 }
 
-// src/commands/collab/recover.ts
-var READY_TIMEOUT_DEFAULT2 = 3e4;
-var STALE_THRESHOLD_DEFAULT = 9e4;
-function defaultIsAliveImpl(pid) {
-  try {
-    process.kill(pid, 0);
-    return Promise.resolve({ alive: true, startTime: null });
-  } catch (err) {
-    const code = err.code;
-    if (code === "EPERM") return Promise.resolve({ alive: true, startTime: null });
-    return Promise.resolve({ alive: false, startTime: null });
-  }
-}
-async function runCollabRecover(opts) {
-  const sqlitePath = getSharedSqlitePath();
-  const db = openDatabase(sqlitePath);
-  applyMigrations(db);
-  const isAlive = opts.isAlive ?? defaultIsAliveImpl;
-  const staleThresholdMs = opts.staleThresholdMs ?? STALE_THRESHOLD_DEFAULT;
-  const resolved = resolveCollab({
-    db,
-    cwd: opts.cwd,
-    ...opts.collabIdOverride ? { collabIdOverride: opts.collabIdOverride } : {},
-    requireActive: true
-  });
-  const collabId = resolved.collabId;
-  const host = "127.0.0.1";
-  const preCheckRow = getBrokerDaemonByCollab(db, collabId);
-  let preCheckPid = null;
-  let preCheckPidStartTime = null;
-  let preCheckHeartbeat = null;
-  if (preCheckRow && preCheckRow.pid !== null) {
-    preCheckPid = preCheckRow.pid;
-    preCheckPidStartTime = preCheckRow.pidStartTime;
-    preCheckHeartbeat = preCheckRow.lastHeartbeatAt;
-    const liveness = await isAlive(preCheckRow.pid);
-    const startTimeMatches = preCheckRow.pidStartTime === null || liveness.startTime === null || liveness.startTime === preCheckRow.pidStartTime;
-    if (liveness.alive && startTimeMatches) {
-      db.close();
-      throw new Error(
-        `daemon already running for collab ${collabId} (pid ${preCheckRow.pid})`
-      );
-    }
-  }
-  const range = opts.portRange ?? DEFAULT_PORT_RANGE;
-  const osFreeCandidates = [];
-  if (opts.explicitPort !== void 0) {
-    if (!await opts.isPortFreeOs(opts.explicitPort)) {
-      db.close();
-      throw new Error(
-        `port ${opts.explicitPort} is in use by another process`
-      );
-    }
-    osFreeCandidates.push(opts.explicitPort);
-  } else {
-    for (let p = range[0]; p <= range[1]; p++) {
-      if (await opts.isPortFreeOs(p)) osFreeCandidates.push(p);
-    }
-    if (osFreeCandidates.length === 0) {
-      db.close();
-      throw new Error(
-        `No OS-free port in range [${range[0]}, ${range[1]}]`
-      );
-    }
-  }
-  const now = opts.now();
-  let allocatedPort = 0;
-  const tx = db.transaction(() => {
-    const existing = getBrokerDaemonByCollab(db, collabId);
-    if (existing) {
-      if (existing.pid === null) {
-        const heartbeatMs = Date.parse(existing.lastHeartbeatAt);
-        const nowMs = Date.parse(now);
-        const ageMs = Number.isFinite(heartbeatMs) && Number.isFinite(nowMs) ? nowMs - heartbeatMs : Number.POSITIVE_INFINITY;
-        if (ageMs < staleThresholdMs) {
-          throw new Error("RECOVERY_ALREADY_IN_PROGRESS");
-        }
-        deleteBrokerDaemonByCollab(db, collabId);
-      } else {
-        if (preCheckPid === null || existing.pid !== preCheckPid || existing.pidStartTime !== preCheckPidStartTime || existing.lastHeartbeatAt !== preCheckHeartbeat) {
-          throw new Error("DAEMON_NOW_RUNNING");
-        }
-        deleteBrokerDaemonByCollab(db, collabId);
-      }
-    }
-    const takenPorts = new Set(
-      db.prepare("SELECT port FROM broker_daemon").all().map((r) => r.port)
-    );
-    const picked = osFreeCandidates.find((p) => !takenPorts.has(p));
-    if (picked === void 0) throw new Error("ALL_CANDIDATES_TAKEN");
-    if (opts.explicitPort !== void 0 && picked !== opts.explicitPort) {
-      throw new Error(
-        `port ${opts.explicitPort} already in use by another daemon`
-      );
-    }
-    allocatedPort = picked;
-    insertBrokerDaemon(db, {
-      collabId,
-      host,
-      port: allocatedPort,
-      startedAt: now,
-      lastHeartbeatAt: now
-    });
-  });
-  try {
-    tx.immediate();
-  } catch (err) {
-    const msg = err.message;
-    db.close();
-    if (msg === "RECOVERY_ALREADY_IN_PROGRESS") {
-      throw new Error(
-        `recovery already in progress for collab ${collabId}`
-      );
-    }
-    if (msg === "DAEMON_NOW_RUNNING") {
-      throw new Error(
-        `daemon already running for collab ${collabId}`
-      );
-    }
-    if (msg === "ALL_CANDIDATES_TAKEN") {
-      throw new Error(
-        `every OS-free port in [${range[0]}, ${range[1]}] is reserved in the registry`
-      );
-    }
-    throw err;
-  }
-  const childPid = opts.spawnBroker({
-    collabId,
-    host,
-    port: allocatedPort,
-    sqlitePath
-  });
-  const cleanupOnFailure = (msg) => {
-    const cleanup = db.transaction(() => {
-      deleteBrokerDaemonByCollab(db, collabId);
-    });
-    cleanup.immediate();
-    try {
-      opts.signalProcess(childPid, "SIGTERM");
-    } catch {
-    }
-    db.close();
-    throw new Error(msg);
-  };
-  const ready = await opts.waitForReady({
-    host,
-    port: allocatedPort,
-    collabId,
-    timeoutMs: opts.readyTimeoutMs ?? READY_TIMEOUT_DEFAULT2
-  });
-  if (!ready) {
-    cleanupOnFailure(
-      `broker readiness check timed out for collab ${collabId}`
-    );
-  }
-  const finalRow = getBrokerDaemonByCollab(db, collabId);
-  if (!finalRow || finalRow.pid === null) {
-    cleanupOnFailure(
-      `daemon did not write its PID for collab ${collabId}`
-    );
-  }
-  db.close();
-  const recoveryBroker = createBrokerRuntime({
-    sqlitePath,
-    runWorkflowDriver: false,
-    runDiagnosticsSweep: false,
-    runDaemonHeartbeat: false,
-    runBrokerDaemonSweep: false
-  });
-  try {
-    const prepared = recoveryBroker.control.prepareCollabRecovery({
-      collabId,
-      now
-    });
-    const hasRememberedBindings = prepared.bindings.some(
-      (b) => b.activeSessionId !== null
-    );
-    upsertRecoveryState(recoveryBroker.db, {
-      collabId,
-      state: hasRememberedBindings ? "recovered" : "normal",
-      idleAfterRecovery: hasRememberedBindings,
-      recoveredAt: hasRememberedBindings ? now : null
-    });
-  } finally {
-    await recoveryBroker.stop();
-  }
-  return {
-    collabId,
-    host,
-    port: allocatedPort,
-    // biome-ignore lint/style/noNonNullAssertion: guarded by cleanupOnFailure
-    pid: finalRow.pid
-  };
-}
-
 // src/commands/collab/reconnect.ts
 async function runCollabReconnect(input) {
   const db = openDatabase(getSharedSqlitePath());
@@ -10517,11 +10844,11 @@ async function runCollabDashboard(input) {
 
 // src/commands/collab/status.ts
 import Database2 from "better-sqlite3";
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 
 // src/runtime/evaluator-config.ts
 import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function isEvaluatorReady(status) {
   return status === "ready" || status === "unknown";
 }
@@ -10532,7 +10859,7 @@ function isEvaluatorPreflightBlocked(status) {
 // src/commands/collab/status.ts
 function runCollabStatus(input) {
   const sqlitePath = getSharedSqlitePath();
-  if (!existsSync7(sqlitePath)) {
+  if (!existsSync8(sqlitePath)) {
     return input.json ? JSON.stringify({ error: "no_collab_for_cwd", cwd: input.cwd }) : `no active collab for ${input.cwd}`;
   }
   const db = new Database2(sqlitePath, { readonly: true });
@@ -10867,9 +11194,9 @@ async function runCollabTell(input) {
 
 // src/runtime/launcher.ts
 import { execSync as execSync3, spawn as nodeSpawn } from "node:child_process";
-import { dirname as dirname3, resolve as resolve4 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-var __dirname = dirname3(fileURLToPath2(import.meta.url));
+import { dirname as dirname4, resolve as resolve4 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+var __dirname = dirname4(fileURLToPath3(import.meta.url));
 var whisperBinPath = resolve4(__dirname, "../bin/whisper.js");
 var relayMonitorBinPath = resolve4(__dirname, "../bin/relay-monitor.js");
 function shellQuote(value) {
@@ -11111,9 +11438,9 @@ async function runWorkflowTypes() {
 // src/commands/skill/install.ts
 import { cp, mkdir, readdir, stat } from "node:fs/promises";
 import path3 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 function defaultBundledSkillsDir() {
-  const here = path3.dirname(fileURLToPath3(import.meta.url));
+  const here = path3.dirname(fileURLToPath4(import.meta.url));
   return path3.resolve(here, "..", "..", "skills");
 }
 function homeForTarget(target, fakeHome) {