ai-whisper 0.2.0 → 0.3.0

package/dist/bin/whisper.js

@@ -599,6 +599,100 @@ function getCollab(db, collabId) {
   });
 }
 
+// ../broker/dist/storage/repositories/workflow-repository.js
+function rowToRecord(row) {
+  return {
+    workflowId: row.workflow_id,
+    collabId: row.collab_id,
+    workflowType: row.workflow_type,
+    name: row.name,
+    specPath: row.spec_path,
+    roleBindings: JSON.parse(row.role_bindings),
+    status: row.status,
+    currentPhaseIndex: row.current_phase_index,
+    haltReason: row.halt_reason,
+    workflowContext: JSON.parse(row.workflow_context),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function insertWorkflow(db, input) {
+  db.prepare(`INSERT INTO workflows
+		 (workflow_id, collab_id, workflow_type, name, spec_path, role_bindings, status,
+		  current_phase_index, halt_reason, workflow_context, created_at, updated_at)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?)`).run(input.workflowId, input.collabId, input.workflowType, input.name, input.specPath, JSON.stringify(input.roleBindings), input.status, input.currentPhaseIndex, JSON.stringify(input.workflowContext), input.now, input.now);
+}
+function getWorkflowById(db, workflowId) {
+  const row = db.prepare("SELECT * FROM workflows WHERE workflow_id = ?").get(workflowId);
+  return row ? rowToRecord(row) : null;
+}
+function listWorkflows(db, filter = {}) {
+  const clauses = [];
+  const args = [];
+  if (filter.collabId) {
+    clauses.push("collab_id = ?");
+    args.push(filter.collabId);
+  }
+  if (filter.status) {
+    clauses.push("status = ?");
+    args.push(filter.status);
+  }
+  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  const rows = db.prepare(`SELECT * FROM workflows ${where} ORDER BY created_at DESC`).all(...args);
+  return rows.map(rowToRecord);
+}
+function setWorkflowStatus(db, input) {
+  db.prepare(`UPDATE workflows
+		   SET status = ?, halt_reason = ?, updated_at = ?
+		 WHERE workflow_id = ?`).run(input.status, input.haltReason, input.now, input.workflowId);
+}
+function updateWorkflowContext(db, input) {
+  const existing = getWorkflowById(db, input.workflowId);
+  if (!existing) {
+    throw new Error(`updateWorkflowContext: unknown workflowId ${input.workflowId}`);
+  }
+  const merged = { ...existing.workflowContext, ...input.patch };
+  db.prepare("UPDATE workflows SET workflow_context = ?, updated_at = ? WHERE workflow_id = ?").run(JSON.stringify(merged), input.now, input.workflowId);
+}
+function incrementCurrentPhaseIndex(db, input) {
+  db.prepare(`UPDATE workflows
+		   SET current_phase_index = current_phase_index + 1, updated_at = ?
+		 WHERE workflow_id = ?`).run(input.now, input.workflowId);
+}
+function countActiveWorkflowsForCollab(db, collabId) {
+  const row = db.prepare("SELECT COUNT(*) AS n FROM workflows WHERE collab_id = ? AND status IN ('running', 'paused')").get(collabId);
+  return row.n;
+}
+
+// ../broker/dist/runtime/workspace-snapshot.js
+import { execFileSync } from "node:child_process";
+function captureWorkspaceSnapshotSync(workspaceRoot) {
+  try {
+    const ref = execFileSync("git", ["-C", workspaceRoot, "stash", "create"], {
+      encoding: "utf8",
+      timeout: 1e4
+    }).trim();
+    if (ref)
+      return ref;
+    const head = execFileSync("git", ["-C", workspaceRoot, "rev-parse", "HEAD"], {
+      encoding: "utf8",
+      timeout: 1e4
+    }).trim();
+    return head || null;
+  } catch {
+    return null;
+  }
+}
+function diffChangedFilesSince(workspaceRoot, sinceRef) {
+  try {
+    const stdout = execFileSync("git", ["-C", workspaceRoot, "diff", "--name-only", sinceRef], { encoding: "utf8", timeout: 1e4 });
+    const files = stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith(".ai-whisper/"));
+    return [...new Set(files)].sort();
+  } catch {
+    return [];
+  }
+}
+
 // ../broker/dist/storage/repositories/reply-repository.js
 function insertReply(db, reply) {
   db.prepare(`INSERT INTO reply (
@@ -1088,7 +1182,7 @@ function upsertRelayTurnState(db, input) {
 }
 
 // ../broker/dist/storage/repositories/relay-capture-diagnostics-repository.js
-function rowToRecord(row) {
+function rowToRecord2(row) {
   return {
     captureId: row.capture_id,
     handoffId: row.handoff_id,
@@ -1105,6 +1199,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 +1207,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;
@@ -1123,32 +1219,32 @@ function listCaptureDiagnosticsByCollab(db, collabId, limit, opts) {
     const rows2 = db.prepare(`SELECT * FROM relay_capture_diagnostics
 				 WHERE collab_id = ?${filterClause}
 				 ORDER BY created_at DESC`).all(collabId, ...filterArgs);
-    return rows2.map(rowToRecord);
+    return rows2.map(rowToRecord2);
   }
   const rows = db.prepare(`SELECT * FROM relay_capture_diagnostics
 			 WHERE collab_id = ?${filterClause}
 			 ORDER BY created_at DESC
 			 LIMIT ?`).all(collabId, ...filterArgs, limit);
-  return rows.map(rowToRecord);
+  return rows.map(rowToRecord2);
 }
 function listCaptureDiagnosticsByCollabAndChain(db, collabId, chainId, limit) {
   if (limit === null) {
     const rows2 = db.prepare(`SELECT * FROM relay_capture_diagnostics
 				 WHERE collab_id = ? AND chain_id = ?
 				 ORDER BY created_at DESC`).all(collabId, chainId);
-    return rows2.map(rowToRecord);
+    return rows2.map(rowToRecord2);
   }
   const rows = db.prepare(`SELECT * FROM relay_capture_diagnostics
 			 WHERE collab_id = ? AND chain_id = ?
 			 ORDER BY created_at DESC
 			 LIMIT ?`).all(collabId, chainId, limit);
-  return rows.map(rowToRecord);
+  return rows.map(rowToRecord2);
 }
 function listCaptureDiagnosticsByHandoff(db, handoffId) {
   const rows = db.prepare(`SELECT * FROM relay_capture_diagnostics
 			 WHERE handoff_id = ?
 			 ORDER BY created_at ASC`).all(handoffId);
-  return rows.map(rowToRecord);
+  return rows.map(rowToRecord2);
 }
 function deleteCaptureDiagnosticsOlderThan(db, cutoffIso) {
   const result = db.prepare("DELETE FROM relay_capture_diagnostics WHERE created_at < ?").run(cutoffIso);
@@ -1156,7 +1252,7 @@ function deleteCaptureDiagnosticsOlderThan(db, cutoffIso) {
 }
 
 // ../broker/dist/storage/repositories/relay-evaluator-diagnostics-repository.js
-function rowToRecord2(row) {
+function rowToRecord3(row) {
   return {
     evaluatorId: row.evaluator_id,
     handoffId: row.handoff_id,
@@ -1201,32 +1297,32 @@ function listEvaluatorDiagnosticsByCollab(db, collabId, limit, opts) {
     const rows2 = db.prepare(`SELECT * FROM relay_evaluator_diagnostics
 				 WHERE collab_id = ?${filterClause}
 				 ORDER BY created_at DESC`).all(collabId, ...filterArgs);
-    return rows2.map(rowToRecord2);
+    return rows2.map(rowToRecord3);
   }
   const rows = db.prepare(`SELECT * FROM relay_evaluator_diagnostics
 			 WHERE collab_id = ?${filterClause}
 			 ORDER BY created_at DESC
 			 LIMIT ?`).all(collabId, ...filterArgs, limit);
-  return rows.map(rowToRecord2);
+  return rows.map(rowToRecord3);
 }
 function listEvaluatorDiagnosticsByCollabAndChain(db, collabId, chainId, limit) {
   if (limit === null) {
     const rows2 = db.prepare(`SELECT * FROM relay_evaluator_diagnostics
 				 WHERE collab_id = ? AND chain_id = ?
 				 ORDER BY created_at DESC`).all(collabId, chainId);
-    return rows2.map(rowToRecord2);
+    return rows2.map(rowToRecord3);
   }
   const rows = db.prepare(`SELECT * FROM relay_evaluator_diagnostics
 			 WHERE collab_id = ? AND chain_id = ?
 			 ORDER BY created_at DESC
 			 LIMIT ?`).all(collabId, chainId, limit);
-  return rows.map(rowToRecord2);
+  return rows.map(rowToRecord3);
 }
 function listEvaluatorDiagnosticsByHandoff(db, handoffId) {
   const rows = db.prepare(`SELECT * FROM relay_evaluator_diagnostics
 			 WHERE handoff_id = ?
 			 ORDER BY created_at ASC`).all(handoffId);
-  return rows.map(rowToRecord2);
+  return rows.map(rowToRecord3);
 }
 function deleteEvaluatorDiagnosticsOlderThan(db, cutoffIso) {
   const result = db.prepare("DELETE FROM relay_evaluator_diagnostics WHERE created_at < ?").run(cutoffIso);
@@ -1234,7 +1330,7 @@ function deleteEvaluatorDiagnosticsOlderThan(db, cutoffIso) {
 }
 
 // ../broker/dist/storage/repositories/relay-handoff-repository.js
-function rowToRecord3(row) {
+function rowToRecord4(row) {
   return {
     handoffId: row.handoff_id,
     collabId: row.collab_id,
@@ -1271,7 +1367,7 @@ function queryRelayHandoff(db, handoffId) {
 			 FROM relay_handoff h
 			 JOIN collab c ON c.collab_id = h.collab_id
 			 WHERE h.handoff_id = ?`).get(handoffId);
-  return row ? rowToRecord3(row) : null;
+  return row ? rowToRecord4(row) : null;
 }
 function createRelayHandoffTxn(db, input) {
   return db.transaction(() => {
@@ -1423,7 +1519,7 @@ function queryLatestHandedBackHandoff(db, collabId) {
 			 WHERE h.collab_id = ? AND h.status = 'handed_back'
 			 ORDER BY h.resolved_at DESC
 			 LIMIT 1`).get(collabId);
-  return row ? rowToRecord3(row) : null;
+  return row ? rowToRecord4(row) : null;
 }
 function failRelayHandoffOnDisconnectTxn(db, input) {
   db.transaction(() => {
@@ -1447,6 +1543,30 @@ function failRelayHandoffOnDisconnectTxn(db, input) {
     }
   })();
 }
+function hasInFlightAcceptedHandoffForWorkflow(db, workflowId) {
+  const row = db.prepare("SELECT COUNT(*) AS n FROM relay_handoff WHERE workflow_id = ? AND status = 'accepted'").get(workflowId);
+  return row.n > 0;
+}
+function resetStrandedOrchestrationForWorkflow(db, workflowId) {
+  const result = db.prepare(`UPDATE relay_handoff
+			    SET orchestrator_status = 'idle', orchestrator_claimed_at = NULL
+			  WHERE workflow_id = ?
+			    AND status = 'handed_back'
+			    AND orchestrator_status = 'pending'
+			    AND evaluator_verdict IS NULL`).run(workflowId);
+  return result.changes;
+}
+function prependToPendingHandoffRequestText(db, input) {
+  const row = db.prepare(`SELECT handoff_id, request_text FROM relay_handoff
+			  WHERE workflow_id = ? AND status = 'pending'
+			  ORDER BY created_at DESC LIMIT 1`).get(input.workflowId);
+  if (!row)
+    return false;
+  db.prepare("UPDATE relay_handoff SET request_text = ?, last_activity_at = ? WHERE handoff_id = ?").run(`${input.prefix}
+
+${row.request_text}`, input.now, row.handoff_id);
+  return true;
+}
 function claimRelayHandoffForOrchestrationTxn(db, input) {
   const result = db.prepare(`UPDATE relay_handoff
 			    SET orchestrator_status = 'pending',
@@ -1465,10 +1585,12 @@ function listRelayHandoffsPendingOrchestration(db, collabId) {
 			        c.orchestrator_max_rounds AS max_rounds
 			 FROM relay_handoff h
 			 JOIN collab c ON c.collab_id = h.collab_id
+			 LEFT JOIN workflows w ON w.workflow_id = h.workflow_id
 			 WHERE h.collab_id = ?
 			   AND h.status = 'handed_back'
-			   AND h.orchestrator_status = 'idle'`).all(collabId);
-  return rows.map(rowToRecord3);
+			   AND h.orchestrator_status = 'idle'
+			   AND (w.status IS NULL OR w.status <> 'paused')`).all(collabId);
+  return rows.map(rowToRecord4);
 }
 function createLoopRelayHandoffTxn(db, input) {
   return db.transaction(() => {
@@ -1664,7 +1786,7 @@ function getHandoffWithWorkflowMetaById(db, handoffId) {
 			 WHERE h.handoff_id = ?`).get(handoffId);
   if (!row)
     return null;
-  const base = rowToRecord3(row);
+  const base = rowToRecord4(row);
   return {
     ...base,
     handoffStep: row.handoff_step,
@@ -1914,71 +2036,6 @@ function listRunCostRows(db, input) {
 // ../broker/dist/control/workflow-control.js
 import { randomUUID } from "node:crypto";
 
-// ../broker/dist/storage/repositories/workflow-repository.js
-function rowToRecord4(row) {
-  return {
-    workflowId: row.workflow_id,
-    collabId: row.collab_id,
-    workflowType: row.workflow_type,
-    name: row.name,
-    specPath: row.spec_path,
-    roleBindings: JSON.parse(row.role_bindings),
-    status: row.status,
-    currentPhaseIndex: row.current_phase_index,
-    haltReason: row.halt_reason,
-    workflowContext: JSON.parse(row.workflow_context),
-    createdAt: row.created_at,
-    updatedAt: row.updated_at
-  };
-}
-function insertWorkflow(db, input) {
-  db.prepare(`INSERT INTO workflows
-		 (workflow_id, collab_id, workflow_type, name, spec_path, role_bindings, status,
-		  current_phase_index, halt_reason, workflow_context, created_at, updated_at)
-		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?)`).run(input.workflowId, input.collabId, input.workflowType, input.name, input.specPath, JSON.stringify(input.roleBindings), input.status, input.currentPhaseIndex, JSON.stringify(input.workflowContext), input.now, input.now);
-}
-function getWorkflowById(db, workflowId) {
-  const row = db.prepare("SELECT * FROM workflows WHERE workflow_id = ?").get(workflowId);
-  return row ? rowToRecord4(row) : null;
-}
-function listWorkflows(db, filter = {}) {
-  const clauses = [];
-  const args = [];
-  if (filter.collabId) {
-    clauses.push("collab_id = ?");
-    args.push(filter.collabId);
-  }
-  if (filter.status) {
-    clauses.push("status = ?");
-    args.push(filter.status);
-  }
-  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
-  const rows = db.prepare(`SELECT * FROM workflows ${where} ORDER BY created_at DESC`).all(...args);
-  return rows.map(rowToRecord4);
-}
-function setWorkflowStatus(db, input) {
-  db.prepare(`UPDATE workflows
-		   SET status = ?, halt_reason = ?, updated_at = ?
-		 WHERE workflow_id = ?`).run(input.status, input.haltReason, input.now, input.workflowId);
-}
-function updateWorkflowContext(db, input) {
-  const existing = getWorkflowById(db, input.workflowId);
-  if (!existing) {
-    throw new Error(`updateWorkflowContext: unknown workflowId ${input.workflowId}`);
-  }
-  const merged = { ...existing.workflowContext, ...input.patch };
-  db.prepare("UPDATE workflows SET workflow_context = ?, updated_at = ? WHERE workflow_id = ?").run(JSON.stringify(merged), input.now, input.workflowId);
-}
-function incrementCurrentPhaseIndex(db, input) {
-  db.prepare(`UPDATE workflows
-		   SET current_phase_index = current_phase_index + 1, updated_at = ?
-		 WHERE workflow_id = ?`).run(input.now, input.workflowId);
-}
-function countRunningWorkflowsForCollab(db, collabId) {
-  const row = db.prepare("SELECT COUNT(*) AS n FROM workflows WHERE collab_id = ? AND status = 'running'").get(collabId);
-  return row.n;
-}
-
 // ../broker/dist/storage/repositories/workflow-phase-repository.js
 function rowToRecord5(row) {
   return {
@@ -2099,6 +2156,14 @@ Findings:           (omit this block entirely if none)
 Non-blocking risks:
 - <quality risk that does NOT block this gate, or "None.">
 --- end protocol ---`;
+var WORKFLOW_OPERATOR_CONTROL = `--- ai-whisper operator control ---
+If the operator interrupts you and asks to pause the workflow (e.g. "pause the workflow, I need to fix X"):
+1. Find the active workflow id: run \`whisper workflow list\`.
+2. Run \`whisper workflow pause <id>\`.
+3. Acknowledge and STOP working \u2014 do not start the next change.
+The operator will edit artifacts and later run \`whisper workflow resume <id> [--message "..."]\`; you will then receive a notice of what changed and must re-read those files before continuing.
+Provider note: the Codex CLI EXITS its session on Ctrl+C at an idle prompt (a mid-task Ctrl+C only interrupts the running task). The operator typically interrupts you while you are BUSY before issuing this instruction; do not assume Ctrl+C is a safe no-op.
+--- end operator control ---`;
 var WORKFLOW_DIAGNOSIS_PROTOCOL = `--- ai-whisper diagnosis review protocol ---
 You are the gatekeeper for an ai-whisper complex-bug-fixing DIAGNOSIS gate. No human is in the loop. Do NOT trust the implementer's diagnosis \u2014 verify it yourself. The gate stays shut until YOU independently agree on the root cause and that the fix is net-safe.
 
@@ -2337,10 +2402,21 @@ var COMPLEX_BUG_FIXING = {
     }
   ]
 };
+function withOperatorControl(def) {
+  return {
+    ...def,
+    phases: def.phases.map((p) => ({
+      ...p,
+      kickoffTemplate: `${p.kickoffTemplate}
+
+${WORKFLOW_OPERATOR_CONTROL}`
+    }))
+  };
+}
 var REGISTRY = {
-  [SPEC_DRIVEN_DEVELOPMENT.type]: SPEC_DRIVEN_DEVELOPMENT,
-  [RALPH_LOOP.type]: RALPH_LOOP,
-  [COMPLEX_BUG_FIXING.type]: COMPLEX_BUG_FIXING
+  [SPEC_DRIVEN_DEVELOPMENT.type]: withOperatorControl(SPEC_DRIVEN_DEVELOPMENT),
+  [RALPH_LOOP.type]: withOperatorControl(RALPH_LOOP),
+  [COMPLEX_BUG_FIXING.type]: withOperatorControl(COMPLEX_BUG_FIXING)
 };
 function ralphRunDir(workspaceRoot, workflowId) {
   return join(workspaceRoot, ".ai-whisper", "ralph", workflowId);
@@ -2396,6 +2472,23 @@ function safeDerivePlanPath(specPath, createdAt) {
     return `${dir}${stem}.plan.md`;
   }
 }
+function composeResumeNotice(input) {
+  const hasFiles = input.changedFiles.length > 0;
+  const hasMessage = !!input.message && input.message.trim().length > 0;
+  if (!hasFiles && !hasMessage)
+    return null;
+  const lines = [];
+  if (hasFiles) {
+    lines.push("While paused, the operator modified these files:");
+    for (const f of input.changedFiles)
+      lines.push(`  - ${f}`);
+    lines.push("Re-read them before continuing.");
+  }
+  if (hasMessage)
+    lines.push(`Operator note: ${input.message.trim()}`);
+  lines.push("Re-evaluate whether your current direction still holds; correct course before proceeding.");
+  return lines.join("\n");
+}
 function createWorkflowControl(deps) {
   const { db, events } = deps;
   function createWorkflow(input) {
@@ -2418,8 +2511,9 @@ function createWorkflowControl(deps) {
     }
     const workflowId = `wf_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
     const tx = db.transaction(() => {
-      if (countRunningWorkflowsForCollab(db, input.collabId) > 0) {
-        throw new Error(`another workflow is already running on this collab (${input.collabId})`);
+      if (countActiveWorkflowsForCollab(db, input.collabId) > 0) {
+        const active = listWorkflows(db, { collabId: input.collabId }).find((w) => w.status === "running" || w.status === "paused");
+        throw new Error(`another workflow is already active on this collab (${input.collabId})` + (active ? `: ${active.workflowId} (${active.status})` : ""));
       }
       insertWorkflow(db, {
         workflowId,
@@ -2587,6 +2681,24 @@ function createWorkflowControl(deps) {
       postmortemPath: bf.postmortemPath
     });
   }
+  function consumeResumeNotice(input) {
+    const wf = getWorkflowById(db, input.workflowId);
+    const notice = wf?.workflowContext?.resumeNotice ?? null;
+    if (notice) {
+      updateWorkflowContext(db, {
+        workflowId: input.workflowId,
+        patch: { resumeNotice: null },
+        now: input.now
+      });
+    }
+    return notice;
+  }
+  function withResumeNotice(workflowId, requestText, now) {
+    const notice = consumeResumeNotice({ workflowId, now });
+    return notice ? `${notice}
+
+${requestText}` : requestText;
+  }
   function createContinuationHandoff(input) {
     const handoffId = `ho_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
     insertWorkflowOwnedRelayHandoff(db, {
@@ -2594,7 +2706,9 @@ function createWorkflowControl(deps) {
       collabId: input.workflow.collabId,
       senderAgent: input.sender,
       targetAgent: input.target,
-      requestText: input.requestText,
+      // Prepend the one-time resume notice (if any) to the FIRST outgoing request
+      // after a resume, then it is cleared — so the agent re-reads changed files.
+      requestText: withResumeNotice(input.workflow.workflowId, input.requestText, input.now),
       chainId: input.chain.chainId,
       roundNumber: input.incrementRound ? input.chain.currentRound + 1 : input.chain.currentRound,
       maxRounds: input.chain.maxRounds,
@@ -2654,7 +2768,9 @@ function createWorkflowControl(deps) {
       collabId: input.workflow.collabId,
       senderAgent: sender,
       targetAgent: target,
-      requestText: kickoffText,
+      // Prepend a pending resume notice (consumed once) so a phase-advance kickoff
+      // after a resume also carries the operator's change notice.
+      requestText: withResumeNotice(input.workflow.workflowId, kickoffText, input.now),
       chainId,
       roundNumber: 1,
       maxRounds: phase.maxRounds,
@@ -3115,20 +3231,100 @@ ${findingsText}`;
       reason: input.reason
     });
   }
+  function maybeCaptureQuiesceSnapshot(input) {
+    const wf = getWorkflowById(db, input.workflowId);
+    if (!wf || wf.status !== "paused")
+      return;
+    if (wf.workflowContext.pauseSnapshotRef !== void 0) {
+      return;
+    }
+    if (hasInFlightAcceptedHandoffForWorkflow(db, input.workflowId))
+      return;
+    const ref = deps.captureSnapshotRef ? deps.captureSnapshotRef(input.workflowId) : null;
+    updateWorkflowContext(db, {
+      workflowId: input.workflowId,
+      patch: { pauseSnapshotRef: ref },
+      now: input.now
+    });
+  }
+  function pauseWorkflow(input) {
+    const workflow = getWorkflowById(db, input.workflowId);
+    if (!workflow) {
+      throw new Error(`pauseWorkflow: unknown workflowId ${input.workflowId}`);
+    }
+    if (workflow.status !== "running") {
+      throw new Error(`pauseWorkflow: workflow ${input.workflowId} is ${workflow.status}, only running workflows can be paused`);
+    }
+    const tx = db.transaction(() => {
+      const current = getWorkflowById(db, input.workflowId);
+      if (!current || current.status !== "running")
+        return;
+      setWorkflowStatus(db, {
+        workflowId: input.workflowId,
+        status: "paused",
+        haltReason: null,
+        now: input.now
+      });
+      updateWorkflowContext(db, {
+        workflowId: input.workflowId,
+        patch: { pausedAt: input.now },
+        now: input.now
+      });
+    });
+    tx.immediate();
+    events.emit("workflow.paused", { workflowId: input.workflowId });
+    maybeCaptureQuiesceSnapshot({ workflowId: input.workflowId, now: input.now });
+  }
+  function resumeHaltedWorkflow(workflow, now) {
+    const tx = db.transaction(() => {
+      const others = listWorkflows(db, { collabId: workflow.collabId }).filter((w) => w.workflowId !== workflow.workflowId && (w.status === "running" || w.status === "paused"));
+      if (others.length > 0) {
+        throw new Error(`resumeWorkflow: another workflow is already active on collab ${workflow.collabId}`);
+      }
+      setWorkflowStatus(db, {
+        workflowId: workflow.workflowId,
+        status: "running",
+        haltReason: null,
+        now
+      });
+    });
+    tx.immediate();
+    events.emit("workflow.resumed", {
+      workflowId: workflow.workflowId,
+      phaseIndex: workflow.currentPhaseIndex
+    });
+  }
   function resumeWorkflow(input) {
     const workflow = getWorkflowById(db, input.workflowId);
     if (!workflow) {
       throw new Error(`resumeWorkflow: unknown workflowId ${input.workflowId}`);
     }
-    if (workflow.status === "canceled") {
-      throw new Error(`resumeWorkflow: workflow ${input.workflowId} is canceled and cannot be resumed`);
+    if (workflow.status === "halted") {
+      resumeHaltedWorkflow(workflow, input.now);
+      return;
     }
-    if (workflow.status !== "halted") {
-      throw new Error(`resumeWorkflow: workflow ${input.workflowId} is not halted (status=${workflow.status})`);
+    if (workflow.status !== "paused") {
+      throw new Error(`resumeWorkflow: workflow ${input.workflowId} is ${workflow.status}, only paused or halted workflows can be resumed`);
     }
+    const ref = workflow.workflowContext.pauseSnapshotRef ?? null;
+    const changedFiles = ref && deps.diffChangedFilesSinceSnapshot ? deps.diffChangedFilesSinceSnapshot(input.workflowId, ref) : [];
+    const notice = composeResumeNotice({
+      changedFiles,
+      message: input.message ?? null
+    });
     const tx = db.transaction(() => {
-      if (countRunningWorkflowsForCollab(db, workflow.collabId) > 0) {
-        throw new Error(`resumeWorkflow: another workflow is already running on collab ${workflow.collabId}`);
+      const others = listWorkflows(db, { collabId: workflow.collabId }).filter((w) => w.workflowId !== input.workflowId && (w.status === "running" || w.status === "paused"));
+      if (others.length > 0) {
+        throw new Error(`resumeWorkflow: another workflow is already active on collab ${workflow.collabId}`);
+      }
+      resetStrandedOrchestrationForWorkflow(db, input.workflowId);
+      let bakedIntoPending = false;
+      if (notice) {
+        bakedIntoPending = prependToPendingHandoffRequestText(db, {
+          workflowId: input.workflowId,
+          prefix: notice,
+          now: input.now
+        });
       }
       setWorkflowStatus(db, {
         workflowId: input.workflowId,
@@ -3136,6 +3332,15 @@ ${findingsText}`;
         haltReason: null,
         now: input.now
       });
+      updateWorkflowContext(db, {
+        workflowId: input.workflowId,
+        patch: {
+          resumeNotice: bakedIntoPending ? null : notice,
+          pausedAt: null,
+          pauseSnapshotRef: null
+        },
+        now: input.now
+      });
     });
     tx.immediate();
     events.emit("workflow.resumed", {
@@ -3236,6 +3441,9 @@ ${findingsText}`;
     beginPhaseRun,
     applyOrchestratorVerdict,
     haltWorkflow,
+    pauseWorkflow,
+    maybeCaptureQuiesceSnapshot,
+    consumeResumeNotice,
     resumeWorkflow,
     cancelWorkflow,
     getHandoffWithWorkflowMeta,
@@ -3251,8 +3459,32 @@ function buildEventId(kind, subjectId, timestamp) {
   return `evt_${kind}_${subjectId}_${normalizeTimestampForEventId(timestamp)}`;
 }
 function createControlService(db, events) {
-  const workflowControl = createWorkflowControl({ db, events });
+  const resolveWorkspaceRoot = (workflowId) => {
+    const wf = getWorkflowById(db, workflowId);
+    if (!wf)
+      return null;
+    return getCollab(db, wf.collabId)?.workspaceRoot ?? null;
+  };
+  const workflowControl = createWorkflowControl({
+    db,
+    events,
+    captureSnapshotRef: (workflowId) => {
+      const root = resolveWorkspaceRoot(workflowId);
+      return root ? captureWorkspaceSnapshotSync(root) : null;
+    },
+    diffChangedFilesSinceSnapshot: (workflowId, sinceRef) => {
+      const root = resolveWorkspaceRoot(workflowId);
+      return root ? diffChangedFilesSince(root, sinceRef) : [];
+    }
+  });
+  const isWorkflowDeliverySuspended = (handoffId) => {
+    const meta = workflowControl.getHandoffWithWorkflowMeta(handoffId);
+    if (!meta?.workflowId)
+      return false;
+    return workflowControl.getWorkflow(meta.workflowId)?.status === "paused";
+  };
   return Object.assign({
+    isWorkflowDeliverySuspended,
     startCollab(input) {
       const collab = collabSchema.parse({
         version: 1,
@@ -3880,6 +4112,8 @@ function createControlService(db, events) {
       return createRelayHandoffTxn(db, input);
     },
     acceptRelayHandoff(input) {
+      if (isWorkflowDeliverySuspended(input.handoffId))
+        return;
       return acceptRelayHandoffTxn(db, input);
     },
     deferRelayHandoff(input) {
@@ -3892,7 +4126,12 @@ function createControlService(db, events) {
       return markRelayHandoffStaleTxn(db, input);
     },
     handoffBackRelay(input) {
-      return handoffBackRelayTxn(db, input);
+      const result = handoffBackRelayTxn(db, input);
+      const meta = workflowControl.getHandoffWithWorkflowMeta(input.handoffId);
+      if (meta?.workflowId && workflowControl.getWorkflow(meta.workflowId)?.status === "paused") {
+        workflowControl.maybeCaptureQuiesceSnapshot({ workflowId: meta.workflowId, now: input.now });
+      }
+      return result;
     },
     failRelayHandoffOnDisconnect(input) {
       return failRelayHandoffOnDisconnectTxn(db, input);
@@ -3904,6 +4143,8 @@ function createControlService(db, events) {
       return queryLatestHandedBackHandoff(db, collabId);
     },
     claimRelayHandoffForOrchestration(input) {
+      if (isWorkflowDeliverySuspended(input.handoffId))
+        return null;
       return claimRelayHandoffForOrchestrationTxn(db, input);
     },
     listRelayHandoffsPendingOrchestration(collabId) {
@@ -3939,6 +4180,7 @@ function createControlService(db, events) {
         clipSample: input.clipSample,
         turnSample: input.turnSample,
         abortedByRaceGuard: input.abortedByRaceGuard,
+        interferenceDetected: input.interferenceDetected ?? false,
         createdAt: input.now
       });
       return { captureId };
@@ -4015,10 +4257,155 @@ function createBrokerApp(input) {
   return app;
 }
 
-// ../broker/dist/storage/apply-migrations.js
-var CURRENT_SCHEMA_VERSION = 4;
-var initMigrationSql = `
-CREATE TABLE IF NOT EXISTS broker_state (
+// ../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 = 5;
+var initMigrationSql = `
+CREATE TABLE IF NOT EXISTS broker_state (
   id INTEGER PRIMARY KEY CHECK (id = 1),
   schema_version INTEGER NOT NULL,
   migrated INTEGER NOT NULL
@@ -4234,8 +4621,9 @@ CREATE TABLE IF NOT EXISTS workflows (
   updated_at TEXT NOT NULL
 );
 
+DROP INDEX IF EXISTS workflows_one_running_per_collab;
 CREATE UNIQUE INDEX IF NOT EXISTS workflows_one_running_per_collab
-  ON workflows(collab_id) WHERE status = 'running';
+  ON workflows(collab_id) WHERE status IN ('running', 'paused');
 
 CREATE TABLE IF NOT EXISTS workflow_phases (
   phase_run_id TEXT PRIMARY KEY,
@@ -4303,6 +4691,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 +4708,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 +4858,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 +4870,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,
@@ -5254,11 +5654,11 @@ function lookupByCwd(db, cwd) {
 }
 
 // src/runtime/current-tty.ts
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
 function resolveCurrentTty() {
   const stdin = process.stdin;
-  const ttyPath = stdin.isTTY && typeof stdin.path === "string" ? stdin.path : execFileSync("tty", [], {
+  const ttyPath = stdin.isTTY && typeof stdin.path === "string" ? stdin.path : execFileSync2("tty", [], {
     encoding: "utf8",
     stdio: ["inherit", "pipe", "pipe"]
   }).trim();
@@ -7098,6 +7498,9 @@ function createMountedTurnOwnedRelay(input) {
     if (!handoff) return null;
     if (handoff.status !== "pending" && handoff.status !== "deferred") return null;
     if (handoff.targetAgent !== input.currentAgent) return null;
+    if (input.broker.control.isWorkflowDeliverySuspended?.(handoff.handoffId)) {
+      return null;
+    }
     return handoff;
   }
   function getAcceptedHandoff() {
@@ -7279,7 +7682,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 +7745,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 +7794,7 @@ ${hint}`,
           clipSample: sampleOf(clipboardText),
           turnSample: sampleOf(turnResult.text),
           abortedByRaceGuard,
+          interferenceDetected,
           now
         });
       } catch (err) {
@@ -7679,6 +8099,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 +8244,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 +8329,7 @@ function createMountSessionRuntime(input) {
                 agentType: input.target,
                 attachmentKind: "mounted"
               });
+              releaseCaptureLease(db, resolvedClaim.collabId);
             } finally {
               db.close();
             }
@@ -7966,17 +8489,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 +8624,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 +8692,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 +8723,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 +8730,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 +8762,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,16 +8789,190 @@ 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 {
+    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();
@@ -8302,7 +9031,7 @@ function recordLaunchedSessions(input) {
 }
 
 // src/commands/collab/mount.ts
-function defaultIsPidAlive(pid) {
+function defaultIsPidAlive3(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -8358,10 +9087,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 +9194,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 +9638,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 +11087,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 +11102,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 +11437,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) {
@@ -11095,7 +11665,16 @@ async function runWorkflowInspect(deps) {
 
 // src/commands/workflow/resume.ts
 async function runWorkflowResume(deps) {
-  deps.broker.control.resumeWorkflow({ workflowId: deps.workflowId, now: deps.now });
+  deps.broker.control.resumeWorkflow({
+    workflowId: deps.workflowId,
+    now: deps.now,
+    ...deps.message !== void 0 ? { message: deps.message } : {}
+  });
+}
+
+// src/commands/workflow/pause.ts
+async function runWorkflowPause(deps) {
+  deps.broker.control.pauseWorkflow({ workflowId: deps.workflowId, now: deps.now });
 }
 
 // src/commands/workflow/cancel.ts
@@ -11111,9 +11690,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) {
@@ -11483,15 +12062,31 @@ Not attached (stdin/stdout is not a TTY). To view the tmux session, run:
       await broker.stop();
     }
   });
-  workflow.command("resume").description("Resume a halted workflow").argument("<workflowId>", "Workflow ID").option("--workspace <path>", "Workspace root", process.cwd()).action(async (workflowId, opts) => {
+  workflow.command("pause").description("Pause a running workflow").argument("<workflowId>", "Workflow ID").option("--workspace <path>", "Workspace root", process.cwd()).action(async (workflowId, opts) => {
     const { broker } = await connectToWorkspaceBroker({ cwd: opts.workspace });
     try {
-      await runWorkflowResume({ broker, workflowId, now: (/* @__PURE__ */ new Date()).toISOString() });
-      console.log(`Workflow resumed: ${workflowId}`);
+      await runWorkflowPause({ broker, workflowId, now: (/* @__PURE__ */ new Date()).toISOString() });
+      console.log(`Workflow paused: ${workflowId}`);
     } finally {
       await broker.stop();
     }
   });
+  workflow.command("resume").description("Resume a paused or halted workflow").argument("<workflowId>", "Workflow ID").option("--workspace <path>", "Workspace root", process.cwd()).option("--message <note>", "Operator note delivered to the agents on resume").action(
+    async (workflowId, opts) => {
+      const { broker } = await connectToWorkspaceBroker({ cwd: opts.workspace });
+      try {
+        await runWorkflowResume({
+          broker,
+          workflowId,
+          now: (/* @__PURE__ */ new Date()).toISOString(),
+          ...opts.message !== void 0 ? { message: opts.message } : {}
+        });
+        console.log(`Workflow resumed: ${workflowId}`);
+      } finally {
+        await broker.stop();
+      }
+    }
+  );
   workflow.command("cancel").description("Cancel a running or halted workflow").argument("<workflowId>", "Workflow ID").option("--workspace <path>", "Workspace root", process.cwd()).action(async (workflowId, opts) => {
     const { broker } = await connectToWorkspaceBroker({ cwd: opts.workspace });
     try {