ai-whisper 0.1.4 → 0.2.1

package/dist/bin/broker-daemon.js

@@ -1031,6 +1031,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
   };
 }
@@ -1038,8 +1039,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, collabId2, limit, opts) {
   const filter = opts?.workflowFilter;
@@ -2025,6 +2027,36 @@ Findings:           (omit this block entirely if none)
 Non-blocking risks:
 - <quality risk that does NOT block this gate, or "None.">
 --- end protocol ---`;
+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.
+
+Required procedure:
+1. Independently reproduce: re-run the implementer's reproduction yourself; do not trust pasted output. If YOU cannot reproduce it, that is a blocking finding (the repro is not real/reliable). Speculation from reading code paths is not a valid reproduction.
+2. Attack the causal claim: is the cause PROVEN by the evidence chain, or merely asserted? Could the named cause be a correlate, or a symptom of something deeper? Demand any missing link.
+3. Attack the fix (anti-whack-a-mole): does the proposed fix remove the root cause, or just this symptom's surface? Could the bug resurface through another path? Name it if so.
+4. Attack the blast radius: is every affected area/module/contract listed? Add what is missing.
+5. Attack residual risks: are the real foreseeable risks named, or hand-waved?
+6. Mutual-agreement gate: approve ONLY when you have independently confirmed the reproduction and agree the cause is proven and the fix is net-safe (fixes more than it risks). "Plausible" is not approval.
+
+Severity: a blocking finding must tie to a concrete diagnosis-contract item (unreproducible repro, unproven cause, symptom-masking fix, incomplete blast radius, un-named risk). Suppress style/taste. Do NOT gag valuable non-contract risk signals \u2014 surface them under "Non-blocking risks:" (always last) so they reach the human at escalation/completion.
+
+Findings vs escalation: a fixable defect in the diagnosis is a FINDING (loops back for revision) \u2014 do NOT say you "cannot proceed" for a defect you can describe. ESCALATE only when you genuinely cannot review (a required reproduction input is absent and is not the implementer's to supply).
+
+Never reply with only a bare verdict; your full reply must be well over 100 characters.
+
+Output format \u2014 the verdict line MUST come before the Non-blocking risks section, which is always LAST:
+Diagnosis review matrix:
+| Claim | Required evidence | Implementer evidence | Independently verified? | Result |
+| ... |
+
+Findings:           (omit this block entirely if none)
+- <blocking finding tied to an exact diagnosis-contract item, with evidence>
+
+<verdict line: "Approved. <one or two sentences>" OR, when blocked/cannot-proceed, state you cannot proceed and why>
+
+Non-blocking risks:
+- <risk that does NOT block this gate, or "None.">
+--- end protocol ---`;
 var SDD_SPEC_REVIEW = "Review the spec at {specPath}. This is an autonomous workflow with no human in the loop.\n\n" + WORKFLOW_REVIEW_PROTOCOL;
 var SDD_CODE_REVIEW = "Review the implementer's changes for this phase \u2014 the commits in {commitRange}. The upper bound is a LIVE `HEAD`: resolve it against the current repository at review time and INCLUDE any commits added during this review round (e.g. fixes for your prior findings); do not pin the review to an earlier tip. Verify against the spec's acceptance criteria and run the project's verification/tests. This is an autonomous workflow with no human in the loop.\n\n" + WORKFLOW_REVIEW_PROTOCOL;
 var SPEC_DRIVEN_DEVELOPMENT = {
@@ -2145,13 +2177,113 @@ var RALPH_LOOP = {
     }
   ]
 };
