@gethmy/agent 1.47.3 → 1.47.4

package/dist/cli.js

@@ -5673,6 +5673,8 @@ function decideAutoMergeAction(input) {
     if (headSha && reviewedSha !== headSha)
       return "rereview";
   }
+  if (input.mergeConflict)
+    return "stamp-conflict";
   const independent = config.independentReview;
   if (independent.enabled) {
     const state = input.independentReview ?? "absent";
@@ -5741,6 +5743,9 @@ async function stampFindingsExhausted(client, card, maxRounds) {
 async function stampReviewIncomplete(client, card) {
   await stampForHumanOnce(client, card, "Independent review did not complete (no verdict)");
 }
+async function stampMergeConflict(client, card) {
+  await stampForHumanOnce(client, card, "Merge conflict with the base branch");
+}
 async function removeApprovedLabel(client, card, resolvedLabels, approvedLabel) {
   const name = approvedLabel.toLowerCase();
   const obj = resolvedLabels.find((l) => l.name.toLowerCase() === name);
@@ -5761,7 +5766,14 @@ async function attemptAutoMerge(deps) {
     return "foreign-pr";
   }
   const independent = autoMerge.independentReview;
-  const { ciStatus, headSha, baseRefName, independentReview, reviewVerdict } = await getPrStatus(prUrl, cwd, provider, independent.enabled ? independent.checkName : undefined, independent.enabled ? independent.verdict.checkName : undefined);
+  const {
+    ciStatus,
+    headSha,
+    baseRefName,
+    mergeConflict,
+    independentReview,
+    reviewVerdict
+  } = await getPrStatus(prUrl, cwd, provider, independent.enabled ? independent.checkName : undefined, independent.enabled ? independent.verdict.checkName : undefined);
   deps.onPrRead?.({ headSha, baseRefName });
   if (driver === "interactive" && baseRefName !== config.worktree.baseBranch) {
     if (baseRefName !== null) {
@@ -5795,7 +5807,8 @@ async function attemptAutoMerge(deps) {
     independentReview,
     reviewVerdict,
     reviewRequestedSha,
-    blockingVerdictRounds
+    blockingVerdictRounds,
+    mergeConflict
   });
   switch (action) {
     case "wait":
@@ -5815,6 +5828,10 @@ async function attemptAutoMerge(deps) {
         log13.debug(TAG13, `#${card.short_id} waiting (ci=${ciStatus}, review=${independentReview}, verdict=${reviewVerdict})`);
       }
       return action;
+    case "stamp-conflict":
+      log13.info(TAG13, `#${card.short_id} PR conflicts with its base — flagging for human. Resolve: gh pr checkout <n> && git fetch origin ${baseRefName ?? "main"} && git merge origin/${baseRefName ?? "main"}`);
+      await stampMergeConflict(client, card);
+      return action;
     case "stamp-failure":
       log13.info(TAG13, `#${card.short_id} CI failed — flagging for human`);
       await stampCiFailure(client, card);
@@ -5975,6 +5992,28 @@ var init_merge_complete = __esm(() => {
   execFileAsync = promisify(execFile);
 });
 
+// src/pr-state-sync.ts
+import {
+  log as log15,
+  readPullRequestSnapshot
+} from "@gethmy/harness";
+async function syncPullRequestState(deps) {
+  try {
+    const snapshot = await readPullRequestSnapshot(deps.prUrl, deps.cwd, deps.provider);
+    if (!snapshot)
+      return;
+    await deps.client.upsertCardPullRequest(deps.cardId, {
+      url: deps.prUrl,
+      state: snapshot.state,
+      ci_status: snapshot.ciStatus
+    });
+  } catch (err) {
+    log15.warn(TAG15, `Could not write PR state for ${deps.prUrl}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var TAG15 = "pr-state-sync";
+var init_pr_state_sync = () => {};
+
 // src/merge-monitor.ts
 var exports_merge_monitor = {};
 __export(exports_merge_monitor, {
@@ -5983,7 +6022,7 @@ __export(exports_merge_monitor, {
 import {
   checkPrMergeStatus,
   detectGitProvider as detectGitProvider2,
-  log as log15,
+  log as log16,
   resolvePrUrl
 } from "@gethmy/harness";
 
@@ -6017,7 +6056,7 @@ class MergeMonitor {
       clearTimeout(this.timer);
       this.timer = null;
     }
-    log15.info(TAG15, "Merge monitor stopped");
+    log16.info(TAG16, "Merge monitor stopped");
   }
   async runOnce() {
     await this.tick();
@@ -6053,21 +6092,28 @@ class MergeMonitor {
         }
       }
       if (candidatesWithLabels.length === 0) {
-        log15.debug(TAG15, "No Ready to Merge cards found");
+        log16.debug(TAG16, "No Ready to Merge cards found");
         return;
       }
       const batch = candidatesWithLabels.slice(0, 5);
-      log15.debug(TAG15, `Checking ${batch.length} Ready to Merge card(s)`);
+      log16.debug(TAG16, `Checking ${batch.length} Ready to Merge card(s)`);
       const results = await Promise.allSettled(batch.map(async ({ card, labels }) => {
         const branchName = extractBranchFromDescription(card.description);
         const prUrl = resolvePrUrl(card.description ?? null, branchName, this.cwd, this.provider);
         if (!prUrl) {
-          log15.debug(TAG15, `#${card.short_id} has no resolvable PR — skipping`);
+          log16.debug(TAG16, `#${card.short_id} has no resolvable PR — skipping`);
           return;
         }
         const state = await checkPrMergeStatus(prUrl, this.cwd, this.provider);
+        await syncPullRequestState({
+          client: this.client,
+          cardId: card.id,
+          prUrl,
+          cwd: this.cwd,
+          provider: this.provider
+        });
         if (state === "merged") {
-          log15.info(TAG15, `#${card.short_id} PR merged — completing`);
+          log16.info(TAG16, `#${card.short_id} PR merged — completing`);
           await this.completeMergedCard(card, labels);
         } else if (state === "open") {
           await attemptAutoMerge({
@@ -6081,16 +6127,16 @@ class MergeMonitor {
             ...this.repairContext ? { repair: this.repairContext } : {}
           });
         } else {
-          log15.debug(TAG15, `#${card.short_id} PR state: ${state}`);
+          log16.debug(TAG16, `#${card.short_id} PR state: ${state}`);
         }
       }));
       for (const r of results) {
         if (r.status === "rejected") {
-          log15.warn(TAG15, `Card processing failed: ${r.reason}`);
+          log16.warn(TAG16, `Card processing failed: ${r.reason}`);
         }
       }
     } catch (err) {
-      log15.error(TAG15, `Tick failed: ${err instanceof Error ? err.message : err}`);
+      log16.error(TAG16, `Tick failed: ${err instanceof Error ? err.message : err}`);
     }
   }
   async completeMergedCard(card, resolvedLabels) {
@@ -6104,11 +6150,12 @@ class MergeMonitor {
     });
   }
 }
-var TAG15 = "merge-monitor";
+var TAG16 = "merge-monitor";
 var init_merge_monitor = __esm(() => {
   init_auto_merge();
   init_board_helpers();
   init_merge_complete();
+  init_pr_state_sync();
   init_review_worktree();
 });
 
@@ -6301,7 +6348,7 @@ __export(exports_plan_criteria, {
   criteriaSettledBy: () => criteriaSettledBy,
   CRITERION_COMPLETED: () => CRITERION_COMPLETED
 });
-import { log as log16 } from "@gethmy/harness";
+import { log as log17 } from "@gethmy/harness";
 function criteriaSettledBy(tasks, cardId) {
   if (!cardId || !Array.isArray(tasks))
     return [];
@@ -6362,7 +6409,7 @@ async function settlePlanCriteria(client, tag, card) {
     const settled = card.plan_id ? criteriaSettledBy(payload?.tasks, card.id) : [];
     const divergent = divergentCriteria(payload, card.id, card.plan_id);
     if (divergent.length > 0) {
-      log16.warn(tag, describeDivergence(card.short_id, card.plan_id, divergent));
+      log17.warn(tag, describeDivergence(card.short_id, card.plan_id, divergent));
     }
     const settleGroup = async (criteria, planIdOf, describe2) => {
       if (criteria.length === 0)
@@ -6373,15 +6420,15 @@ async function settlePlanCriteria(client, tag, card) {
             status: CRITERION_COMPLETED
           });
         }
-        log16.info(tag, describe2());
+        log17.info(tag, describe2());
       } catch (err) {
-        log16.warn(tag, `plan criteria write-back failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log17.warn(tag, `plan criteria write-back failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     };
     await settleGroup(settled, () => card.plan_id, () => describeSettled(card.short_id, settled));
     await settleGroup(divergent, (criterion) => criterion.plan_id, () => `${describeSettled(card.short_id, divergent)} (from the criterion side)`);
   } catch (err) {
-    log16.warn(tag, `plan criteria write-back failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log17.warn(tag, `plan criteria write-back failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
 }
 async function fetchAcceptanceCriteria(client, tag, card) {
@@ -6390,12 +6437,12 @@ async function fetchAcceptanceCriteria(client, tag, card) {
   try {
     const plan = await client.getPlanByCardId(card.id);
     if (!plan?.plan) {
-      log16.warn(tag, `#${card.short_id} names plan ${card.plan_id}, but the plan read returned no plan — grading the card text alone; check that the card's plan_id still resolves`);
+      log17.warn(tag, `#${card.short_id} names plan ${card.plan_id}, but the plan read returned no plan — grading the card text alone; check that the card's plan_id still resolves`);
       return [];
     }
     return normalizeAcceptanceCriteria(plan.tasks, card.id);
   } catch (err) {
-    log16.warn(tag, `plan criteria fetch failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log17.warn(tag, `plan criteria fetch failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     return [];
   }
 }
@@ -6502,7 +6549,7 @@ var init_budget_pause = __esm(() => {
 });
 
 // src/queue.ts
-import { log as log17 } from "@gethmy/harness";
+import { log as log18 } from "@gethmy/harness";
 function scoreCardBreakdown(config, card, column, labels, signals = {}) {
   const w = config.ranking;
   const priority = w.priorityWeight * (PRIORITY_STEP[card.priority ?? "medium"] ?? PRIORITY_STEP.medium);
@@ -6563,7 +6610,7 @@ class PriorityQueue {
   enqueue(card, column, labels, mode = "implement", signals = {}) {
     const existing = this.items.findIndex((i) => i.cardId === card.id);
     if (existing !== -1) {
-      log17.debug(TAG16, `Card #${card.short_id} already queued, updating priority`);
+      log18.debug(TAG17, `Card #${card.short_id} already queued, updating priority`);
       this.items.splice(existing, 1);
     }
     const breakdown = scoreCardBreakdown(this.config, card, column, labels, signals);
@@ -6584,7 +6631,7 @@ class PriorityQueue {
       }
     }
     this.items.splice(insertIdx, 0, item);
-    log17.info(TAG16, `Enqueued #${card.short_id} "${card.title}" (${formatBreakdown(breakdown)}, pos=${insertIdx}, queue=${this.items.length})`);
+    log18.info(TAG17, `Enqueued #${card.short_id} "${card.title}" (${formatBreakdown(breakdown)}, pos=${insertIdx}, queue=${this.items.length})`);
   }
   dequeue() {
     return this.items.shift() ?? null;
@@ -6594,7 +6641,7 @@ class PriorityQueue {
     if (idx === -1)
       return null;
     const [item] = this.items.splice(idx, 1);
-    log17.info(TAG16, `Removed #${item.shortId} from queue`);
+    log18.info(TAG17, `Removed #${item.shortId} from queue`);
     return item;
   }
   has(cardId) {
@@ -6613,7 +6660,7 @@ class PriorityQueue {
     return this.items.slice();
   }
 }
-var TAG16 = "queue", MS_PER_DAY = 86400000, PRIORITY_STEP;
+var TAG17 = "queue", MS_PER_DAY = 86400000, PRIORITY_STEP;
 var init_queue = __esm(() => {
   init_src();
   PRIORITY_STEP = {
@@ -6625,7 +6672,7 @@ var init_queue = __esm(() => {
 });
 
 // src/reported-config-cache.ts
-import { log as log18 } from "@gethmy/harness";
+import { log as log19 } from "@gethmy/harness";
 
 class ReportedConfigCache {
   client;
@@ -6642,27 +6689,27 @@ class ReportedConfigCache {
       await this.client.reportAgentConfig(workspaceId, agentId, report);
       this.last = serialized;
     } catch (err) {
-      log18.warn(TAG17, `Could not report the resolved model config: ${err instanceof Error ? err.message : String(err)}`);
+      log19.warn(TAG18, `Could not report the resolved model config: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
 }
-var TAG17 = "reported-config";
+var TAG18 = "reported-config";
 var init_reported_config_cache = () => {};
 
 // src/run-closeout.ts
-import { log as log19 } from "@gethmy/harness";
+import { log as log20 } from "@gethmy/harness";
 async function transferCardToCompletion(deps, card, moveToColumn, onPromoted) {
   await moveCardToColumn(deps.client, card, moveToColumn);
   try {
     await releaseAssignedAgent(deps.client, card.id);
   } catch (err) {
-    log19.warn(deps.tag, `assignment release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log20.warn(deps.tag, `assignment release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
   if (onPromoted) {
     try {
       await onPromoted(card);
     } catch (err) {
-      log19.warn(deps.tag, `successor promotion failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+      log20.warn(deps.tag, `successor promotion failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
@@ -6676,7 +6723,7 @@ async function endRunSession(deps, card, disposition, extraPayload, onError) {
   } catch (err) {
     if (onError === "throw")
       throw err;
-    log19.error(deps.tag, `endAgentSession after the run failed on #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log20.error(deps.tag, `endAgentSession after the run failed on #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
 }
 var init_run_closeout = __esm(() => {
@@ -6692,7 +6739,7 @@ import {
   extractPrUrl as extractPrUrl2,
   GIT_NO_HOOKS as GIT_NO_HOOKS6,
   getBranchWebUrl,
-  log as log20,
+  log as log21,
   pushBranch,
   reportFindings,
   runFormatFix,
@@ -6739,24 +6786,24 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
   if (!hasCommits) {
     const { maxTurnsExhausted, failureSummary } = describeNoCommitFailure(sessionStats?.cost?.numTurns ?? 0, effectiveMaxTurns ?? config.claude.maxTurns);
     if (noCommitOutcome(maxTurnsExhausted, config.budget.pause.enabled) === "park") {
-      log20.warn(TAG18, `No commits on branch ${branchName} — ${failureSummary}; parking for a decision`);
+      log21.warn(TAG19, `No commits on branch ${branchName} — ${failureSummary}; parking for a decision`);
       return "park";
     }
     if (expectsCommits === false) {
-      log20.info(TAG18, `No commits on branch ${branchName} — this stage's deliverable is not a diff; its gate decides the run`);
+      log21.info(TAG19, `No commits on branch ${branchName} — this stage's deliverable is not a diff; its gate decides the run`);
       if (onBeforeWorktreeCleanup) {
         try {
           await onBeforeWorktreeCleanup(worktreePath);
         } catch (err) {
-          log20.warn(TAG18, `onBeforeWorktreeCleanup hook failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+          log21.warn(TAG19, `onBeforeWorktreeCleanup hook failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
         }
       } else {
-        await endRunSession({ client, tag: TAG18 }, card, { status: "completed" }, buildTokenPayload(sessionStats), "throw");
+        await endRunSession({ client, tag: TAG19 }, card, { status: "completed" }, buildTokenPayload(sessionStats), "throw");
       }
       await teardownWorktree(client, card.id, worktreePath, branchName, agentSessionId);
       return true;
     }
-    log20.warn(TAG18, `No commits on branch ${branchName} — ${failureSummary}; counting as a failed attempt`);
+    log21.warn(TAG19, `No commits on branch ${branchName} — ${failureSummary}; counting as a failed attempt`);
     const noCommitHandback = await guardedHandback(client, card.id, {
       agentId,
       workingColumnId: card.column_id
@@ -6773,13 +6820,13 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
     await teardownWorktree(client, card.id, worktreePath, branchName, agentSessionId);
     return false;
   }
-  log20.info(TAG18, `Pushing branch ${branchName} (pre-verify)...`);
+  log21.info(TAG19, `Pushing branch ${branchName} (pre-verify)...`);
   let lastPushedSha = null;
   try {
     pushBranch(branchName, worktreePath);
     lastPushedSha = readHeadSha(worktreePath);
   } catch (err) {
-    log20.error(TAG18, `pre-verify push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+    log21.error(TAG19, `pre-verify push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
   }
   const recoveryUrl = lastPushedSha ? getBranchWebUrl(branchName, worktreePath) : null;
   if (lastPushedSha) {
@@ -6798,7 +6845,7 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
     let autoFixAttempts = 0;
     if (!result.passed && config.verification.autoFix) {
       for (let attempt = 0;attempt < config.verification.maxFixAttempts; attempt++) {
-        log20.info(TAG18, `Auto-fix attempt ${attempt + 1}/${config.verification.maxFixAttempts}`);
+        log21.info(TAG19, `Auto-fix attempt ${attempt + 1}/${config.verification.maxFixAttempts}`);
         await client.updateAgentProgress(card.id, {
           agentIdentifier: sessionIdentifier,
           agentName: AGENT_NAME,
@@ -6815,14 +6862,14 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
         result = await runVerification(worktreePath, config, workerId);
         autoFixAttempts = attempt + 1;
         if (result.passed) {
-          log20.info(TAG18, `Auto-fix succeeded on attempt ${attempt + 1}`);
+          log21.info(TAG19, `Auto-fix succeeded on attempt ${attempt + 1}`);
           const sha = readHeadSha(worktreePath);
           if (sha && sha !== lastPushedSha) {
             try {
               pushBranch(branchName, worktreePath);
               lastPushedSha = sha;
             } catch (err) {
-              log20.warn(TAG18, `post-fix push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+              log21.warn(TAG19, `post-fix push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
             }
           }
           break;
@@ -6830,14 +6877,14 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
       }
     }
     if (!result.passed) {
-      log20.warn(TAG18, `Verification failed for #${card.short_id} — reporting findings`);
+      log21.warn(TAG19, `Verification failed for #${card.short_id} — reporting findings`);
       const failSha = readHeadSha(worktreePath);
       if (failSha && failSha !== lastPushedSha) {
         try {
           pushBranch(branchName, worktreePath);
           lastPushedSha = failSha;
         } catch (err) {
-          log20.warn(TAG18, `post-fail push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+          log21.warn(TAG19, `post-fail push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
         }
       }
       const failureSummary = buildVerificationFailureSummary(result, autoFixAttempts);
@@ -6848,7 +6895,7 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
           recoveryBranch: branchName
         });
       } catch (err) {
-        log20.debug(TAG18, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
+        log21.debug(TAG19, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
       }
       await reportFindings(client, card.id, result, lastPushedSha ? { branchName, branchUrl: recoveryUrl } : null);
       const verifyHandback = await guardedHandback(client, card.id, {
@@ -6868,15 +6915,24 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
       await teardownWorktree(client, card.id, worktreePath, branchName, agentSessionId);
       return false;
     }
-    log20.info(TAG18, `Verification passed for #${card.short_id}`);
+    log21.info(TAG19, `Verification passed for #${card.short_id}`);
   }
   let prUrl = null;
   if (config.completion.createPR) {
     const provider = detectGitProvider3(worktreePath);
     prUrl = createPullRequest(card, branchName, worktreePath, config, provider);
+    if (prUrl) {
+      await syncPullRequestState({
+        client,
+        cardId: card.id,
+        prUrl,
+        cwd: worktreePath,
+        provider
+      });
+    }
   }
   if (config.completion.moveToColumn) {
-    await transferCardToCompletion({ client, tag: TAG18 }, card, config.completion.moveToColumn, onMovedToCompletion);
+    await transferCardToCompletion({ client, tag: TAG19 }, card, config.completion.moveToColumn, onMovedToCompletion);
   }
   if (config.completion.postSummary) {
     await postSummary(client, card, branchName, worktreePath, prUrl, config.worktree.baseBranch, sessionStats);
@@ -6885,14 +6941,14 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
     try {
       await onBeforeWorktreeCleanup(worktreePath);
     } catch (err) {
-      log20.warn(TAG18, `onBeforeWorktreeCleanup hook failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+      log21.warn(TAG19, `onBeforeWorktreeCleanup hook failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     }
   }
   if (!onBeforeWorktreeCleanup) {
-    await endRunSession({ client, tag: TAG18 }, card, { status: "completed" }, buildTokenPayload(sessionStats), "throw");
+    await endRunSession({ client, tag: TAG19 }, card, { status: "completed" }, buildTokenPayload(sessionStats), "throw");
   }
   await teardownWorktree(client, card.id, worktreePath, branchName, agentSessionId);
-  log20.info(TAG18, `Completion done for #${card.short_id}${prUrl ? ` — PR: ${prUrl}` : ""}`);
+  log21.info(TAG19, `Completion done for #${card.short_id}${prUrl ? ` — PR: ${prUrl}` : ""}`);
   return true;
 }
 function buildVerificationFailureSummary(result, autoFixAttempts) {
@@ -6934,7 +6990,7 @@ function commitUncommittedChanges(worktreePath, card) {
       encoding: "utf-8"
     }).trim();
   } catch (err) {
-    log20.warn(TAG18, `git status failed in ${worktreePath}: ${err instanceof Error ? err.message : err}`);
+    log21.warn(TAG19, `git status failed in ${worktreePath}: ${err instanceof Error ? err.message : err}`);
     return false;
   }
   if (status.length === 0)
@@ -6950,10 +7006,10 @@ function commitUncommittedChanges(worktreePath, card) {
       cwd: worktreePath,
       encoding: "utf-8"
     });
-    log20.warn(TAG18, `Auto-committed uncommitted worktree changes for #${card.short_id} — agent ended without committing`);
+    log21.warn(TAG19, `Auto-committed uncommitted worktree changes for #${card.short_id} — agent ended without committing`);
     return true;
   } catch (err) {
-    log20.error(TAG18, `auto-commit failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log21.error(TAG19, `auto-commit failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     return false;
   }
 }
@@ -7002,9 +7058,9 @@ async function recordBranchProvenance(client, card, branchName) {
 ${BRANCH_PROVENANCE_MARKER} (pushed — a later run continues it)
 Branch: \`${branchName}\``;
     await client.updateCard(card.id, { description: description + block });
-    log20.info(TAG18, `Recorded branch provenance on #${card.short_id}`);
+    log21.info(TAG19, `Recorded branch provenance on #${card.short_id}`);
   } catch (err) {
-    log20.warn(TAG18, `Failed to record branch provenance on #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log21.warn(TAG19, `Failed to record branch provenance on #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
 }
 async function postSummary(client, card, branchName, worktreePath, prUrl, baseBranch, sessionStats) {
@@ -7058,24 +7114,25 @@ ${commitLog}
       description: baseDesc + parts.join(`
 `)
     });
-    log20.info(TAG18, `Posted completion summary to #${card.short_id}`);
+    log21.info(TAG19, `Posted completion summary to #${card.short_id}`);
   } catch (err) {
-    log20.error(TAG18, `Failed to post summary: ${err instanceof Error ? err.message : err}`);
+    log21.error(TAG19, `Failed to post summary: ${err instanceof Error ? err.message : err}`);
   }
 }
-var TAG18 = "completion", SUMMARY_MARKER = `---
+var TAG19 = "completion", SUMMARY_MARKER = `---
 **Agent completed**`, BRANCH_PROVENANCE_MARKER = `---
 **Agent branch**`;
 var init_completion = __esm(() => {
   init_src();
   init_board_helpers();
   init_handback();
+  init_pr_state_sync();
   init_run_closeout();
   init_types();
 });
 
 // src/progress-tracker.ts
-import { log as log21 } from "@gethmy/harness";
+import { log as log22 } from "@gethmy/harness";
 function truncate2(str, max) {
   return str.length > max ? `${str.slice(0, max - 3)}...` : str;
 }
@@ -7194,7 +7251,7 @@ class ProgressTracker {
   }
   onToolStart(name, input) {
     this.toolCallCount++;
-    log21.debug(TAG19, `Tool: ${name} (count: ${this.toolCallCount}, phase: ${this.phase})`);
+    log22.debug(TAG20, `Tool: ${name} (count: ${this.toolCallCount}, phase: ${this.phase})`);
     const filePath = this.extractString(input, "file_path");
     if (filePath) {
       if (EDIT_TOOLS.has(name)) {
@@ -7261,7 +7318,7 @@ class ProgressTracker {
   transitionTo(newPhase) {
     if (PHASE_ORDER[newPhase] <= PHASE_ORDER[this.phase])
       return;
-    log21.info(TAG19, `Phase: ${this.phase} → ${newPhase}`);
+    log22.info(TAG20, `Phase: ${this.phase} → ${newPhase}`);
     const previousPhase = this.phase;
     this.runEventSink?.recordPhaseChanged(newPhase, previousPhase);
     this.phase = newPhase;
@@ -7366,7 +7423,7 @@ class ProgressTracker {
   }
   sendUpdate(currentTask) {
     this.lastUpdateAt = Date.now();
-    log21.debug(TAG19, `Progress: ${this.progress}% — ${currentTask}`);
+    log22.debug(TAG20, `Progress: ${this.progress}% — ${currentTask}`);
     this.client.updateAgentProgress(this.cardId, {
       agentIdentifier: this.sessionIdentifier,
       agentName: AGENT_NAME,
@@ -7383,7 +7440,7 @@ class ProgressTracker {
       modelName: this.lastCost?.modelName ?? this.requestedModel ?? undefined,
       numTurns: this.lastCost?.numTurns ?? 0
     }).catch((err) => {
-      log21.warn(TAG19, `Failed to send progress update: ${err}`);
+      log22.warn(TAG20, `Failed to send progress update: ${err}`);
     });
     if (this.runEventSink && this.progress !== this.lastEmittedProgress) {
       this.lastEmittedProgress = this.progress;
@@ -7414,7 +7471,7 @@ class ProgressTracker {
     return null;
   }
 }
-var TAG19 = "progress-tracker", THROTTLE_MS = 5000, HEARTBEAT_MS = 60000, MAX_TASK_LENGTH = 120, SENTENCE_SPLIT, ACTION_PREFIX, GIT_COMMIT_RE, BUILD_CMD_RE, PHASES, PHASE_ORDER, EDIT_TOOLS, FILE_TOOL_VERBS;
+var TAG20 = "progress-tracker", THROTTLE_MS = 5000, HEARTBEAT_MS = 60000, MAX_TASK_LENGTH = 120, SENTENCE_SPLIT, ACTION_PREFIX, GIT_COMMIT_RE, BUILD_CMD_RE, PHASES, PHASE_ORDER, EDIT_TOOLS, FILE_TOOL_VERBS;
 var init_progress_tracker = __esm(() => {
   init_types();
   SENTENCE_SPLIT = /\.\s|\n/;
@@ -7448,7 +7505,7 @@ var init_progress_tracker = __esm(() => {
 });
 
 // src/prompt.ts
-import { log as log22 } from "@gethmy/harness";
+import { log as log23 } from "@gethmy/harness";
 import {
   buildMemoryQuery,
   RERANK_MAX_CANDIDATES,
@@ -7499,11 +7556,11 @@ async function buildPrompt(enriched, branchName, worktreePath, client, workspace
 Do NOT push to main. All your work stays on \`${branchName}\`.
 The daemon owns the run lifecycle: once your work is committed it ends the agent session, pushes the branch, and moves the card to Review for you. Do NOT call harmony_end_agent_session, do NOT start a new session, and do NOT move the card or change its column yourself. If the skill driving this work tells you to move the card or end the session as a final step, SKIP it — it is handled for you (those tools are disabled for this run). Finish the implementation, commit, and stop.`
     });
-    log22.info(TAG20, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
+    log23.info(TAG21, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
     return result.prompt + referenceSection;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log22.warn(TAG20, `Failed to generate prompt via API, using fallback: ${msg}`);
+    log23.warn(TAG21, `Failed to generate prompt via API, using fallback: ${msg}`);
     onPromptFallback?.();
     const commentsSection = await renderCommentsSection(client, card.id);
     return buildFallbackPrompt(enriched, branchName, worktreePath) + commentsSection + referenceSection;
@@ -7525,7 +7582,7 @@ ${untrustedDataBlock(section, {
       purpose: "discussion to take into account"
     })}` : "";
   } catch (err) {
-    log22.warn(TAG20, "comment-thread fetch failed", {
+    log23.warn(TAG21, "comment-thread fetch failed", {
       event: "comment_fetch_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -7567,7 +7624,7 @@ ${bullets}`, {
     })}`;
   } catch (err) {
     const error = err instanceof Error ? err.message : String(err);
-    log22.warn(TAG20, "reference recall failed", {
+    log23.warn(TAG21, "reference recall failed", {
       event: "reference_recall_failed",
       error
     });
@@ -7609,7 +7666,7 @@ ${subtaskStr}
 You are working in a git worktree at \`${worktreePath}\` on branch \`${branchName}\`.
 Do NOT push to main. All your work stays on \`${branchName}\`.`;
 }
-var TAG20 = "prompt", RESUME_CONTINUATION = `Continue from where you stopped.
+var TAG21 = "prompt", RESUME_CONTINUATION = `Continue from where you stopped.
 
 This is the same session. The task you were given, the work you have already done,
 and everything you read are above in this conversation. None of it has changed, and
@@ -7634,7 +7691,7 @@ import {
   extractPrUrl as extractPrUrl3,
   getBranchWebUrl as getBranchWebUrl2,
   getHeadSha,
-  log as log23,
+  log as log24,
   pushBranch as pushBranch2,
   renameRemoteBranch,
   sanitizeCiText as sanitizeCiText2,
@@ -7753,6 +7810,20 @@ function extractResult(parsed) {
     findings
   };
 }
+function parseStructuredReview(structured) {
+  try {
+    const parsed = JSON.parse(structured);
+    if (parsed && typeof parsed === "object" && "verdict" in parsed) {
+      return extractResult(parsed);
+    }
+  } catch {}
+  log24.warn(TAG22, "Review spawn returned no schema-valid verdict — returning error verdict (card stays in Review)");
+  return {
+    verdict: "error",
+    summary: structured.slice(0, 500),
+    findings: []
+  };
+}
 function parseReviewOutput(stdout) {
   const fencedBlocks = [...stdout.matchAll(/```json\s*([\s\S]*?)```/g)];
   for (let i = fencedBlocks.length - 1;i >= 0; i--) {
@@ -7760,7 +7831,7 @@ function parseReviewOutput(stdout) {
     try {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && "verdict" in parsed) {
-        log23.debug(TAG21, "Parsed review output from fenced JSON block");
+        log24.debug(TAG22, "Parsed review output from fenced JSON block");
         return extractResult(parsed);
       }
     } catch {}
@@ -7786,21 +7857,21 @@ function parseReviewOutput(stdout) {
     try {
       const parsed = JSON.parse(candidates[i]);
       if (parsed && typeof parsed === "object" && "verdict" in parsed) {
-        log23.debug(TAG21, "Parsed review output from raw JSON object");
+        log24.debug(TAG22, "Parsed review output from raw JSON object");
         return extractResult(parsed);
       }
     } catch {}
   }
   const verdictMatch = stdout.match(/"verdict"\s*:\s*"(approved|rejected)"/i);
   if (verdictMatch) {
-    log23.warn(TAG21, `Parsed verdict via regex fallback — findings lost (${verdictMatch[1]})`);
+    log24.warn(TAG22, `Parsed verdict via regex fallback — findings lost (${verdictMatch[1]})`);
     return {
       verdict: verdictMatch[1].toLowerCase(),
       summary: "Parsed via regex fallback — original JSON was malformed. Check run log.",
       findings: []
     };
   }
-  log23.warn(TAG21, "Failed to parse review JSON output — returning error verdict (card stays in Review)");
+  log24.warn(TAG22, "Failed to parse review JSON output — returning error verdict (card stays in Review)");
   return {
     verdict: "error",
     summary: stdout.slice(0, 500),
@@ -7836,7 +7907,7 @@ async function postReviewComment(client, card, commentType, body, agentSessionId
       agentSessionId: agentSessionId ?? undefined
     });
   } catch (err) {
-    log23.error(TAG21, `Failed to post review comment to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log24.error(TAG22, `Failed to post review comment to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
 }
 async function runReviewCompletion(client, card, result, config, worktreePath, branchName, sessionStats, runLogPath, agentSessionId, stateStore, agentId, resolvedFromPrUrl, visualLensSkipReason) {
@@ -7860,7 +7931,7 @@ async function runReviewCompletion(client, card, result, config, worktreePath, b
     };
   }
   if (!handbackVerdict.proceed) {
-    log23.info(TAG21, `#${card.short_id}: review outcome will not move the card — ${handbackVerdict.detail} (${handbackVerdict.reason})`);
+    log24.info(TAG22, `#${card.short_id}: review outcome will not move the card — ${handbackVerdict.detail} (${handbackVerdict.reason})`);
   }
   const lensLine = visualLensSkipReason ? `Visual QA did not run — ${sanitizeCiText2(visualLensSkipReason, REVIEW_FAILURE_REASON_MAX)}. Anything that needs a rendered page is ungraded.` : "";
   const LOOPING_REFUSALS = new Set(["unreadable", "released", "done"]);
@@ -7870,19 +7941,19 @@ async function runReviewCompletion(client, card, result, config, worktreePath, b
     }
     try {
       await addLabelByName(client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
-      log23.warn(TAG21, `#${card.short_id} labelled "${NEED_REVIEW_LABEL}" (${handbackVerdict.reason}) so the daemon stops re-claiming and re-reviewing it`);
+      log24.warn(TAG22, `#${card.short_id} labelled "${NEED_REVIEW_LABEL}" (${handbackVerdict.reason}) so the daemon stops re-claiming and re-reviewing it`);
     } catch (err) {
-      log23.warn(TAG21, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
+      log24.warn(TAG22, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
     }
   }
   const currentCycle = getReviewCycle(freshDesc) + 1;
   const maxCycles = config.review.maxReviewCycles;
   if (result.verdict === "error") {
-    log23.warn(TAG21, `#${card.short_id} review output unparseable — labelling "${NEED_REVIEW_LABEL}" for manual inspection`);
+    log24.warn(TAG22, `#${card.short_id} review output unparseable — labelling "${NEED_REVIEW_LABEL}" for manual inspection`);
     try {
       await addLabelByName(client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
     } catch (err) {
-      log23.warn(TAG21, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
+      log24.warn(TAG22, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
     }
     if (config.review.postFindings) {
       const rawTail = runLogPath ? tailRunLog(runLogPath) : null;
@@ -7925,12 +7996,21 @@ ${runLogTail}
           renameRemoteBranch(branchName, newRef, worktreePath);
           approvedBranch = newRef;
         } catch (err) {
-          log23.warn(TAG21, `Branch rename failed (continuing on ${branchName}): ${err instanceof Error ? err.message : err}`);
+          log24.warn(TAG22, `Branch rename failed (continuing on ${branchName}): ${err instanceof Error ? err.message : err}`);
         }
       }
       if (config.review.createPR && approvedBranch) {
         const provider = detectGitProvider4(worktreePath);
         prUrl = createPullRequest2(card, approvedBranch, worktreePath, config, provider, resolvedFromPrUrl ?? null);
+        if (prUrl) {
+          await syncPullRequestState({
+            client,
+            cardId: card.id,
+            prUrl,
+            cwd: worktreePath,
+            provider
+          });
+        }
       }
     }
     await addLabelByName(client, card, config.review.approvedLabel, config.review.approvedLabelColor);
@@ -7958,14 +8038,14 @@ ${runLogTail}
           await client.updateCard(card.id, { description: desc });
         }
       } catch (err) {
-        log23.warn(TAG21, `Failed to persist PR URL / branch rename to #${card.short_id} description: ${err instanceof Error ? err.message : err}`);
+        log24.warn(TAG22, `Failed to persist PR URL / branch rename to #${card.short_id} description: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (branchName) {
       try {
         await persistReviewedSha(client, card, worktreePath);
       } catch (err) {
-        log23.warn(TAG21, `Failed to persist Reviewed-SHA to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log24.warn(TAG22, `Failed to persist Reviewed-SHA to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (config.review.postFindings) {
@@ -7988,7 +8068,7 @@ ${runLogTail}
       progressPercent: 100,
       ...buildTokenPayload(sessionStats)
     });
-    log23.info(TAG21, `#${card.short_id} approved${prUrl ? ` — PR: ${prUrl}` : ""} — labeled "${config.review.approvedLabel}"`);
+    log24.info(TAG22, `#${card.short_id} approved${prUrl ? ` — PR: ${prUrl}` : ""} — labeled "${config.review.approvedLabel}"`);
   } else {
     const reworkFindings = result.findings.filter((f) => f.relatedToDiff !== false);
     const criticalFindings = reworkFindings.filter((f) => f.severity === "critical").slice(0, MAX_FINDINGS);
@@ -7996,7 +8076,7 @@ ${runLogTail}
     const linkedFindings = [...criticalFindings, ...majorFindings];
     const minorFindings = reworkFindings.filter((f) => f.severity === "minor").slice(0, MAX_FINDINGS);
     if (currentCycle >= maxCycles) {
-      log23.warn(TAG21, `#${card.short_id} reached max review cycles (${maxCycles}), moving to Done with note`);
+      log24.warn(TAG22, `#${card.short_id} reached max review cycles (${maxCycles}), moving to Done with note`);
       if (handbackVerdict.proceed) {
         await moveCardToColumn(client, freshCard ?? card, config.review.moveToColumn);
       } else {
@@ -8024,7 +8104,7 @@ ${runLogTail}
         try {
           await client.createSubtask(card.id, clampSubtaskTitle(`[${finding.severity}] ${finding.title}`));
         } catch (err) {
-          log23.error(TAG21, `Failed to create finding subtask: ${err instanceof Error ? err.message : err}`);
+          log24.error(TAG22, `Failed to create finding subtask: ${err instanceof Error ? err.message : err}`);
         }
       }));
       if (linkedFindings.length > 0) {
@@ -8036,7 +8116,7 @@ ${runLogTail}
         try {
           await client.createSubtask(card.id, clampSubtaskTitle(finding.title));
         } catch (err) {
-          log23.error(TAG21, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
+          log24.error(TAG22, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
         }
       }));
       if (handbackVerdict.proceed) {
@@ -8045,7 +8125,7 @@ ${runLogTail}
         try {
           await client.updateCard(card.id, { description: updatedDesc });
         } catch (err) {
-          log23.error(TAG21, `Failed to update review cycle marker: ${err instanceof Error ? err.message : err}`);
+          log24.error(TAG22, `Failed to update review cycle marker: ${err instanceof Error ? err.message : err}`);
         }
       }
       const scopeLine = result.scopeCheck ? `Scope: ${result.scopeCheck.status}${result.scopeCheck.notes ? ` — ${result.scopeCheck.notes}` : ""}` : "";
@@ -8064,9 +8144,9 @@ ${runLogTail}
     if (handbackVerdict.proceed && config.planning.enabled && card.plan_id) {
       try {
         await client.updateCard(card.id, { needsPlanRefresh: true });
-        log23.info(TAG21, `#${card.short_id} flagged needs_plan_refresh after rejected review`);
+        log24.info(TAG22, `#${card.short_id} flagged needs_plan_refresh after rejected review`);
       } catch (err) {
-        log23.warn(TAG21, `Failed to flag needs_plan_refresh for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log24.warn(TAG22, `Failed to flag needs_plan_refresh for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (handbackVerdict.proceed) {
@@ -8084,10 +8164,10 @@ ${runLogTail}
         recoveryBranch
       });
     } catch (err) {
-      log23.debug(TAG21, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
+      log24.debug(TAG22, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
     }
     if (recoveryBranch) {
-      log23.info(TAG21, `#${card.short_id} recovery branch ${recoveryBranch}${recoveryUrl ? ` (${recoveryUrl})` : ""}`);
+      log24.info(TAG22, `#${card.short_id} recovery branch ${recoveryBranch}${recoveryUrl ? ` (${recoveryUrl})` : ""}`);
     }
     await client.endAgentSession(card.id, {
       status: "failed",
@@ -8096,19 +8176,20 @@ ${runLogTail}
       recoveryBranch,
       ...buildTokenPayload(sessionStats)
     });
-    log23.info(TAG21, `#${card.short_id} rejected (cycle ${currentCycle}/${maxCycles}) — moved to "${config.review.failColumn}"`);
+    log24.info(TAG22, `#${card.short_id} rejected (cycle ${currentCycle}/${maxCycles}) — moved to "${config.review.failColumn}"`);
   }
   if (branchName) {
     cleanupWorktree3(worktreePath, branchName);
   }
 }
-var TAG21 = "review-completion", MAX_FINDINGS = 10, MAX_SUBTASK_TITLE = 120, COMMENT_BODY_BUDGET = 9500, REVIEW_MARKER = `---
+var TAG22 = "review-completion", MAX_FINDINGS = 10, MAX_SUBTASK_TITLE = 120, COMMENT_BODY_BUDGET = 9500, REVIEW_MARKER = `---
 **Review:`, RUN_LOG_TAIL_BYTES = 2048;
 var init_review_completion = __esm(() => {
   init_src();
   init_board_helpers();
   init_completion();
   init_handback();
+  init_pr_state_sync();
   init_types();
 });
 
@@ -8250,7 +8331,7 @@ Set \`relatedToDiff\` on every finding — only diff-caused findings gate the ve
 ${step3Body}
 
 ### Step 4: Output
-After completing all steps, output EXACTLY one JSON block (and nothing else after it):
+After completing all steps, answer with the structured verdict. Its fields:
 
 \`\`\`json
 ${REVIEW_VERDICT_SCHEMA}
@@ -8291,9 +8372,9 @@ ${serverSection}
 ## Finish with the verdict
 
 Only this turn's output is read. A verdict you already wrote earlier in this session
-does NOT count — you must output it again here, or this review produces nothing.
+does NOT count — you must answer with the structured verdict again here, or this review produces nothing.
 
-When the review is complete, output EXACTLY one JSON block (and nothing else after it):
+When the review is complete, answer with the structured verdict. Its fields:
 
 \`\`\`json
 ${REVIEW_VERDICT_SCHEMA}
@@ -8325,6 +8406,61 @@ var init_review_prompt = __esm(() => {
   init_types();
 });
 
+// src/review-verdict-schema.ts
+var REVIEW_VERDICT_JSON_SCHEMA;
+var init_review_verdict_schema = __esm(() => {
+  REVIEW_VERDICT_JSON_SCHEMA = {
+    type: "object",
+    properties: {
+      verdict: { type: "string", enum: ["approved", "rejected"] },
+      summary: { type: "string" },
+      scopeCheck: {
+        type: "object",
+        properties: {
+          status: { type: "string", enum: ["clean", "drift", "missing"] },
+          notes: { type: "string" }
+        },
+        required: ["status"],
+        additionalProperties: false
+      },
+      acceptanceChecks: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            criterion: { type: "string" },
+            status: {
+              type: "string",
+              enum: ["pass", "partial", "fail", "unverifiable"]
+            },
+            evidence: { type: "string" }
+          },
+          required: ["criterion", "status"],
+          additionalProperties: false
+        }
+      },
+      findings: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            severity: { type: "string", enum: ["critical", "major", "minor"] },
+            category: { type: "string" },
+            title: { type: "string" },
+            description: { type: "string" },
+            location: { type: "string" },
+            relatedToDiff: { type: "boolean" }
+          },
+          required: ["severity", "title", "description", "relatedToDiff"],
+          additionalProperties: false
+        }
+      }
+    },
+    required: ["verdict", "summary", "acceptanceChecks", "findings"],
+    additionalProperties: false
+  };
+});
+
 // src/run-log.ts
 import {
   appendFileSync,
@@ -8332,7 +8468,7 @@ import {
   mkdirSync as mkdirSync3
 } from "node:fs";
 import { join as join5 } from "node:path";
-import { log as log24 } from "@gethmy/harness";
+import { log as log25 } from "@gethmy/harness";
 function runLogPath(runId, shortId) {
   return join5(runsDir(), `${runId}-card-${shortId}.log`);
 }
@@ -8346,7 +8482,7 @@ function appendRunLog(tag, runId, shortId, line) {
 `, "utf-8");
     return path;
   } catch (err) {
-    log24.warn(tag, `Failed to append to run log: ${err instanceof Error ? err.message : err}`);
+    log25.warn(tag, `Failed to append to run log: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -8358,11 +8494,11 @@ function openRunLog(tag, runId, shortId) {
     const path = runLogPath(runId, shortId);
     const stream = createWriteStream(path, { flags: "a" });
     stream.on("error", (err) => {
-      log24.warn(tag, `Run log ${path} failed: ${err.message}`);
+      log25.warn(tag, `Run log ${path} failed: ${err.message}`);
     });
     return { path, stream };
   } catch (err) {
-    log24.warn(tag, `Failed to open run log: ${err instanceof Error ? err.message : err}`);
+    log25.warn(tag, `Failed to open run log: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -8399,7 +8535,7 @@ function isOwnNoticeConflict(err) {
   const driver = sessionConflictDriver(err);
   return driver === null || driver === NOTICE_DRIVER;
 }
-async function startSessionYieldingNotice(start, client, cardId, log25) {
+async function startSessionYieldingNotice(start, client, cardId, log26) {
   try {
     return await start();
   } catch (err) {
@@ -8408,12 +8544,12 @@ async function startSessionYieldingNotice(start, client, cardId, log25) {
     try {
       const { session } = await client.getAgentSession(cardId);
       if (!session) {
-        log25.info(`The session that refused the start is already gone — retrying: ${err instanceof Error ? err.message : String(err)}`);
+        log26.info(`The session that refused the start is already gone — retrying: ${err instanceof Error ? err.message : String(err)}`);
       } else if (!isPoolNotice(session)) {
-        log25.warn("The session that refused the start is not a pool notice on a re-read — leaving it alone");
+        log26.warn("The session that refused the start is not a pool notice on a re-read — leaving it alone");
         throw err;
       } else {
-        log25.info(`Ending this pool's own notice on the card and retrying the session start: ${err instanceof Error ? err.message : String(err)}`);
+        log26.info(`Ending this pool's own notice on the card and retrying the session start: ${err instanceof Error ? err.message : String(err)}`);
         await client.endAgentSession(cardId, {
           status: "failed",
           failureReason: "stale",
@@ -8423,7 +8559,7 @@ async function startSessionYieldingNotice(start, client, cardId, log25) {
     } catch (endErr) {
       if (endErr === err)
         throw err;
-      log25.warn(`Could not yield this pool's own notice: ${endErr instanceof Error ? endErr.message : String(endErr)}`);
+      log26.warn(`Could not yield this pool's own notice: ${endErr instanceof Error ? endErr.message : String(endErr)}`);
       throw err;
     }
     return await start();
@@ -8460,7 +8596,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { dirname as dirname2, join as join6 } from "node:path";
-import { log as log25 } from "@gethmy/harness";
+import { log as log26 } from "@gethmy/harness";
 function emptyTokens() {
   return cloneWithoutPrototype({
     inputTokens: 0,
@@ -8599,7 +8735,7 @@ class StateStore {
       const raw = readFileSync6(this.path, "utf-8");
       const parsed = parseJsonWithoutPrototypes(raw);
       if (parsed?.version !== SCHEMA_VERSION) {
-        log25.warn(TAG22, `state file has version ${parsed?.version}, expected ${SCHEMA_VERSION} — migrating (preserving card budget/attempts, dropping in-flight runs)`);
+        log26.warn(TAG23, `state file has version ${parsed?.version}, expected ${SCHEMA_VERSION} — migrating (preserving card budget/attempts, dropping in-flight runs)`);
         return cloneWithoutPrototype({
           version: SCHEMA_VERSION,
           daemonId: null,
@@ -8624,7 +8760,7 @@ class StateStore {
         account: parsed.account ?? emptyAccount()
       });
     } catch (err) {
-      log25.error(TAG22, `failed to read state file: ${err instanceof Error ? err.message : err}`);
+      log26.error(TAG23, `failed to read state file: ${err instanceof Error ? err.message : err}`);
       return emptyState();
     }
   }
@@ -9021,7 +9157,7 @@ class StateStore {
     return this.state.daily.find((d) => d.date === key)?.costCents ?? 0;
   }
 }
-var TAG22 = "state-store", SCHEMA_VERSION = 1;
+var TAG23 = "state-store", SCHEMA_VERSION = 1;
 var init_state_store = __esm(() => {
   init_src();
   init_paths();
@@ -9029,7 +9165,7 @@ var init_state_store = __esm(() => {
 
 // src/stream-parser.ts
 import { EventEmitter } from "node:events";
-import { log as log26 } from "@gethmy/harness";
+import { log as log27 } from "@gethmy/harness";
 function normalizeToolResultContent(raw) {
   if (raw == null)
     return;
@@ -9050,7 +9186,7 @@ function normalizeToolResultContent(raw) {
     return String(raw);
   }
 }
-var TAG23 = "stream-parser", StreamParser;
+var TAG24 = "stream-parser", StreamParser;
 var init_stream_parser = __esm(() => {
   StreamParser = class StreamParser extends EventEmitter {
     buffer = "";
@@ -9097,14 +9233,14 @@ var init_stream_parser = __esm(() => {
       try {
         msg = JSON.parse(line);
       } catch {
-        log26.debug(TAG23, `Non-JSON line: ${line.slice(0, 100)}`);
+        log27.debug(TAG24, `Non-JSON line: ${line.slice(0, 100)}`);
         return;
       }
       try {
         this.handleMessage(msg);
       } catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
-        log26.warn(TAG23, `Error handling stream event: ${errMsg}`);
+        log27.warn(TAG24, `Error handling stream event: ${errMsg}`);
         this.emit("parse_error", errMsg);
       }
     }
@@ -9171,6 +9307,9 @@ var init_stream_parser = __esm(() => {
               modelName: this.observedModel ?? (typeof msg.model === "string" ? msg.model : undefined)
             });
           }
+          if (msg.structured_output !== undefined) {
+            this.emit("structured_output", msg.structured_output);
+          }
           this.emit("result", msg.stop_reason ?? msg.subtype ?? "unknown");
           break;
         }
@@ -9180,7 +9319,7 @@ var init_stream_parser = __esm(() => {
 });
 
 // src/transitions.ts
-import { log as log27 } from "@gethmy/harness";
+import { log as log28 } from "@gethmy/harness";
 async function withRetry(step, cardShortId, op, attempts, backoffMs) {
   let lastErr;
   for (let i = 0;i < attempts; i++) {
@@ -9191,7 +9330,7 @@ async function withRetry(step, cardShortId, op, attempts, backoffMs) {
       const msg2 = err instanceof Error ? err.message : String(err);
       if (i < attempts - 1) {
         const wait = backoffMs * 2 ** i;
-        log27.warn(TAG24, `${step} failed for #${cardShortId} (attempt ${i + 1}/${attempts}): ${msg2} — retrying in ${wait}ms`);
+        log28.warn(TAG25, `${step} failed for #${cardShortId} (attempt ${i + 1}/${attempts}): ${msg2} — retrying in ${wait}ms`);
         await new Promise((r) => setTimeout(r, wait));
       }
     }
@@ -9215,10 +9354,10 @@ async function runTransition(client, card, plan, opts = {}) {
       if (opts.strictColumn) {
         throw new TransitionError("move", 1, msg);
       }
-      log27.warn(TAG24, `#${shortId}: ${msg} — skipping move`);
+      log28.warn(TAG25, `#${shortId}: ${msg} — skipping move`);
     } else if (card.column_id !== target.id) {
       await withRetry("move", shortId, () => client.moveCard(card.id, target.id), attempts, backoffMs);
-      log27.info(TAG24, `#${shortId} → "${target.name}"`);
+      log28.info(TAG25, `#${shortId} → "${target.name}"`);
       card.column_id = target.id;
       moveLanded = true;
     } else {
@@ -9237,7 +9376,7 @@ async function runTransition(client, card, plan, opts = {}) {
         continue;
       await withRetry("addLabel", shortId, () => client.addLabelToCard(card.id, labelId), attempts, backoffMs);
       existing.add(labelId);
-      log27.info(TAG24, `#${shortId} +label "${name}"`);
+      log28.info(TAG25, `#${shortId} +label "${name}"`);
     }
     card.labelIds = Array.from(existing);
   }
@@ -9249,23 +9388,23 @@ async function runTransition(client, card, plan, opts = {}) {
         continue;
       await withRetry("removeLabel", shortId, () => client.removeLabelFromCard(card.id, match.id), attempts, backoffMs);
       existing.delete(match.id);
-      log27.info(TAG24, `#${shortId} -label "${name}"`);
+      log28.info(TAG25, `#${shortId} -label "${name}"`);
     }
     card.labelIds = Array.from(existing);
   }
   if (plan.updateCard) {
     await withRetry("updateCard", shortId, () => client.updateCard(card.id, plan.updateCard), attempts, backoffMs);
-    log27.info(TAG24, `#${shortId} updated`);
+    log28.info(TAG25, `#${shortId} updated`);
   }
   if (plan.endSession) {
     const endResult = await withRetry("endSession", shortId, () => client.endAgentSession(card.id, plan.endSession), attempts, backoffMs);
     result.endSession = endResult;
-    log27.info(TAG24, `#${shortId} session ended (${plan.endSession.status})`);
+    log28.info(TAG25, `#${shortId} session ended (${plan.endSession.status})`);
   }
   if (plan.assignAgent !== undefined) {
     const assignedAgentId = plan.assignAgent;
     await withRetry("assignAgent", shortId, () => client.updateCard(card.id, { assignedAgentId }), attempts, backoffMs);
-    log27.info(TAG24, assignedAgentId ? `#${shortId} assigned → agent ${assignedAgentId}` : `#${shortId} unassigned`);
+    log28.info(TAG25, assignedAgentId ? `#${shortId} assigned → agent ${assignedAgentId}` : `#${shortId} unassigned`);
   }
   if (opts.store && opts.runId) {
     try {
@@ -9279,11 +9418,11 @@ async function ensureLabel(client, projectId, name, color, attempts, backoffMs)
     const result = await withRetry("addLabel", 0, () => client.createLabel(projectId, { name, color: color ?? "#8b5cf6" }), attempts, backoffMs);
     return result?.label?.id ?? null;
   } catch (err) {
-    log27.warn(TAG24, `ensureLabel "${name}" failed: ${err instanceof Error ? err.message : err}`);
+    log28.warn(TAG25, `ensureLabel "${name}" failed: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
-var TAG24 = "transition", TransitionError;
+var TAG25 = "transition", TransitionError;
 var init_transitions = __esm(() => {
   TransitionError = class TransitionError extends Error {
     step;
@@ -9313,7 +9452,7 @@ import {
   formatDiffSummary,
   GIT_NO_HOOKS as GIT_NO_HOOKS7,
   implementRunContainmentCliArgs,
-  log as log28,
+  log as log29,
   probeDevServer,
   removeSandboxContainer,
   resolveStageGate,
@@ -9409,11 +9548,11 @@ class ReviewWorker {
         cliSessionId: this.cliSessionId
       });
     } catch (err) {
-      log28.warn(this.tag, `state store updateRun failed: ${err instanceof Error ? err.message : err}`);
+      log29.warn(this.tag, `state store updateRun failed: ${err instanceof Error ? err.message : err}`);
     }
   }
   get tag() {
-    return `${TAG25}:${this.id}`;
+    return `${TAG26}:${this.id}`;
   }
   get isIdle() {
     return this.state === "idle";
@@ -9451,7 +9590,7 @@ class ReviewWorker {
       try {
         const after = await this.stateStore.addTurns(cardId, numTurns);
         if (crossedTurnCap(before, after, cap)) {
-          log28.warn(TAG25, `#${this.stateStore.getRun(this.runId ?? "")?.cardShortId ?? cardId} reached its per-card turn cap on a review leg — ${after} of ${cap} turns. The implement pipeline will not pick it up again until it is reassigned or the cap is raised.`);
+          log29.warn(TAG26, `#${this.stateStore.getRun(this.runId ?? "")?.cardShortId ?? cardId} reached its per-card turn cap on a review leg — ${after} of ${cap} turns. The implement pipeline will not pick it up again until it is reassigned or the cap is raised.`);
           const legs = this.stateStore.getRun(this.runId ?? "")?.legs?.length || 1;
           await this.client.addComment(cardId, buildTurnCapComment(after, cap, legs), {
             commentType: "blocker",
@@ -9493,12 +9632,12 @@ class ReviewWorker {
           resumeMessage: null
         });
       } catch (err) {
-        log28.warn(this.tag, `Failed to clear the consumed grant: ${err}`);
+        log29.warn(this.tag, `Failed to clear the consumed grant: ${err}`);
       }
     }
     try {
       this.state = "preparing";
-      log28.info(this.tag, resuming ? `Resuming review of #${card.short_id} "${card.title}" with ${this.grantedTurns ?? "the default"} more turns` : `Preparing review for #${card.short_id} "${card.title}"`);
+      log29.info(this.tag, resuming ? `Resuming review of #${card.short_id} "${card.title}" with ${this.grantedTurns ?? "the default"} more turns` : `Preparing review for #${card.short_id} "${card.title}"`);
       this.startHeartbeat();
       if (!resuming) {
         await this.stateStore.insertRun({
@@ -9526,7 +9665,7 @@ class ReviewWorker {
         const resolution = await resolveReviewBranch(card.description, repoRoot);
         if (resolution.kind !== "branch") {
           const why = resolution.kind === "skip" ? resolution.reason : "no branch or PR reference";
-          log28.info(this.tag, `#${card.short_id} not auto-reviewable (${why}) — marking for human review (staying in Review)`);
+          log29.info(this.tag, `#${card.short_id} not auto-reviewable (${why}) — marking for human review (staying in Review)`);
           await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
           return;
         }
@@ -9537,13 +9676,13 @@ class ReviewWorker {
             reviewedSha: extractReviewedSha2(card.description ?? null)
           });
           if (continuity.kind === "skip") {
-            log28.warn(this.tag, `#${card.short_id} refusing the PR-derived re-review (${continuity.reason}) — marking for human review (staying in Review)`);
+            log29.warn(this.tag, `#${card.short_id} refusing the PR-derived re-review (${continuity.reason}) — marking for human review (staying in Review)`);
             await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
             return;
           }
         }
         this.branchName = resolution.branch;
-        log28.info(this.tag, `Review branch: ${this.branchName}`);
+        log29.info(this.tag, `Review branch: ${this.branchName}`);
         let reviewSession;
         try {
           const startSession = () => this.client.startAgentSession(card.id, {
@@ -9559,14 +9698,14 @@ class ReviewWorker {
             awaitingDecisionUntil: null
           });
           const started = await startSessionYieldingNotice(startSession, this.client, card.id, {
-            info: (message) => log28.info(this.tag, message),
-            warn: (message) => log28.warn(this.tag, message)
+            info: (message) => log29.info(this.tag, message),
+            warn: (message) => log29.warn(this.tag, message)
           });
           reviewSession = started.session;
         } catch (err) {
           if (isSessionConflict(err)) {
             this.sessionConflict = true;
-            log28.info(this.tag, `Skipping review of #${card.short_id}: ${err instanceof Error ? err.message : String(err)}`);
+            log29.info(this.tag, `Skipping review of #${card.short_id}: ${err instanceof Error ? err.message : String(err)}`);
             return;
           }
           throw err;
@@ -9587,7 +9726,7 @@ class ReviewWorker {
       const cwd = this.worktreePath;
       const devServer = await this.startDevServer(card, cwd, port);
       if (devServer.skipReason) {
-        log28.warn(this.tag, `Reviewing #${card.short_id} without the visual lens — ${devServer.skipReason}`);
+        log29.warn(this.tag, `Reviewing #${card.short_id} without the visual lens — ${devServer.skipReason}`);
       }
       await this.client.updateAgentProgress(card.id, {
         agentIdentifier: this.sessionIdentifier,
@@ -9625,10 +9764,10 @@ class ReviewWorker {
             pinnedContract = extractPinnedContract(comments, this.identity);
           }
         } catch (err) {
-          log28.warn(this.tag, `pinned-contract fetch failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+          log29.warn(this.tag, `pinned-contract fetch failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
         }
         if (pinnedContract) {
-          log28.info(this.tag, `Grading pinned contract for #${card.short_id} (${pinnedContract.assertions.length} criteria)`);
+          log29.info(this.tag, `Grading pinned contract for #${card.short_id} (${pinnedContract.assertions.length} criteria)`);
         }
       }
       const systemPrompt = buildReviewSystemPrompt();
@@ -9643,7 +9782,7 @@ class ReviewWorker {
       } else {
         const planCriteria2 = await fetchAcceptanceCriteria(this.client, this.tag, card);
         if (planCriteria2.length > 0) {
-          log28.info(this.tag, `Grading ${planCriteria2.length} plan criteria for #${card.short_id}`);
+          log29.info(this.tag, `Grading ${planCriteria2.length} plan criteria for #${card.short_id}`);
         }
         userPrompt = buildReviewUserPrompt(enriched, this.branchName, cwd, previewUrl, diffSummary, this.config.worktree.baseBranch, undefined, pinnedContract, planCriteria2, devServer.skipReason);
         if (resuming && this.resumeMessage) {
@@ -9660,7 +9799,7 @@ ${userPrompt}`;
           contextIncluded: { source: "review-knowledge", mode: "review" }
         });
       } catch (err) {
-        log28.warn(this.tag, `prompt_history persistence skipped: ${err instanceof Error ? err.message : String(err)}`);
+        log29.warn(this.tag, `prompt_history persistence skipped: ${err instanceof Error ? err.message : String(err)}`);
       }
       await this.client.updateAgentProgress(card.id, {
         agentIdentifier: this.sessionIdentifier,
@@ -9670,7 +9809,7 @@ ${userPrompt}`;
         progressPercent: 20
       });
       this.timeoutTimer = setTimeout(() => {
-        log28.warn(this.tag, `Review timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
+        log29.warn(this.tag, `Review timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
         this.timedOut = true;
         this.cancel("timeout");
       }, this.config.review.maxTimeout);
@@ -9692,10 +9831,10 @@ ${userPrompt}`;
       }
       this.state = "completing";
       await this.recordPhase("completing");
-      log28.info(this.tag, `Claude review finished for #${card.short_id}`);
+      log29.info(this.tag, `Claude review finished for #${card.short_id}`);
       this.killDevServer();
-      const result = parseReviewOutput(stdout);
-      log28.info(this.tag, `Review verdict: ${result.verdict} (${result.findings.length} finding(s))`);
+      const result = parseStructuredReview(stdout);
+      log29.info(this.tag, `Review verdict: ${result.verdict} (${result.findings.length} finding(s))`);
       await this.client.updateAgentProgress(card.id, {
         agentIdentifier: this.sessionIdentifier,
         agentName: `${AGENT_NAME} (Review)`,
@@ -9717,7 +9856,7 @@ ${userPrompt}`;
       this.state = "error";
       const msg = err instanceof Error ? err.message : String(err);
       this.lastErrorMessage = msg;
-      log28.error(this.tag, `Error reviewing #${card.short_id}: ${msg}`);
+      log29.error(this.tag, `Error reviewing #${card.short_id}: ${msg}`);
       this.lastRunLogPath = appendRunLog(this.tag, this.runId, card.short_id, `[${new Date().toISOString()}] review failed before completion: ${msg}`) ?? this.lastRunLogPath;
       const reviewHandback = await guardedHandback(this.client, card.id, {
         agentId: this.identity.agentId,
@@ -9733,7 +9872,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
             agentSessionId: this.sessionId ?? undefined
           });
         } catch (cErr) {
-          log28.warn(this.tag, `Failed to post the failure reason to #${card.short_id}: ${cErr instanceof Error ? cErr.message : cErr}`);
+          log29.warn(this.tag, `Failed to post the failure reason to #${card.short_id}: ${cErr instanceof Error ? cErr.message : cErr}`);
         }
       }
       try {
@@ -9745,21 +9884,21 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
           }
         });
       } catch (tErr) {
-        log28.error(this.tag, `endAgentSession unrecoverable on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+        log29.error(this.tag, `endAgentSession unrecoverable on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
       }
       if (reviewHandback.verdict.proceed) {
         try {
           await moveCardToColumn(this.client, reviewHandback.card ?? card, this.config.review.failColumn);
-          log28.info(this.tag, `Moved #${card.short_id} to "${this.config.review.failColumn}" after error`);
+          log29.info(this.tag, `Moved #${card.short_id} to "${this.config.review.failColumn}" after error`);
         } catch {
-          log28.warn(this.tag, "Failed to move card to fail column after error");
+          log29.warn(this.tag, "Failed to move card to fail column after error");
         }
       } else if (reviewHandback.verdict.reason === "unreadable" || reviewHandback.verdict.reason === "released" || reviewHandback.verdict.reason === "done") {
         try {
           await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
-          log28.warn(this.tag, `#${card.short_id} could not be re-read — labelled "${NEED_REVIEW_LABEL}" so reconcile stops re-enqueueing the review`);
+          log29.warn(this.tag, `#${card.short_id} could not be re-read — labelled "${NEED_REVIEW_LABEL}" so reconcile stops re-enqueueing the review`);
         } catch {
-          log28.warn(this.tag, `Failed to add "${NEED_REVIEW_LABEL}" label after an unreadable card`);
+          log29.warn(this.tag, `Failed to add "${NEED_REVIEW_LABEL}" label after an unreadable card`);
         }
       }
       if (this.runId) {
@@ -9803,7 +9942,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
     const holderMessage = err instanceof Error ? err.message : String(err);
     const waitHours = this.config.budget.pause.waitHours;
     const until = computeDecisionDeadline(waitHours);
-    log28.warn(this.tag, `#${card.short_id} stays parked — the resume could not reclaim its session: ${holderMessage}`);
+    log29.warn(this.tag, `#${card.short_id} stays parked — the resume could not reclaim its session: ${holderMessage}`);
     try {
       await this.client.addComment(card.id, formatResumeConflictComment({
         holderMessage,
@@ -9815,7 +9954,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
         agentSessionId: this.sessionId ?? undefined
       });
     } catch (commentErr) {
-      log28.warn(this.tag, `Failed to post the resume-conflict note for #${card.short_id}: ${commentErr}`);
+      log29.warn(this.tag, `Failed to post the resume-conflict note for #${card.short_id}: ${commentErr}`);
     }
     if (this.runId) {
       const run = this.stateStore.getRun(this.runId);
@@ -9826,7 +9965,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
           awaitingDecisionUntil: until
         });
       } catch (storeErr) {
-        log28.error(this.tag, `#${card.short_id} could not be re-parked after a resume conflict — the daemon has no hold on it: ${storeErr}`);
+        log29.error(this.tag, `#${card.short_id} could not be re-parked after a resume conflict — the daemon has no hold on it: ${storeErr}`);
       }
     }
   }
@@ -9839,7 +9978,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
     this.progressTracker = null;
     const waitHours = this.config.budget.pause.waitHours;
     const until = computeDecisionDeadline(waitHours);
-    log28.warn(this.tag, `#${card.short_id} parked (${trigger}) — awaiting a human decision for ${waitHours}h`);
+    log29.warn(this.tag, `#${card.short_id} parked (${trigger}) — awaiting a human decision for ${waitHours}h`);
     const body = formatBudgetComment({
       trigger,
       numTurns: stats?.cost?.numTurns ?? 0,
@@ -9861,7 +10000,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
       });
       commentId = res?.comment?.id ?? null;
     } catch (err) {
-      log28.warn(this.tag, `Failed to post the budget-pause comment: ${err}`);
+      log29.warn(this.tag, `Failed to post the budget-pause comment: ${err}`);
     }
     try {
       await this.client.updateAgentProgress(card.id, {
@@ -9872,7 +10011,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
         awaitingDecisionUntil: new Date(until).toISOString()
       });
     } catch (err) {
-      log28.warn(this.tag, `Failed to mark the session blocked: ${err}`);
+      log29.warn(this.tag, `Failed to mark the session blocked: ${err}`);
     }
     if (this.runId) {
       try {
@@ -9883,14 +10022,14 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
           ...this.endLedger()
         });
       } catch (err) {
-        log28.error(this.tag, `#${card.short_id} parkRun failed after the blocker comment + blocked session were already written — the daemon has no local record of this park: ${err}`);
+        log29.error(this.tag, `#${card.short_id} parkRun failed after the blocker comment + blocked session were already written — the daemon has no local record of this park: ${err}`);
       }
     }
   }
   async pause() {
     if (!this.isActive || !this.process || this.process.killed)
       return;
-    log28.info(this.tag, `Pausing review on ${this.cardId}`);
+    log29.info(this.tag, `Pausing review on ${this.cardId}`);
     signalGroup(this.process, "SIGSTOP");
     if (this.timeoutTimer) {
       clearTimeout(this.timeoutTimer);
@@ -9904,17 +10043,17 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
           status: "paused"
         });
       } catch {
-        log28.warn(this.tag, "Failed to update agent session to paused");
+        log29.warn(this.tag, "Failed to update agent session to paused");
       }
     }
   }
   async resume() {
     if (!this.isActive || !this.process || this.process.killed)
       return;
-    log28.info(this.tag, `Resuming review on ${this.cardId}`);
+    log29.info(this.tag, `Resuming review on ${this.cardId}`);
     signalGroup(this.process, "SIGCONT");
     this.timeoutTimer = setTimeout(() => {
-      log28.warn(this.tag, `Timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
+      log29.warn(this.tag, `Timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
       this.timedOut = true;
       this.cancel("timeout");
     }, this.config.review.maxTimeout);
@@ -9926,7 +10065,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
           status: "working"
         });
       } catch {
-        log28.warn(this.tag, "Failed to update agent session to working");
+        log29.warn(this.tag, "Failed to update agent session to working");
       }
     }
   }
@@ -9935,7 +10074,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
       return;
     this.aborted = true;
     this.state = "cancelling";
-    log28.info(this.tag, `Cancelling review on ${this.cardId}`);
+    log29.info(this.tag, `Cancelling review on ${this.cardId}`);
     const snapshotStats = this.lastSessionStats ?? this.progressTracker?.stats;
     if (this.progressTracker) {
       this.progressTracker?.stop();
@@ -9976,6 +10115,8 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
         String(effectiveMaxTurns),
         "--allowedTools",
         "Bash(readonly),Read,Glob,Grep,Agent,mcp__harmony__*",
+        "--json-schema",
+        JSON.stringify(REVIEW_VERDICT_JSON_SCHEMA),
         ...opts.resumeSessionId ? ["--resume", opts.resumeSessionId] : [],
         ...systemPrompt ? ["--append-system-prompt", systemPrompt] : [],
         ...this.config.claude.additionalArgs,
@@ -9988,11 +10129,11 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
         "--",
         prompt
       ];
-      log28.info(this.tag, `Spawning review: claude ${args.slice(0, 5).join(" ")} ...`);
+      log29.info(this.tag, `Spawning review: claude ${args.slice(0, 5).join(" ")} ...`);
       const runLog = openRunLog(this.tag, this.runId, shortId);
       this.lastRunLogPath = runLog?.path ?? null;
       if (runLog) {
-        log28.info(this.tag, `Run log: ${runLog.path}`);
+        log29.info(this.tag, `Run log: ${runLog.path}`);
         runLog.stream.write(`# run=${this.runId} card=#${shortId} pipeline=review started=${new Date().toISOString()}
 ` + `# args: ${args.slice(0, -2).join(" ")} -- <prompt:${prompt.length} chars>
 
@@ -10006,12 +10147,16 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
       const parser = new StreamParser;
       tracker.attach(parser);
       const textChunks = [];
+      let structuredOutput;
+      parser.on("structured_output", (output) => {
+        structuredOutput = output;
+      });
       parser.on("text", (content) => {
         textChunks.push(content);
         this.captureCliSessionId(parser.sessionId);
       });
       parser.on("parse_error", (msg) => {
-        log28.debug(this.tag, `Stream parse error (non-fatal): ${msg}`);
+        log29.debug(this.tag, `Stream parse error (non-fatal): ${msg}`);
         runLog?.stream.write(`
 [parse_error] ${msg}
 `);
@@ -10038,7 +10183,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
       this.process?.on("close", (code) => {
         this.process = null;
         this.captureCliSessionId(parser.sessionId);
-        const stdout = textChunks.join("");
+        const stdout = structuredOutput !== undefined ? JSON.stringify(structuredOutput) : textChunks.join("");
         const stats = tracker.stats;
         if (runLog) {
           runLog.stream.write(`
@@ -10090,16 +10235,16 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
       const evidence = await collectGateEvidence(registry, context);
       const evaluation = gateEvaluate(resolved.gate, evidence);
       await this.client.request("POST", `/cards/${encodeURIComponent(card.id)}/stage-gate-evidence`, toStageGateEvidenceInsert(context, evidence));
-      log28.info(this.tag, `Recorded review_passed gate evidence for #${card.short_id} stage "${resolved.stage.name}": result=${evidence.result} passed=${evaluation.passed}`);
+      log29.info(this.tag, `Recorded review_passed gate evidence for #${card.short_id} stage "${resolved.stage.name}": result=${evidence.result} passed=${evaluation.passed}`);
     } catch (err) {
-      log28.warn(this.tag, `review gate evidence collection failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+      log29.warn(this.tag, `review gate evidence collection failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     }
   }
   async startDevServer(card, cwd, port) {
     const declined = devServerSkipReason(cwd, this.config.commands);
     if (declined)
       return { previewUrl: null, skipReason: declined };
-    log28.info(this.tag, `Starting dev server on port ${port}...`);
+    log29.info(this.tag, `Starting dev server on port ${port}...`);
     const launch = devServerLaunch({
       worktreePath: cwd,
       port,
@@ -10140,14 +10285,14 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
         skipReason: launch.origin ? `${launch.origin}, and ${failure}` : failure
       };
     }
-    log28.info(this.tag, `Dev server ready on port ${port}`);
+    log29.info(this.tag, `Dev server ready on port ${port}`);
     return { previewUrl: `http://localhost:${port}`, skipReason: null };
   }
   killDevServer() {
     if (this.devServerProcess && !this.devServerProcess.killed) {
       signalGroup(this.devServerProcess, "SIGTERM");
       this.devServerProcess = null;
-      log28.debug(this.tag, "Killed dev server group");
+      log29.debug(this.tag, "Killed dev server group");
     }
     if (this.devServerContainer) {
       const name = this.devServerContainer;
@@ -10170,7 +10315,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
       try {
         cleanupWorktree4(this.worktreePath);
       } catch {
-        log28.warn(this.tag, "Failed to cleanup review worktree");
+        log29.warn(this.tag, "Failed to cleanup review worktree");
       }
     }
     this.process = null;
@@ -10182,7 +10327,7 @@ No verdict was produced, so this card has not been reviewed. The run's log is at
     this.lastSessionStats = null;
   }
 }
-var TAG25 = "review-worker", CANCEL_SIGINT_TIMEOUT = 30000, CANCEL_SIGTERM_TIMEOUT = 1e4;
+var TAG26 = "review-worker", CANCEL_SIGINT_TIMEOUT = 30000, CANCEL_SIGTERM_TIMEOUT = 1e4;
 var init_review_worker = __esm(() => {
   init_src();
   init_board_helpers();
@@ -10195,6 +10340,7 @@ var init_review_worker = __esm(() => {
   init_prompt();
   init_review_completion();
   init_review_prompt();
+  init_review_verdict_schema();
   init_review_worktree();
   init_run_log();
   init_session_conflict();
@@ -10206,7 +10352,7 @@ var init_review_worker = __esm(() => {
 
 // src/sleep-guard.ts
 import { spawn } from "node:child_process";
-import { log as log29 } from "@gethmy/harness";
+import { log as log30 } from "@gethmy/harness";
 
 class SleepGuard {
   platform;
@@ -10234,7 +10380,7 @@ class SleepGuard {
       if (!this.child.killed)
         this.child.kill("SIGTERM");
       this.child = null;
-      log29.info(TAG26, "sleep assertion released");
+      log30.info(TAG27, "sleep assertion released");
     }
   }
   start() {
@@ -10249,7 +10395,7 @@ class SleepGuard {
         spawned = true;
       });
       child.on("error", (err) => {
-        log29.warn(TAG26, `caffeinate unavailable: ${err.message}`);
+        log30.warn(TAG27, `caffeinate unavailable: ${err.message}`);
         if (this.child === child)
           this.child = null;
       });
@@ -10262,13 +10408,13 @@ class SleepGuard {
       });
       child.unref();
       this.child = child;
-      log29.info(TAG26, "sleep assertion acquired (caffeinate -i)");
+      log30.info(TAG27, "sleep assertion acquired (caffeinate -i)");
     } catch (err) {
-      log29.warn(TAG26, `failed to spawn caffeinate: ${err instanceof Error ? err.message : err}`);
+      log30.warn(TAG27, `failed to spawn caffeinate: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG26 = "sleep-guard";
+var TAG27 = "sleep-guard";
 var init_sleep_guard = () => {};
 
 // src/stage-hold.ts
@@ -10293,13 +10439,13 @@ function stageHoldUntil(holdMinutes, nowMs) {
 }
 
 // src/unblock.ts
-import { log as log30 } from "@gethmy/harness";
+import { log as log31 } from "@gethmy/harness";
 async function fetchBlocksLinks(client, cardId) {
   try {
     const { links } = await client.getCardLinks(cardId);
     return links.filter((l) => l.link_type === "blocks");
   } catch (err) {
-    log30.warn(TAG27, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log31.warn(TAG28, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -10333,31 +10479,31 @@ async function promoteUnblockedSuccessors(completedCard, deps) {
   const successors = links.filter((l) => l.direction === "outgoing" && !l.target_card.done);
   if (successors.length === 0)
     return;
-  log30.info(TAG27, `#${completedCard.short_id} completed — checking ${successors.length} chained successor(s)`);
+  log31.info(TAG28, `#${completedCard.short_id} completed — checking ${successors.length} chained successor(s)`);
   for (const link of successors) {
     const successorId = link.target_card.id;
     try {
       const { card } = await deps.client.getCard(successorId);
       if (card.assigned_agent_id === deps.agentId) {} else if (card.assigned_agent_id === null && !card.assignee_id) {
-        log30.info(TAG27, `successor #${card.short_id} unassigned — auto-assigning to continue chain`);
+        log31.info(TAG28, `successor #${card.short_id} unassigned — auto-assigning to continue chain`);
         await deps.client.updateCard(successorId, {
           assignedAgentId: deps.agentId
         });
       } else {
-        log30.debug(TAG27, `successor #${card.short_id} assigned to different entity — skipping`);
+        log31.debug(TAG28, `successor #${card.short_id} assigned to different entity — skipping`);
         continue;
       }
       await deps.enqueue(successorId);
     } catch (err) {
-      log30.warn(TAG27, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
+      log31.warn(TAG28, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG27 = "unblock";
+var TAG28 = "unblock";
 var init_unblock = () => {};
 
 // src/cli-agent-runner.ts
-import { log as log31 } from "@gethmy/harness";
+import { log as log32 } from "@gethmy/harness";
 function truncateOutput(value) {
   return value === undefined ? undefined : value.slice(0, MAX_OUTPUT_CHARS);
 }
@@ -10522,7 +10668,7 @@ class CliAgentRunner {
       return;
     const draft = sanitizeRunEventDraft(body);
     if (runEventPayloadExceedsLimit(draft.payload)) {
-      log31.warn(TAG28, `Dropping ${body.kind} event: payload exceeds ${MAX_RUN_EVENT_PAYLOAD_BYTES} bytes, or cannot be serialized`);
+      log32.warn(TAG29, `Dropping ${body.kind} event: payload exceeds ${MAX_RUN_EVENT_PAYLOAD_BYTES} bytes, or cannot be serialized`);
       return;
     }
     this.buffer.push({ ...draft, createdAt: new Date().toISOString() });
@@ -10554,15 +10700,15 @@ class CliAgentRunner {
         this.requeue(batch);
         if (batch.length > 1) {
           this.nextBatchSize = Math.ceil(batch.length / 2);
-          log31.warn(TAG28, `Flush of ${batch.length} run event(s) failed ${MAX_BATCH_ATTEMPTS}×; bisecting to ${this.nextBatchSize}: ${err}`);
+          log32.warn(TAG29, `Flush of ${batch.length} run event(s) failed ${MAX_BATCH_ATTEMPTS}×; bisecting to ${this.nextBatchSize}: ${err}`);
           return;
         }
         const dropped = this.buffer.shift();
         this.nextBatchSize = MAX_BUFFER;
-        log31.warn(TAG28, `Dropping one ${dropped?.kind} event the API refused ${MAX_BATCH_ATTEMPTS}×: ${err}`);
+        log32.warn(TAG29, `Dropping one ${dropped?.kind} event the API refused ${MAX_BATCH_ATTEMPTS}×: ${err}`);
         return;
       }
-      log31.warn(TAG28, `Failed to flush run events (attempt ${this.batchAttempts}/${MAX_BATCH_ATTEMPTS}): ${err}`);
+      log32.warn(TAG29, `Failed to flush run events (attempt ${this.batchAttempts}/${MAX_BATCH_ATTEMPTS}): ${err}`);
       this.requeue(batch);
     } finally {
       this.flushing = false;
@@ -10605,26 +10751,26 @@ function mapCost(cost) {
     durationMs: cost.durationMs
   };
 }
-var TAG28 = "cli-agent-runner", FLUSH_INTERVAL_MS = 2000, MAX_BUFFER = 1000, MAX_TEXT_LEN = 8000, MAX_BATCH_ATTEMPTS = 3, FINAL_FLUSH_ATTEMPTS = 40;
+var TAG29 = "cli-agent-runner", FLUSH_INTERVAL_MS = 2000, MAX_BUFFER = 1000, MAX_TEXT_LEN = 8000, MAX_BATCH_ATTEMPTS = 3, FINAL_FLUSH_ATTEMPTS = 40;
 var init_cli_agent_runner = __esm(() => {
   init_src();
 });
 
 // src/fanout.ts
-import { log as log32 } from "@gethmy/harness";
+import { log as log33 } from "@gethmy/harness";
 async function fetchLinks(client, cardId) {
   try {
     const { links } = await client.getCardLinks(cardId);
     return links;
   } catch (err) {
-    log32.warn(TAG29, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log33.warn(TAG30, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
 async function isFanoutChildOf(card, stage, client) {
   const links = await fetchLinks(client, card.id);
   if (links === null) {
-    log32.warn(TAG29, `#${card.short_id}: link read failed — treating as a fan-out child (fail closed, no recursive dispatch)`);
+    log33.warn(TAG30, `#${card.short_id}: link read failed — treating as a fan-out child (fail closed, no recursive dispatch)`);
     return true;
   }
   const parents = links.filter((l) => l.direction === "outgoing" && l.link_type === "is_part_of");
@@ -10711,7 +10857,7 @@ async function readStageHandoff(card, fromStage, deps) {
     }
     return null;
   } catch (err) {
-    log32.warn(TAG29, `handoff read failed for #${card.short_id} stage "${fromStage}": ${err instanceof Error ? err.message : err}`);
+    log33.warn(TAG30, `handoff read failed for #${card.short_id} stage "${fromStage}": ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -10812,7 +10958,7 @@ async function dispatchWave(parent, stage, plan, items, deps) {
     });
     spawned = res.children ?? [];
   } catch (err) {
-    log32.warn(TAG29, `child spawn failed for #${parent.short_id} stage "${stage.id}": ${err instanceof Error ? err.message : err}`);
+    log33.warn(TAG30, `child spawn failed for #${parent.short_id} stage "${stage.id}": ${err instanceof Error ? err.message : err}`);
     return 0;
   }
   let created = 0;
@@ -10867,10 +11013,10 @@ async function seedChildHandoff(parent, stage, item, total, childId, deps) {
   try {
     await deps.client.addComment(childId, body, { commentType: "decision" });
   } catch (err) {
-    log32.warn(TAG29, `seed handoff failed for child ${childId}: ${err instanceof Error ? err.message : err}`);
+    log33.warn(TAG30, `seed handoff failed for child ${childId}: ${err instanceof Error ? err.message : err}`);
   }
 }
-var TAG29 = "fanout";
+var TAG30 = "fanout";
 var init_fanout = __esm(() => {
   init_src();
 });
@@ -11147,7 +11293,7 @@ function runSizedPayload(input) {
 }
 
 // src/stage-advance.ts
-import { gateConfigErrorReason, log as log33 } from "@gethmy/harness";
+import { gateConfigErrorReason, log as log34 } from "@gethmy/harness";
 function endDispositionFor(outcome) {
   return "endDisposition" in outcome && outcome.endDisposition ? outcome.endDisposition : { status: "completed" };
 }
@@ -11178,7 +11324,7 @@ async function resolveStageColumnName(client, card, stage) {
     const match = board.columns.find((c) => c.id === target || c.name.toLowerCase() === target.toLowerCase());
     return match ? match.name : null;
   } catch (err) {
-    log33.warn(TAG30, `board fetch failed resolving stage column for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log34.warn(TAG31, `board fetch failed resolving stage column for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -11217,7 +11363,7 @@ async function holdGateMisconfigured(card, stage, detail, deps) {
     });
   } catch {}
   const endDisposition = await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, { agentSessionId: deps.agentSessionId });
-  log33.info(TAG30, `#${card.short_id} GateMisconfigured: ${reason}`);
+  log34.info(TAG31, `#${card.short_id} GateMisconfigured: ${reason}`);
   return { kind: "held_misconfigured", reason, endDisposition };
 }
 function firstErrorMessage(evaluation) {
@@ -11248,7 +11394,7 @@ async function advanceConvergeLoop(card, stage, stageIndex, def, evaluation, loo
     evidence,
     summary
   });
-  log33.info(TAG30, `#${card.short_id} converge loop "${stage.name}": ${summary} → ${decision}`);
+  log34.info(TAG31, `#${card.short_id} converge loop "${stage.name}": ${summary} → ${decision}`);
   if (decision === "exit") {
     await deps.stateStore.resetLoopIterations(card.id).catch(() => {});
     deps.sink?.recordLoopCompleted?.({
@@ -11293,7 +11439,7 @@ async function advanceConvergeLoop(card, stage, stageIndex, def, evaluation, loo
       blockers: [reason],
       agentSessionId: deps.agentSessionId
     });
-    log33.info(TAG30, `#${card.short_id} LoopExhausted: ${reason}`);
+    log34.info(TAG31, `#${card.short_id} LoopExhausted: ${reason}`);
     return { kind: "held_gate_unmet", reason, endDisposition };
   }
   const guard = await guardStageReclaim(card, `converge-loop iteration of "${stage.name}"`, deps);
@@ -11318,7 +11464,7 @@ async function advanceConvergeLoop(card, stage, stageIndex, def, evaluation, loo
     addLabels: [{ name: AGENT_LABEL }],
     ...isAgentRunnableOwner(stage.owner) ? { assignAgent: deps.agentId } : {}
   }, { store: deps.stateStore, runId: deps.runId });
-  log33.info(TAG30, `#${card.short_id} converge loop "${stage.name}" — requeued to "${toColumn}" for iteration ${iteration + 1}/${maxIterations}`);
+  log34.info(TAG31, `#${card.short_id} converge loop "${stage.name}" — requeued to "${toColumn}" for iteration ${iteration + 1}/${maxIterations}`);
   return { kind: "requeued_gate_unmet", toColumn };
 }
 async function writeIterationHandoff(card, stage, iteration, maxIterations, evaluation, deps) {
@@ -11340,7 +11486,7 @@ ${findings.map((f) => `- [${f.level}] ${f.message}`).join(`
       agentSessionId: deps.agentSessionId ?? undefined
     });
   } catch (err) {
-    log33.warn(TAG30, `iteration-handoff write failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log34.warn(TAG31, `iteration-handoff write failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
 }
 async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps) {
@@ -11368,7 +11514,7 @@ async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps
       reason: "Playbook complete — final stage gate passed."
     });
     deps.stateStore.recordOutcome(card.id, "success").catch(() => {});
-    log33.info(TAG30, `#${card.short_id} terminal stage "${stage.name}" passed — playbook complete (done left to the column)`);
+    log34.info(TAG31, `#${card.short_id} terminal stage "${stage.name}" passed — playbook complete (done left to the column)`);
     return { kind: "completed_terminal" };
   }
   if (next.kind === "out_of_range") {
@@ -11400,7 +11546,7 @@ async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps
     ...isAgentRunnableOwner(next.stage.owner) ? { assignAgent: deps.agentId } : {}
   }, { store: deps.stateStore, runId: deps.runId });
   deps.stateStore.recordOutcome(card.id, "success").catch(() => {});
-  log33.info(TAG30, `#${card.short_id} advanced "${stage.name}" → "${next.stage.name}" (column "${toColumn}")`);
+  log34.info(TAG31, `#${card.short_id} advanced "${stage.name}" → "${next.stage.name}" (column "${toColumn}")`);
   if (next.stage.owner === "human") {
     const reason = `Stage "${next.stage.name}" is yours: ${handoffText(next.stage)}`;
     const endDisposition = await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, {
@@ -11437,7 +11583,7 @@ async function handleGateUnmet(card, stage, summary, deps) {
       blockers: [reason],
       agentSessionId: deps.agentSessionId
     });
-    log33.info(TAG30, `#${card.short_id} GateUnmetExhausted: ${reason}`);
+    log34.info(TAG31, `#${card.short_id} GateUnmetExhausted: ${reason}`);
     return { kind: "held_gate_unmet", reason, endDisposition };
   }
   const guard = await guardStageReclaim(card, `gate-unmet re-run of "${stage.name}"`, deps);
@@ -11460,7 +11606,7 @@ async function handleGateUnmet(card, stage, summary, deps) {
     addLabels: [{ name: AGENT_LABEL }],
     ...isAgentRunnableOwner(stage.owner) ? { assignAgent: deps.agentId } : {}
   }, { store: deps.stateStore, runId: deps.runId });
-  log33.info(TAG30, `#${card.short_id} gate unmet for "${stage.name}" — requeued to "${toColumn}" for re-run (attempt ${attempts}/${deps.maxAttempts})`);
+  log34.info(TAG31, `#${card.short_id} gate unmet for "${stage.name}" — requeued to "${toColumn}" for re-run (attempt ${attempts}/${deps.maxAttempts})`);
   return { kind: "requeued_gate_unmet", toColumn };
 }
 async function guardStageReclaim(card, what, deps) {
@@ -11486,10 +11632,10 @@ async function guardStageReclaim(card, what, deps) {
       }, { store: deps.stateStore, runId: deps.runId });
       released = stillOurs;
     } catch (err) {
-      log33.warn(TAG30, `#${card.short_id} could not hand the card over after refusing the ${what}: ${err instanceof Error ? err.message : err}${stillOurs ? " — the claim is still ours, so the next reconcile tick may re-pick the card" : ""}`);
+      log34.warn(TAG31, `#${card.short_id} could not hand the card over after refusing the ${what}: ${err instanceof Error ? err.message : err}${stillOurs ? " — the claim is still ours, so the next reconcile tick may re-pick the card" : ""}`);
     }
   }
-  log33.info(TAG30, `#${card.short_id} ${what} refused — ${detail} (${reason})${released ? "; released the daemon's claim so the stage router stops here" : ""}`);
+  log34.info(TAG31, `#${card.short_id} ${what} refused — ${detail} (${reason})${released ? "; released the daemon's claim so the stage router stops here" : ""}`);
   try {
     await deps.client.addComment(card.id, `Stopped the ${what} — ${detail}. The card is not the daemon's to reclaim, so this stage will not re-run until it is assigned back.`, {
       commentType: "decision",
@@ -11511,7 +11657,7 @@ async function holdForHuman(client, card, reason, runId, stateStore, opts = {})
   try {
     await runTransition(client, card, { removeLabels: [AGENT_LABEL] }, { store: stateStore, runId });
   } catch (err) {
-    log33.warn(TAG30, `hold transition failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log34.warn(TAG31, `hold transition failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
   return {
     status: opts.endStatus ?? "paused",
@@ -11520,7 +11666,7 @@ async function holdForHuman(client, card, reason, runId, stateStore, opts = {})
     failureSummary: reason.slice(0, 300)
   };
 }
-var TAG30 = "stage-advance", AGENT_LABEL = "agent";
+var TAG31 = "stage-advance", AGENT_LABEL = "agent";
 var init_stage_advance = __esm(() => {
   init_src();
   init_handback();
@@ -11628,7 +11774,7 @@ import {
   GIT_NO_HOOKS as GIT_NO_HOOKS8,
   implementRunContainment,
   implementRunContainmentCliArgs as implementRunContainmentCliArgs2,
-  log as log34,
+  log as log35,
   makeBranchName,
   normalizeGateSpec,
   pushBranch as pushBranch3,
@@ -11834,11 +11980,11 @@ class Worker {
         sessionId: this.sessionId
       });
     } catch (err) {
-      log34.warn(this.tag, `state store updateRun failed: ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `state store updateRun failed: ${err instanceof Error ? err.message : err}`);
     }
   }
   get tag() {
-    return `${TAG31}:${this.id}`;
+    return `${TAG32}:${this.id}`;
   }
   get isIdle() {
     return this.state === "idle";
@@ -11900,12 +12046,12 @@ class Worker {
     }
     if (!crossedTurnCap(before, after, cap))
       return;
-    log34.warn(TAG31, `#${shortId ?? cardId} reached its per-card turn cap — ${after} of ${cap} turns. It will not be picked up again until it is reassigned or the cap is raised.`);
+    log35.warn(TAG32, `#${shortId ?? cardId} reached its per-card turn cap — ${after} of ${cap} turns. It will not be picked up again until it is reassigned or the cap is raised.`);
     try {
       const legs = this.stateStore.getRun(this.runId ?? "")?.legs?.length || 1;
       await this.client.addComment(cardId, buildTurnCapComment(after, cap, legs), { commentType: "blocker", agentSessionId: this.sessionId ?? undefined });
     } catch (err) {
-      log34.warn(TAG31, `Could not post the turn-cap notice for ${cardId}: ${err instanceof Error ? err.message : err}`);
+      log35.warn(TAG32, `Could not post the turn-cap notice for ${cardId}: ${err instanceof Error ? err.message : err}`);
     }
   }
   async run(card, column, labels, subtasks) {
@@ -11960,7 +12106,7 @@ class Worker {
           resumeReason: null
         });
       } catch (err) {
-        log34.warn(this.tag, `Failed to clear the consumed grant: ${err}`);
+        log35.warn(this.tag, `Failed to clear the consumed grant: ${err}`);
       }
     }
     try {
@@ -11968,20 +12114,20 @@ class Worker {
       if (!resuming) {
         this.branchName = makeBranchName(card.short_id, card.title, this.config.worktree.failedBranchPrefix);
       }
-      log34.info(this.tag, resuming ? `Resuming #${card.short_id} "${card.title}" with ${this.grantedTurns ?? "the default"} more turns` : `Preparing #${card.short_id} "${card.title}"`);
+      log35.info(this.tag, resuming ? `Resuming #${card.short_id} "${card.title}" with ${this.grantedTurns ?? "the default"} more turns` : `Preparing #${card.short_id} "${card.title}"`);
       const attemptCount = await this.stateStore.incrementAttempt(card.id);
       const isRework = attemptCount > 1;
       const runStarts = this.stateStore.getCardRunStarts(card.id);
       const runCap = this.config.budget.maxRunsPerCard;
       if (crossedTurnCap(runStarts - 1, runStarts, runCap)) {
-        log34.warn(this.tag, `#${card.short_id} reached its per-card run backstop — ${runStarts} of ${runCap} run starts. It will not be picked up again until it is reassigned or the cap is raised.`);
+        log35.warn(this.tag, `#${card.short_id} reached its per-card run backstop — ${runStarts} of ${runCap} run starts. It will not be picked up again until it is reassigned or the cap is raised.`);
         try {
           await this.client.addComment(card.id, buildRunCapComment(runStarts, runCap), {
             commentType: "blocker",
             agentSessionId: this.sessionId ?? undefined
           });
         } catch (err) {
-          log34.warn(this.tag, `Could not post the run-backstop notice for ${card.id}: ${err instanceof Error ? err.message : err}`);
+          log35.warn(this.tag, `Could not post the run-backstop notice for ${card.id}: ${err instanceof Error ? err.message : err}`);
         }
       }
       const recordedBranch = recordedBranchForCard(card.description, card.short_id, [
@@ -11991,10 +12137,10 @@ class Worker {
       const continuesPushedWork = isRework || recordedBranch !== null;
       if (!resuming && recordedBranch) {
         if (recordedBranch !== this.branchName) {
-          log34.info(this.tag, `Card records pushed work on ${recordedBranch} — continuing that branch instead of ${this.branchName}`);
+          log35.info(this.tag, `Card records pushed work on ${recordedBranch} — continuing that branch instead of ${this.branchName}`);
           this.branchName = recordedBranch;
         } else if (!isRework) {
-          log34.info(this.tag, `Card records pushed work on ${this.branchName} — continuing that branch instead of rebuilding from ${this.config.worktree.baseBranch}`);
+          log35.info(this.tag, `Card records pushed work on ${this.branchName} — continuing that branch instead of rebuilding from ${this.config.worktree.baseBranch}`);
         }
       }
       this.startHeartbeat();
@@ -12036,14 +12182,14 @@ class Worker {
             awaitingDecisionUntil: null
           });
           const started = await startSessionYieldingNotice(startSession, this.client, card.id, {
-            info: (message) => log34.info(this.tag, message),
-            warn: (message) => log34.warn(this.tag, message)
+            info: (message) => log35.info(this.tag, message),
+            warn: (message) => log35.warn(this.tag, message)
           });
           session = started.session;
         } catch (err) {
           if (isSessionConflict(err)) {
             this.sessionConflict = true;
-            log34.info(this.tag, `Skipping #${card.short_id}: ${err instanceof Error ? err.message : String(err)}`);
+            log35.info(this.tag, `Skipping #${card.short_id}: ${err instanceof Error ? err.message : String(err)}`);
             await this.stateStore.decrementAttempt(card.id);
             return;
           }
@@ -12051,7 +12197,7 @@ class Worker {
         }
         const sid = session && typeof session === "object" && "id" in session ? session.id : null;
         if (!sid) {
-          log34.warn(TAG31, "startAgentSession returned no session id");
+          log35.warn(TAG32, "startAgentSession returned no session id");
         }
         this.sessionId = sid;
       }
@@ -12069,7 +12215,7 @@ class Worker {
       if (!resuming) {
         const moved = await moveCardAndAddLabel(this.client, card, IN_PROGRESS_COLUMN, "agent");
         if (!moved) {
-          log34.warn(this.tag, `Card #${card.short_id} was NOT moved to "In Progress" — check API logs`);
+          log35.warn(this.tag, `Card #${card.short_id} was NOT moved to "In Progress" — check API logs`);
         }
       }
       if (this.aborted)
@@ -12096,10 +12242,10 @@ class Worker {
         }).trim();
         const target = resolveContinuationTarget(this.branchName, continueRequested, this.config.worktree.failedBranchPrefix, this.config.worktree.approvedBranchPrefix, (ref) => fetchExistingBranch(repoRoot, ref));
         if (target.branchName !== this.branchName) {
-          log34.info(this.tag, `Branch ${this.branchName} is gone from origin but its approved rename ${target.branchName} exists — continuing that branch`);
+          log35.info(this.tag, `Branch ${this.branchName} is gone from origin but its approved rename ${target.branchName} exists — continuing that branch`);
           this.branchName = target.branchName;
         } else if (target.reason === "exists_on_origin") {
-          log34.info(this.tag, `Branch ${this.branchName} exists on origin with no card record — continuing it rather than resetting it`);
+          log35.info(this.tag, `Branch ${this.branchName} exists on origin with no card record — continuing it rather than resetting it`);
         }
         this.worktreePath = createWorktree(this.config.worktree.basePath, this.config.worktree.baseBranch, this.branchName, {
           continueExisting: target.continueExisting,
@@ -12133,7 +12279,7 @@ class Worker {
         if (this.aborted)
           return;
         if (parked) {
-          log34.info(this.tag, `#${card.short_id} parked for plan approval — ending run`);
+          log35.info(this.tag, `#${card.short_id} parked for plan approval — ending run`);
           return;
         }
       }
@@ -12154,7 +12300,7 @@ class Worker {
         progressPercent: 10
       });
       this.timeoutTimer = setTimeout(() => {
-        log34.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms), cancelling`);
+        log35.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms), cancelling`);
         this.timedOut = true;
         this.cancel("timeout");
       }, this.config.maxTimeout);
@@ -12181,7 +12327,7 @@ class Worker {
       }
       this.state = "verifying";
       await this.recordPhase("verifying");
-      log34.info(this.tag, `Claude finished for #${card.short_id}, running verification & completion`);
+      log35.info(this.tag, `Claude finished for #${card.short_id}, running verification & completion`);
       await this.client.updateAgentProgress(card.id, {
         agentIdentifier: this.sessionIdentifier,
         agentName: AGENT_NAME,
@@ -12216,7 +12362,7 @@ class Worker {
               break;
             case "reclaim_refused":
               this.held = true;
-              log34.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
+              log35.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
               break;
             case "advanced":
             case "completed_terminal":
@@ -12254,7 +12400,7 @@ class Worker {
         return;
       }
       this.state = "error";
-      log34.error(this.tag, `Error on #${card.short_id}: ${msg}`);
+      log35.error(this.tag, `Error on #${card.short_id}: ${msg}`);
       const apiError = errClass.kind !== null;
       const baseError = err instanceof WorktreeBaseError;
       const noBudgetBurn = apiError || baseError;
@@ -12272,7 +12418,7 @@ class Worker {
         try {
           await teardownWorktree2(this.client, card.id, this.worktreePath, this.branchName ?? undefined, this.sessionId);
         } catch {
-          log34.warn(this.tag, "Failed to cleanup worktree before requeue");
+          log35.warn(this.tag, "Failed to cleanup worktree before requeue");
         }
         this.worktreePath = null;
       }
@@ -12297,7 +12443,7 @@ class Worker {
           }
         });
       } catch (tErr) {
-        log34.error(this.tag, `error transition failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+        log35.error(this.tag, `error transition failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
       }
       if (this.runId) {
         try {
@@ -12333,7 +12479,7 @@ class Worker {
           try {
             await teardownWorktree2(this.client, card.id, this.worktreePath, this.branchName ?? undefined, this.sessionId);
           } catch {
-            log34.warn(this.tag, "Failed to cleanup worktree before requeue");
+            log35.warn(this.tag, "Failed to cleanup worktree before requeue");
           }
           this.worktreePath = null;
         }
@@ -12356,7 +12502,7 @@ class Worker {
             }
           });
         } catch (tErr) {
-          log34.error(this.tag, `timeout transition failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+          log35.error(this.tag, `timeout transition failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
         }
         try {
           await this.stateStore.endRun(this.runId, "failed", {
@@ -12370,15 +12516,15 @@ class Worker {
           try {
             await this.client.updateCard(card.id, { assignedAgentId: null });
           } catch (err) {
-            log34.warn(this.tag, `failed to release card after stop: ${err instanceof Error ? err.message : err}`);
+            log35.warn(this.tag, `failed to release card after stop: ${err instanceof Error ? err.message : err}`);
           }
           try {
             await runTransition(this.client, card, { removeLabels: ["agent"] });
           } catch (tErr) {
-            log34.warn(this.tag, `stop label cleanup failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+            log35.warn(this.tag, `stop label cleanup failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
           }
         } else {
-          log34.info(this.tag, `cancel arrived after completion on #${card.short_id} — keeping assignment so review picks it up (#585)`);
+          log35.info(this.tag, `cancel arrived after completion on #${card.short_id} — keeping assignment so review picks it up (#585)`);
         }
         try {
           await this.stateStore.endRun(this.runId, "paused", {
@@ -12442,28 +12588,28 @@ class Worker {
       };
       const { pick, reason } = selectAutoPlaybook(subject, playbooks ?? []);
       if (!pick) {
-        log34.info(this.tag, `No playbook auto-bound to #${card.short_id}: ${reason}`);
+        log35.info(this.tag, `No playbook auto-bound to #${card.short_id}: ${reason}`);
         return card;
       }
       const undeclared = undeclaredGateMetricsIn(pick, declaredMetricSet(this.config));
       if (undeclared.length > 0) {
-        log34.warn(this.tag, `Not binding "${pick.name}" to #${card.short_id}: stage ` + undeclared.map((u) => `"${u.stageName}" gates on metric "${u.metric}" (declare \`agent.playbooks.metrics.${u.metric}\`)`).join(", ") + " — this daemon cannot measure it, so the card runs the generic path instead.");
+        log35.warn(this.tag, `Not binding "${pick.name}" to #${card.short_id}: stage ` + undeclared.map((u) => `"${u.stageName}" gates on metric "${u.metric}" (declare \`agent.playbooks.metrics.${u.metric}\`)`).join(", ") + " — this daemon cannot measure it, so the card runs the generic path instead.");
         return card;
       }
       const applyResult = await this.client.request("POST", `/cards/${card.id}/apply-playbook`, {
         playbookId: pick.id
       });
-      log34.info(this.tag, `Auto-bound #${card.short_id} to playbook "${pick.name}": ${reason}`);
+      log35.info(this.tag, `Auto-bound #${card.short_id} to playbook "${pick.name}": ${reason}`);
       try {
         await this.client.addComment(card.id, `Bound playbook "${pick.name}" automatically — ${reason} Apply a different playbook from the card's stage rail to override, or turn the rule off in the playbook editor.`);
       } catch (commentErr) {
-        log34.warn(this.tag, `Auto-bind comment failed for #${card.short_id}: ${commentErr instanceof Error ? commentErr.message : String(commentErr)}`);
+        log35.warn(this.tag, `Auto-bind comment failed for #${card.short_id}: ${commentErr instanceof Error ? commentErr.message : String(commentErr)}`);
       }
       try {
         const { card: fresh } = await this.client.getCard(card.id);
         return fresh;
       } catch (fetchErr) {
-        log34.warn(this.tag, `Auto-bind re-fetch failed for #${card.short_id} after binding playbook "${pick.name}" — using the apply-playbook response's fields for this pickup: ${fetchErr instanceof Error ? fetchErr.message : String(fetchErr)}`);
+        log35.warn(this.tag, `Auto-bind re-fetch failed for #${card.short_id} after binding playbook "${pick.name}" — using the apply-playbook response's fields for this pickup: ${fetchErr instanceof Error ? fetchErr.message : String(fetchErr)}`);
         return {
           ...card,
           playbook_id: applyResult.card.playbook_id,
@@ -12472,7 +12618,7 @@ class Worker {
         };
       }
     } catch (err) {
-      log34.warn(this.tag, `Auto-bind playbook check failed for #${card.short_id}, continuing unbound: ${err instanceof Error ? err.message : String(err)}`);
+      log35.warn(this.tag, `Auto-bind playbook check failed for #${card.short_id}, continuing unbound: ${err instanceof Error ? err.message : String(err)}`);
       return card;
     }
   }
@@ -12584,7 +12730,7 @@ class Worker {
       });
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
-      log34.warn(this.tag, `fan-out tick failed on #${card.short_id}: ${detail}`);
+      log35.warn(this.tag, `fan-out tick failed on #${card.short_id}: ${detail}`);
       await this.holdStageCard(card, `Fan-out stage "${ctx.stage.name}" could not run: ${detail}`);
       return;
     }
@@ -12593,7 +12739,7 @@ class Worker {
       case "waiting": {
         const total = outcome.kind === "dispatched" ? outcome.total : outcome.total;
         const note = outcome.kind === "dispatched" ? `Fan-out stage "${ctx.stage.name}": dispatched ${outcome.created} of ${total} item(s); ${outcome.inFlight} in flight.` : `Fan-out stage "${ctx.stage.name}": ${outcome.settled} of ${total} item(s) settled; waiting on the rest.`;
-        log34.info(this.tag, `#${card.short_id} ${note}`);
+        log35.info(this.tag, `#${card.short_id} ${note}`);
         await this.client.updateAgentProgress(card.id, {
           agentIdentifier: "claude-code-stage",
           agentName: "Harmony Agent",
@@ -12621,7 +12767,7 @@ class Worker {
         if (advance.kind === "advanced" || advance.kind === "completed_terminal") {
           this.held = false;
         }
-        log34.info(this.tag, `#${card.short_id} ${summary} → ${advance.kind}`);
+        log35.info(this.tag, `#${card.short_id} ${summary} → ${advance.kind}`);
         return;
       }
       case "halted": {
@@ -12641,7 +12787,7 @@ class Worker {
     }
   }
   async holdStageCard(card, reason, wait = false, armCooldown = false) {
-    log34.info(this.tag, `Holding #${card.short_id}: ${reason}`);
+    log35.info(this.tag, `Holding #${card.short_id}: ${reason}`);
     await this.stateStore.decrementAttempt(card.id);
     let announced = false;
     const holdStage = armCooldown ? card.current_stage : null;
@@ -12654,11 +12800,11 @@ class Worker {
         });
         announced = recorded.announced;
       } catch (err) {
-        log34.warn(this.tag, `stage hold not recorded on #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log35.warn(this.tag, `stage hold not recorded on #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (announced) {
-      log34.debug(this.tag, `#${card.short_id} already carries this blocker — not reposting`);
+      log35.debug(this.tag, `#${card.short_id} already carries this blocker — not reposting`);
     } else {
       try {
         await this.client.addComment(card.id, reason, {
@@ -12680,7 +12826,7 @@ class Worker {
         }
       });
     } catch (tErr) {
-      log34.warn(this.tag, `hold transition failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+      log35.warn(this.tag, `hold transition failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
     }
     if (this.runId) {
       try {
@@ -12698,7 +12844,7 @@ class Worker {
     const holderMessage = err instanceof Error ? err.message : String(err);
     const waitHours = this.config.budget.pause.waitHours;
     const until = computeDecisionDeadline(waitHours);
-    log34.warn(this.tag, `#${card.short_id} stays parked — the resume could not reclaim its session: ${holderMessage}`);
+    log35.warn(this.tag, `#${card.short_id} stays parked — the resume could not reclaim its session: ${holderMessage}`);
     try {
       await this.client.addComment(card.id, formatResumeConflictComment({
         holderMessage,
@@ -12710,7 +12856,7 @@ class Worker {
         agentSessionId: this.sessionId ?? undefined
       });
     } catch (commentErr) {
-      log34.warn(this.tag, `Failed to post the resume-conflict note for #${card.short_id}: ${commentErr}`);
+      log35.warn(this.tag, `Failed to post the resume-conflict note for #${card.short_id}: ${commentErr}`);
     }
     if (this.runId) {
       const run = this.stateStore.getRun(this.runId);
@@ -12721,7 +12867,7 @@ class Worker {
           awaitingDecisionUntil: until
         });
       } catch (storeErr) {
-        log34.error(this.tag, `#${card.short_id} could not be re-parked after a resume conflict — the daemon has no hold on it: ${storeErr}`);
+        log35.error(this.tag, `#${card.short_id} could not be re-parked after a resume conflict — the daemon has no hold on it: ${storeErr}`);
       }
     }
   }
@@ -12733,7 +12879,7 @@ class Worker {
     this.progressTracker = null;
     const waitHours = this.config.budget.pause.waitHours;
     const until = computeDecisionDeadline(waitHours);
-    log34.warn(this.tag, `#${card.short_id} parked (${trigger}) — awaiting a human decision for ${waitHours}h`);
+    log35.warn(this.tag, `#${card.short_id} parked (${trigger}) — awaiting a human decision for ${waitHours}h`);
     const measured = this.worktreePath && this.runExpectsCommits ? measureRunCommits(this.worktreePath, this.config.worktree.baseBranch, this.runBaselineSha) : "unknown";
     const hasCommits = measured === "unknown" ? undefined : measured === "committed";
     if (hasCommits === false && !this.noCommitNoticeSettled) {
@@ -12763,7 +12909,7 @@ class Worker {
       });
       commentId = res?.comment?.id ?? null;
     } catch (err) {
-      log34.warn(this.tag, `Failed to post the budget-pause comment: ${err}`);
+      log35.warn(this.tag, `Failed to post the budget-pause comment: ${err}`);
     }
     const cardCostCents = this.stateStore.getCardCostCents(card.id) + Math.max(0, this.runCostCents - this.chargedCents);
     const readout = [
@@ -12784,7 +12930,7 @@ class Worker {
         awaitingDecisionUntil: new Date(until).toISOString()
       });
     } catch (err) {
-      log34.warn(this.tag, `Failed to mark the session blocked: ${err}`);
+      log35.warn(this.tag, `Failed to mark the session blocked: ${err}`);
     }
     if (this.runId) {
       try {
@@ -12795,7 +12941,7 @@ class Worker {
           ...this.runLedger()
         });
       } catch (err) {
-        log34.error(this.tag, `#${card.short_id} parkRun failed after the blocker comment + blocked session were already written — the daemon has no local record of this park: ${err}`);
+        log35.error(this.tag, `#${card.short_id} parkRun failed after the blocker comment + blocked session were already written — the daemon has no local record of this park: ${err}`);
       }
     }
   }
@@ -12826,11 +12972,11 @@ class Worker {
     });
     const gate = normalizeGateSpec(ctx.stage.gate);
     const metricsPath = gate?.kind === "custom" ? writeMetricsFile(this.config.playbooks.metrics ?? {}) : null;
-    log34.info(this.tag, `Running stage "${ctx.stage.name}" (role ${ctx.role}) for #${card.short_id} under the harness motor`);
+    log35.info(this.tag, `Running stage "${ctx.stage.name}" (role ${ctx.role}) for #${card.short_id} under the harness motor`);
     const motorAbort = new AbortController;
     this.motorAbort = motorAbort;
     this.timeoutTimer = setTimeout(() => {
-      log34.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms) during the motor stage run, cancelling`);
+      log35.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms) during the motor stage run, cancelling`);
       this.timedOut = true;
       this.cancel("timeout");
     }, this.config.maxTimeout);
@@ -12841,12 +12987,12 @@ class Worker {
     let motorRunSettled = false;
     const onMotorLine = (line) => {
       if (line.type !== "agent_event") {
-        log34.info(this.tag, `motor: ${line.type}`);
+        log35.info(this.tag, `motor: ${line.type}`);
         return;
       }
       if (motorRunSettled)
         return;
-      log34.debug(this.tag, `motor: agent_event ${line.event.kind}`);
+      log35.debug(this.tag, `motor: agent_event ${line.event.kind}`);
       if (line.event.kind === "tool_started" && STAGE_DAEMON_OWNED_TOOLS.includes(line.event.payload.toolName)) {
         return;
       }
@@ -12866,7 +13012,7 @@ class Worker {
         currentTask: motorTask,
         progressPercent: MOTOR_RUN_PROGRESS_PERCENT
       }).catch((err) => {
-        log34.warn(this.tag, `motor session heartbeat failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log35.warn(this.tag, `motor session heartbeat failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       });
     }, MOTOR_SESSION_HEARTBEAT_MS);
     heartbeat.unref?.();
@@ -12940,7 +13086,7 @@ class Worker {
           break;
         case "reclaim_refused":
           this.held = true;
-          log34.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
+          log35.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
           break;
         case "advanced":
         case "completed_terminal":
@@ -12964,7 +13110,7 @@ class Worker {
           pushBranch3(this.branchName, worktreePath);
           pushed = true;
         } catch (err) {
-          log34.error(this.tag, `push after the motor stage "${ctx.stage.name}" failed for ${this.branchName}: ${err instanceof Error ? err.message : err}`);
+          log35.error(this.tag, `push after the motor stage "${ctx.stage.name}" failed for ${this.branchName}: ${err instanceof Error ? err.message : err}`);
         }
         if (pushed) {
           await recordBranchProvenance(this.client, card, this.branchName);
@@ -12976,7 +13122,7 @@ class Worker {
     if (completionColumn) {
       await transferCardToCompletion({ client: this.client, tag: this.tag }, card, completionColumn, this.onCardCompleted);
     } else {
-      log34.warn(this.tag, `completion.moveToColumn is empty — #${card.short_id} stays in its current column after the motor stage run`);
+      log35.warn(this.tag, `completion.moveToColumn is empty — #${card.short_id} stays in its current column after the motor stage run`);
     }
     await this.closeoutMotorWorktree(card);
   }
@@ -12987,7 +13133,7 @@ class Worker {
     try {
       await teardownWorktree2(this.client, card.id, worktreePath, this.branchName ?? undefined, this.sessionId);
     } catch {
-      log34.warn(this.tag, "Failed to cleanup worktree after the motor stage run");
+      log35.warn(this.tag, "Failed to cleanup worktree after the motor stage run");
     }
     this.worktreePath = null;
   }
@@ -13047,7 +13193,7 @@ ${prompt}`;
       });
       return handoff ? renderInheritedHandoffSection(handoff) : "";
     } catch (err) {
-      log34.warn(this.tag, `inherited-handoff fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `inherited-handoff fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
       return "";
     }
   }
@@ -13067,9 +13213,9 @@ ${prompt}`;
         commentType: "decision",
         agentSessionId: this.sessionId ?? undefined
       });
-      log34.info(this.tag, `Wrote stage handoff for #${card.short_id} (stage "${stage.name}")`);
+      log35.info(this.tag, `Wrote stage handoff for #${card.short_id} (stage "${stage.name}")`);
     } catch (err) {
-      log34.warn(this.tag, `stage-handoff write failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `stage-handoff write failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     }
   }
   async collectStageGateEvidence(card, stage, worktreePath, subtasks) {
@@ -13081,12 +13227,12 @@ ${prompt}`;
         return null;
       }
       if (gate.pendingEngine === true) {
-        log34.info(this.tag, `Stage "${stage.name}" gate "${gate.kind}" is advisory — skipping enforcement`);
+        log35.info(this.tag, `Stage "${stage.name}" gate "${gate.kind}" is advisory — skipping enforcement`);
         return null;
       }
       const review = gate.kind === "review_passed" ? parseReviewOutput(this.lastRunText) : undefined;
       if (review) {
-        log34.info(this.tag, `Review-gated stage "${stage.name}" verdict: ${review.verdict} (${review.findings.length} finding(s))`);
+        log35.info(this.tag, `Review-gated stage "${stage.name}" verdict: ${review.verdict} (${review.findings.length} finding(s))`);
       }
       const registry = buildGateCollectorRegistry2({
         build: {
@@ -13103,7 +13249,7 @@ ${prompt}`;
               return [];
             const criteria = await fetchAcceptanceCriteria(this.client, this.tag, card);
             if (criteria.length > 0) {
-              log34.info(this.tag, `Grading the artifact gate for #${card.short_id} against ${criteria.length} plan criteria instead of the stage's own rubric`);
+              log35.info(this.tag, `Grading the artifact gate for #${card.short_id} against ${criteria.length} plan criteria instead of the stage's own rubric`);
             }
             return criteria;
           })()
@@ -13125,10 +13271,10 @@ ${prompt}`;
       const evaluation = gateEvaluate(gate, evidence);
       const insert = toStageGateEvidenceInsert(context, evidence);
       await this.client.request("POST", `/cards/${encodeURIComponent(card.id)}/stage-gate-evidence`, insert);
-      log34.info(this.tag, `Recorded ${gate.kind} gate evidence for #${card.short_id} stage "${stage.name}": result=${evidence.result} passed=${evaluation.passed}`);
+      log35.info(this.tag, `Recorded ${gate.kind} gate evidence for #${card.short_id} stage "${stage.name}": result=${evidence.result} passed=${evaluation.passed}`);
       return evaluation;
     } catch (err) {
-      log34.warn(this.tag, `stage-gate evidence collection failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `stage-gate evidence collection failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       return null;
     }
   }
@@ -13146,7 +13292,7 @@ ${prompt}`;
         agentSessionId: this.sessionId
       });
     } catch (err) {
-      log34.warn(this.tag, `stage advancement failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `stage advancement failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       return { kind: "no_advance" };
     }
   }
@@ -13172,7 +13318,7 @@ ${prompt}`;
     this.modelChoice = choice;
     const { model, escalated, source } = choice;
     if (source !== "policy" || escalated) {
-      log34.info(this.tag, `Implement model "${model}" (source=${source}, escalated=${escalated}, attempts=${attempts}, priority=${card.priority ?? "none"}, tier=${this.sizing?.tier ?? "none"})`);
+      log35.info(this.tag, `Implement model "${model}" (source=${source}, escalated=${escalated}, attempts=${attempts}, priority=${card.priority ?? "none"}, tier=${this.sizing?.tier ?? "none"})`);
     }
     return model;
   }
@@ -13191,7 +13337,7 @@ ${prompt}`;
         encoding: "utf-8"
       }).trim();
     } catch (err) {
-      log34.warn(this.tag, `Sizing #${card.short_id} failed (spawn): could not resolve the repo root (${err instanceof Error ? err.message : String(err)}) — using the policy fallback`);
+      log35.warn(this.tag, `Sizing #${card.short_id} failed (spawn): could not resolve the repo root (${err instanceof Error ? err.message : String(err)}) — using the policy fallback`);
       return { status: "failed", reason: "spawn" };
     }
     const outcome = await sizeRun({
@@ -13205,9 +13351,9 @@ ${prompt}`;
       scoreBands: claude.scoreBands
     });
     if (outcome.status === "sized") {
-      log34.info(this.tag, `Sized #${card.short_id}: complexity ${outcome.sizing.complexity}/10 -> ${outcome.sizing.tier}`);
+      log35.info(this.tag, `Sized #${card.short_id}: complexity ${outcome.sizing.complexity}/10 -> ${outcome.sizing.tier}`);
     } else if (outcome.status === "failed") {
-      log34.warn(this.tag, `Sizing #${card.short_id} failed (${outcome.reason}) — using the policy fallback`);
+      log35.warn(this.tag, `Sizing #${card.short_id} failed (${outcome.reason}) — using the policy fallback`);
     }
     return outcome;
   }
@@ -13223,14 +13369,14 @@ ${prompt}`;
       ]);
       const outcome = decideJevSizing(response);
       if (outcome.status === "failed") {
-        log34.warn(this.tag, `Sizing #${card.short_id} failed (${outcome.reason}): the sizing route answered with no usable tier — using the policy fallback`);
+        log35.warn(this.tag, `Sizing #${card.short_id} failed (${outcome.reason}): the sizing route answered with no usable tier — using the policy fallback`);
         return outcome;
       }
-      log34.info(this.tag, `Sized #${card.short_id} with ${describeJevSizing(response, outcome.sizing.tier)}`);
+      log35.info(this.tag, `Sized #${card.short_id} with ${describeJevSizing(response, outcome.sizing.tier)}`);
       return outcome;
     } catch (err) {
       const reason = err instanceof JevSizingDeadline ? "timeout" : "spawn";
-      log34.warn(this.tag, `Sizing #${card.short_id} failed (${reason}): ${err instanceof Error ? err.message : String(err)} — using the policy fallback`);
+      log35.warn(this.tag, `Sizing #${card.short_id} failed (${reason}): ${err instanceof Error ? err.message : String(err)} — using the policy fallback`);
       return { status: "failed", reason };
     } finally {
       if (deadline)
@@ -13271,7 +13417,7 @@ ${prompt}`;
     const measured = measureRunCommits(this.worktreePath, this.config.worktree.baseBranch, this.runBaselineSha);
     if (measured !== "none") {
       if (measured === "unknown") {
-        log34.debug(this.tag, `no-commit check could not attribute this run's commits — staying quiet on ${this.branchName ?? "this branch"}`);
+        log35.debug(this.tag, `no-commit check could not attribute this run's commits — staying quiet on ${this.branchName ?? "this branch"}`);
       }
       return;
     }
@@ -13280,7 +13426,7 @@ ${prompt}`;
   recordNoCommitsYet(trigger, numTurns) {
     const turnBudget = this.effectiveMaxTurns;
     const threshold = noCommitNoticeThreshold(turnBudget);
-    log34.warn(this.tag, `No commits yet on ${this.branchName ?? "this run's branch"} — ${this.runToolCalls} tool calls into a ${turnBudget}-turn budget (${trigger})`);
+    log35.warn(this.tag, `No commits yet on ${this.branchName ?? "this run's branch"} — ${this.runToolCalls} tool calls into a ${turnBudget}-turn budget (${trigger})`);
     this.cliRunner?.record({
       kind: "no_commits_yet",
       source: "system",
@@ -13334,9 +13480,9 @@ ${prompt}`;
               agentSessionId: this.sessionId ?? undefined
             });
             giveUpCommentId = res?.comment?.id ?? null;
-            log34.warn(this.tag, `gave up on ${cardId} after ${attempts} attempts`);
+            log35.warn(this.tag, `gave up on ${cardId} after ${attempts} attempts`);
           } catch (err) {
-            log34.warn(this.tag, `failed to post give-up comment for ${cardId}: ${err instanceof Error ? err.message : err}`);
+            log35.warn(this.tag, `failed to post give-up comment for ${cardId}: ${err instanceof Error ? err.message : err}`);
           }
           if (this.config.budget.pause.enabled) {
             const waitHours = this.config.budget.pause.waitHours;
@@ -13350,7 +13496,7 @@ ${prompt}`;
                 awaitingDecisionUntil: new Date(until).toISOString()
               });
             } catch (err) {
-              log34.warn(this.tag, `Failed to mark the attempt cap pending for ${cardId}: ${err}`);
+              log35.warn(this.tag, `Failed to mark the attempt cap pending for ${cardId}: ${err}`);
             }
             try {
               await this.stateStore.markAwaitingDecision(cardId, {
@@ -13359,19 +13505,19 @@ ${prompt}`;
                 agentIdentifier: this.sessionIdentifier
               });
             } catch (err) {
-              log34.warn(this.tag, `Failed to record the attempt-cap decision locally for ${cardId}: ${err}`);
+              log35.warn(this.tag, `Failed to record the attempt-cap decision locally for ${cardId}: ${err}`);
             }
           }
         }
       }
     } catch (err) {
-      log34.warn(this.tag, `recordOutcome(${outcome}) failed: ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `recordOutcome(${outcome}) failed: ${err instanceof Error ? err.message : err}`);
     }
   }
   async pause() {
     if (!this.isActive || !this.process || this.process.killed)
       return;
-    log34.info(this.tag, `Pausing work on ${this.cardId}`);
+    log35.info(this.tag, `Pausing work on ${this.cardId}`);
     signalGroup2(this.process, "SIGSTOP");
     if (this.timeoutTimer) {
       clearTimeout(this.timeoutTimer);
@@ -13385,17 +13531,17 @@ ${prompt}`;
           status: "paused"
         });
       } catch {
-        log34.warn(this.tag, "Failed to update agent session to paused");
+        log35.warn(this.tag, "Failed to update agent session to paused");
       }
     }
   }
   async resume() {
     if (!this.isActive || !this.process || this.process.killed)
       return;
-    log34.info(this.tag, `Resuming work on ${this.cardId}`);
+    log35.info(this.tag, `Resuming work on ${this.cardId}`);
     signalGroup2(this.process, "SIGCONT");
     this.timeoutTimer = setTimeout(() => {
-      log34.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms), cancelling`);
+      log35.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms), cancelling`);
       this.timedOut = true;
       this.cancel("timeout");
     }, this.config.maxTimeout);
@@ -13407,7 +13553,7 @@ ${prompt}`;
           status: "working"
         });
       } catch {
-        log34.warn(this.tag, "Failed to update agent session to working");
+        log35.warn(this.tag, "Failed to update agent session to working");
       }
     }
   }
@@ -13416,7 +13562,7 @@ ${prompt}`;
       return;
     this.aborted = true;
     this.state = "cancelling";
-    log34.info(this.tag, `Cancelling work on ${this.cardId}`);
+    log35.info(this.tag, `Cancelling work on ${this.cardId}`);
     this.motorAbort?.abort();
     if (this.sdkRunner) {
       await this.sdkRunner.stop(this.timedOut ? "timeout" : "user_requested");
@@ -13434,14 +13580,14 @@ ${prompt}`;
           ...buildTokenPayload(stats)
         });
       } catch (err) {
-        log34.warn(this.tag, `endAgentSession after cancel failed: ${err instanceof Error ? err.message : err}`);
+        log35.warn(this.tag, `endAgentSession after cancel failed: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
   async runPlanningPhase(enriched) {
     const planning = this.config.planning;
     const { card } = enriched;
-    log34.info(this.tag, `Planning pass for #${card.short_id} (mode=${planning.mode}, model=${planning.model})`);
+    log35.info(this.tag, `Planning pass for #${card.short_id} (mode=${planning.mode}, model=${planning.model})`);
     await this.client.updateAgentProgress(card.id, {
       agentIdentifier: this.sessionIdentifier,
       agentName: AGENT_NAME,
@@ -13454,7 +13600,7 @@ ${prompt}`;
     let planTimedOut = false;
     const planTimeout = setTimeout(() => {
       planTimedOut = true;
-      log34.warn(this.tag, "Planning pass exceeded timeout — abandoning, implementing directly");
+      log35.warn(this.tag, "Planning pass exceeded timeout — abandoning, implementing directly");
       if (this.sdkRunner) {
         this.sdkRunner.stop("timeout").catch(() => {});
       } else if (this.process && !this.process.killed) {
@@ -13472,7 +13618,7 @@ ${prompt}`;
         initialPhase: "planning"
       });
     } catch (err) {
-      log34.warn(this.tag, `Planning pass failed (non-fatal): ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `Planning pass failed (non-fatal): ${err instanceof Error ? err.message : err}`);
       return false;
     } finally {
       clearTimeout(planTimeout);
@@ -13483,7 +13629,7 @@ ${prompt}`;
     await this.chargeDailyLedger(card.id, card.short_id);
     const planText = stats?.lastAssistantText ?? "";
     if (!planText.trim()) {
-      log34.warn(this.tag, `Planning pass for #${card.short_id} produced no text — implementing directly`);
+      log35.warn(this.tag, `Planning pass for #${card.short_id} produced no text — implementing directly`);
       return false;
     }
     const artifact = extractPlanArtifact(planText, card.title);
@@ -13504,9 +13650,9 @@ ${prompt}`;
         });
         planId = createdId;
       }
-      log34.info(this.tag, `Stored plan ${planId ?? "(unlinked)"} for #${card.short_id} (${artifact.tasks.length} tasks)`);
+      log35.info(this.tag, `Stored plan ${planId ?? "(unlinked)"} for #${card.short_id} (${artifact.tasks.length} tasks)`);
     } catch (err) {
-      log34.warn(this.tag, `Failed to store/link plan (non-fatal): ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `Failed to store/link plan (non-fatal): ${err instanceof Error ? err.message : err}`);
     }
     if (planning.mode === "gated" && planId) {
       try {
@@ -13525,11 +13671,11 @@ ${prompt}`;
             ...buildTokenPayload(stats)
           }
         }, { store: this.stateStore, runId: this.runId ?? undefined });
-        log34.info(this.tag, `#${card.short_id} parked in "${planning.awaitingApprovalColumn}" for plan approval`);
+        log35.info(this.tag, `#${card.short_id} parked in "${planning.awaitingApprovalColumn}" for plan approval`);
         this.lastSessionStats = undefined;
         return true;
       } catch (err) {
-        log34.warn(this.tag, `Gated park failed for #${card.short_id} (non-fatal, implementing directly): ${err instanceof TransitionError ? err.detail : err instanceof Error ? err.message : err}`);
+        log35.warn(this.tag, `Gated park failed for #${card.short_id} (non-fatal, implementing directly): ${err instanceof TransitionError ? err.detail : err instanceof Error ? err.message : err}`);
       }
     }
     if (planId && planning.postComment) {
@@ -13539,7 +13685,7 @@ ${prompt}`;
           agentSessionId: this.sessionId ?? undefined
         });
       } catch (err) {
-        log34.warn(this.tag, `Failed to post advisory plan comment (non-fatal): ${err instanceof Error ? err.message : err}`);
+        log35.warn(this.tag, `Failed to post advisory plan comment (non-fatal): ${err instanceof Error ? err.message : err}`);
       }
     }
     return false;
@@ -13549,10 +13695,10 @@ ${prompt}`;
     const { card } = enriched;
     const existing = await this.loadPinnedContract(card.id);
     if (existing) {
-      log34.info(this.tag, `Contract already pinned for #${card.short_id} (${existing.assertions.length} assertions) — reusing`);
+      log35.info(this.tag, `Contract already pinned for #${card.short_id} (${existing.assertions.length} assertions) — reusing`);
       return;
     }
-    log34.info(this.tag, `Contract pass for #${card.short_id} (model=${contractCfg.model})`);
+    log35.info(this.tag, `Contract pass for #${card.short_id} (model=${contractCfg.model})`);
     await this.client.updateAgentProgress(card.id, {
       agentIdentifier: this.sessionIdentifier,
       agentName: AGENT_NAME,
@@ -13565,7 +13711,7 @@ ${prompt}`;
     let contractTimedOut = false;
     const contractTimeout = setTimeout(() => {
       contractTimedOut = true;
-      log34.warn(this.tag, "Contract pass exceeded timeout — abandoning, implementing directly");
+      log35.warn(this.tag, "Contract pass exceeded timeout — abandoning, implementing directly");
       if (this.sdkRunner) {
         this.sdkRunner.stop("timeout").catch(() => {});
       } else if (this.process && !this.process.killed) {
@@ -13583,7 +13729,7 @@ ${prompt}`;
         initialPhase: "planning"
       });
     } catch (err) {
-      log34.warn(this.tag, `Contract pass failed (non-fatal): ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `Contract pass failed (non-fatal): ${err instanceof Error ? err.message : err}`);
       return;
     } finally {
       clearTimeout(contractTimeout);
@@ -13594,12 +13740,12 @@ ${prompt}`;
     await this.chargeDailyLedger(card.id, card.short_id);
     const contractText = stats?.lastAssistantText ?? "";
     if (!contractText.trim()) {
-      log34.warn(this.tag, `Contract pass for #${card.short_id} produced no text — implementing directly`);
+      log35.warn(this.tag, `Contract pass for #${card.short_id} produced no text — implementing directly`);
       return;
     }
     const contract = extractContract(contractText, card);
     if (contract.assertions.length < contractCfg.minAssertions) {
-      log34.warn(this.tag, `Contract for #${card.short_id} had ${contract.assertions.length} assertion(s) (< ${contractCfg.minAssertions}) — not pinning, implementing directly`);
+      log35.warn(this.tag, `Contract for #${card.short_id} had ${contract.assertions.length} assertion(s) (< ${contractCfg.minAssertions}) — not pinning, implementing directly`);
       return;
     }
     try {
@@ -13607,9 +13753,9 @@ ${prompt}`;
         commentType: "decision",
         agentSessionId: this.sessionId ?? undefined
       });
-      log34.info(this.tag, `Pinned acceptance contract for #${card.short_id} (${contract.assertions.length} assertions)`);
+      log35.info(this.tag, `Pinned acceptance contract for #${card.short_id} (${contract.assertions.length} assertions)`);
     } catch (err) {
-      log34.warn(this.tag, `Failed to pin contract (non-fatal): ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `Failed to pin contract (non-fatal): ${err instanceof Error ? err.message : err}`);
     }
   }
   async loadPinnedContract(cardId) {
@@ -13619,7 +13765,7 @@ ${prompt}`;
         return null;
       return extractPinnedContract(comments, this.identity);
     } catch (err) {
-      log34.warn(this.tag, `pinned-contract fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+      log35.warn(this.tag, `pinned-contract fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
       return null;
     }
   }
@@ -13632,13 +13778,13 @@ ${prompt}`;
         const res = await this.client.getPendingUserMessages(this.cardId, this.sessionId, this.lastDrainedSeq);
         messages = res.messages ?? [];
       } catch (err) {
-        log34.warn(this.tag, `Failed to fetch steering messages (non-fatal): ${err instanceof Error ? err.message : err}`);
+        log35.warn(this.tag, `Failed to fetch steering messages (non-fatal): ${err instanceof Error ? err.message : err}`);
         return;
       }
       if (messages.length === 0)
         return;
       this.lastDrainedSeq = Math.max(this.lastDrainedSeq, ...messages.map((m) => m.seq));
-      log34.info(this.tag, `Steering #${card.short_id}: resuming with ${messages.length} queued message(s)`);
+      log35.info(this.tag, `Steering #${card.short_id}: resuming with ${messages.length} queued message(s)`);
       this.state = "running";
       await this.recordPhase("running");
       try {
@@ -13650,7 +13796,7 @@ ${prompt}`;
           ...this.activeRunSpawnOpts ?? {}
         });
       } catch (err) {
-        log34.warn(this.tag, `Steering resume failed (non-fatal): ${err instanceof Error ? err.message : err}`);
+        log35.warn(this.tag, `Steering resume failed (non-fatal): ${err instanceof Error ? err.message : err}`);
         return;
       }
     }
@@ -13685,10 +13831,10 @@ ${prompt}`;
         "--",
         prompt
       ];
-      log34.info(this.tag, `Spawning: claude ${args.slice(0, 4).join(" ")} ...`);
+      log35.info(this.tag, `Spawning: claude ${args.slice(0, 4).join(" ")} ...`);
       const runLog = openRunLog(this.tag, this.runId, card.short_id);
       if (runLog) {
-        log34.info(this.tag, `Run log: ${runLog.path}`);
+        log35.info(this.tag, `Run log: ${runLog.path}`);
         runLog.stream.write(`# run=${this.runId} card=#${card.short_id} started=${new Date().toISOString()}
 ` + `# args: ${args.slice(0, -2).join(" ")} -- <prompt:${prompt.length} chars>
 
@@ -13725,7 +13871,7 @@ ${prompt}`;
         });
       }
       parser.on("parse_error", (msg) => {
-        log34.debug(this.tag, `Stream parse error (non-fatal): ${msg}`);
+        log35.debug(this.tag, `Stream parse error (non-fatal): ${msg}`);
         runLog?.stream.write(`
 [parse_error] ${msg}
 `);
@@ -13798,10 +13944,10 @@ ${prompt}`;
     const disallowedTools = opts.disallowedTools ? opts.disallowedTools.split(",").map((t) => t.trim()).filter(Boolean) : undefined;
     const initialPhase = opts.initialPhase ?? "exploring";
     const maxBudgetUsd = this.effectiveMaxBudgetUsd;
-    log34.info(this.tag, `Spawning Agent SDK runner (model=${model}, maxBudgetUsd=${maxBudgetUsd || "off"}, maxTurns=${maxTurns}${opts.resumeSessionId ? ", resume" : ""})`);
+    log35.info(this.tag, `Spawning Agent SDK runner (model=${model}, maxBudgetUsd=${maxBudgetUsd || "off"}, maxTurns=${maxTurns}${opts.resumeSessionId ? ", resume" : ""})`);
     const runLog = openRunLog(this.tag, this.runId, card.short_id);
     if (runLog) {
-      log34.info(this.tag, `Run log: ${runLog.path}`);
+      log35.info(this.tag, `Run log: ${runLog.path}`);
       runLog.stream.write(`# run=${this.runId} card=#${card.short_id} runner=sdk started=${new Date().toISOString()}
 ` + `# model=${model} maxTurns=${maxTurns} <prompt:${prompt.length} chars>
 
@@ -13936,7 +14082,7 @@ ${prompt}`;
       try {
         await teardownWorktree2(this.client, this.cardId, this.worktreePath, this.branchName ?? undefined, this.sessionId);
       } catch {
-        log34.warn(this.tag, "Failed to cleanup worktree");
+        log35.warn(this.tag, "Failed to cleanup worktree");
       }
     }
     this.process = null;
@@ -13955,7 +14101,7 @@ ${prompt}`;
     this.chargedTokens = emptyTokens();
   }
 }
-var TAG31 = "worker", CANCEL_SIGINT_TIMEOUT2 = 30000, CANCEL_SIGTERM_TIMEOUT2 = 1e4, MOTOR_SESSION_HEARTBEAT_MS = 60000, MOTOR_RUN_PROGRESS_PERCENT = 10, STEERING_MAX_TURNS = 15, MAX_STEERING_ITERATIONS = 10, PLAN_ALLOWED_TOOLS = "Read,Grep,Glob,mcp__harmony__*", IMPLEMENT_ALLOWED_TOOLS = "Bash,Read,Write,Edit,Glob,Grep,Agent,mcp__harmony__*", PLAN_PHASE_TIMEOUT, MAX_STAGE_NAME_CHARS = 80, MAX_HANDOFF_CHARS = 400;
+var TAG32 = "worker", CANCEL_SIGINT_TIMEOUT2 = 30000, CANCEL_SIGTERM_TIMEOUT2 = 1e4, MOTOR_SESSION_HEARTBEAT_MS = 60000, MOTOR_RUN_PROGRESS_PERCENT = 10, STEERING_MAX_TURNS = 15, MAX_STEERING_ITERATIONS = 10, PLAN_ALLOWED_TOOLS = "Read,Grep,Glob,mcp__harmony__*", IMPLEMENT_ALLOWED_TOOLS = "Bash,Read,Write,Edit,Glob,Grep,Agent,mcp__harmony__*", PLAN_PHASE_TIMEOUT, MAX_STAGE_NAME_CHARS = 80, MAX_HANDOFF_CHARS = 400;
 var init_worker = __esm(() => {
   init_src();
   init_board_helpers();
@@ -13987,7 +14133,7 @@ var init_worker = __esm(() => {
 });
 
 // src/workspace-model-cache.ts
-import { log as log35 } from "@gethmy/harness";
+import { log as log36 } from "@gethmy/harness";
 
 class WorkspaceModelCache {
   fetcher;
@@ -14022,7 +14168,7 @@ class WorkspaceModelCache {
       this.stale = false;
     } catch (err) {
       this.stale = true;
-      log35.warn("config", `Could not refresh a pickup-cached value, using ${this.everFetched ? "the last known value" : "local config only"}: ${err instanceof Error ? err.message : String(err)}`);
+      log36.warn("config", `Could not refresh a pickup-cached value, using ${this.everFetched ? "the last known value" : "local config only"}: ${err instanceof Error ? err.message : String(err)}`);
     }
     return this.value;
   }
@@ -14033,7 +14179,7 @@ var init_workspace_model_cache = () => {};
 import {
   cooldownMsFor,
   describeApiError as describeApiError3,
-  log as log36
+  log as log37
 } from "@gethmy/harness";
 function httpStatusOf(err) {
   if (typeof err !== "object" || err === null)
@@ -14126,11 +14272,11 @@ class Pool {
   }
   async enqueue(card, column, labels, subtasks, mode = "implement") {
     if (card.done || card.archived_at) {
-      log36.debug(TAG32, `#${card.short_id} skipped — ${card.done ? "done" : "archived"} (finished work is never enqueued, #1102)`);
+      log37.debug(TAG33, `#${card.short_id} skipped — ${card.done ? "done" : "archived"} (finished work is never enqueued, #1102)`);
       return;
     }
     if (this.isCardKnown(card.id) || this.reservations.has(card.id)) {
-      log36.debug(TAG32, `Card ${card.id} already queued, active, or reserved, skipping`);
+      log37.debug(TAG33, `Card ${card.id} already queued, active, or reserved, skipping`);
       return;
     }
     this.reservations.add(card.id);
@@ -14138,25 +14284,25 @@ class Pool {
     try {
       const account = this.accountGuard?.check();
       if (account && !account.running) {
-        log36.debug(TAG32, `#${card.short_id} held — ${account.detail}`);
+        log37.debug(TAG33, `#${card.short_id} held — ${account.detail}`);
         await this.emitWaiting(card.id, account.detail);
         return;
       }
       if (mode === "implement") {
         if (this.authPaused) {
-          log36.debug(TAG32, `#${card.short_id} held — agent paused (auth error)`);
+          log37.debug(TAG33, `#${card.short_id} held — agent paused (auth error)`);
           await this.emitWaiting(card.id, "Agent paused — Anthropic auth error, check API credentials");
           return;
         }
         const cooldownMs = this.apiCooldownRemainingMs();
         if (cooldownMs > 0) {
-          log36.debug(TAG32, `#${card.short_id} held — API cooldown ${Math.round(cooldownMs / 1000)}s remaining`);
+          log37.debug(TAG33, `#${card.short_id} held — API cooldown ${Math.round(cooldownMs / 1000)}s remaining`);
           await this.emitWaiting(card.id, `Paused — Anthropic API limit, retrying in ~${Math.round(cooldownMs / 1000)}s`);
           return;
         }
         const stageHold = classifyStageHold(card, this.stateStore.getStageHold(card.id), Date.now());
         if (stageHold.kind === "holding") {
-          log36.debug(TAG32, `#${card.short_id} held — ${stageHold.detail}`);
+          log37.debug(TAG33, `#${card.short_id} held — ${stageHold.detail}`);
           return;
         }
         if (stageHold.kind === "stale") {
@@ -14167,19 +14313,19 @@ class Pool {
           if (decision.reason === "daily_budget") {
             await this.denyDailyBudget(card, decision.detail);
           } else {
-            log36.debug(TAG32, `#${card.short_id} skipped (${decision.reason}): ${decision.detail}`);
+            log37.debug(TAG33, `#${card.short_id} skipped (${decision.reason}): ${decision.detail}`);
           }
           return;
         }
         const { blockers, successors } = await getChainSignals(this.client, card, this.projectId);
         chainSuccessors = successors;
         if (blockers === null) {
-          log36.warn(TAG32, `#${card.short_id} blocker check failed — deferring to next tick`);
+          log37.warn(TAG33, `#${card.short_id} blocker check failed — deferring to next tick`);
           return;
         }
         if (blockers.length > 0) {
           const list = blockers.map((b) => `#${b.shortId}`).join(", ");
-          log36.info(TAG32, `#${card.short_id} blocked by ${list} — waiting`);
+          log37.info(TAG33, `#${card.short_id} blocked by ${list} — waiting`);
           await this.emitWaiting(card.id, `Blocked by ${list} — waiting for chain`);
           return;
         }
@@ -14211,9 +14357,9 @@ class Pool {
     const reason = `Daily budget reached — waiting for reset (${detail})`;
     const line = `#${card.short_id} skipped (daily_budget): ${detail}`;
     if (this.lastWaitingEmit.get(card.id) === reason)
-      log36.debug(TAG32, line);
+      log37.debug(TAG33, line);
     else
-      log36.warn(TAG32, line);
+      log37.warn(TAG33, line);
     await this.emitWaiting(card.id, reason);
   }
   lastWaitingEmit = new Map;
@@ -14230,7 +14376,7 @@ class Pool {
       });
       this.lastWaitingEmit.set(cardId, currentTask);
     } catch (err) {
-      log36.debug(TAG32, `waiting emit failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+      log37.debug(TAG33, `waiting emit failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     }
   }
   noteApiError(err) {
@@ -14238,13 +14384,13 @@ class Pool {
       return;
     if (err.kind === "spend_limit") {
       this.accountGuard?.halt("spend_limit").catch((hErr) => {
-        log36.error(TAG32, `Failed to latch the account halt: ${hErr}`);
+        log37.error(TAG33, `Failed to latch the account halt: ${hErr}`);
       });
       return;
     }
     if (err.kind === "auth") {
       if (!this.authPaused) {
-        log36.error(TAG32, "Auth error from Claude CLI — pausing implement pickups until the daemon is restarted with valid credentials");
+        log37.error(TAG33, "Auth error from Claude CLI — pausing implement pickups until the daemon is restarted with valid credentials");
       }
       this.authPaused = true;
       return;
@@ -14253,7 +14399,7 @@ class Pool {
     const until = Date.now() + cooldownMs;
     if (until > this.apiCooldownUntil) {
       this.apiCooldownUntil = until;
-      log36.warn(TAG32, `${describeApiError3(err.kind)} — pausing implement pickups for ${Math.round(cooldownMs / 1000)}s`);
+      log37.warn(TAG33, `${describeApiError3(err.kind)} — pausing implement pickups for ${Math.round(cooldownMs / 1000)}s`);
     }
   }
   apiCooldownRemainingMs() {
@@ -14267,13 +14413,13 @@ class Pool {
       const removed = queue.remove(cardId);
       if (removed) {
         this.cardDataCache.delete(cardId);
-        log36.info(TAG32, `Removed #${removed.shortId} from ${removed.mode} queue`);
+        log37.info(TAG33, `Removed #${removed.shortId} from ${removed.mode} queue`);
         return;
       }
     }
     const worker = this.implWorkers.find((w) => w.cardId === cardId) ?? this.reviewWorkers.find((w) => w.cardId === cardId);
     if (worker) {
-      log36.info(TAG32, `Cancelling worker ${worker.id} for card ${cardId}`);
+      log37.info(TAG33, `Cancelling worker ${worker.id} for card ${cardId}`);
       await worker.cancel("unassigned");
     }
   }
@@ -14330,10 +14476,10 @@ class Pool {
     }
     const worker = this.implWorkers.find((w) => w.cardId === cardId && w.isActive) ?? this.reviewWorkers.find((w) => w.cardId === cardId && w.isActive);
     if (!worker) {
-      log36.debug(TAG32, `No active worker for card ${cardId}, ignoring ${command}`);
+      log37.debug(TAG33, `No active worker for card ${cardId}, ignoring ${command}`);
       return;
     }
-    log36.info(TAG32, `Agent command: ${command} → worker ${worker.id} (card ${cardId})`);
+    log37.info(TAG33, `Agent command: ${command} → worker ${worker.id} (card ${cardId})`);
     switch (command) {
       case "pause":
         await worker.pause();
@@ -14381,7 +14527,7 @@ class Pool {
     };
   }
   async shutdown() {
-    log36.info(TAG32, "Shutting down pool...");
+    log37.info(TAG33, "Shutting down pool...");
     this.shuttingDown = true;
     const active = [
       ...this.implWorkers.filter((w) => w.isActive),
@@ -14389,7 +14535,7 @@ class Pool {
     ];
     await Promise.all(active.map((w) => w.cancel("shutdown")));
     this.sleepGuard.stop();
-    log36.info(TAG32, "Pool shutdown complete");
+    log37.info(TAG33, "Pool shutdown complete");
   }
   async drainBudgetDecisions(cardId) {
     const targets = cardId ? [cardId] : [
@@ -14424,7 +14570,7 @@ class Pool {
           await this.forgetDeletedCard(cardId, run);
           return;
         }
-        log36.warn(TAG32, `getBudgetDecisions failed for ${cardId}: ${err}`);
+        log37.warn(TAG33, `getBudgetDecisions failed for ${cardId}: ${err}`);
         return;
       }
       if (decisions.length > 0) {
@@ -14455,16 +14601,16 @@ class Pool {
           errorMessage: "card deleted"
         });
       } catch (err) {
-        log36.warn(TAG32, `Failed to end the parked run for the deleted card ${cardId}: ${err}`);
+        log37.warn(TAG33, `Failed to end the parked run for the deleted card ${cardId}: ${err}`);
       }
     }
     try {
       const dropped = await this.stateStore.forgetCard(cardId);
       if (dropped) {
-        log36.info(TAG32, `Card ${cardId} no longer exists on the server — dropped from the local ledger; its budget question can never be answered`);
+        log37.info(TAG33, `Card ${cardId} no longer exists on the server — dropped from the local ledger; its budget question can never be answered`);
       }
     } catch (err) {
-      log36.warn(TAG32, `Failed to drop the deleted card ${cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to drop the deleted card ${cardId}: ${err}`);
     }
   }
   async releaseExpiredPark(run) {
@@ -14478,7 +14624,7 @@ class Pool {
         ...run.blockerCommentId ? { replyToId: run.blockerCommentId } : {}
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to post the expired-park closing comment for ${run.cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to post the expired-park closing comment for ${run.cardId}: ${err}`);
     }
     try {
       const { verdict, card } = await guardedHandback(this.client, run.cardId, {
@@ -14492,14 +14638,14 @@ class Pool {
         });
       }
     } catch (err) {
-      log36.error(TAG32, `Failed to move #${run.cardShortId} after an expired park: ${err}`);
+      log37.error(TAG33, `Failed to move #${run.cardShortId} after an expired park: ${err}`);
     }
     try {
       await this.stateStore.endRun(run.runId, "failed", {
         errorMessage: "budget decision expired"
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to release the expired park for ${run.cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to release the expired park for ${run.cardId}: ${err}`);
     }
   }
   async releaseExpiredAttemptCap(cardId, blockerCommentId) {
@@ -14509,7 +14655,7 @@ class Pool {
         ...blockerCommentId ? { replyToId: blockerCommentId } : {}
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to post the expired attempt-cap note for ${cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to post the expired attempt-cap note for ${cardId}: ${err}`);
     }
     try {
       await this.client.endAgentSession(cardId, {
@@ -14518,7 +14664,7 @@ class Pool {
         failureSummary: "The attempt-budget decision expired with no answer. Reassign the card to grant a fresh attempt."
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to end the expired attempt-cap session for ${cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to end the expired attempt-cap session for ${cardId}: ${err}`);
     }
     await this.stateStore.clearAwaitingDecision(cardId);
   }
@@ -14529,16 +14675,16 @@ class Pool {
     }
     const account = this.accountGuard?.check();
     if (account && !account.running) {
-      log36.debug(TAG32, `#${run.cardShortId}: granted continue held — ${account.detail}`);
+      log37.debug(TAG33, `#${run.cardShortId}: granted continue held — ${account.detail}`);
       return;
     }
     const first = !this.adoptAnnounced.has(run.runId);
     this.adoptAnnounced.add(run.runId);
     const line = `#${run.cardShortId}: granted continue never reached a worker — re-enqueueing (${run.pipeline})`;
     if (first)
-      log36.warn(TAG32, line);
+      log37.warn(TAG33, line);
     else
-      log36.debug(TAG32, line);
+      log37.debug(TAG33, line);
     await this.enqueueCard(run.cardId, run.pipeline);
   }
   adoptAnnounced = new Set;
@@ -14557,7 +14703,7 @@ class Pool {
   async continueRun(run, opts) {
     const turns = this.budget.checkCardTurns(run.cardId);
     if (!turns.allow) {
-      log36.warn(TAG32, `Refusing a Continue on ${run.cardId} — ${turns.detail}. Handing the card back: reassign it to clear the count, or raise budget.maxTurnsPerCard.`);
+      log37.warn(TAG33, `Refusing a Continue on ${run.cardId} — ${turns.detail}. Handing the card back: reassign it to clear the count, or raise budget.maxTurnsPerCard.`);
       try {
         await this.client.addComment(run.cardId, `**That Continue cannot be granted.** ${turns.detail}, which is this card's ceiling (\`budget.maxTurnsPerCard\`), so the implement pipeline would refuse it again the moment it was dispatched.
 
@@ -14566,14 +14712,14 @@ I am handing the card back rather than holding it parked. Reassign it — that c
           agentSessionId: run.sessionId ?? undefined
         });
       } catch (err) {
-        log36.warn(TAG32, `Could not explain the refused Continue on ${run.cardId}: ${err instanceof Error ? err.message : err}`);
+        log37.warn(TAG33, `Could not explain the refused Continue on ${run.cardId}: ${err instanceof Error ? err.message : err}`);
       }
       await this.stopRun(run, "Continue refused: the card is at its per-card turn cap.");
       return;
     }
     const runsSpent = this.budget.checkCardRuns(run.cardId);
     if (!runsSpent.allow) {
-      log36.warn(TAG32, `Refusing a Continue on ${run.cardId} — ${runsSpent.detail}. Handing the card back: reassign it to clear the count, or raise budget.maxRunsPerCard.`);
+      log37.warn(TAG33, `Refusing a Continue on ${run.cardId} — ${runsSpent.detail}. Handing the card back: reassign it to clear the count, or raise budget.maxRunsPerCard.`);
       try {
         await this.client.addComment(run.cardId, `**That Continue cannot be granted.** ${runsSpent.detail}, which is this card's run backstop (\`budget.maxRunsPerCard\`), so the implement pipeline would refuse it again the moment it was dispatched.
 
@@ -14582,7 +14728,7 @@ I am handing the card back rather than holding it parked. Reassign it — that c
           agentSessionId: run.sessionId ?? undefined
         });
       } catch (err) {
-        log36.warn(TAG32, `Could not explain the refused Continue on ${run.cardId}: ${err instanceof Error ? err.message : err}`);
+        log37.warn(TAG33, `Could not explain the refused Continue on ${run.cardId}: ${err instanceof Error ? err.message : err}`);
       }
       await this.stopRun(run, "Continue refused: the card is at its per-card run backstop.");
       return;
@@ -14606,7 +14752,7 @@ I am handing the card back rather than holding it parked. Reassign it — that c
         awaitingDecisionUntil: null
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to clear the decision deadline for ${run.cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to clear the decision deadline for ${run.cardId}: ${err}`);
     }
     if (run.blockerCommentId) {
       try {
@@ -14614,7 +14760,7 @@ I am handing the card back rather than holding it parked. Reassign it — that c
           resolve: true
         });
       } catch (err) {
-        log36.warn(TAG32, `Failed to resolve the blocker comment: ${err}`);
+        log37.warn(TAG33, `Failed to resolve the blocker comment: ${err}`);
       }
     }
     await this.enqueueCard(run.cardId, run.pipeline);
@@ -14638,7 +14784,7 @@ I am handing the card back rather than holding it parked. Reassign it — that c
             awaitingDecisionUntil: null
           });
         } catch (err) {
-          log36.warn(TAG32, `Failed to clear the decision deadline for ${run.cardId}: ${err}`);
+          log37.warn(TAG33, `Failed to clear the decision deadline for ${run.cardId}: ${err}`);
         }
         if (run.blockerCommentId) {
           try {
@@ -14646,13 +14792,13 @@ I am handing the card back rather than holding it parked. Reassign it — that c
               resolve: true
             });
           } catch (err) {
-            log36.warn(TAG32, `Failed to resolve the blocker comment: ${err}`);
+            log37.warn(TAG33, `Failed to resolve the blocker comment: ${err}`);
           }
         }
         await this.enqueueCard(run.cardId, run.pipeline);
         released += 1;
       } catch (err) {
-        log36.error(TAG32, `Failed to release the account-limit park on ${run.cardId}: ${err}`);
+        log37.error(TAG33, `Failed to release the account-limit park on ${run.cardId}: ${err}`);
       }
     }
     return released;
@@ -14664,7 +14810,7 @@ I am handing the card back rather than holding it parked. Reassign it — that c
           resolve: true
         });
       } catch (err) {
-        log36.warn(TAG32, `Failed to resolve the blocker comment: ${err}`);
+        log37.warn(TAG33, `Failed to resolve the blocker comment: ${err}`);
       }
     }
     try {
@@ -14673,7 +14819,7 @@ I am handing the card back rather than holding it parked. Reassign it — that c
         awaitingDecisionUntil: null
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to clear the decision deadline for ${run.cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to clear the decision deadline for ${run.cardId}: ${err}`);
     }
     try {
       const { verdict, card } = await guardedHandback(this.client, run.cardId, {
@@ -14695,26 +14841,26 @@ I am handing the card back rather than holding it parked. Reassign it — that c
         await this.client.endAgentSession(run.cardId, endSession);
       }
     } catch (err) {
-      log36.error(TAG32, `Failed to hand #${run.cardShortId} back after a stop: ${err}`);
+      log37.error(TAG33, `Failed to hand #${run.cardShortId} back after a stop: ${err}`);
     }
     try {
       await this.stateStore.endRun(run.runId, "failed", {
         errorMessage: "budget_decision_stop"
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to end the local run record for ${run.cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to end the local run record for ${run.cardId}: ${err}`);
     }
   }
   async grantAttempt(cardId) {
     const turns = this.budget.checkCardTurns(cardId);
     if (!turns.allow) {
-      log36.warn(TAG32, `Attempt grant on ${cardId} cannot start a run — ${turns.detail}. Clearing the attempt budget anyway; reassign the card to clear the turn count, or raise budget.maxTurnsPerCard.`);
+      log37.warn(TAG33, `Attempt grant on ${cardId} cannot start a run — ${turns.detail}. Clearing the attempt budget anyway; reassign the card to clear the turn count, or raise budget.maxTurnsPerCard.`);
       try {
         await this.client.addComment(cardId, `**Attempt budget cleared, but this card is at its turn cap.** ${turns.detail}, which is its ceiling (\`budget.maxTurnsPerCard\`), so I will not pick it up even with attempts restored.
 
 Reassign the card — that clears the turn count and starts it fresh — or raise the cap in the daemon config.`, { commentType: "blocker" });
       } catch (err) {
-        log36.warn(TAG32, `Could not explain the capped attempt grant on ${cardId}: ${err instanceof Error ? err.message : err}`);
+        log37.warn(TAG33, `Could not explain the capped attempt grant on ${cardId}: ${err instanceof Error ? err.message : err}`);
       }
       await this.stateStore.resetAttempts(cardId, { clearTurns: false });
       await this.stopAttemptCap(cardId, "Attempt budget cleared, but the card is at its per-card turn cap.");
@@ -14722,13 +14868,13 @@ Reassign the card — that clears the turn count and starts it fresh — or rais
     }
     const runsSpent = this.budget.checkCardRuns(cardId);
     if (!runsSpent.allow) {
-      log36.warn(TAG32, `Attempt grant on ${cardId} cannot start a run — ${runsSpent.detail}. Clearing the attempt budget anyway; reassign the card to clear the run count, or raise budget.maxRunsPerCard.`);
+      log37.warn(TAG33, `Attempt grant on ${cardId} cannot start a run — ${runsSpent.detail}. Clearing the attempt budget anyway; reassign the card to clear the run count, or raise budget.maxRunsPerCard.`);
       try {
         await this.client.addComment(cardId, `**Attempt budget cleared, but this card is at its run backstop.** ${runsSpent.detail}, which is its ceiling (\`budget.maxRunsPerCard\`), so I will not pick it up even with attempts restored.
 
 Reassign the card — that clears the run count and starts it fresh — or raise the cap in the daemon config.`, { commentType: "blocker" });
       } catch (err) {
-        log36.warn(TAG32, `Could not explain the capped attempt grant on ${cardId}: ${err instanceof Error ? err.message : err}`);
+        log37.warn(TAG33, `Could not explain the capped attempt grant on ${cardId}: ${err instanceof Error ? err.message : err}`);
       }
       await this.stateStore.resetAttempts(cardId, { clearTurns: false });
       await this.stopAttemptCap(cardId, "Attempt budget cleared, but the card is at its per-card run backstop.");
@@ -14743,7 +14889,7 @@ Reassign the card — that clears the run count and starts it fresh — or raise
         awaitingDecisionUntil: null
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to clear the attempt-cap decision deadline for ${cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to clear the attempt-cap decision deadline for ${cardId}: ${err}`);
     }
     await this.enqueueCard(cardId, "implement");
   }
@@ -14754,7 +14900,7 @@ Reassign the card — that clears the run count and starts it fresh — or raise
       try {
         await this.client.updateComment(blockerCommentId, { resolve: true });
       } catch (err) {
-        log36.warn(TAG32, `Failed to resolve the blocker comment: ${err}`);
+        log37.warn(TAG33, `Failed to resolve the blocker comment: ${err}`);
       }
     }
     try {
@@ -14763,7 +14909,7 @@ Reassign the card — that clears the run count and starts it fresh — or raise
         awaitingDecisionUntil: null
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to clear the decision deadline for ${cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to clear the decision deadline for ${cardId}: ${err}`);
     }
     try {
       await this.client.endAgentSession(cardId, {
@@ -14772,7 +14918,7 @@ Reassign the card — that clears the run count and starts it fresh — or raise
         failureSummary
       });
     } catch (err) {
-      log36.warn(TAG32, `Failed to end the attempt-cap session for ${cardId}: ${err}`);
+      log37.warn(TAG33, `Failed to end the attempt-cap session for ${cardId}: ${err}`);
     }
     await this.stateStore.clearAwaitingDecision(cardId);
   }
@@ -14803,12 +14949,12 @@ Reassign the card — that clears the run count and starts it fresh — or raise
       const subtasks = card.subtasks ?? [];
       await this.enqueue(card, column, cardLabels, subtasks, mode);
     } catch (err) {
-      log36.error(TAG32, `Failed to re-enqueue ${cardId} after a budget decision: ${err}`);
+      log37.error(TAG33, `Failed to re-enqueue ${cardId} after a budget decision: ${err}`);
     }
   }
   async retireUnroutableRuns(shortId, cardId, reason = "column not found on this board") {
     const unended = this.stateStore.getRunsForCard(cardId).filter((r) => r.endedAt === null);
-    log36.warn(TAG32, `#${shortId}: ${reason} — retiring ${unended.length} run record(s) instead of re-enqueueing`);
+    log37.warn(TAG33, `#${shortId}: ${reason} — retiring ${unended.length} run record(s) instead of re-enqueueing`);
     for (const run of unended) {
       await this.stateStore.endRun(run.runId, "orphaned", {
         errorMessage: `${reason} at re-enqueue — retired as unroutable (#1057/#1102)`
@@ -14821,12 +14967,12 @@ Reassign the card — that clears the run count and starts it fresh — or raise
     if (this.shuttingDown)
       return false;
     if (this.accountGuard && !this.accountGuard.check().running) {
-      log36.debug(TAG32, `${label} dispatch held — the account is halted`);
+      log37.debug(TAG33, `${label} dispatch held — the account is halted`);
       return false;
     }
     const idle = workers.find((w) => w.isIdle);
     if (!idle) {
-      log36.debug(TAG32, `No idle ${label} workers (queue: ${queue.length})`);
+      log37.debug(TAG33, `No idle ${label} workers (queue: ${queue.length})`);
       return false;
     }
     const next = queue.dequeue();
@@ -14834,18 +14980,18 @@ Reassign the card — that clears the run count and starts it fresh — or raise
       return false;
     const data = this.cardDataCache.get(next.cardId);
     if (!data) {
-      log36.warn(TAG32, `No cached data for card ${next.cardId}, skipping`);
+      log37.warn(TAG33, `No cached data for card ${next.cardId}, skipping`);
       return false;
     }
     this.cardDataCache.delete(next.cardId);
     this.lastWaitingEmit.delete(next.cardId);
-    log36.info(TAG32, `Dispatching #${next.shortId} to ${label} worker ${idle.id}`);
+    log37.info(TAG33, `Dispatching #${next.shortId} to ${label} worker ${idle.id}`);
     this.sleepGuard.acquire();
     idle.run(data.card, data.column, data.labels, data.subtasks);
     return true;
   }
 }
-var TAG32 = "pool";
+var TAG33 = "pool";
 var init_pool = __esm(() => {
   init_src();
   init_board_helpers();
@@ -14880,7 +15026,7 @@ import {
   writeFileSync as writeFileSync4
 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
-import { log as log37 } from "@gethmy/harness";
+import { log as log38 } from "@gethmy/harness";
 function defaultRegistryPath() {
   return portRegistryPath();
 }
@@ -14895,7 +15041,7 @@ function load(path) {
     }
     return emptyRegistry();
   } catch (err) {
-    log37.warn(TAG33, `failed to read ${path}: ${err instanceof Error ? err.message : err}`);
+    log38.warn(TAG34, `failed to read ${path}: ${err instanceof Error ? err.message : err}`);
     return emptyRegistry();
   }
 }
@@ -14916,7 +15062,7 @@ function recordDaemonPort(projectId, entry, path = defaultRegistryPath()) {
     registry[projectId] = { ...entry, updatedAt: Date.now() };
     save(path, registry);
   } catch (err) {
-    log37.warn(TAG33, `failed to record port for ${projectId}: ${err instanceof Error ? err.message : err}`);
+    log38.warn(TAG34, `failed to record port for ${projectId}: ${err instanceof Error ? err.message : err}`);
   }
 }
 function daemonBaseUrl(bindAddr, port) {
@@ -14936,17 +15082,17 @@ function clearDaemonPort(projectId, pid, path = defaultRegistryPath()) {
     delete registry[projectId];
     save(path, registry);
   } catch (err) {
-    log37.warn(TAG33, `failed to clear port for ${projectId}: ${err instanceof Error ? err.message : err}`);
+    log38.warn(TAG34, `failed to clear port for ${projectId}: ${err instanceof Error ? err.message : err}`);
   }
 }
-var TAG33 = "port-registry";
+var TAG34 = "port-registry";
 var init_port_registry = __esm(() => {
   init_src();
   init_paths();
 });
 
 // src/recovery.ts
-import { log as log38, teardownWorktree as teardownWorktree3 } from "@gethmy/harness";
+import { log as log39, teardownWorktree as teardownWorktree3 } from "@gethmy/harness";
 function isProcessAlive(pid, currentPid) {
   if (pid === currentPid)
     return true;
@@ -14962,7 +15108,7 @@ async function fetchCardSafely(client, cardId) {
     const { card } = await client.getCard(cardId);
     return card;
   } catch (err) {
-    log38.warn(TAG34, `cannot fetch card ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log39.warn(TAG35, `cannot fetch card ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -14972,7 +15118,7 @@ async function recoverOrphans(store, client, config, opts = {}) {
     return [];
   }
   const outcomes = [];
-  log38.info(TAG34, `recovering ${active.length} orphan run(s) from prior daemon`);
+  log39.info(TAG35, `recovering ${active.length} orphan run(s) from prior daemon`);
   for (const run of active) {
     const outcome = {
       runId: run.runId,
@@ -14984,16 +15130,16 @@ async function recoverOrphans(store, client, config, opts = {}) {
     };
     outcomes.push(outcome);
     if (isBudgetHeldRun(run)) {
-      log38.info(TAG34, `run ${run.runId} (#${run.cardShortId}) is held for a human budget decision — leaving it`);
+      log39.info(TAG35, `run ${run.runId} (#${run.cardShortId}) is held for a human budget decision — leaving it`);
       outcome.actions.push("skipped: held for a human budget decision");
       continue;
     }
     if (isProcessAlive(run.daemonPid, process.pid)) {
-      log38.warn(TAG34, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
+      log39.warn(TAG35, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
       outcome.actions.push("skipped: daemon pid still alive");
       continue;
     }
-    log38.info(TAG34, `recovering ${run.pipeline} run ${run.runId} for card #${run.cardShortId}`);
+    log39.info(TAG35, `recovering ${run.pipeline} run ${run.runId} for card #${run.cardShortId}`);
     await recoverRun(run, store, client, config, outcome, {
       rollbackAttempt: true,
       agentId: opts.agentId
@@ -15014,7 +15160,7 @@ async function recoverRun(run, store, client, config, outcome, opts = {}) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     outcome.errors.push(`endAgentSession: ${msg}`);
-    log38.warn(TAG34, `endAgentSession failed for ${run.cardId}: ${msg}`);
+    log39.warn(TAG35, `endAgentSession failed for ${run.cardId}: ${msg}`);
   }
   const card = await fetchCardSafely(client, run.cardId);
   if (card) {
@@ -15074,9 +15220,9 @@ async function recoverRun(run, store, client, config, outcome, opts = {}) {
       outcome.errors.push(`decrementAttempt: ${msg}`);
     }
   }
-  log38.info(TAG34, `recovered run ${run.runId} (card #${run.cardShortId}): ${outcome.actions.join(", ")}${outcome.errors.length ? ` | errors: ${outcome.errors.join("; ")}` : ""}`);
+  log39.info(TAG35, `recovered run ${run.runId} (card #${run.cardShortId}): ${outcome.actions.join(", ")}${outcome.errors.length ? ` | errors: ${outcome.errors.join("; ")}` : ""}`);
 }
-var TAG34 = "recovery", RECOVERED_LABEL = "agent-recovered", RECOVERED_LABEL_COLOR = "#f59e0b";
+var TAG35 = "recovery", RECOVERED_LABEL = "agent-recovered", RECOVERED_LABEL_COLOR = "#f59e0b";
 var init_recovery = __esm(() => {
   init_board_helpers();
   init_handback();
@@ -15105,18 +15251,18 @@ function isTrustedCardAuthor(card, trustedAuthors) {
 }
 
 // src/claim.ts
-import { log as log39 } from "@gethmy/harness";
+import { log as log40 } from "@gethmy/harness";
 async function claimUnassignedCard(client, cardId, agentId, opts) {
   try {
     const { claimed } = opts ? await client.claimCard(cardId, agentId, opts) : await client.claimCard(cardId, agentId);
-    log39.debug(TAG35, `claim ${cardId} → ${claimed ? "won" : "lost"}`);
+    log40.debug(TAG36, `claim ${cardId} → ${claimed ? "won" : "lost"}`);
     return claimed;
   } catch (err) {
-    log39.error(TAG35, `claim ${cardId} failed: ${err instanceof Error ? err.message : err}`);
+    log40.error(TAG36, `claim ${cardId} failed: ${err instanceof Error ? err.message : err}`);
     return false;
   }
 }
-var TAG35 = "claim";
+var TAG36 = "claim";
 var init_claim = () => {};
 
 // src/strand-recovery.ts
@@ -15124,7 +15270,7 @@ var exports_strand_recovery = {};
 __export(exports_strand_recovery, {
   reclaimPreReviewStrands: () => reclaimPreReviewStrands
 });
-import { log as log40, resolvePrUrl as resolvePrUrl2 } from "@gethmy/harness";
+import { log as log41, resolvePrUrl as resolvePrUrl2 } from "@gethmy/harness";
 async function reclaimPreReviewStrands(opts) {
   const {
     client,
@@ -15160,7 +15306,7 @@ async function reclaimPreReviewStrands(opts) {
       continue;
     const daemonBranch = daemonBranches.get(card.id);
     if (!isTrustedCardAuthor(card, trustedAuthors) && daemonBranch !== branch) {
-      log40.debug(TAG36, `#${card.short_id} - skipped: ${card.source != null ? `card was filed externally (source: ${card.source})` : `author ${card.created_by ?? "(none)"} is not trusted`}, and ${daemonBranch ? `the card records ${branch} while this daemon pushed ${daemonBranch}` : "this daemon has pushed no branch for it"}`);
+      log41.debug(TAG37, `#${card.short_id} - skipped: ${card.source != null ? `card was filed externally (source: ${card.source})` : `author ${card.created_by ?? "(none)"} is not trusted`}, and ${daemonBranch ? `the card records ${branch} while this daemon pushed ${daemonBranch}` : "this daemon has pushed no branch for it"}`);
       continue;
     }
     const labels = resolveCardLabels(card, labelMap);
@@ -15176,22 +15322,22 @@ async function reclaimPreReviewStrands(opts) {
       continue;
     const won = await claimUnassignedCard(client, card.id, agentId);
     if (!won) {
-      log40.debug(TAG36, `#${card.short_id} — lost the review claim race, skipping`);
+      log41.debug(TAG37, `#${card.short_id} — lost the review claim race, skipping`);
       continue;
     }
-    log40.warn(TAG36, `#${card.short_id} claimed for review (branch pushed, no PR, unowned)`);
+    log41.warn(TAG37, `#${card.short_id} claimed for review (branch pushed, no PR, unowned)`);
     reclaimed.push(card.id);
     if (opts.onClaimed) {
       try {
         await opts.onClaimed(card);
       } catch (err) {
-        log40.error(TAG36, `onClaimed for #${card.short_id} failed: ${err instanceof Error ? err.message : err}`);
+        log41.error(TAG37, `onClaimed for #${card.short_id} failed: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
   return reclaimed;
 }
-var TAG36 = "strand-recovery";
+var TAG37 = "strand-recovery";
 var init_strand_recovery = __esm(() => {
   init_src();
   init_board_helpers();
@@ -15357,7 +15503,7 @@ var init_scope = __esm(() => {
 });
 
 // src/sweep.ts
-import { log as log41 } from "@gethmy/harness";
+import { log as log42 } from "@gethmy/harness";
 function rankSweepCandidates(opts) {
   const {
     agentId,
@@ -15476,10 +15622,10 @@ async function sweepForCard(opts) {
   let { candidates, skipped, scope } = rankSweepCandidates(opts);
   const cohesionCounts = opts.ranking.cohesionWeight !== 0;
   if (cohesionCounts) {
-    log41.debug(TAG37, describeActiveScope(scope.active));
+    log42.debug(TAG38, describeActiveScope(scope.active));
   }
   if (candidates.length === 0) {
-    log41.debug(TAG37, `no claimable card (${skipped.length} skipped in a pickup column)`);
+    log42.debug(TAG38, `no claimable card (${skipped.length} skipped in a pickup column)`);
     return { claimed: null, skipped, probed: 0 };
   }
   const probeWindow = candidates.slice(0, maxProbes);
@@ -15495,12 +15641,12 @@ async function sweepForCard(opts) {
       chainNeighbors: chainNeighbors(chain2)
     }));
   } else if (chainTermsCount && candidates.length > 1) {
-    log41.debug(TAG37, `chain signals not ranked — maxProbesPerTick=${maxProbes} leaves nothing to reorder among ${candidates.length} candidates`);
+    log42.debug(TAG38, `chain signals not ranked — maxProbesPerTick=${maxProbes} leaves nothing to reorder among ${candidates.length} candidates`);
   }
   let probed = 0;
   for (const candidate of candidates) {
     if (probed >= maxProbes) {
-      log41.debug(TAG37, `probe budget ${maxProbes} spent — ${candidates.length - probed} candidate(s) deferred to the next tick`);
+      log42.debug(TAG38, `probe budget ${maxProbes} spent — ${candidates.length - probed} candidate(s) deferred to the next tick`);
       break;
     }
     probed++;
@@ -15578,10 +15724,10 @@ async function sweepForCard(opts) {
       continue;
     }
     verified.card.assigned_agent_id = agentId;
-    log41.info(TAG37, claimLine(verified, probed, candidates, skipped, cohesionCounts ? scope.active : null));
+    log42.info(TAG38, claimLine(verified, probed, candidates, skipped, cohesionCounts ? scope.active : null));
     return { claimed: verified, skipped, probed };
   }
-  log41.debug(TAG37, `claimed nothing this sweep (${probed} probed, ${skipped.length} skipped)`);
+  log42.debug(TAG38, `claimed nothing this sweep (${probed} probed, ${skipped.length} skipped)`);
   return { claimed: null, skipped, probed };
 }
 function claimLine(claimed, rank, candidates, skipped, scope) {
@@ -15602,7 +15748,7 @@ async function refetchCard(client, cardId) {
     const { card } = await client.getCard(cardId);
     return card ?? null;
   } catch (err) {
-    log41.warn(TAG37, `re-read failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log42.warn(TAG38, `re-read failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -15611,11 +15757,11 @@ async function hasLiveSession(client, cardId) {
     const { session } = await client.getAgentSession(cardId);
     return session != null;
   } catch (err) {
-    log41.warn(TAG37, `session lookup failed for ${cardId} — treating as busy: ${err instanceof Error ? err.message : err}`);
+    log42.warn(TAG38, `session lookup failed for ${cardId} — treating as busy: ${err instanceof Error ? err.message : err}`);
     return true;
   }
 }
-var TAG37 = "sweep";
+var TAG38 = "sweep";
 var init_sweep = __esm(() => {
   init_board_helpers();
   init_claim();
@@ -15626,7 +15772,7 @@ var init_sweep = __esm(() => {
 });
 
 // src/sweep-commands.ts
-import { log as log42 } from "@gethmy/harness";
+import { log as log43 } from "@gethmy/harness";
 function parseSweepCommands(payload) {
   if (!payload || typeof payload !== "object")
     return [];
@@ -15653,14 +15799,14 @@ function parseSweepCommands(payload) {
 async function claimSweepCommands(client, agentId, projectId, daemonId) {
   const request = client.request?.bind(client);
   if (typeof request !== "function") {
-    log42.warn(TAG38, "installed @gethmy/mcp has no generic request method — board sweep commands cannot be claimed; use `harmony-agent sweep stop|resume` until it is upgraded");
+    log43.warn(TAG39, "installed @gethmy/mcp has no generic request method — board sweep commands cannot be claimed; use `harmony-agent sweep stop|resume` until it is upgraded");
     return [];
   }
   try {
     const res = await request("POST", `/agents/${encodeURIComponent(agentId)}/sweep-commands/claim`, { projectId, daemonId });
     return parseSweepCommands(res);
   } catch (err) {
-    log42.warn(TAG38, `could not claim sweep commands: ${err instanceof Error ? err.message : err}`);
+    log43.warn(TAG39, `could not claim sweep commands: ${err instanceof Error ? err.message : err}`);
     return [];
   }
 }
@@ -15673,15 +15819,15 @@ async function applySweepCommands(commands, actions) {
       await actions.resume();
     }
     applied = command.verb;
-    log42.info(TAG38, `applied "${command.verb}" from the board (${command.id})`);
+    log43.info(TAG39, `applied "${command.verb}" from the board (${command.id})`);
   }
   return applied;
 }
-var TAG38 = "sweep-cmd";
+var TAG39 = "sweep-cmd";
 var init_sweep_commands = () => {};
 
 // src/sweep-guard.ts
-import { log as log43 } from "@gethmy/harness";
+import { log as log44 } from "@gethmy/harness";
 
 class SweepGuard {
   config;
@@ -15737,7 +15883,7 @@ class SweepGuard {
     await this.store.haltSweep(reason);
     if (!already) {
       const claimed = this.store.getSweep().claimed;
-      log43.info(TAG39, `claiming stopped (${reason}) after ${claimed} claimed`);
+      log44.info(TAG40, `claiming stopped (${reason}) after ${claimed} claimed`);
     }
     return this.snapshot();
   }
@@ -15746,7 +15892,7 @@ class SweepGuard {
     const was = before.haltReason ? this.describeStop(before.haltReason) : null;
     await this.store.resumeSweep();
     if (was)
-      log43.info(TAG39, `claiming resumed by the operator — was stopped: ${was}`);
+      log44.info(TAG40, `claiming resumed by the operator — was stopped: ${was}`);
     return this.snapshot();
   }
   snapshot() {
@@ -15808,11 +15954,11 @@ function sweepBannerLine(config) {
   const authors = extra ? `you + ${extra} trusted author${extra === 1 ? "" : "s"}` : "you only";
   return `Sweep ON — claims ${scope} in ${config.pickupColumns.join(", ")}, ` + `authored by ${authors}; caps: ${describeCaps(sweep, config.budget.dailyBudgetCents)}; ` + `${sweep.maxProbesPerTick} probes/tick`;
 }
-var TAG39 = "sweep";
+var TAG40 = "sweep";
 var init_sweep_guard = () => {};
 
 // src/reconcile.ts
-import { detectGitProvider as detectGitProvider5, log as log44 } from "@gethmy/harness";
+import { detectGitProvider as detectGitProvider5, log as log45 } from "@gethmy/harness";
 function daemonProcessLabels(approvedLabel) {
   const names = ["agent", "agent-recovered", NEED_REVIEW_LABEL, approvedLabel];
   return new Set(names.filter(Boolean).map((n) => n.toLowerCase()));
@@ -15875,7 +16021,7 @@ class Reconciler {
       clearInterval(this.timer);
       this.timer = null;
     }
-    log44.info(TAG40, "Heartbeat stopped");
+    log45.info(TAG41, "Heartbeat stopped");
   }
   async recoverStaleRuns() {
     if (!this.stateStore || !this.agentConfig)
@@ -15886,7 +16032,7 @@ class Reconciler {
     const pool = this.pool;
     for (const run of active) {
       if (isBudgetHeldRun(run)) {
-        log44.info(TAG40, `run ${run.runId} (#${run.cardShortId}) is held for a human budget decision — leaving it`);
+        log45.info(TAG41, `run ${run.runId} (#${run.cardShortId}) is held for a human budget decision — leaving it`);
         continue;
       }
       const foreignDaemon = run.daemonPid !== process.pid;
@@ -15896,7 +16042,7 @@ class Reconciler {
       if (!daemonDead && !(heartbeatStale && ourZombie))
         continue;
       const reason = daemonDead ? `foreign daemon ${run.daemonPid} is dead` : `our worker lost card ${run.cardId} with ${Math.round((now - run.lastHeartbeatAt) / 1000)}s stale heartbeat`;
-      log44.warn(TAG40, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
+      log45.warn(TAG41, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
       await recoverRun(run, this.stateStore, this.client, this.agentConfig, {
         runId: run.runId,
         cardId: run.cardId,
@@ -15923,11 +16069,11 @@ class Reconciler {
       const stalledAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(stalledAt) || now - stalledAt < graceMs)
         continue;
-      log44.warn(TAG40, `#${card.short_id} stranded in "${inProgressCol.name}" (no live run) — requeueing to "${pickupCol.name}"`);
+      log45.warn(TAG41, `#${card.short_id} stranded in "${inProgressCol.name}" (no live run) — requeueing to "${pickupCol.name}"`);
       try {
         await this.client.moveCard(card.id, pickupCol.id);
       } catch (err) {
-        log44.error(TAG40, `stranded requeue failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log45.error(TAG41, `stranded requeue failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -15980,7 +16126,7 @@ class Reconciler {
           return;
         const cardLabels = resolveCardLabels(card, labelMap);
         const subtasks = card.subtasks ?? [];
-        log44.info(TAG40, `Enqueuing claimed review card #${card.short_id} (agent-agnostic pickup)`);
+        log45.info(TAG41, `Enqueuing claimed review card #${card.short_id} (agent-agnostic pickup)`);
         await this.pool.enqueue(card, column, cardLabels, subtasks, "review");
       }
     });
@@ -16004,11 +16150,11 @@ class Reconciler {
       const parkedAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(parkedAt) || now - parkedAt < ttlMs)
         continue;
-      log44.warn(TAG40, `#${card.short_id} parked for approval > ${planning.approvalTtlHours}h — auto-releasing to "${pickupCol.name}"`);
+      log45.warn(TAG41, `#${card.short_id} parked for approval > ${planning.approvalTtlHours}h — auto-releasing to "${pickupCol.name}"`);
       try {
         await this.client.moveCard(card.id, pickupCol.id);
       } catch (err) {
-        log44.error(TAG40, `auto-release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log45.error(TAG41, `auto-release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -16043,7 +16189,7 @@ class Reconciler {
     }
     this.lastSweepStopReported = null;
     if (!this.pool.hasFreeImplementSlot()) {
-      log44.debug(TAG40, "sweep skipped — no free implement slot");
+      log45.debug(TAG41, "sweep skipped — no free implement slot");
       return;
     }
     const { claimed } = await sweepForCard({
@@ -16062,9 +16208,9 @@ class Reconciler {
   reportSweepStopped(reason, detail) {
     const line = `sweep stopped claiming — ${detail}`;
     if (this.lastSweepStopReported === reason)
-      log44.debug(TAG40, line);
+      log45.debug(TAG41, line);
     else
-      log44.warn(TAG40, line);
+      log45.warn(TAG41, line);
     this.lastSweepStopReported = reason;
   }
   setSweepPresenceSink(sink) {
@@ -16102,7 +16248,7 @@ class Reconciler {
       return;
     this.lastSweepNudgeAt = now;
     this.drainSweepCommands().catch((err) => {
-      log44.error(TAG40, `sweep command nudge failed: ${err instanceof Error ? err.message : err}`);
+      log45.error(TAG41, `sweep command nudge failed: ${err instanceof Error ? err.message : err}`);
     });
   }
   resolveRepoDirectories() {
@@ -16111,9 +16257,9 @@ class Reconciler {
     const dirs = readRepoDirectories(process.cwd());
     this.repoDirectories = dirs;
     if (dirs.size === 0) {
-      log44.warn(TAG40, `Could not read top-level directories of ${process.cwd()} — sweep cohesion runs without its path signal`);
+      log45.warn(TAG41, `Could not read top-level directories of ${process.cwd()} — sweep cohesion runs without its path signal`);
     } else {
-      log44.debug(TAG40, `Path signal allows ${dirs.size} top-level directories`);
+      log45.debug(TAG41, `Path signal allows ${dirs.size} top-level directories`);
     }
     return dirs;
   }
@@ -16149,7 +16295,7 @@ class Reconciler {
       if (accountHalt !== this.lastAccountHoldReported) {
         if (accountHalt) {
           const unqueued = assignedCards.filter((c) => !knownCardIds.has(c.id)).length;
-          log44.warn(TAG40, `Account halted (${accountHalt}) — ${unqueued} assigned card(s) not queued; nothing is dispatched until \`harmony-agent resume\``);
+          log45.warn(TAG41, `Account halted (${accountHalt}) — ${unqueued} assigned card(s) not queued; nothing is dispatched until \`harmony-agent resume\``);
         }
         this.lastAccountHoldReported = accountHalt;
       }
@@ -16165,24 +16311,24 @@ class Reconciler {
           const subtasks = card.subtasks ?? [];
           const mode = route.mode;
           if (route.stage) {
-            log44.info(TAG40, `Stage card #${card.short_id} (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement) regardless of column`);
+            log45.info(TAG41, `Stage card #${card.short_id} (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement) regardless of column`);
           }
           if (mode === "review" && this.approvedLabel && hasLabel(cardLabels, this.approvedLabel)) {
-            log44.debug(TAG40, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
+            log45.debug(TAG41, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
             continue;
           }
           if (mode === "review" && hasLabel(cardLabels, NEED_REVIEW_LABEL)) {
-            log44.debug(TAG40, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
+            log45.debug(TAG41, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
             continue;
           }
           if (mode === "review" && !qualifiesForAutoReview(card.description)) {
-            log44.debug(TAG40, `Skipping #${card.short_id} — no branch or PR reference (not qualified for auto-review)`);
+            log45.debug(TAG41, `Skipping #${card.short_id} — no branch or PR reference (not qualified for auto-review)`);
             continue;
           }
           if (accountHalt) {
-            log44.debug(TAG40, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — holding, account halted (${accountHalt})`);
+            log45.debug(TAG41, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — holding, account halted (${accountHalt})`);
           } else {
-            log44.info(TAG40, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
+            log45.info(TAG41, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
           }
           await this.pool.enqueue(card, column, cardLabels, subtasks, mode);
         }
@@ -16193,13 +16339,13 @@ class Reconciler {
       try {
         await this.pool.drainBudgetDecisions();
       } catch (err) {
-        log44.error(TAG40, `budget decisions were not drained this tick: ${err instanceof Error ? err.message : err}`);
+        log45.error(TAG41, `budget decisions were not drained this tick: ${err instanceof Error ? err.message : err}`);
       }
       await this.recoverStrandedInProgress(cards, columns, knownCardIds);
       await this.recoverStrandedReview(cards, columns, labelMap, knownCardIds);
       for (const knownId of knownCardIds) {
         if (!allAgentCardIds.has(knownId)) {
-          log44.info(TAG40, `Missed unassign: ${knownId} — removing`);
+          log45.info(TAG41, `Missed unassign: ${knownId} — removing`);
           await this.pool.removeCard(knownId);
         }
       }
@@ -16207,20 +16353,20 @@ class Reconciler {
       try {
         await this.drainSweepCommands();
       } catch (err) {
-        log44.error(TAG40, `sweep commands were not drained this tick: ${err instanceof Error ? err.message : err}`);
+        log45.error(TAG41, `sweep commands were not drained this tick: ${err instanceof Error ? err.message : err}`);
       }
       try {
         await this.sweepForWork(cards, columns, labelMap, pickupConfig);
       } catch (err) {
-        log44.error(TAG40, `sweep failed this tick: ${err instanceof Error ? err.message : err}`);
+        log45.error(TAG41, `sweep failed this tick: ${err instanceof Error ? err.message : err}`);
       }
-      log44.debug(TAG40, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
+      log45.debug(TAG41, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
     } catch (err) {
-      log44.error(TAG40, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
+      log45.error(TAG41, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG40 = "reconcile", SWEEP_NUDGE_COOLDOWN_MS = 15000;
+var TAG41 = "reconcile", SWEEP_NUDGE_COOLDOWN_MS = 15000;
 var init_reconcile = __esm(() => {
   init_board_helpers();
   init_recovery();
@@ -16339,7 +16485,7 @@ __export(exports_startup_banner, {
   createStartupBanner: () => createStartupBanner,
   contextSourceLine: () => contextSourceLine
 });
-import { isPretty, log as log45 } from "@gethmy/harness";
+import { isPretty, log as log46 } from "@gethmy/harness";
 function createStartupBanner(config, version) {
   return isPretty() ? prettyBanner(config, version) : jsonBanner(config, version);
 }
@@ -16368,7 +16514,7 @@ function prettyBanner(config, version) {
       checks.push({ kind: "ok", message });
     },
     warn(message) {
-      log45.warn(TAG41, message);
+      log46.warn(TAG42, message);
       checks.push({ kind: "warn", message: message.split(`
 `, 1)[0] });
     },
@@ -16394,31 +16540,31 @@ function prettyBanner(config, version) {
   };
 }
 function jsonBanner(config, version) {
-  log45.info(TAG41, `Harmony Agent Daemon v${version} starting...`);
-  log45.info(TAG41, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Runner: ${config.agent.runner} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
-  log45.info(TAG41, `Config: ${contextSourceLine(config)}`);
+  log46.info(TAG42, `Harmony Agent Daemon v${version} starting...`);
+  log46.info(TAG42, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Runner: ${config.agent.runner} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
+  log46.info(TAG42, `Config: ${contextSourceLine(config)}`);
   if (config.agent.review.enabled) {
-    log45.info(TAG41, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
+    log46.info(TAG42, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
   }
   let failed = false;
   let modelLogged = false;
   return {
     setProjectName(_name) {},
     setGitProvider(provider) {
-      log45.info(TAG41, `Git provider: ${provider}`);
+      log46.info(TAG42, `Git provider: ${provider}`);
     },
     setHttpPort(port) {
-      log45.info(TAG41, `HTTP server on port ${port}`);
+      log46.info(TAG42, `HTTP server on port ${port}`);
     },
     setModel(resolved) {
       modelLogged = true;
-      log45.info(TAG41, `Model: ${startupModelLine(resolved)}`);
+      log46.info(TAG42, `Model: ${startupModelLine(resolved)}`);
     },
     check(message) {
-      log45.info(TAG41, message);
+      log46.info(TAG42, message);
     },
     warn(message) {
-      log45.warn(TAG41, message);
+      log46.warn(TAG42, message);
     },
     fail() {
       failed = true;
@@ -16427,8 +16573,8 @@ function jsonBanner(config, version) {
       if (failed)
         return;
       if (!modelLogged)
-        log45.info(TAG41, `Model: ${localModelLine(config)}`);
-      log45.info(TAG41, message);
+        log46.info(TAG42, `Model: ${localModelLine(config)}`);
+      log46.info(TAG42, message);
     }
   };
 }
@@ -16524,7 +16670,7 @@ function cyan(s) {
 function yellow(s) {
   return `${ANSI.yellow}${s}${ANSI.reset}`;
 }
-var TAG41 = "daemon", RULE_WIDTH = 70, ANSI;
+var TAG42 = "daemon", RULE_WIDTH = 70, ANSI;
 var init_startup_banner = __esm(() => {
   init_port_registry();
   init_startup_model();
@@ -16546,7 +16692,7 @@ import {
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { dirname as dirname5, resolve as resolve2, sep as sep2 } from "node:path";
-import { log as log46 } from "@gethmy/harness";
+import { log as log47 } from "@gethmy/harness";
 function migrationMarkerPath(targetPath) {
   return `${targetPath}.migrated`;
 }
@@ -16620,7 +16766,7 @@ function migrateLegacyStateFile(opts) {
       throw new Error("not an object");
     legacy = parsed;
   } catch (err) {
-    log46.warn(TAG42, `legacy state file unreadable — skipping the split this start; it retries on the next (${err instanceof Error ? err.message : err})`);
+    log47.warn(TAG43, `legacy state file unreadable — skipping the split this start; it retries on the next (${err instanceof Error ? err.message : err})`);
     return NO_MIGRATION;
   }
   const runs = Array.isArray(legacy.runs) ? legacy.runs : [];
@@ -16642,13 +16788,13 @@ function migrateLegacyStateFile(opts) {
   const legacyVersion = typeof legacy.version === "number" ? legacy.version : SCHEMA_VERSION;
   const existing = existsSync5(targetPath) ? readTargetFile(targetPath) : null;
   if (existsSync5(targetPath) && !existing) {
-    log46.warn(TAG42, "existing project state file unreadable — the split overwrites it");
+    log47.warn(TAG43, "existing project state file unreadable — the split overwrites it");
   }
   let target;
   if (existing) {
     const existingVersion = typeof existing.version === "number" ? existing.version : SCHEMA_VERSION;
     if (existingVersion !== legacyVersion) {
-      log46.warn(TAG42, `legacy state is schema v${legacyVersion} but the project store is v${existingVersion} — skipping the split`);
+      log47.warn(TAG43, `legacy state is schema v${legacyVersion} but the project store is v${existingVersion} — skipping the split`);
       return NO_MIGRATION;
     }
     const existingRuns = Array.isArray(existing.runs) ? existing.runs : [];
@@ -16694,7 +16840,7 @@ function migrateLegacyStateFile(opts) {
     if (!existsSync5(backupPath))
       copyFileSync(legacyPath, backupPath);
   } catch (err) {
-    log46.warn(TAG42, `could not back up the legacy state file (continuing): ${err instanceof Error ? err.message : err}`);
+    log47.warn(TAG43, `could not back up the legacy state file (continuing): ${err instanceof Error ? err.message : err}`);
   }
   const remainingRuns = runs.filter((r) => !ownRunIds.has(r.runId));
   const remainingCards = cards.filter((c) => !ownCardIds.has(c.cardId));
@@ -16718,10 +16864,10 @@ function migrateLegacyStateFile(opts) {
     copiedIndeterminateCards: indeterminateCards.length,
     foreignUnendedRuns: remainingRuns.filter((r) => r.endedAt === null).length
   };
-  log46.info(TAG42, `split legacy state into ${targetPath}: moved ${result.movedRuns} run(s) ` + `(${result.movedUnendedRuns} unended) and ${result.movedCards} card record(s), ` + `copied ${result.copiedIndeterminateCards} unattributable card record(s); ` + `left ${remainingRuns.length} run(s) (${result.foreignUnendedRuns} unended) for other projects`);
+  log47.info(TAG43, `split legacy state into ${targetPath}: moved ${result.movedRuns} run(s) ` + `(${result.movedUnendedRuns} unended) and ${result.movedCards} card record(s), ` + `copied ${result.copiedIndeterminateCards} unattributable card record(s); ` + `left ${remainingRuns.length} run(s) (${result.foreignUnendedRuns} unended) for other projects`);
   return result;
 }
-var TAG42 = "state-migration", NO_MIGRATION;
+var TAG43 = "state-migration", NO_MIGRATION;
 var init_state_migration = __esm(() => {
   init_src();
   init_state_store();
@@ -16828,7 +16974,7 @@ var init_stream_parser_selftest = __esm(() => {
 
 // src/watcher.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { isPretty as isPretty2, log as log47 } from "@gethmy/harness";
+import { isPretty as isPretty2, log as log48 } from "@gethmy/harness";
 import { createClient } from "@supabase/supabase-js";
 function toPresenceColumns(names) {
   return names.map((n) => n.trim()).filter((n) => n.length > 0).slice(0, MAX_PRESENCE_COLUMNS).map((n) => n.slice(0, MAX_PRESENCE_COLUMN_LENGTH));
@@ -16889,7 +17035,7 @@ class Watcher {
     const stillHeld = this.supabase?.getChannels().some((c) => c.topic === old.topic) ?? false;
     if (!stillHeld)
       return true;
-    log47.warn(TAG43, `removeChannel(${old.topic}) returned "${status}" and the client still holds that topic — retrying the removal`);
+    log48.warn(TAG44, `removeChannel(${old.topic}) returned "${status}" and the client still holds that topic — retrying the removal`);
     return false;
   }
   constructor(credentials, projectId, identity, routing, onCardBroadcast, onAgentCommand, onSweepCommandNudge) {
@@ -16903,7 +17049,7 @@ class Watcher {
   }
   async start() {
     if (!isPretty2()) {
-      log47.info(TAG43, "Connecting to Supabase realtime (broadcast)...");
+      log48.info(TAG44, "Connecting to Supabase realtime (broadcast)...");
     }
     this.supabase = createClient(this.credentials.supabaseUrl, this.credentials.supabaseAnonKey);
     this.subscribeBroadcast();
@@ -16941,7 +17087,7 @@ class Watcher {
         status = `threw (${String(err)})`;
       }
       if (status !== "ok") {
-        log47.debug(TAG43, `Presence sweep update returned "${status}"`);
+        log48.debug(TAG44, `Presence sweep update returned "${status}"`);
       }
     })();
   }
@@ -16952,7 +17098,7 @@ class Watcher {
     const presenceChannel = this.supabase.channel(`board-presence-${this.projectId}`);
     this.presenceChannel = presenceChannel;
     presenceChannel.on("presence", { event: "sync" }, () => {
-      log47.debug(TAG43, "Presence sync");
+      log48.debug(TAG44, "Presence sync");
     }).subscribe(async (status) => {
       if (gen !== this.presenceGen)
         return;
@@ -16968,13 +17114,13 @@ class Watcher {
         if (trackStatus !== "ok") {
           this.presenceTracked = false;
           if (!this.stopping) {
-            log47.warn(TAG43, `Presence track returned "${trackStatus}" — scheduling reconnect`);
+            log48.warn(TAG44, `Presence track returned "${trackStatus}" — scheduling reconnect`);
             this.schedulePresenceReconnect();
           }
           return;
         }
         if (!isPretty2() || !this.suppressStartupLogs) {
-          log47.info(TAG43, "Presence tracked on board-presence channel");
+          log48.info(TAG44, "Presence tracked on board-presence channel");
         }
         this.presenceTracked = true;
         this.presenceReconnectAttempts = 0;
@@ -16982,7 +17128,7 @@ class Watcher {
       } else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT" || status === "CLOSED") {
         this.presenceTracked = false;
         if (!this.stopping) {
-          log47.warn(TAG43, `Presence subscription ${status} — scheduling reconnect`);
+          log48.warn(TAG44, `Presence subscription ${status} — scheduling reconnect`);
           this.schedulePresenceReconnect();
         }
       }
@@ -17001,7 +17147,7 @@ class Watcher {
   async reconnectPresence() {
     if (this.stopping || !this.supabase)
       return;
-    log47.warn(TAG43, `Reconnecting presence subscription (attempt ${this.presenceReconnectAttempts})`);
+    log48.warn(TAG44, `Reconnecting presence subscription (attempt ${this.presenceReconnectAttempts})`);
     if (this.presenceChannel) {
       const old = this.presenceChannel;
       this.presenceChannel = null;
@@ -17024,13 +17170,13 @@ class Watcher {
       return;
     const gen = ++this.broadcastGen;
     this.channel = this.supabase.channel(`board-${this.projectId}`).on("broadcast", { event: "card_update" }, (msg) => {
-      log47.debug(TAG43, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
+      log48.debug(TAG44, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_update",
         payload: msg.payload ?? {}
       });
     }).on("broadcast", { event: "card_created" }, (msg) => {
-      log47.debug(TAG43, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
+      log48.debug(TAG44, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_created",
         payload: msg.payload ?? {}
@@ -17040,11 +17186,11 @@ class Watcher {
       const cardId = payload.card_id;
       const command = payload.command;
       if (cardId && command) {
-        log47.info(TAG43, `Broadcast: agent_command ${command} for ${cardId}`);
+        log48.info(TAG44, `Broadcast: agent_command ${command} for ${cardId}`);
         this.onAgentCommand?.({ cardId, command });
       }
     }).on("broadcast", { event: "sweep_command" }, () => {
-      log47.debug(TAG43, "Broadcast: sweep_command — draining");
+      log48.debug(TAG44, "Broadcast: sweep_command — draining");
       this.onSweepCommandNudge?.();
     }).subscribe((status) => {
       if (gen !== this.broadcastGen)
@@ -17053,13 +17199,13 @@ class Watcher {
         this.connected = true;
         this.reconnectAttempts = 0;
         if (!isPretty2() || !this.suppressStartupLogs) {
-          log47.info(TAG43, "Broadcast subscription active");
+          log48.info(TAG44, "Broadcast subscription active");
         }
         this.maybeResolveReady();
       } else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT" || status === "CLOSED") {
         this.connected = false;
         if (!this.stopping) {
-          log47.warn(TAG43, `Broadcast subscription ${status} — scheduling reconnect`);
+          log48.warn(TAG44, `Broadcast subscription ${status} — scheduling reconnect`);
           this.scheduleReconnect();
         }
       }
@@ -17078,7 +17224,7 @@ class Watcher {
   async reconnectBroadcast() {
     if (this.stopping || !this.supabase)
       return;
-    log47.warn(TAG43, `Reconnecting broadcast subscription (attempt ${this.reconnectAttempts})`);
+    log48.warn(TAG44, `Reconnecting broadcast subscription (attempt ${this.reconnectAttempts})`);
     if (this.channel) {
       const old = this.channel;
       this.channel = null;
@@ -17120,10 +17266,10 @@ class Watcher {
     }
     this.connected = false;
     this.presenceTracked = false;
-    log47.info(TAG43, "Broadcast subscription stopped");
+    log48.info(TAG44, "Broadcast subscription stopped");
   }
 }
-var TAG43 = "watcher", MAX_PRESENCE_COLUMNS = 24, MAX_PRESENCE_COLUMN_LENGTH = 120;
+var TAG44 = "watcher", MAX_PRESENCE_COLUMNS = 24, MAX_PRESENCE_COLUMN_LENGTH = 120;
 var init_watcher = __esm(() => {
   init_sweep_guard();
 });
@@ -17397,7 +17543,7 @@ __export(exports_run_gc, {
   pruneRunLogs: () => pruneRunLogs
 });
 import { unlinkSync as unlinkSync2 } from "node:fs";
-import { log as log48 } from "@gethmy/harness";
+import { log as log49 } from "@gethmy/harness";
 function pruneRunLogs(dir, beforeMs, keepRunIds = new Set) {
   let deleted = 0;
   let bytesFreed = 0;
@@ -17411,7 +17557,7 @@ function pruneRunLogs(dir, beforeMs, keepRunIds = new Set) {
       deleted++;
       bytesFreed += file.sizeBytes;
     } catch (err) {
-      log48.debug(TAG44, `Could not remove ${file.path}: ${err instanceof Error ? err.message : err}`);
+      log49.debug(TAG45, `Could not remove ${file.path}: ${err instanceof Error ? err.message : err}`);
     }
   }
   return { deleted, bytesFreed };
@@ -17434,7 +17580,7 @@ async function runRetentionGc(store, opts) {
     logs = pruneRunLogs(opts.runsDirectory ?? runsDir(), now - opts.runLogDays * DAY_MS2, openRunIds);
   }
   if (runRecordsPurged > 0 || logs.deleted > 0) {
-    log48.info(TAG44, `Retention sweep: trimmed ${runRecordsPurged} run record(s), removed ${logs.deleted} run log(s) (${Math.round(logs.bytesFreed / 1024)} KB)`);
+    log49.info(TAG45, `Retention sweep: trimmed ${runRecordsPurged} run record(s), removed ${logs.deleted} run log(s) (${Math.round(logs.bytesFreed / 1024)} KB)`);
   }
   return {
     runRecordsPurged,
@@ -17442,7 +17588,7 @@ async function runRetentionGc(store, opts) {
     logBytesFreed: logs.bytesFreed
   };
 }
-var TAG44 = "gc", DAY_MS2 = 86400000;
+var TAG45 = "gc", DAY_MS2 = 86400000;
 var init_run_gc = __esm(() => {
   init_paths();
   init_run_stats();
@@ -17459,7 +17605,7 @@ __export(exports_worktree_gc, {
 import { execFileSync as execFileSync8 } from "node:child_process";
 import { existsSync as existsSync6, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
 import { resolve as resolve3 } from "node:path";
-import { cleanupWorktree as cleanupWorktree5, GIT_NO_HOOKS as GIT_NO_HOOKS9, log as log49 } from "@gethmy/harness";
+import { cleanupWorktree as cleanupWorktree5, GIT_NO_HOOKS as GIT_NO_HOOKS9, log as log50 } from "@gethmy/harness";
 function isTransientGitNetworkError(message) {
   return TRANSIENT_GIT_NETWORK_ERROR.test(message);
 }
@@ -17572,10 +17718,10 @@ function runWorktreeGc(basePath, store, opts = {}) {
     });
   } catch {}
   if (result.removed.length > 0) {
-    log49.info(TAG45, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
+    log50.info(TAG46, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log49.warn(TAG45, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
+    log50.warn(TAG46, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -17605,7 +17751,7 @@ function pruneFailedRemoteBranches(opts) {
   } catch (err) {
     const detail = gitErrorDetail2(err);
     if (isTransientGitNetworkError(detail)) {
-      log49.debug(TAG45, `Remote branch GC skipped — remote unreachable: ${detail}`);
+      log50.debug(TAG46, `Remote branch GC skipped — remote unreachable: ${detail}`);
       return result;
     }
     result.errors.push({ ref: "fetch", error: detail });
@@ -17645,7 +17791,7 @@ function pruneFailedRemoteBranches(opts) {
       continue;
     }
     if (clock() > sweepDeadline) {
-      log49.debug(TAG45, `Remote branch GC budget spent — removed ${result.removed.length}, remaining deferred to next tick`);
+      log50.debug(TAG46, `Remote branch GC budget spent — removed ${result.removed.length}, remaining deferred to next tick`);
       break;
     }
     try {
@@ -17658,17 +17804,17 @@ function pruneFailedRemoteBranches(opts) {
     } catch (err) {
       const detail = gitErrorDetail2(err);
       if (isTransientGitNetworkError(detail)) {
-        log49.debug(TAG45, `Remote branch GC interrupted — remote unreachable: ${detail}`);
+        log50.debug(TAG46, `Remote branch GC interrupted — remote unreachable: ${detail}`);
         break;
       }
       result.errors.push({ ref, error: detail });
     }
   }
   if (result.removed.length > 0) {
-    log49.info(TAG45, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
+    log50.info(TAG46, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log49.warn(TAG45, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
+    log50.warn(TAG46, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -17701,18 +17847,18 @@ class WorktreeGc {
     try {
       runWorktreeGc(this.basePath, this.store);
     } catch (err) {
-      log49.warn(TAG45, `GC tick failed: ${err instanceof Error ? err.message : err}`);
+      log50.warn(TAG46, `GC tick failed: ${err instanceof Error ? err.message : err}`);
     }
     if (this.remoteOpts) {
       try {
         pruneFailedRemoteBranches(this.remoteOpts);
       } catch (err) {
-        log49.warn(TAG45, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
+        log50.warn(TAG46, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (this.retentionOpts) {
       runRetentionGc(this.store, this.retentionOpts).catch((err) => {
-        log49.warn(TAG45, `Retention GC tick failed: ${err instanceof Error ? err.message : err}`);
+        log50.warn(TAG46, `Retention GC tick failed: ${err instanceof Error ? err.message : err}`);
       });
     }
   }
@@ -17726,7 +17872,7 @@ function getRepoRoot2() {
     return null;
   }
 }
-var TAG45 = "worktree-gc", GIT_NETWORK_TIMEOUT_MS = 30000, GIT_SSH_CONNECT_TIMEOUT_SECS = 10, GIT_PRUNE_SWEEP_BUDGET_MS = 60000, GIT_NETWORK_EXEC, TRANSIENT_GIT_NETWORK_ERROR;
+var TAG46 = "worktree-gc", GIT_NETWORK_TIMEOUT_MS = 30000, GIT_SSH_CONNECT_TIMEOUT_SECS = 10, GIT_PRUNE_SWEEP_BUDGET_MS = 60000, GIT_NETWORK_EXEC, TRANSIENT_GIT_NETWORK_ERROR;
 var init_worktree_gc = __esm(() => {
   init_run_gc();
   GIT_NETWORK_EXEC = {
@@ -17767,7 +17913,7 @@ import {
   claudeVersion,
   detectGitProvider as detectGitProvider6,
   GIT_NO_HOOKS as GIT_NO_HOOKS10,
-  log as log50,
+  log as log51,
   validateGitProviderCli
 } from "@gethmy/harness";
 async function validatePrerequisites(config, banner) {
@@ -17841,7 +17987,7 @@ async function main() {
   } catch (err) {
     if (err instanceof ConfigValidationError) {
       banner.fail();
-      log50.error(TAG46, err.message);
+      log51.error(TAG47, err.message);
       process.exit(1);
     }
     throw err;
@@ -17859,7 +18005,7 @@ async function main() {
   } catch (err) {
     if (err instanceof ConfigValidationError) {
       banner.fail();
-      log50.error(TAG46, err.message);
+      log51.error(TAG47, err.message);
       process.exit(1);
     }
     throw err;
@@ -17883,7 +18029,7 @@ async function main() {
   try {
     await client.reportAgentConfig(config.workspaceId, agentId, effectiveModelReport(config.agent));
   } catch (err) {
-    log50.warn(TAG46, `Could not report model config: ${err instanceof Error ? err.message : String(err)}`);
+    log51.warn(TAG47, `Could not report model config: ${err instanceof Error ? err.message : String(err)}`);
   }
   const startupModel = await resolveStartupModel(config, client);
   banner.setModel(startupModel);
@@ -17898,7 +18044,7 @@ async function main() {
       worktreePrefix: resolve4(config.repoRoot, config.agent.worktree.basePath)
     });
   } catch (err) {
-    log50.error(TAG46, `legacy state split failed — starting with the project store as-is: ${err instanceof Error ? err.message : err}`);
+    log51.error(TAG47, `legacy state split failed — starting with the project store as-is: ${err instanceof Error ? err.message : err}`);
   }
   const stateStore = StateStore.open({ projectId: config.projectId });
   const daemonId = randomUUID4();
@@ -18049,7 +18195,7 @@ async function main() {
     if (shuttingDown)
       return;
     shuttingDown = true;
-    log50.info(TAG46, `Received ${signal}, shutting down gracefully...`);
+    log51.info(TAG47, `Received ${signal}, shutting down gracefully...`);
     reconciler.stop();
     mergeMonitor?.stop();
     worktreeGc.stop();
@@ -18060,19 +18206,19 @@ async function main() {
     }
     await watcher.stop();
     await pool.shutdown();
-    log50.info(TAG46, "Daemon stopped.");
+    log51.info(TAG47, "Daemon stopped.");
     process.exit(exitCode);
   };
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGHUP", () => shutdown("SIGHUP"));
   process.on("uncaughtException", (err) => {
-    log50.error(TAG46, `Uncaught exception: ${err.message}`);
+    log51.error(TAG47, `Uncaught exception: ${err.message}`);
     exitCode = 1;
     shutdown("uncaughtException");
   });
   process.on("unhandledRejection", (reason) => {
-    log50.error(TAG46, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+    log51.error(TAG47, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
     exitCode = 1;
     shutdown("unhandledRejection");
   });
@@ -18132,33 +18278,33 @@ async function handleBroadcast(event, client, pool, config, agentId) {
   if (assignedAgentId === undefined)
     return;
   if (assignedAgentId === agentId) {
-    log50.info(TAG46, `Broadcast: card ${cardId} assigned to agent`);
+    log51.info(TAG47, `Broadcast: card ${cardId} assigned to agent`);
     try {
       await pool.resetAttemptsForReassign(cardId);
       await tryEnqueueCard(cardId, client, pool, config, agentId);
     } catch (err) {
-      log50.error(TAG46, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
+      log51.error(TAG47, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
     }
   } else if (pool.isCardKnown(cardId)) {
-    log50.info(TAG46, `Broadcast: card ${cardId} unassigned from agent`);
+    log51.info(TAG47, `Broadcast: card ${cardId} unassigned from agent`);
     await pool.removeCard(cardId);
   }
 }
 async function tryEnqueueCard(cardId, client, pool, config, agentId) {
   const { card } = await client.getCard(cardId);
   if (card.assigned_agent_id !== agentId) {
-    log50.debug(TAG46, `Card ${cardId} no longer assigned to agent — skipping`);
+    log51.debug(TAG47, `Card ${cardId} no longer assigned to agent — skipping`);
     return;
   }
   if (card.done || card.archived_at) {
-    log50.debug(TAG46, `Card ${cardId} is finished — skipping`);
+    log51.debug(TAG47, `Card ${cardId} is finished — skipping`);
     return;
   }
   const board = await client.getBoard(config.projectId, { summary: true });
   const columns = board.columns;
   const column = columns.find((c) => c.id === card.column_id);
   if (!column) {
-    log50.warn(TAG46, `Column not found for card ${cardId}`);
+    log51.warn(TAG47, `Column not found for card ${cardId}`);
     return;
   }
   const route = classifyPickup(card, column.name, {
@@ -18167,31 +18313,31 @@ async function tryEnqueueCard(cardId, client, pool, config, agentId) {
     playbooks: config.agent.playbooks
   });
   if (!route) {
-    log50.info(TAG46, `Card #${card.short_id} is in "${column.name}", not a pickup/review/stage column — skipping`);
+    log51.info(TAG47, `Card #${card.short_id} is in "${column.name}", not a pickup/review/stage column — skipping`);
     return;
   }
   if (route.stage) {
-    log50.info(TAG46, `Card #${card.short_id} is a playbook stage card (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement pool) regardless of column`);
+    log51.info(TAG47, `Card #${card.short_id} is a playbook stage card (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement pool) regardless of column`);
   }
   const mode = route.mode;
   const labelMap = buildLabelMap(board.labels ?? []);
   const cardLabels = resolveCardLabels(card, labelMap);
   const subtasks = card.subtasks ?? [];
   if (mode === "review" && config.agent.review.approvedLabel && hasLabel(cardLabels, config.agent.review.approvedLabel)) {
-    log50.debug(TAG46, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
+    log51.debug(TAG47, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
     return;
   }
   if (mode === "review" && hasLabel(cardLabels, NEED_REVIEW_LABEL)) {
-    log50.debug(TAG46, `Card #${card.short_id} has "${NEED_REVIEW_LABEL}" label (needs human) — skipping review`);
+    log51.debug(TAG47, `Card #${card.short_id} has "${NEED_REVIEW_LABEL}" label (needs human) — skipping review`);
     return;
   }
   if (mode === "review" && !qualifiesForAutoReview(card.description)) {
-    log50.info(TAG46, `Card #${card.short_id} has no branch or PR reference — skipping auto-review`);
+    log51.info(TAG47, `Card #${card.short_id} has no branch or PR reference — skipping auto-review`);
     return;
   }
   await pool.enqueue(card, column, cardLabels, subtasks, mode);
 }
-var TAG46 = "daemon", BASE_REMOTE = "origin", PKG_VERSION;
+var TAG47 = "daemon", BASE_REMOTE = "origin", PKG_VERSION;
 var init_src2 = __esm(() => {
   init_account_guard();
   init_account_probe();
@@ -18317,22 +18463,22 @@ function realOrResolved(path) {
 var init_local_pin_migration = () => {};
 
 // src/head-anchor.ts
-import { log as log51 } from "@gethmy/harness";
+import { log as log52 } from "@gethmy/harness";
 function sealProvenHead(sha, provenance) {
   if (!/^[0-9a-f]{40}$/.test(sha)) {
-    log51.warn(TAG47, `refusing to seal "${sha}" as a head anchor (${provenance}) — an anchor is compared against the pull request's own head for equality, so an abbreviated or malformed sha would read as a mismatch rather than as the unreadable head it is`);
+    log52.warn(TAG48, `refusing to seal "${sha}" as a head anchor (${provenance}) — an anchor is compared against the pull request's own head for equality, so an abbreviated or malformed sha would read as a mismatch rather than as the unreadable head it is`);
     return;
   }
   return sha;
 }
-var TAG47 = "head-anchor";
+var TAG48 = "head-anchor";
 var init_head_anchor = () => {};
 
 // src/merge-cleanup.ts
 import { execFileSync as execFileSync11 } from "node:child_process";
 import { existsSync as existsSync7, lstatSync as lstatSync3, realpathSync as realpathSync2, statSync as statSync6 } from "node:fs";
 import { basename, dirname as dirname7, isAbsolute, resolve as resolve6, sep as sep4 } from "node:path";
-import { cleanupWorktree as cleanupWorktree6, GIT_NO_HOOKS as GIT_NO_HOOKS12, log as log52 } from "@gethmy/harness";
+import { cleanupWorktree as cleanupWorktree6, GIT_NO_HOOKS as GIT_NO_HOOKS12, log as log53 } from "@gethmy/harness";
 function canonicalize(p) {
   const original = isAbsolute(p) ? p : `${process.cwd()}${sep4}${p}`;
   try {
@@ -18407,7 +18553,7 @@ function linkedWorktreePaths(cwd) {
   if (main2 !== null && records.some((r) => r.path === main2)) {
     return records.filter((r) => r.path !== main2).map((r) => r.path);
   }
-  log52.warn(TAG48, `could not identify the main working tree of ${cwd} by path (git derived ${main2 ?? "nothing"} from --git-common-dir, which names no worktree in the listing) — falling back to dropping the first record, which git documents as the main tree. A merge or cleanup that then refuses a worktree it should accept is this fallback, not a forged registration.`);
+  log53.warn(TAG49, `could not identify the main working tree of ${cwd} by path (git derived ${main2 ?? "nothing"} from --git-common-dir, which names no worktree in the listing) — falling back to dropping the first record, which git documents as the main tree. A merge or cleanup that then refuses a worktree it should accept is this fallback, not a forged registration.`);
   return records.slice(1).map((r) => r.path);
 }
 function sameDirectoryIgnoringCase(asked, registered) {
@@ -18450,18 +18596,18 @@ function cleanupMergedWorktree(args) {
   }
   if (registration.kind !== "registered") {
     const reason = `refusing to clean up ${args.worktreePath} — git does not list it as a ` + `worktree of the repository at ${args.cwd}, and removing a path git ` + `does not manage would be a recursive delete of an unknown directory. ` + `Pass the worktree path Step B5 created, and re-run from the ` + `repository root.`;
-    log52.warn(TAG48, reason);
+    log53.warn(TAG49, reason);
     return { removed: false, reason };
   }
   if (cwdIsInsideWorktree(args.cwd, args.worktreePath) || cwdIsInsideWorktree(process.cwd(), args.worktreePath)) {
     const reason = `refusing to clean up ${args.worktreePath} from inside it — the branch ` + `delete would run with a deleted cwd and fail silently. Re-run from the ` + `repository root.`;
-    log52.warn(TAG48, reason);
+    log53.warn(TAG49, reason);
     return { removed: false, reason };
   }
   cleanupWorktree6(args.worktreePath, args.branchName ?? undefined);
   return { removed: !existsSync7(args.worktreePath) };
 }
-var TAG48 = "merge-cleanup";
+var TAG49 = "merge-cleanup";
 var init_merge_cleanup = () => {};
 
 // src/merge-command.ts
@@ -18476,7 +18622,7 @@ import { resolve as resolve7 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 import {
   GIT_NO_HOOKS as GIT_NO_HOOKS13,
-  log as log53,
+  log as log54,
   resolvePrHeadBranch as resolvePrHeadBranch3
 } from "@gethmy/harness";
 function buildFindingsBlock(items) {
@@ -18503,7 +18649,7 @@ async function gitRevParse(what, at) {
 async function cwdIsRepositoryTopLevel(cwd) {
   const top = await gitRevParse("--show-toplevel", cwd);
   if (!top || realpathOr(top) !== realpathOr(cwd)) {
-    log53.warn(TAG49, `not reading a local head from ${cwd} — it is not the top level of a git checkout (git answered ${top ?? "nothing"}). Run merge from the repository root, or pass --worktree.`);
+    log54.warn(TAG50, `not reading a local head from ${cwd} — it is not the top level of a git checkout (git answered ${top ?? "nothing"}). Run merge from the repository root, or pass --worktree.`);
     return false;
   }
   const gitDir = await gitRevParse("--git-dir", cwd);
@@ -18515,7 +18661,7 @@ async function cwdIsRepositoryTopLevel(cwd) {
   }
   if (isRegisteredWorktree(cwd, cwd))
     return true;
-  log53.warn(TAG49, `not reading a local head from ${cwd} — git does not list it as a worktree of its own repository.`);
+  log54.warn(TAG50, `not reading a local head from ${cwd} — git does not list it as a worktree of its own repository.`);
   return false;
 }
 function realpathOr(p) {
@@ -18540,7 +18686,7 @@ async function readValidatedWorktreeHead(deps) {
     const registration = classifyWorktreeRegistration(worktreePath, cwd);
     if (registration.kind !== "registered") {
       const detail = registration.kind === "case-mismatch" ? ` The worktree ${worktreePath} is the same directory as the registered ${registration.registered} and differs from it only in case, but git's registration carries the spelling above and this merge matches it exactly. Pass the registered spelling.` : registration.kind === "unanswerable" ? ` The worktree registrations of ${cwd} could not be listed at all, so ${worktreePath} could not be proved to be one of them.` : ` No validated worktree HEAD was available for ${worktreePath} — git does not list it as a worktree of the repository at ${cwd} — so the merge could not be bound to the head this run built and held for a person.`;
-      log53.warn(TAG49, `not reading a local head from ${worktreePath} (${registration.kind}).${detail} The merge will refuse: an interactive merge is only allowed for a head this run can prove it built.`);
+      log54.warn(TAG50, `not reading a local head from ${worktreePath} (${registration.kind}).${detail} The merge will refuse: an interactive merge is only allowed for a head this run can prove it built.`);
       return { sha: undefined, detail };
     }
   }
@@ -18554,7 +18700,7 @@ async function readValidatedWorktreeHead(deps) {
   const raw = await gitRevParse("HEAD", readAt);
   const sha = raw ? sealProvenHead(raw, worktreePath ? "registered-worktree" : "repository-top-level") : undefined;
   if (!sha) {
-    log53.warn(TAG49, `could not read a HEAD sha from ${readAt} (git answered ${raw ? `"${raw}"` : "nothing"}) — the merge will refuse, since it can only run for a head this run can prove it built`);
+    log54.warn(TAG50, `could not read a HEAD sha from ${readAt} (git answered ${raw ? `"${raw}"` : "nothing"}) — the merge will refuse, since it can only run for a head this run can prove it built`);
     return {
       sha: undefined,
       detail: ` No HEAD sha could be read from ${readAt}, so the merge could not be bound to the head this run built and held for a person.`
@@ -18563,14 +18709,14 @@ async function readValidatedWorktreeHead(deps) {
   if (worktreePath) {
     const resolved = await resolvePrHeadBranch3(deps.prUrl, cwd, deps.provider);
     if (resolved.kind === "skip") {
-      log53.warn(TAG49, `not corroborating ${worktreePath} against the head branch of ${deps.prUrl}: ${resolved.reason}. The anchor stands on the head sha alone.`);
+      log54.warn(TAG50, `not corroborating ${worktreePath} against the head branch of ${deps.prUrl}: ${resolved.reason}. The anchor stands on the head sha alone.`);
     } else {
       const branch = await checkedOutBranch(worktreePath);
       if (branch === null) {
-        log53.warn(TAG49, `${worktreePath} has no branch checked out (detached HEAD), so it could not be corroborated against ${resolved.branch}. The anchor stands on the head sha alone.`);
+        log54.warn(TAG50, `${worktreePath} has no branch checked out (detached HEAD), so it could not be corroborated against ${resolved.branch}. The anchor stands on the head sha alone.`);
       } else if (branch !== resolved.branch) {
         const detail = ` The worktree ${worktreePath} is on "${branch}", and ${deps.prUrl} has "${resolved.branch}" as its head branch — so that worktree is not where this pull request was built. --worktree is composed from a model's memory of the Step B5 path, which is why it is checked against the pull request and not only against git.`;
-        log53.warn(TAG49, `refusing the anchor from ${worktreePath}.${detail}`);
+        log54.warn(TAG50, `refusing the anchor from ${worktreePath}.${detail}`);
         return { sha: undefined, detail };
       }
     }
@@ -18620,7 +18766,7 @@ async function runMergeCommand(deps) {
       });
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
-      log53.warn(TAG49, `merge attempt failed: ${detail}`);
+      log54.warn(TAG50, `merge attempt failed: ${detail}`);
       deps.emit({
         type: "parked",
         reason: `the merge attempt failed: ${detail}`
@@ -18641,7 +18787,7 @@ async function runMergeCommand(deps) {
     if (outcome === "report-findings") {
       const reported = findings[0];
       if (!reported) {
-        log53.warn(TAG49, "the merge reported findings but none arrived through the callback — parking rather than reporting an empty list");
+        log54.warn(TAG50, "the merge reported findings but none arrived through the callback — parking rather than reporting an empty list");
         deps.emit({
           type: "parked",
           reason: "the independent review posted blocking findings, but they could not be reported — the card stays in Review for a person"
@@ -18691,7 +18837,7 @@ async function branchRefGone(branchName, cwd) {
     const stderr = String(failure.stderr ?? "").trim();
     if (failure.code === 1 && !stderr)
       return true;
-    log53.warn(TAG49, `could not determine whether ${branchName} still exists (code=${String(failure.code)}${stderr ? `, ${stderr}` : ""}) — reporting it as possibly present`);
+    log54.warn(TAG50, `could not determine whether ${branchName} still exists (code=${String(failure.code)}${stderr ? `, ${stderr}` : ""}) — reporting it as possibly present`);
     return false;
   }
 }
@@ -18702,7 +18848,7 @@ async function finish(deps) {
       const resolved = await resolvePrHeadBranch3(deps.prUrl, deps.cwd, deps.provider);
       const branch = resolved.kind === "branch" ? resolved.branch : null;
       if (resolved.kind === "skip") {
-        log53.warn(TAG49, `no head branch for ${deps.prUrl}: ${resolved.reason}`);
+        log54.warn(TAG50, `no head branch for ${deps.prUrl}: ${resolved.reason}`);
       }
       const out = cleanupMergedWorktree({
         worktreePath,
@@ -18711,12 +18857,12 @@ async function finish(deps) {
       });
       if (!out.removed) {
         const reason = out.reason ?? "the worktree directory still exists after cleanup";
-        log53.warn(TAG49, `cleanup refused for ${worktreePath}: ${reason}`);
+        log54.warn(TAG50, `cleanup refused for ${worktreePath}: ${reason}`);
         deps.emit({ type: "cleanup_refused", worktree: worktreePath, reason });
       } else {
         const branchGone = branch ? await branchRefGone(branch, deps.cwd) : true;
         if (branch && !branchGone) {
-          log53.warn(TAG49, `local branch ${branch} may still exist after cleanup`);
+          log54.warn(TAG50, `local branch ${branch} may still exist after cleanup`);
         }
         deps.emit({
           type: "cleaned",
@@ -18727,7 +18873,7 @@ async function finish(deps) {
       }
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
-      log53.warn(TAG49, `worktree cleanup failed for ${worktreePath}: ${detail}`);
+      log54.warn(TAG50, `worktree cleanup failed for ${worktreePath}: ${detail}`);
       deps.emit({
         type: "cleanup_refused",
         worktree: worktreePath,
@@ -18745,16 +18891,16 @@ async function finish(deps) {
     });
     if (!out.moved) {
       const reason = out.reason ?? "the card could not be moved out of Review";
-      log53.warn(TAG49, `board not updated after merge: ${reason}`);
+      log54.warn(TAG50, `board not updated after merge: ${reason}`);
       deps.emit({ type: "board_incomplete", reason });
     }
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
-    log53.warn(TAG49, `board not updated after merge: ${detail}`);
+    log54.warn(TAG50, `board not updated after merge: ${detail}`);
     deps.emit({ type: "board_incomplete", reason: detail });
   }
 }
-var TAG49 = "merge-command", POLL_INTERVAL_MS = 30000, execFileAsync2, KEEP_WAITING, PARK_REASONS;
+var TAG50 = "merge-command", POLL_INTERVAL_MS = 30000, execFileAsync2, KEEP_WAITING, PARK_REASONS;
 var init_merge_command = __esm(() => {
   init_src();
   init_auto_merge();
@@ -18770,6 +18916,7 @@ var init_merge_command = __esm(() => {
     "stamp-failure": "CI is red — the card stays in Review for a person",
     "stamp-findings-exhausted": "the findings loop spent its rounds and the independent review still objects — the findings were read and acted on, so this needs a person rather than another push",
     "stamp-review-findings": "the independent review posted blocking findings — nothing merges over an unread finding",
+    "stamp-conflict": "the pull request conflicts with its base — merge the base branch into it and push",
     "stamp-review-incomplete": "the independent review never reached a verdict (truncated or errored run)",
     rereview: "the branch moved since it was reviewed — the merge needs a fresh review",
     repair: "CI needs repair, which the interactive driver does not do",
@@ -18898,7 +19045,7 @@ init_package_version();
 import { readFileSync as readFileSync11, realpathSync as realpathSync4 } from "node:fs";
 import { dirname as dirname8, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { log as log54 } from "@gethmy/harness";
+import { log as log55 } from "@gethmy/harness";
 var USAGE = `
 Harmony Agent — push-based daemon + ops toolkit.
 
@@ -19773,7 +19920,7 @@ if (isMainModule()) {
     if (code !== 0)
       process.exit(code);
   }).catch((err) => {
-    log54.error("cli", err instanceof Error ? err.message : String(err));
+    log55.error("cli", err instanceof Error ? err.message : String(err));
     process.exit(1);
   });
 }