baxian 1.2.24 → 1.2.26

package/dist/event/handlers.js

@@ -6,8 +6,6 @@ const HEAD_SHA_RE = /^[0-9a-f]{40}$/i;
 function validHeadSha(value) {
     return typeof value === 'string' && HEAD_SHA_RE.test(value) ? value : undefined;
 }
-// Re-establish the develop-phase watcher after a handler-side rejection so the same
-// task can consume a corrected emit (same token) without a server restart.
 async function reArmDevelopWatcher(manager, task, agentId, opts = {}) {
     const kinds = task.phase === 'code' ? ['pr-created'] : ['spec-done', 'pr-created'];
     await manager.setupPhaseSignal(task.id, agentId, kinds, { skipSnapshot: opts.skipSnapshot ?? true });
@@ -49,9 +47,6 @@ async function resolveAuthoritativeHead(manager, task, opts = {}) {
         return { headSha: undefined, source: 'unknown', fetchError };
     }
 }
-// pr-fixed verification needs a LIVE head (no stale fallback). GitHub has brief
-// read-after-write lag + transient failures, so retry a few times, then throw so
-// the handler fails closed instead of mis-reading a no-op.
 async function fetchVerifiedHeadSha(manager, taskId) {
     let lastErr;
     for (let attempt = 0; attempt < 3; attempt++) {
@@ -66,13 +61,7 @@ async function fetchVerifiedHeadSha(manager, taskId) {
     }
     throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
 }
-// Budget = initial APPROVE dispatch + N redispatches; sized to converge a ~10-finding PR.
 export const POST_APPROVE_REDISPATCH_CAP = 10;
-// Clock-skew tolerance for the verdict freshness gate. GitHub `submitted_at` is
-// second-granularity and its clock drifts from baxian's ms-precision
-// `reviewDispatchedAt`; a false-reject is costly (poller cursor marks the review
-// processed and won't retry → task strands), while real superseded passes are
-// seconds-to-minutes stale, so a few seconds of slack is safe.
 export const VERDICT_FRESHNESS_SKEW_MS = 5000;
 async function dispatchDevPostApproveCheck(bus, manager, task, approvedHeadSha, opts = {}) {
     if (!approvedHeadSha) {
@@ -163,8 +152,6 @@ async function handlePrMergeReady(bus, manager, event) {
         });
     }
     const verdictAgentId = event.data.verdictAgentId;
-    // PhaseSignalWatcher unified `data.token`; old PostApproveSignalWatcher used
-    // `data.signalToken` — reading the wrong field strands approved tasks.
     const signalToken = event.data.token;
     const completion = await manager.getPostApproveCompletion(taskNow.id);
     if (taskNow.status !== 'approved'
@@ -204,8 +191,6 @@ async function handlePrMergeReady(bus, manager, event) {
         await dispatchDevPostApproveCheck(bus, manager, freshTask, freshCompletion.approvedHeadSha, { redispatchCount: nextCount });
         return;
     }
-    // merge:'auto' decides what confirm executes; persist the approved head so
-    // confirm's merge guard catches a push inside the gate window.
     const readied = await manager.transitionTaskStatus(freshTask.id, 'merge-ready', { fromStatus: ['approved'] }, { latestHeadSha: freshCompletion.approvedHeadSha });
     if (readied) {
         await manager.clearPostApproveCompletionIfMatches(freshTask.id, signalToken);
@@ -240,7 +225,6 @@ async function handlePrFeedback(bus, manager, event) {
         });
         return;
     }
-    // Don't Ctrl-C dev mid-pass on its own webhook echo — coalesce via pendingRedispatch.
     const devState = await manager.getAgentState(taskNow.agentId);
     if (devState?.taskId === taskNow.id) {
         if (!completion.pendingRedispatch) {
@@ -276,8 +260,6 @@ async function handlePrCodePush(bus, manager, event) {
     const eventPrUrl = event.data.prUrl;
     const eventKind = event.data.kind;
     const eventHeadSha = validHeadSha(event.data.headSha);
-    // Only `push` freshens `latestHeadSha` — legacy events (kind=undefined) use headSha
-    // for the review anchor only, not for the staleness fallback cache.
     const prPatch = {
         ...(eventPrNumber !== undefined ? { prNumber: eventPrNumber } : {}),
         ...(eventPrUrl !== undefined ? { prUrl: eventPrUrl } : {}),
@@ -292,13 +274,11 @@ async function handlePrCodePush(bus, manager, event) {
             `deferring catch-up`);
         return;
     }
-    // Anchor at dispatch time — must NOT shift if a subsequent push lands mid-review.
     const anchorAtDispatch = eventHeadSha ?? validHeadSha(taskBeforeTransition.latestHeadSha);
     const result = await manager.transitionTaskStatus(taskId, 'review', { fromStatus: ['in_progress', 'fixing', 'review', 'approved', 'merge-ready'] }, {
         ...prPatch,
         ...(anchorAtDispatch ? { reviewHeadAnchorSha: anchorAtDispatch } : {}),
         reviewDispatchedAt: new Date().toISOString(),
-        // Rotate token atomically so an old QA's late verdict is rejected by the gate.
         signalToken: createSignalToken(),
     });
     if (!result)
@@ -359,15 +339,11 @@ async function handlePrCodePush(bus, manager, event) {
         });
         return;
     }
-    // Persist qaAgentId BEFORE setting up so a pane-fallback verdict's review.submitted
-    // handler can read it for the release path.
     await manager.updateTask(transitioned.id, { qaAgentId: qa.id });
     const { armed } = await manager.rotateAndSetupPhaseSignal(transitioned.id, qa.id, ['pr-approved', 'pr-changes-requested']);
     if (!armed) {
         console.warn(`[EventHandler] pr.updated verdict watcher failed to arm for task=${transitioned.id} (${qaPhase}); rolling back recheck dispatch`);
         if (previousStatus === 'in_progress' || previousStatus === 'fixing') {
-            // Full rollback: restore status+token+anchor and re-arm so the dev's already-emitted
-            // signal isn't stranded by the token rotation.
             await manager.rollbackVerdictArmFailure(transitioned.id, {
                 status: previousStatus,
                 signalToken: taskBeforeTransition.signalToken,
@@ -376,8 +352,6 @@ async function handlePrCodePush(bus, manager, event) {
             });
         }
         else {
-            // approved/review: don't restore status (approved with cleared completion is unsafe;
-            // review was already current). Leave in review for operator follow-up.
             await manager.updateTask(transitioned.id, { qaAgentId: undefined });
         }
         await manager.releaseAgentForTask(qa.id, transitioned.id, 'idle').catch(err => {
@@ -406,7 +380,6 @@ async function handlePrCodePush(bus, manager, event) {
             await manager.failTaskForDispatchError(transitioned.id, qaPhase, qa.id, dispatchErr);
         }
         else if (dispatchErr instanceof EnsureSessionError && dispatchErr.partial.handled) {
-            // handleDialogPendingFromRuntime already marked QA Held + fail task + release partners
         }
         else {
             await manager.updateTask(transitioned.id, { qaAgentId: undefined });
@@ -433,8 +406,6 @@ async function handlePrCodePush(bus, manager, event) {
         }
         return;
     }
-    // Bump round for first review / approved re-review only; fixing/review→review recheck
-    // of the in-flight pass must NOT bump.
     if (previousStatus === 'in_progress' || previousStatus === 'approved' || previousStatus === 'merge-ready') {
         await manager.bumpReviewRoundIfStillAt(transitioned.id, expectedRound);
     }
@@ -468,14 +439,10 @@ async function handleReviewApproval(bus, manager, task, reviewedHeadSha, current
         });
         return;
     }
-    const result = await manager.transitionTaskStatus(task.id, 'approved', { fromStatus: ['review'] }, 
-    // reviewRound 0 = first pass entered via catch-up (deferred bump). Count it now.
-    task.reviewRound === 0 ? { ...prPatch, reviewRound: 1 } : prPatch);
+    const result = await manager.transitionTaskStatus(task.id, 'approved', { fromStatus: ['review'] }, task.reviewRound === 0 ? { ...prPatch, reviewRound: 1 } : prPatch);
     if (!result)
         return;
     const { task: transitioned } = result;
-    // Verdict consumed → tear down the fallback verdict watcher (poller path leaves
-    // it set-up-but-unfired; pane path already removed its entry — this is a no-op).
     manager.stopPhaseSignalWatcher(transitioned.id);
     if (transitioned.qaAgentId) {
         await manager.releaseAgentForTask(transitioned.qaAgentId, transitioned.id, 'idle', { allowAwaitingHuman: true })
@@ -507,8 +474,6 @@ async function handleReviewRequestChanges(bus, manager, task, reviewedHeadSha, c
     const reviewedRound = task.reviewRound === 0 ? 1 : task.reviewRound;
     const nextRound = reviewedRound + 1;
     if (task.status === 'approved' && nextRound <= manager.getConfig().review.rounds) {
-        // Post-approve check may still be running — clearing completion blocks auto-merge;
-        // fix dispatch deferred to avoid prompt collision with the in-flight check.
         const devState = await manager.getAgentState(task.agentId);
         const postApproveActive = await manager.getPostApproveCompletion(task.id);
         if (devState?.taskId === task.id && postApproveActive) {
@@ -646,13 +611,6 @@ export function registerEventHandlers(bus, manager) {
             return;
         if (await isServerModeTask(manager, event.taskId))
             return;
-        // pane-signal pr.created carries data.prNumber (extracted from the agent's
-        // [bx:pr-created:<num>:<token>] signal) but no prUrl / headSha. The
-        // transition only needs prNumber to wire task→PR; prUrl is derivable from
-        // repo+number; headSha lands via the next pr.updated push event.
-        //
-        // spec phase 由 server 评审链（server.spec.* handlers）驱动；poller 不应越过它派 QA review，
-        // 否则 QA 在 spec-review 槽位上跑 pr-review 流程，gh pr review --approve 会误触 post-approve。
         {
             const taskNow = await manager.getTask(event.taskId);
             if (taskNow?.phase === 'spec') {
@@ -715,8 +673,6 @@ export function registerEventHandlers(bus, manager) {
             }
         }
         const createdHeadSha = validHeadSha(event.data.headSha) ?? paneVerifiedHeadSha;
-        // Snapshot pre-transition fields so an arm failure can be rolled back atomically (restore
-        // status/token/anchor instead of stranding the task in review with no QA — see armed gate below).
         const taskBeforeTransition = await manager.getTask(event.taskId);
         const result = await manager.transitionTaskStatus(event.taskId, 'review', { fromStatus: ['in_progress', 'fixing'] }, {
             ...(event.data.prNumber !== undefined ? { prNumber: event.data.prNumber } : {}),
@@ -746,8 +702,6 @@ export function registerEventHandlers(bus, manager) {
             console.log(`[EventHandler] pr.created reconciled branch for task ${event.taskId}: ` +
                 `${taskBeforeTransition?.branch} → ${reconciledBranch}`);
         }
-        // Round captured before any verdict can land (watcher armed only after this) — the
-        // count-once token for bumpReviewRoundIfStillAt on the dispatch success path.
         const expectedRound = transitioned.reviewRound;
         const qa = manager.findQaPartner(event.agentId);
         if (!qa) {
@@ -759,7 +713,6 @@ export function registerEventHandlers(bus, manager) {
             }
             return;
         }
-        // Acquire before startSession so the lock window covers the task binding write.
         const acquired = await manager.acquireAgentForTask(qa.id, transitioned.id, 'review');
         if (!acquired) {
             await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
@@ -768,21 +721,9 @@ export function registerEventHandlers(bus, manager) {
             });
             return;
         }
-        // Persist qaAgentId BEFORE setting up so a pane-fallback verdict's review.submitted
-        // handler can read task.qaAgentId for the release path.
         await manager.updateTask(transitioned.id, { qaAgentId: qa.id });
-        // Poller is authoritative for the verdict (native `gh pr review` state, with
-        // commit_id + submitted_at). Set up the verdict watcher as a FALLBACK: when dev
-        // and qa share a GitHub identity, `gh pr review` is rejected (422 — can't
-        // review your own PR) and leaves no GitHub state to poll, so QA echoes the
-        // verdict as a pane signal instead. A distinct-identity task never fires this
-        // watcher; the review.submitted handler tears it down when the poller verdict lands.
         const { armed } = await manager.rotateAndSetupPhaseSignal(transitioned.id, qa.id, ['pr-approved', 'pr-changes-requested']);
         if (!armed) {
-            // Verdict watcher didn't arm. For a same-identity task the poller can't supply a verdict
-            // (422), so dispatching now would deadlock with no consumer. Atomically restore the
-            // pre-transition state (status/token/anchor) + re-arm the develop watcher so the dev's
-            // already-emitted pr-created is re-consumed (self-heal), then release QA + intervention.
             console.warn(`[EventHandler] pr.created verdict watcher failed to arm for task=${transitioned.id}; rolling back review dispatch`);
             await manager.rollbackVerdictArmFailure(transitioned.id, {
                 status: previousStatus,
@@ -816,11 +757,8 @@ export function registerEventHandlers(bus, manager) {
                 await manager.failTaskForDispatchError(transitioned.id, 'review', qa.id, dispatchErr);
             }
             else if (dispatchErr instanceof EnsureSessionError && dispatchErr.partial.handled) {
-                // handleDialogPendingFromRuntime 已标 QA Held + fail task + release partners；这里
-                // 再调 release 会因 boundTask terminal 让 shouldReleaseHeldBinding 放行 → 解锁仍卡 dialog 的 pane。
             }
             else {
-                // Rollback the pre-set up qaAgentId so the task doesn't keep a binding to a QA we never started.
                 await manager.updateTask(transitioned.id, { qaAgentId: undefined });
                 await manager.releaseAgentForTask(qa.id, transitioned.id, 'idle')
                     .catch(err => {
@@ -834,17 +772,11 @@ export function registerEventHandlers(bus, manager) {
             }
             return;
         }
-        // QA review pass started → count it (1-based Round). Bump on the success path only,
-        // so a no-QA / acquire / startSession failure above never inflates the round. The
-        // count-once token no-ops if a same-identity verdict already counted this pass.
         if (previousStatus === 'in_progress') {
             await manager.bumpReviewRoundIfStillAt(transitioned.id, expectedRound);
         }
         const ok = await manager.markAgentWaiting(event.agentId, transitioned.id);
         if (!ok) {
-            // QA review prompt 已粘进 pane 在跑；裸 release 让下一 review 派来同一 pane 会污染 outcome。
-            // 标 awaiting_human 让 operator 决定如何收尾（取消该 task 走 cancelTask，或等 QA 跑完再 Resume）。
-            // expectedTaskId: 防止迟到的 mark 撞 outcome 已被接受 + QA release+reassign 后的新 binding。
             await manager.markAwaitingHuman(qa.id, 'dev-wait-gate-failed-after-qa-started', `QA review for task ${transitioned.id} started but dev wait-gate failed; QA prompt may still be running, needs operator decision.`, { expectedTaskId: transitioned.id }).catch(err => {
                 console.error(`[EventHandler] pr.created markAwaitingHuman(QA=${qa.id}) after dev-wait-gate-fail:`, err);
             });
@@ -853,13 +785,9 @@ export function registerEventHandlers(bus, manager) {
     bus.on('pr.updated', async (event) => {
         if (!event.taskId || !event.agentId)
             return;
-        // Server tasks review via the exchange protocol — a poller-observed sync on
-        // the published PR must not drag them into legacy QA review.
-        // pr.merged stays open: external merges of a ready PR finish through it.
         if (await isServerModeTask(manager, event.taskId))
             return;
         const eventKind = event.data.kind;
-        // spec phase 由 server 评审链驱动；pr-merge-ready 是 dev 内部状态推进，不受限。
         if (eventKind !== 'pr-merge-ready') {
             const taskNow = await manager.getTask(event.taskId);
             if (taskNow?.phase === 'spec') {
@@ -882,18 +810,11 @@ export function registerEventHandlers(bus, manager) {
             ...(eventPrNumber !== undefined ? { prNumber: eventPrNumber } : {}),
             ...(eventPrUrl !== undefined ? { prUrl: eventPrUrl } : {}),
         };
-        const result = await manager.transitionTaskStatus(event.taskId, 'merged', 
-        // max_rounds included so manual mark-complete (and an externally-merged
-        // max_rounds PR the poller detects) transitions to merged + runs cleanup.
-        // ready included for server-mode afterDone:'pr' tasks whose managed PR is
-        // merged directly on GitHub instead of via baxian's Confirm.
-        { fromStatus: ['in_progress', 'fixing', 'review', 'approved', 'merge-ready', 'ready', 'max_rounds'] }, prPatch);
+        const result = await manager.transitionTaskStatus(event.taskId, 'merged', { fromStatus: ['in_progress', 'fixing', 'review', 'approved', 'merge-ready', 'ready', 'max_rounds'] }, prPatch);
         if (!result)
             return;
         const { task: transitioned } = result;
         if (transitioned.qaAgentId) {
-            // Keep QA bound (non-dispatchable) until its branch cleanup + /clear finish, then release.
-            // dispatchPostMergeCleanup owns the worktree removal → branch delete → /clear → release.
             if (transitioned.prNumber && transitioned.branch) {
                 await manager.dispatchPostMergeCleanup(transitioned.qaAgentId, {
                     taskId: transitioned.id,
@@ -901,7 +822,6 @@ export function registerEventHandlers(bus, manager) {
                 }).catch(err => console.warn(`[EventHandler] pr.merged dispatchPostMergeCleanup(QA=${transitioned.qaAgentId}) failed:`, err));
             }
             else {
-                // Nothing to clean up or compact — release QA immediately so it frees up.
                 try {
                     await manager.releaseAgentForTask(transitioned.qaAgentId, transitioned.id, 'idle');
                 }
@@ -926,11 +846,6 @@ export function registerEventHandlers(bus, manager) {
         let task = await manager.getTask(event.taskId);
         if (!task)
             return;
-        // Terminal-task escape: release QA on manual reviews of merged/cancelled/failed/max_rounds
-        // tasks; transitions below return null on terminal so QA would otherwise stay glued.
-        // 注：spec phase 任务也可能终态（spec-review max_rounds 只改 status 不清 phase）。terminal
-        // escape 必须在 spec gate 之前，否则 spec terminal 状态的残留 QA 绑定无法靠这条 manual
-        // review 兜底释放。
         {
             const terminalQaId = task.qaAgentId;
             if (terminalQaId && TASK_TERMINAL_STATUS_SET.has(task.status)) {
@@ -951,26 +866,14 @@ export function registerEventHandlers(bus, manager) {
                 }
             }
         }
-        // spec phase（非 terminal）由 server 评审链（server.spec.review.submitted）驱动 verdict；
-        // GitHub PR review 不应改 task.status，早退避免误推 approved + 派 dev post-approve。
-        // terminal 状态已在前面兜底释放，此处只屏蔽 active spec 路径。
         if (task.phase === 'spec') {
             console.warn(`[EventHandler] review.submitted (action=${action}) ignored for task ${task.id}: task in spec phase`);
             return;
         }
-        // Freshness gate: reject a verdict whose GitHub submit time precedes the
-        // current review pass's dispatch. Such a verdict belongs to a SUPERSEDED
-        // pass — dev force-pushed mid-review, the server re-dispatched a fresh pass,
-        // and the prior pass's late verdict is now landing. GitHub attributes a
-        // review to its submit-time head, so commit_id can't catch this; only baxian
-        // knows when it dispatched the active pass. Skipped when either timestamp is
-        // absent (can't prove staleness → allow).
         const verdictSubmittedAt = typeof event.data.submittedAt === 'string' ? event.data.submittedAt : undefined;
         if (verdictSubmittedAt && task.reviewDispatchedAt) {
             const submittedMs = Date.parse(verdictSubmittedAt);
             const dispatchedMs = Date.parse(task.reviewDispatchedAt);
-            // Reject only when clearly older than dispatch (beyond the skew budget) — a
-            // same-second fresh verdict must not be killed by clock granularity/drift.
             if (Number.isFinite(submittedMs) && Number.isFinite(dispatchedMs)
                 && submittedMs < dispatchedMs - VERDICT_FRESHNESS_SKEW_MS) {
                 await emitIntervention(bus, task.projectId, task.agentId, task.id, {
@@ -982,18 +885,6 @@ export function registerEventHandlers(bus, manager) {
                 return;
             }
         }
-        // Per-pass identity gate. signalToken rotates on every (re)dispatch, so a verdict
-        // whose pass token != the task's current token belongs to a SUPERSEDED pass. The
-        // token arrives two ways and BOTH must be checked:
-        //   - poller verdict: `reviewPassToken` (QA stamps it into the gh review body,
-        //     <!-- baxian:pr-approved:TOKEN -->; mapper/poller extract it).
-        //   - pane fallback verdict: `data.token` (the signal the watcher matched).
-        // Checking only the poller stamp leaves a hole: an old QA's late
-        // `[bx:pr-approved:<old-token>]`, fired by a not-yet-replaced watcher after a
-        // redispatch whose new-QA dispatch failed, would bypass the rotation. That pane
-        // case is worse — it has no headSha, so the handler would otherwise bind it to the
-        // new anchor head the old QA never reviewed. Verify-if-present: a human review (no
-        // stamp / no token) is not rejected.
         const verdictPassToken = (typeof event.data.reviewPassToken === 'string' ? event.data.reviewPassToken : undefined)
             ?? (typeof event.data.token === 'string' ? event.data.token : undefined);
         if (verdictPassToken && task.signalToken && verdictPassToken !== task.signalToken) {
@@ -1012,23 +903,11 @@ export function registerEventHandlers(bus, manager) {
             ...(eventPrNumber !== undefined && eventPrNumber !== task.prNumber ? { prNumber: eventPrNumber } : {}),
             ...(eventPrUrl !== undefined && eventPrUrl !== task.prUrl ? { prUrl: eventPrUrl } : {}),
         };
-        // Poller verdicts carry `headSha` (the review's GitHub commit_id) and
-        // `currentHeadSha` (the PR's live head). A pane-fallback verdict (same-identity
-        // 422 case) carries neither — the agent doesn't observe SHAs — so it applies to
-        // the head pinned at dispatch into `task.reviewHeadAnchorSha`. Using
-        // `latestHeadSha` would let a mid-review push silently re-anchor the approval to
-        // a commit QA never saw; the anchor is immutable per review round.
         const isPaneSignal = event.data.source === 'pane-signal';
         const reviewedHeadSha = validHeadSha(event.data.headSha)
             ?? (isPaneSignal ? validHeadSha(task.reviewHeadAnchorSha) : undefined);
         const currentHeadSha = validHeadSha(event.data.currentHeadSha)
             ?? (isPaneSignal ? validHeadSha(task.reviewHeadAnchorSha) : undefined);
-        // A late verdict can arrive while the task is still in_progress/fixing (the
-        // pr.created/pr.updated that should have moved it to review was missed). Catch up
-        // to review WITHOUT bumping here: the first-review count is derived from persisted
-        // state below (reviewRound === 0 ⇒ first pass) and applied only when the verdict is
-        // accepted. So a stale verdict that returns early leaves reviewRound 0, and the
-        // NEXT valid verdict — which no longer re-enters this catch-up — still counts it.
         if ((task.status === 'in_progress' || task.status === 'fixing') && eventPrNumber !== undefined) {
             const catchup = await manager.transitionTaskStatus(event.taskId, 'review', { fromStatus: ['in_progress', 'fixing'] }, prPatch);
             if (catchup) {
@@ -1053,10 +932,6 @@ export function registerEventHandlers(bus, manager) {
             return handleReviewRequestChanges(bus, manager, task, reviewedHeadSha, currentHeadSha, prPatch);
         }
     });
-    // Dev emitted pr-fixed: it claims the fixing round is done. Verify on GitHub
-    // before advancing (option C) — a new commit OR a reply to the findings means
-    // real work; neither means a no-op claim. Every GitHub read
-    // fails closed: a verification we can't complete must NOT be read as "no-op".
     bus.on('pr.fix.submitted', async (event) => {
         if (!event.taskId || !event.agentId)
             return;
@@ -1064,17 +939,10 @@ export function registerEventHandlers(bus, manager) {
         if (!task || task.reviewMode === 'server' || task.status !== 'fixing' || task.phase === 'spec')
             return;
         const { projectId, agentId } = task;
-        // The watcher is one-shot and already consumed this pr-fixed. For paths that
-        // leave the task in `fixing`, re-establish (skipSnapshot so we don't re-fire on the
-        // same scrollback signal) so the dev can retry pr-fixed after addressing the
-        // note — otherwise a corrected retry has no watcher and the task strands.
         const stayFixing = async (data) => {
             await emitIntervention(bus, projectId, agentId, task.id, data);
             await manager.setupPhaseSignal(task.id, agentId, 'pr-fixed', { skipSnapshot: true });
         };
-        // Anti-stale, fail-closed: a pr-fixed with a missing OR mismatched token
-        // (superseded pass) must not advance. No re-establish — a superseded pass means a
-        // fresh dispatch already set up its own watcher.
         const token = typeof event.data.token === 'string' ? event.data.token : undefined;
         if (!token || !task.signalToken || token !== task.signalToken) {
             await emitIntervention(bus, projectId, agentId, task.id, {
@@ -1084,9 +952,6 @@ export function registerEventHandlers(bus, manager) {
             });
             return;
         }
-        // pr-fixed's premise is "read the real GitHub state", so the head MUST come
-        // from a live fetch (resolveAuthoritativeHead's stale fallback could read the
-        // pre-push anchor). Fail closed on fetch failure rather than guessing no-op.
         let headSha;
         try {
             headSha = await fetchVerifiedHeadSha(manager, task.id);
@@ -1098,19 +963,12 @@ export function registerEventHandlers(bus, manager) {
             });
             return;
         }
-        // Without a review anchor we can't tell a pushed fix from a no-op — fail closed
-        // rather than mis-read the missing anchor as "no new commit".
         if (!task.reviewHeadAnchorSha) {
             await stayFixing({ phase: 'fix-verify-no-anchor', headSha });
             return;
         }
-        // New commit → the poller's pr.updated(push) is the authoritative advance;
-        // re-dispatching here too would double-trigger the QA recheck. Defer to it.
         if (headSha !== task.reviewHeadAnchorSha)
             return;
-        // No new commit: did the dev do anything since THIS fix round started? Use
-        // fixDispatchedAt (not reviewDispatchedAt) so QA/human comments left during the
-        // prior review don't count as dev activity. Fail closed on a fetch error.
         const since = task.fixDispatchedAt ?? task.reviewDispatchedAt;
         let hasReplies;
         try {
@@ -1130,8 +988,6 @@ export function registerEventHandlers(bus, manager) {
             });
             return;
         }
-        // Replies but no new commit (all "Won't fix"): recheck the same head + the
-        // replies. Reuse the push path for identical round/anchor/token semantics.
         await bus.emit({
             id: '',
             type: 'pr.updated',
@@ -1147,10 +1003,6 @@ export function registerEventHandlers(bus, manager) {
                 source: 'pr-fixed',
             },
         });
-        // If that synthetic advance failed downstream — the push handler rolls a failed
-        // QA dispatch back from review to fixing — the one-shot pr-fixed watcher is
-        // already consumed and (unlike a real push) there is no poller event to retry
-        // it. Surface it rather than leaving the task silently stuck in fixing.
         const afterAdvance = await manager.getTask(task.id);
         if (afterAdvance?.status === 'fixing') {
             await emitIntervention(bus, projectId, agentId, task.id, {