+var BUGFIX_DIAGNOSIS_KICKOFF = `You are the implementer in an autonomous complex-bug-fixing workflow. No human is in the loop \u2014 never ask for confirmation, permission, or clarification; do the work yourself.
+
+Read the bug report at {specPath}. A human (dev or QA) already observed this bug, so you must reproduce it too \u2014 do NOT theorize from reading code paths.
+
+Write a diagnosis artifact to {diagnosisPath} (create the file) with these sections:
+1. Reproduction \u2014 an ACTUALLY OBSERVED reproduction you ran yourself. Strongly prefer a failing test (RED) failing for the right reason; commit that test in THIS phase. If the project supports e2e/real-browser (e.g. Playwright), use it. Only if no automated test can capture it, give command/log output WITH an explicit justification.
+2. Root cause \u2014 the causal chain symptom\u2192cause, each link backed by concrete evidence (stack trace, log line, failing assertion, bisect), not assertion.
+3. Proposed fix approach \u2014 what changes and WHY that removes the root cause rather than masking the symptom.
+4. Blast radius \u2014 every area/module/contract the fix could affect.
+5. Residual risks \u2014 foreseeable risks remaining after the fix.
+
+Commit the RED reproduction test (do NOT commit {bugfixDir}; it is gitignored). End your handback with a 1-2 sentence summary; your reply must be at least two sentences, well over 100 characters \u2014 never hand back only a single word.`;
+var BUGFIX_DIAGNOSIS_REVIEW = "Review the diagnosis artifact at {diagnosisPath} for the bug reported at {specPath}. This is an autonomous workflow with no human in the loop.\n\n" + WORKFLOW_DIAGNOSIS_PROTOCOL;
+var BUGFIX_DIAGNOSIS_FIX = "Apply the reviewer's findings to the diagnosis at {diagnosisPath} now. This is an autonomous workflow \u2014 no human will respond. Make the edits yourself (re-reproduce if needed) and hand back the corrected diagnosis; never ask for confirmation, permission, or clarification. If you added or changed the RED reproduction test while addressing the findings, COMMIT it in this round (do NOT commit {bugfixDir}; it is gitignored) \u2014 the next phase reviews the committed change set, so an uncommitted repro update would be invisible to it. End your handback with a 1-2 sentence summary of what you changed; your reply must be at least two sentences, well over 100 characters \u2014 never hand back only a single word.";
+var BUGFIX_FIX_KICKOFF = `The diagnosis at {diagnosisPath} is APPROVED \u2014 treat it as ground truth (re-orient from it, not prior conversation). This is an autonomous workflow \u2014 no human will respond; do the work yourself.
+
+1. Implement the fix per the APPROVED approach.
+2. Turn the reproduction GREEN \u2014 the failing test now passes for the right reason; if the repro was a non-test demonstration, re-run it and show the symptom is gone.
+3. Run the project's verification/test command PLUS targeted checks across the declared blast radius, including the full suite, to catch regressions.
+4. Commit the fix and any added happy-path/edge-case coverage tests (the RED test was committed in diagnosis). Do NOT commit {bugfixDir} (gitignored).
+
+If you discover the approved cause was WRONG, do NOT silently switch to a different fix \u2014 the cause was the agreed premise of this run. Stop and hand back that you CANNOT PROCEED because the approved cause is wrong, explaining what the evidence now shows; do not deliver a fix built on a second, unreviewed theory. This halts the run and returns control to a human, who re-opens the diagnosis (a new run, or a resume after they adjust the report) \u2014 the workflow does not loop back to the diagnosis phase on its own. Otherwise, hand back the commit SHAs + verification output + a 1-2 sentence summary; your reply must be at least two sentences, well over 100 characters.`;
+var BUGFIX_FIX_REVIEW = "The implementer claims the fix for the bug at {specPath} is complete \u2014 the changes are commits {commitRange}; resolve the upper bound against LIVE HEAD and include fix-round commits. Verify against the APPROVED diagnosis at {diagnosisPath}. Independently re-run the reproduction (it must be GREEN) and the verification suite \u2014 do not trust pasted output. Confirm: the root cause is actually removed (not just relocated \u2014 anti-whack-a-mole); every declared blast-radius area is regression-free; residual risks are handled or explicitly accepted; and COVERAGE is adequate \u2014 every happy path has at least one covering test and edge cases are covered. A case that genuinely cannot be covered must be explicitly noted (not silently passed); thin coverage is a blocking finding. This is an autonomous workflow with no human in the loop.\n\n" + WORKFLOW_REVIEW_PROTOCOL;
+var BUGFIX_FIX_FIX = "Apply the reviewer's findings to commits {commitRange} now (amend or add commits). This is an autonomous workflow \u2014 no human will respond. Do the work yourself and hand back the updated commit SHAs and verification output; never ask for confirmation, permission, or clarification. End your handback with a 1-2 sentence summary; your reply must be at least two sentences, well over 100 characters.";
+var BUGFIX_POSTMORTEM_KICKOFF = "Write a post-mortem report to {postmortemPath} (create the file) for the bug fixed in this run. This is an autonomous workflow \u2014 no human will respond; do the work yourself. Recap: confirmed root cause; the fix applied; reproduction\u2192GREEN evidence; blast radius touched; coverage gaps explicitly listed (carried from the fix review); residual risks; and lessons learned. Do NOT commit {bugfixDir} (gitignored). End your handback with a 1-2 sentence summary; your reply must be at least two sentences, well over 100 characters.";
+var BUGFIX_POSTMORTEM_REVIEW = "Review the post-mortem report at {postmortemPath}. Confirm it faithfully reflects what actually happened in this run \u2014 confirmed cause, the fix, the noted coverage gaps, and residual risks are all present and honest. This is not a rubber stamp; gloss-overs or omissions are findings. This is an autonomous workflow with no human in the loop.\n\n" + WORKFLOW_REVIEW_PROTOCOL;
+var BUGFIX_POSTMORTEM_FIX = "Apply the reviewer's findings to the post-mortem at {postmortemPath} now. This is an autonomous workflow \u2014 no human will respond. Make the edits yourself and hand back the corrected report; never ask for confirmation, permission, or clarification. End your handback with a 1-2 sentence summary; your reply must be at least two sentences, well over 100 characters.";
+var COMPLEX_BUG_FIXING = {
+  type: "complex-bug-fixing",
+  displayName: "Complex Bug Fixing",
+  description: "Reproduce \u2192 adversarially-gated diagnosis \u2192 fix & verify \u2192 post-mortem, for a reported bug whose root cause is unknown",
+  defaultImplementer: "claude",
+  defaultReviewer: "codex",
+  phases: [
+    {
+      name: "diagnosis",
+      implementerRole: "implementer",
+      reviewerRole: "reviewer",
+      maxRounds: 5,
+      initialHandoffStep: "implement",
+      kickoffTemplate: BUGFIX_DIAGNOSIS_KICKOFF,
+      stepTemplates: {
+        implement: BUGFIX_DIAGNOSIS_KICKOFF,
+        review: BUGFIX_DIAGNOSIS_REVIEW,
+        fix: BUGFIX_DIAGNOSIS_FIX
+      },
+      reviewMode: "phase-review",
+      evaluatorPromptKey: "review-loop",
+      artifactOut: { kind: "spec", pathTemplate: "{diagnosisPath}" },
+      anchorCommitBaseOnEntry: true,
+      renderFixTemplateOnFindings: true
+    },
+    {
+      name: "fix-and-verify",
+      implementerRole: "implementer",
+      reviewerRole: "reviewer",
+      maxRounds: 5,
+      initialHandoffStep: "implement",
+      kickoffTemplate: BUGFIX_FIX_KICKOFF,
+      stepTemplates: {
+        implement: BUGFIX_FIX_KICKOFF,
+        review: BUGFIX_FIX_REVIEW,
+        fix: BUGFIX_FIX_FIX
+      },
+      reviewMode: "acceptance-review",
+      evaluatorPromptKey: "review-loop",
+      artifactOut: { kind: "commit-range" },
+      renderFixTemplateOnFindings: true
+    },
+    {
+      name: "post-mortem",
+      implementerRole: "implementer",
+      reviewerRole: "reviewer",
+      maxRounds: 3,
+      initialHandoffStep: "implement",
+      kickoffTemplate: BUGFIX_POSTMORTEM_KICKOFF,
+      stepTemplates: {
+        implement: BUGFIX_POSTMORTEM_KICKOFF,
+        review: BUGFIX_POSTMORTEM_REVIEW,
+        fix: BUGFIX_POSTMORTEM_FIX
+      },
+      reviewMode: "phase-review",
+      evaluatorPromptKey: "review-loop",
+      artifactOut: { kind: "spec", pathTemplate: "{postmortemPath}" },
+      renderFixTemplateOnFindings: true
+    }
+  ]
+};
 var REGISTRY = {
   [SPEC_DRIVEN_DEVELOPMENT.type]: SPEC_DRIVEN_DEVELOPMENT,
-  [RALPH_LOOP.type]: RALPH_LOOP
+  [RALPH_LOOP.type]: RALPH_LOOP,
+  [COMPLEX_BUG_FIXING.type]: COMPLEX_BUG_FIXING
 };
 function ralphRunDir(workspaceRoot, workflowId) {
   return join(workspaceRoot, ".ai-whisper", "ralph", workflowId);
 }
+function bugfixRunDir(workspaceRoot, workflowId) {
+  return join(workspaceRoot, ".ai-whisper", "bugfix", workflowId);
+}
+function bugfixPaths(workspaceRoot, workflowId) {
+  const bugfixDir = bugfixRunDir(workspaceRoot, workflowId);
+  return {
+    bugfixDir,
+    diagnosisPath: join(bugfixDir, "diagnosis.md"),
+    postmortemPath: join(bugfixDir, "postmortem.md")
+  };
+}
 function getWorkflowDefinition(type) {
   return REGISTRY[type];
 }
@@ -2371,12 +2503,16 @@ function createWorkflowControl(deps) {
     const collab2 = getCollab(db, input.workflow.collabId);
     const ralphDir = collab2 ? ralphRunDir(collab2.workspaceRoot, input.workflow.workflowId) : "";
     const reviewMode = useAcceptance ? "acceptance-review" : input.phase.reviewMode ?? "phase-review";
+    const bf = collab2 ? bugfixPaths(collab2.workspaceRoot, input.workflow.workflowId) : { bugfixDir: "", diagnosisPath: "", postmortemPath: "" };
     return renderTemplate(tmpl, {
       specPath: input.workflow.specPath,
       planPath: safeDerivePlanPath(input.workflow.specPath, input.workflow.createdAt),
       commitRange: liveReviewCommitRange(ctx),
       ralphDir,
-      reviewMode
+      reviewMode,
+      bugfixDir: bf.bugfixDir,
+      diagnosisPath: bf.diagnosisPath,
+      postmortemPath: bf.postmortemPath
     });
   }
   function createContinuationHandoff(input) {
@@ -2413,12 +2549,16 @@ function createWorkflowControl(deps) {
     const ctx = input.workflow.workflowContext;
     const collab2 = getCollab(db, input.workflow.collabId);
     const ralphDir = collab2 ? ralphRunDir(collab2.workspaceRoot, input.workflow.workflowId) : "";
+    const bf = collab2 ? bugfixPaths(collab2.workspaceRoot, input.workflow.workflowId) : { bugfixDir: "", diagnosisPath: "", postmortemPath: "" };
     const kickoffText = renderTemplate(phase.kickoffTemplate, {
       specPath: input.workflow.specPath,
       planPath: safeDerivePlanPath(input.workflow.specPath, input.workflow.createdAt),
       commitRange: liveReviewCommitRange(ctx),
       ralphDir,
-      reviewMode: phase.reviewMode ?? "phase-review"
+      reviewMode: phase.reviewMode ?? "phase-review",
+      bugfixDir: bf.bugfixDir,
+      diagnosisPath: bf.diagnosisPath,
+      postmortemPath: bf.postmortemPath
     });
     const chainId = `relay_ch_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
     const phaseRunId = `wfp_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
@@ -2676,15 +2816,19 @@ function createWorkflowControl(deps) {
       } else if (normalized.verdict === "findings") {
         const findingsText = input.followUpMessage ?? "Address the reviewer's findings.";
         let fixRequestText;
-        if (phase.repeatUntilComplete && phase.stepTemplates.fix) {
+        if ((phase.repeatUntilComplete || phase.renderFixTemplateOnFindings) && phase.stepTemplates.fix) {
           const ctx = workflow.workflowContext;
           const collab2 = getCollab(db, workflow.collabId);
           const ralphDir = collab2 ? ralphRunDir(collab2.workspaceRoot, workflow.workflowId) : "";
+          const bf = collab2 ? bugfixPaths(collab2.workspaceRoot, workflow.workflowId) : { bugfixDir: "", diagnosisPath: "", postmortemPath: "" };
           const fixTmpl = renderTemplate(phase.stepTemplates.fix, {
             specPath: workflow.specPath,
             planPath: safeDerivePlanPath(workflow.specPath, workflow.createdAt),
             commitRange: liveReviewCommitRange(ctx),
-            ralphDir
+            ralphDir,
+            bugfixDir: bf.bugfixDir,
+            diagnosisPath: bf.diagnosisPath,
+            postmortemPath: bf.postmortemPath
           });
           fixRequestText = `${fixTmpl}
 
@@ -3723,6 +3867,7 @@ function createControlService(db, events) {
         clipSample: input.clipSample,
         turnSample: input.turnSample,
         abortedByRaceGuard: input.abortedByRaceGuard,
+        interferenceDetected: input.interferenceDetected ?? false,
         createdAt: input.now
       });
       return { captureId };
@@ -3799,8 +3944,130 @@ 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 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),
@@ -4087,6 +4354,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)
@@ -4097,20 +4371,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);
@@ -4247,6 +4521,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
@@ -4258,6 +4533,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,
@@ -4512,6 +4791,23 @@ function ensureRalphWorkspace(workspaceRoot, workflowId) {
   return dir;
 }
 
+// ../broker/dist/runtime/bugfix-setup.js
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+function ensureBugfixWorkspace(workspaceRoot, workflowId) {
+  const dir = bugfixRunDir(workspaceRoot, workflowId);
+  mkdirSync2(dir, { recursive: true });
+  const ignorePath = join3(workspaceRoot, ".ai-whisper", ".gitignore");
+  if (!existsSync3(ignorePath)) {
+    writeFileSync2(ignorePath, "*\n");
+  }
+  const bugfixIgnorePath = join3(workspaceRoot, ".ai-whisper", "bugfix", ".gitignore");
+  if (!existsSync3(bugfixIgnorePath)) {
+    writeFileSync2(bugfixIgnorePath, "*\n");
+  }
+  return dir;
+}
+
 // ../broker/dist/runtime/workflow-driver.js
 function createWorkflowDriver(deps) {
   const { broker: broker2, headReader } = deps;
@@ -4582,7 +4878,7 @@ function createWorkflowDriver(deps) {
     const sender = phase.initialHandoffStep === "review" ? implementerAgent : reviewerAgent;
     const target = phase.initialHandoffStep === "review" ? reviewerAgent : implementerAgent;
     let executionBaseHeadSha;
-    if (phase.initialHandoffStep === "execute") {
+    if (phase.initialHandoffStep === "execute" || phase.anchorCommitBaseOnEntry === true) {
       try {
         executionBaseHeadSha = await headReader.readHead(collab2.workspaceRoot);
       } catch (err) {
@@ -4605,6 +4901,15 @@ function createWorkflowDriver(deps) {
     } else {
       ralphDir = ralphRunDir(collab2.workspaceRoot, workflowId);
     }
+    if (workflow.workflowType === "complex-bug-fixing") {
+      try {
+        ensureBugfixWorkspace(collab2.workspaceRoot, workflowId);
+      } catch (err) {
+        broker2.control.haltWorkflow({ workflowId, reason: `bugfix setup failed: ${String(err)}`, now });
+        return;
+      }
+    }
+    const bugfix = bugfixPaths(collab2.workspaceRoot, workflowId);
     const ctx = workflow.workflowContext;
     let planPath = workflow.specPath;
     try {
@@ -4616,7 +4921,10 @@ function createWorkflowDriver(deps) {
       planPath,
       commitRange: ctx.commitRange ?? "HEAD",
       ralphDir,
-      reviewMode: phase.reviewMode ?? "phase-review"
+      reviewMode: phase.reviewMode ?? "phase-review",
+      bugfixDir: bugfix.bugfixDir,
+      diagnosisPath: bugfix.diagnosisPath,
+      postmortemPath: bugfix.postmortemPath
     });
     try {
       broker2.control.beginPhaseRun({
@@ -5548,7 +5856,7 @@ function writeOwnPidToBrokerDaemon(db, input) {
 
 // src/runtime/evaluator-config.ts
 import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 
 // src/runtime/state-root.ts
 import os from "node:os";
@@ -5607,15 +5915,15 @@ function loadEvaluatorConfig() {
   const root = getStateRoot();
   let dotenv = {};
   try {
-    dotenv = parseDotEnv(readFileSync2(join3(root, ".env"), "utf8"));
+    dotenv = parseDotEnv(readFileSync2(join4(root, ".env"), "utf8"));
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
   const envGet = (k) => process.env[k] ?? dotenv[k];
-  const authPath = join3(root, "auth.json");
+  const authPath = join4(root, "auth.json");
   warnIfLoosePerms(authPath);
   const auth = readJsonFile(authPath, "auth.json");
-  const config = readJsonFile(join3(root, "config.json"), "config.json");
+  const config = readJsonFile(join4(root, "config.json"), "config.json");
   const evalCfg = config?.evaluator ?? {};
   const evalOllama = evalCfg.ollama ?? {};
   const provider = (envGet("AI_WHISPER_EVALUATOR_PROVIDER") ?? evalCfg.provider) === "ollama" ? "ollama" : "anthropic";