baxian 0.0.1 → 0.2.0

package/dist/event/handlers.js

@@ -0,0 +1,1121 @@
+import { createMarkerToken } from '../agent/marker-protocol.js';
+import { TASK_TERMINAL_STATUS_SET } from '../shared/index.js';
+import { DispatchTerminalError, EnsureSessionError } from '../agent/manager.js';
+const HEAD_SHA_RE = /^[0-9a-f]{40}$/i;
+function validHeadSha(value) {
+    return typeof value === 'string' && HEAD_SHA_RE.test(value) ? value : undefined;
+}
+async function emitIntervention(bus, projectId, agentId, taskId, data) {
+    try {
+        const evt = {
+            id: '',
+            type: 'human.intervention',
+            timestamp: new Date().toISOString(),
+            projectId,
+            agentId,
+            taskId,
+            data,
+        };
+        await bus.emit(evt);
+    }
+    catch (emitErr) {
+        console.warn(`[EventHandler] human.intervention emit failed (phase=${data.phase}):`, emitErr);
+    }
+}
+async function resolveAuthoritativeHead(manager, task, opts = {}) {
+    try {
+        const headSha = await manager.fetchPrHeadSha(task.id);
+        return { headSha, source: 'fetch' };
+    }
+    catch (err) {
+        const fetchError = err instanceof Error ? err.message : String(err);
+        console.warn(`[handlers] fetchPrHeadSha(task=${task.id}) failed; falling back to stored / payload:`, err);
+        const stored = validHeadSha(task.latestHeadSha);
+        if (stored)
+            return { headSha: stored, source: 'task-store', fetchError };
+        if (opts.payloadCurrentHeadSha) {
+            return { headSha: opts.payloadCurrentHeadSha, source: 'payload-self', fetchError };
+        }
+        if (opts.legacyFallback) {
+            return { headSha: opts.legacyFallback, source: 'completion-approved', fetchError };
+        }
+        return { headSha: undefined, source: 'unknown', fetchError };
+    }
+}
+// Budget = initial APPROVE dispatch + N redispatches; sized to converge a ~10-finding PR.
+export const POST_APPROVE_REDISPATCH_CAP = 10;
+async function dispatchDevPostApproveCheck(bus, manager, task, approvedHeadSha, opts = {}) {
+    if (!approvedHeadSha) {
+        await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+            phase: 'post-approve-approved-head-unavailable',
+        });
+        return;
+    }
+    const acquired = await manager.acquireAgentForTask(task.agentId, task.id, 'post_approve');
+    if (!acquired) {
+        await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+            phase: 'post-approve-dev-acquire-failed',
+            devAgentId: task.agentId,
+        });
+        return;
+    }
+    const postApproveToken = createMarkerToken();
+    await manager.setPostApproveCompletion(task.id, {
+        token: postApproveToken,
+        approvedHeadSha,
+        ...(typeof opts.redispatchCount === 'number' ? { redispatchCount: opts.redispatchCount } : {}),
+    });
+    let resumed = false;
+    let dispatchErr = null;
+    try {
+        resumed = await manager.continueSession(task.id, task.agentId, 'post_approve', {
+            postApproveToken,
+        });
+    }
+    catch (err) {
+        dispatchErr = err;
+        console.error(`[EventHandler] APPROVE continueSession(dev=${task.agentId}, post_approve) failed:`, err);
+    }
+    if (resumed)
+        return;
+    await manager.clearPostApproveCompletionIfMatches(task.id, postApproveToken);
+    if (dispatchErr instanceof DispatchTerminalError) {
+        await manager.failTaskForDispatchError(task.id, 'post_approve', task.agentId, dispatchErr);
+        return;
+    }
+    await manager.markAgentWaiting(task.agentId, task.id)
+        .catch(err => {
+        console.error(`[EventHandler] APPROVE markAgentWaiting(dev=${task.agentId}) rollback failed:`, err);
+        return false;
+    });
+    await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+        phase: 'post-approve-dispatch-failed',
+        reviewRound: task.reviewRound,
+        ...(dispatchErr instanceof DispatchTerminalError ? { terminalReason: dispatchErr.reason } : {}),
+        ...(dispatchErr ? { error: dispatchErr instanceof Error ? dispatchErr.message : String(dispatchErr) } : {}),
+    });
+}
+async function gateDevForPostApproveRedispatch(bus, manager, task) {
+    const ready = await manager
+        .releaseAgentForTask(task.agentId, task.id, 'waiting')
+        .catch(err => {
+        console.error(`[EventHandler] post-approve redispatch releaseAgentForTask(dev=${task.agentId}) failed:`, err);
+        return false;
+    });
+    if (ready)
+        return true;
+    await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+        phase: 'post-approve-dev-wait-gate-failed-before-redispatch',
+        devAgentId: task.agentId,
+    });
+    return false;
+}
+export function registerEventHandlers(bus, manager, config) {
+    bus.on('pr.created', async (event) => {
+        if (!event.taskId || !event.agentId)
+            return;
+        const createdHeadSha = validHeadSha(event.data.headSha);
+        const result = await manager.transitionTaskStatus(event.taskId, 'review', { fromStatus: ['in_progress', 'fixing'] }, {
+            ...(event.data.prNumber !== undefined ? { prNumber: event.data.prNumber } : {}),
+            ...(event.data.prUrl !== undefined ? { prUrl: event.data.prUrl } : {}),
+            ...(createdHeadSha ? { latestHeadSha: createdHeadSha } : {}),
+        });
+        if (!result) {
+            console.warn(`[EventHandler] pr.created: cannot transition task ${event.taskId} (terminal or invalid from-state)`);
+            return;
+        }
+        const { task: transitioned } = result;
+        const qa = manager.findQaPartner(event.agentId);
+        if (!qa) {
+            const ok = await manager.markAgentWaiting(event.agentId, transitioned.id);
+            if (!ok) {
+                await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                    phase: 'dev-wait-gate-failed-no-qa',
+                });
+            }
+            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, {
+                phase: 'qa-acquire-failed',
+                qaAgentId: qa.id,
+            });
+            return;
+        }
+        let started = false;
+        let dispatchErr = null;
+        try {
+            started = await manager.startSession(transitioned.id, qa.id, 'review');
+        }
+        catch (err) {
+            dispatchErr = err;
+            console.error(`[EventHandler] pr.created startSession(QA=${qa.id}) hard error:`, err);
+        }
+        if (!started) {
+            console.warn(`[EventHandler] pr.created QA session not started for task=${transitioned.id}; ` +
+                `task stays in 'review' but no active QA — emitting human.intervention`);
+            if (dispatchErr instanceof DispatchTerminalError) {
+                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 {
+                await manager.releaseAgentForTask(qa.id, transitioned.id, 'idle')
+                    .catch(err => {
+                    console.error(`[EventHandler] pr.created releaseAgentForTask(QA=${qa.id}) after start-not-true failed:`, err);
+                    return false;
+                });
+                await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                    phase: 'qa-review-start-failed',
+                    qaAgentId: qa.id,
+                });
+            }
+            return;
+        }
+        // Persist qaAgentId BEFORE markAgentWaiting so failure can still mark the QA.
+        await manager.updateTask(transitioned.id, { qaAgentId: qa.id });
+        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);
+            });
+        }
+    });
+    bus.on('pr.updated', async (event) => {
+        if (!event.taskId || !event.agentId)
+            return;
+        const eventPrNumber = event.data.prNumber;
+        const eventPrUrl = event.data.prUrl;
+        const eventKind = event.data.kind;
+        // Only `push` freshens `latestHeadSha` — other event payloads can regress it under reorder.
+        const eventHeadSha = validHeadSha(event.data.headSha);
+        const prPatch = {
+            ...(eventPrNumber !== undefined ? { prNumber: eventPrNumber } : {}),
+            ...(eventPrUrl !== undefined ? { prUrl: eventPrUrl } : {}),
+            ...(eventKind === 'push' && eventHeadSha ? { latestHeadSha: eventHeadSha } : {}),
+        };
+        if (eventKind === 'post-approve-complete') {
+            const taskNow = await manager.getTask(event.taskId);
+            if (!taskNow)
+                return;
+            const needsPatch = (eventPrNumber !== undefined && eventPrNumber !== taskNow.prNumber)
+                || (eventPrUrl !== undefined && eventPrUrl !== taskNow.prUrl);
+            if (needsPatch) {
+                await manager.updateTask(event.taskId, prPatch);
+            }
+            const verdictAgentId = event.data.verdictAgentId;
+            const postApproveToken = event.data.postApproveToken;
+            const completion = await manager.getPostApproveCompletion(taskNow.id);
+            if (taskNow.status !== 'approved'
+                || verdictAgentId !== taskNow.agentId
+                || !postApproveToken
+                || completion?.token !== postApproveToken)
+                return;
+            const ok = await manager.markAgentWaiting(taskNow.agentId, taskNow.id);
+            if (!ok) {
+                await emitIntervention(bus, taskNow.projectId, taskNow.agentId, taskNow.id, {
+                    phase: 'post-approve-dev-wait-gate-failed',
+                });
+                return;
+            }
+            const freshTask = await manager.getTask(taskNow.id);
+            const freshCompletion = await manager.getPostApproveCompletion(taskNow.id);
+            if (!freshTask
+                || freshTask.status !== 'approved'
+                || freshTask.agentId !== taskNow.agentId
+                || freshCompletion?.token !== postApproveToken) {
+                await emitIntervention(bus, taskNow.projectId, taskNow.agentId, taskNow.id, {
+                    phase: 'post-approve-merge-skipped-stale-task',
+                });
+                return;
+            }
+            // pendingRedispatch means new feedback arrived mid-pass — redispatch instead of merging.
+            if (freshCompletion.pendingRedispatch) {
+                const nextCount = (freshCompletion.redispatchCount ?? 0) + 1;
+                if (nextCount > POST_APPROVE_REDISPATCH_CAP) {
+                    await manager.clearPostApproveCompletion(freshTask.id);
+                    await emitIntervention(bus, freshTask.projectId, freshTask.agentId, freshTask.id, {
+                        phase: 'post-approve-redispatch-cap-exceeded',
+                        redispatchCount: freshCompletion.redispatchCount ?? 0,
+                        cap: POST_APPROVE_REDISPATCH_CAP,
+                    });
+                    return;
+                }
+                await dispatchDevPostApproveCheck(bus, manager, freshTask, freshCompletion.approvedHeadSha, { redispatchCount: nextCount });
+                return;
+            }
+            const project = manager.getProjectConfig(freshTask.projectId);
+            if (project?.merge === 'auto') {
+                try {
+                    await manager.mergePr(freshTask.id, { matchHeadSha: freshCompletion.approvedHeadSha });
+                    await manager.clearPostApproveCompletionIfMatches(freshTask.id, postApproveToken);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    console.error(`[EventHandler] post-approve auto-merge failed for task=${freshTask.id}:`, err);
+                    await emitIntervention(bus, freshTask.projectId, freshTask.agentId, freshTask.id, {
+                        phase: 'merge-failed',
+                        error: message,
+                    });
+                    throw err;
+                }
+            }
+            return;
+        }
+        const isCodeUpdate = eventKind === 'push' || eventKind === undefined;
+        if (!isCodeUpdate) {
+            const taskNow = await manager.getTask(event.taskId);
+            if (!taskNow)
+                return;
+            const needsPatch = (eventPrNumber !== undefined && eventPrNumber !== taskNow.prNumber)
+                || (eventPrUrl !== undefined && eventPrUrl !== taskNow.prUrl);
+            if (needsPatch) {
+                await manager.updateTask(event.taskId, prPatch);
+            }
+            const completion = taskNow.status === 'approved'
+                ? await manager.getPostApproveCompletion(taskNow.id)
+                : null;
+            const isNewFeedback = eventKind === 'comment' || eventKind === 'review-comment';
+            if (taskNow.status === 'approved' && isNewFeedback) {
+                if (!completion) {
+                    await emitIntervention(bus, taskNow.projectId, taskNow.agentId, taskNow.id, {
+                        phase: 'post-approve-approved-head-unavailable',
+                    });
+                    return;
+                }
+                // Don't Ctrl-C Dev mid-pass on its own webhook echo — coalesce via pendingRedispatch instead.
+                const devState = await manager.getAgentState(taskNow.agentId);
+                if (devState?.taskId === taskNow.id) {
+                    if (!completion.pendingRedispatch) {
+                        await manager.setPostApproveCompletion(taskNow.id, {
+                            token: completion.token,
+                            approvedHeadSha: completion.approvedHeadSha,
+                            ...(typeof completion.redispatchCount === 'number'
+                                ? { redispatchCount: completion.redispatchCount } : {}),
+                            pendingRedispatch: true,
+                        });
+                    }
+                    return;
+                }
+                const nextCount = (completion.redispatchCount ?? 0) + 1;
+                if (nextCount > POST_APPROVE_REDISPATCH_CAP) {
+                    // Clear completion so an in-flight marker can't auto-merge past the cap.
+                    await manager.clearPostApproveCompletion(taskNow.id);
+                    await emitIntervention(bus, taskNow.projectId, taskNow.agentId, taskNow.id, {
+                        phase: 'post-approve-redispatch-cap-exceeded',
+                        redispatchCount: completion.redispatchCount ?? 0,
+                        cap: POST_APPROVE_REDISPATCH_CAP,
+                    });
+                    return;
+                }
+                const ready = await gateDevForPostApproveRedispatch(bus, manager, taskNow);
+                if (!ready)
+                    return;
+                await dispatchDevPostApproveCheck(bus, manager, { ...taskNow, ...prPatch }, completion.approvedHeadSha, { redispatchCount: nextCount });
+            }
+            return;
+        }
+        const taskBeforeTransition = await manager.getTask(event.taskId);
+        if (!taskBeforeTransition)
+            return;
+        const willHavePrNumber = taskBeforeTransition.prNumber !== undefined || eventPrNumber !== undefined;
+        if (taskBeforeTransition.status === 'in_progress' && !willHavePrNumber) {
+            console.warn(`[EventHandler] pr.updated: task ${event.taskId} in_progress but neither task nor event has prNumber; ` +
+                `deferring catch-up`);
+            return;
+        }
+        const result = await manager.transitionTaskStatus(event.taskId, 'review', { fromStatus: ['in_progress', 'fixing', 'review', 'approved'] }, prPatch);
+        if (!result)
+            return;
+        const { task: transitioned, previousStatus } = result;
+        await manager.clearPostApproveCompletion(transitioned.id);
+        let devAlreadyWaiting = false;
+        if (previousStatus === 'approved') {
+            devAlreadyWaiting = await manager
+                .releaseAgentForTask(transitioned.agentId, transitioned.id, 'waiting')
+                .catch(err => {
+                console.error(`[EventHandler] pr.updated releaseAgentForTask(dev=${transitioned.agentId}) before approved→recheck failed:`, err);
+                return false;
+            });
+            if (!devAlreadyWaiting) {
+                await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                    phase: 'post-approve-dev-wait-gate-failed-before-recheck',
+                    devAgentId: transitioned.agentId,
+                });
+                return;
+            }
+        }
+        // Release stale QA before recheck — a half-released REPL must not receive new prompt.
+        if (previousStatus === 'review' && transitioned.qaAgentId) {
+            const released = await manager
+                .releaseAgentForTask(transitioned.qaAgentId, transitioned.id, 'idle')
+                .catch(err => {
+                console.error(`[EventHandler] pr.updated releaseAgentForTask(QA=${transitioned.qaAgentId}) for review→review push failed:`, err);
+                return false;
+            });
+            if (!released) {
+                await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                    phase: 'qa-release-failed-cannot-recheck',
+                    qaAgentId: transitioned.qaAgentId,
+                });
+                return;
+            }
+        }
+        const qaPhase = previousStatus === 'fixing' || previousStatus === 'review' || previousStatus === 'approved'
+            ? 'recheck'
+            : 'review';
+        const qa = manager.findQaPartner(event.agentId);
+        if (!qa) {
+            if (!devAlreadyWaiting && !(await manager.markAgentWaiting(event.agentId, transitioned.id))) {
+                await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                    phase: 'dev-wait-gate-failed-no-qa',
+                });
+            }
+            return;
+        }
+        const acquired = await manager.acquireAgentForTask(qa.id, transitioned.id, qaPhase);
+        if (!acquired) {
+            await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                phase: 'qa-acquire-failed',
+                qaAgentId: qa.id,
+                qaPhase,
+            });
+            return;
+        }
+        let started = false;
+        let dispatchErr = null;
+        try {
+            started = await manager.startSession(transitioned.id, qa.id, qaPhase);
+        }
+        catch (err) {
+            dispatchErr = err;
+            console.error(`[EventHandler] pr.updated startSession(QA=${qa.id}, ${qaPhase}) hard error:`, err);
+        }
+        if (!started) {
+            console.warn(`[EventHandler] pr.updated QA ${qaPhase} not started; previousStatus=${previousStatus}`);
+            if (dispatchErr instanceof DispatchTerminalError) {
+                await manager.failTaskForDispatchError(transitioned.id, qaPhase, 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 {
+                await manager.releaseAgentForTask(qa.id, transitioned.id, 'idle')
+                    .catch(err => {
+                    console.error(`[EventHandler] pr.updated releaseAgentForTask(QA=${qa.id}) after start-not-true failed:`, err);
+                    return false;
+                });
+                if (previousStatus === 'approved') {
+                    await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                        phase: 'qa-recheck-failed-after-approved-push',
+                        qaAgentId: qa.id,
+                    });
+                }
+                else if (previousStatus !== 'review') {
+                    await manager.transitionTaskStatus(transitioned.id, previousStatus, { fromStatus: ['review'] });
+                }
+                else {
+                    await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                        phase: 'qa-recheck-failed-after-stop',
+                        qaAgentId: qa.id,
+                    });
+                }
+            }
+            return;
+        }
+        await manager.updateTask(transitioned.id, { qaAgentId: qa.id });
+        const ok = devAlreadyWaiting || (await manager.markAgentWaiting(event.agentId, transitioned.id));
+        if (!ok) {
+            // 同 pr.created 路径：QA review prompt 已粘进 pane 在跑，裸 release 让下一 review
+            // 派同一 QA 时新 prompt 灌进仍在跑旧 review 的 pane。标 awaiting_human 让 operator 处理。
+            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.updated markAwaitingHuman(QA=${qa.id}) after dev-wait-gate-fail:`, err);
+            });
+        }
+    });
+    bus.on('pr.merged', async (event) => {
+        if (!event.taskId)
+            return;
+        const eventPrNumber = event.data.prNumber;
+        const eventPrUrl = event.data.prUrl;
+        const prPatch = {
+            ...(eventPrNumber !== undefined ? { prNumber: eventPrNumber } : {}),
+            ...(eventPrUrl !== undefined ? { prUrl: eventPrUrl } : {}),
+        };
+        const result = await manager.transitionTaskStatus(event.taskId, 'merged', { fromStatus: ['in_progress', 'fixing', 'review', 'approved'] }, prPatch);
+        if (!result)
+            return;
+        const { task: transitioned } = result;
+        if (transitioned.qaAgentId) {
+            // Release first: 'idle' release removes QA's worktree, and the cleanup must run
+            // in the stable post-release state (server-side git ops use the main repo clone).
+            try {
+                await manager.releaseAgentForTask(transitioned.qaAgentId, transitioned.id, 'idle');
+            }
+            catch (err) {
+                console.error(`[EventHandler] pr.merged releaseAgentForTask(QA=${transitioned.qaAgentId}) failed:`, err);
+            }
+            if (transitioned.prNumber && transitioned.branch) {
+                await manager.dispatchPostMergeCleanup(transitioned.qaAgentId, {
+                    prNumber: transitioned.prNumber,
+                    taskId: transitioned.id,
+                    branch: transitioned.branch,
+                }).catch(err => console.warn(`[EventHandler] pr.merged dispatchPostMergeCleanup(QA=${transitioned.qaAgentId}) failed:`, err));
+            }
+        }
+        try {
+            await manager.cleanupAfterMerge(transitioned.id);
+        }
+        catch (err) {
+            console.error(`[EventHandler] cleanupAfterMerge(${transitioned.id}) failed:`, err);
+        }
+        try {
+            await manager.drainQueue(transitioned.projectId);
+        }
+        catch (err) {
+            console.error(`[EventHandler] drainQueue(${transitioned.projectId}) failed:`, err);
+        }
+    });
+    bus.on('review.submitted', async (event) => {
+        if (!event.taskId)
+            return;
+        const action = event.data.action;
+        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.
+        {
+            const terminalQaId = task.qaAgentId;
+            if (terminalQaId && TASK_TERMINAL_STATUS_SET.has(task.status)) {
+                const qaState = await manager.getAgentState(terminalQaId);
+                if (qaState?.taskId === task.id) {
+                    const terminalTask = task;
+                    await manager
+                        .releaseAgentForTask(terminalQaId, terminalTask.id, 'idle')
+                        .catch(err => console.error(`[EventHandler] terminal-task manual review releaseAgentForTask(QA=${terminalQaId}) failed:`, err));
+                    await emitIntervention(bus, terminalTask.projectId, terminalTask.agentId, terminalTask.id, {
+                        phase: 'manual-review-on-terminal-task-completed',
+                        qaAgentId: terminalQaId,
+                        taskStatus: terminalTask.status,
+                        reviewAction: action,
+                        note: 'Manual QA review on a terminal task finished. Task state untouched; QA released. Operator owns any follow-up.',
+                    });
+                    return;
+                }
+            }
+        }
+        const eventPrNumber = event.data.prNumber;
+        const eventPrUrl = event.data.prUrl;
+        const prPatch = {
+            ...(eventPrNumber !== undefined && eventPrNumber !== task.prNumber ? { prNumber: eventPrNumber } : {}),
+            ...(eventPrUrl !== undefined && eventPrUrl !== task.prUrl ? { prUrl: eventPrUrl } : {}),
+        };
+        const reviewedHeadSha = validHeadSha(event.data.headSha);
+        const currentHeadSha = validHeadSha(event.data.currentHeadSha);
+        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) {
+                task = catchup.task;
+                if (task.agentId) {
+                    const ok = await manager.markAgentWaiting(task.agentId, task.id);
+                    if (!ok) {
+                        await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                            phase: 'dev-wait-gate-failed-late-catchup',
+                        });
+                    }
+                }
+            }
+            else {
+                return;
+            }
+        }
+        if (action === 'APPROVE') {
+            if (!reviewedHeadSha) {
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'approval-reviewed-head-unavailable',
+                });
+                return;
+            }
+            const anchor = await resolveAuthoritativeHead(manager, task, {
+                payloadCurrentHeadSha: currentHeadSha,
+            });
+            // Refresh cache BEFORE the reject decision so a fetch outage can't fall back to a stale store.
+            if (anchor.source === 'fetch' && anchor.headSha && task.latestHeadSha !== anchor.headSha) {
+                await manager.updateTask(task.id, { latestHeadSha: anchor.headSha });
+            }
+            // No anchor (fetch + fallbacks all missing) ⇒ proceed; can't prove staleness either way.
+            if (anchor.headSha && reviewedHeadSha !== anchor.headSha) {
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'stale-approval-head-mismatch',
+                    reviewedHeadSha,
+                    currentHeadSha: anchor.headSha,
+                    source: anchor.source,
+                    ...(anchor.fetchError ? { fetchError: anchor.fetchError } : {}),
+                });
+                return;
+            }
+            const result = await manager.transitionTaskStatus(event.taskId, 'approved', { fromStatus: ['review'] }, prPatch);
+            if (!result)
+                return;
+            const { task: transitioned } = result;
+            if (transitioned.qaAgentId) {
+                // outcome 到达 = QA turn 完成，即使 QA 之前 Held（dev_wait_gate_failed / ack_unknown）也可放行。
+                await manager.releaseAgentForTask(transitioned.qaAgentId, transitioned.id, 'idle', { allowAwaitingHuman: true })
+                    .catch(err => console.error(`[EventHandler] APPROVE releaseAgentForTask(QA=${transitioned.qaAgentId}) failed:`, err));
+            }
+            await dispatchDevPostApproveCheck(bus, manager, transitioned, reviewedHeadSha);
+            return;
+        }
+        if (action === 'REQUEST_CHANGES') {
+            const approvedCompletion = task.status === 'approved'
+                ? await manager.getPostApproveCompletion(task.id)
+                : null;
+            const anchor = await resolveAuthoritativeHead(manager, task, {
+                payloadCurrentHeadSha: currentHeadSha,
+                legacyFallback: approvedCompletion?.approvedHeadSha,
+            });
+            if (anchor.source === 'fetch' && anchor.headSha && task.latestHeadSha !== anchor.headSha) {
+                await manager.updateTask(task.id, { latestHeadSha: anchor.headSha });
+            }
+            if (reviewedHeadSha && anchor.headSha && reviewedHeadSha !== anchor.headSha) {
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'stale-request-changes-head-mismatch',
+                    reviewedHeadSha,
+                    currentHeadSha: anchor.headSha,
+                    source: anchor.source,
+                    ...(anchor.fetchError ? { fetchError: anchor.fetchError } : {}),
+                });
+                return;
+            }
+            const nextRound = task.reviewRound + 1;
+            if (task.status === 'approved' && nextRound <= config.review.rounds) {
+                // post-approve check 可能仍在 dev pane 中跑——release(waiting) 只 bump updatedAt 不 wait ready，
+                // 后续 continueSession(fix) 会把 fix prompt 灌进 busy pane (pr.updated approved+new feedback 已通过
+                // pendingRedispatch 走 coalesce；review.submitted 这里需要同等 gate)。检测 dev 仍绑 task + post-approve
+                // completion 仍存在 → emit intervention + skip 派发；marker 完成后 (post-approve-complete handler)
+                // task 会回到 approved，operator 可以重新触发 REQUEST_CHANGES manual review 或 cancel task。
+                const devState = await manager.getAgentState(task.agentId);
+                const postApproveActive = await manager.getPostApproveCompletion(task.id);
+                if (devState?.taskId === task.id && postApproveActive) {
+                    // 必须先清 PostApproveCompletion 阻止 marker 完成后 auto-merge：
+                    // post-approve-complete handler 看 completion.token 仍匹配 + freshTask.status='approved'
+                    // + pendingRedispatch=false 会调 mergePr——但我们刚收到 REQUEST_CHANGES，绝不能 merge。
+                    await manager.clearPostApproveCompletion(task.id);
+                    await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                        phase: 'request-changes-during-post-approve',
+                        devAgentId: task.agentId,
+                        note: 'Dev is still running post-approve check; fix dispatch deferred to avoid prompt collision. PostApproveCompletion cleared to block auto-merge. Operator: wait for post-approve marker to complete, then re-trigger REQUEST_CHANGES manually or cancel the task.',
+                    });
+                    return;
+                }
+                const ready = await manager
+                    .releaseAgentForTask(task.agentId, task.id, 'waiting')
+                    .catch(err => {
+                    console.error(`[EventHandler] REQUEST_CHANGES releaseAgentForTask(dev=${task.agentId}) before fix failed:`, err);
+                    return false;
+                });
+                if (!ready) {
+                    await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                        phase: 'post-approve-dev-wait-gate-failed-before-fix',
+                        devAgentId: task.agentId,
+                    });
+                    return;
+                }
+            }
+            if (nextRound > config.review.rounds) {
+                const result = await manager.transitionTaskStatus(event.taskId, 'max_rounds', { fromStatus: ['review', 'approved'] }, prPatch);
+                if (!result)
+                    return;
+                const { task: transitioned, previousStatus } = result;
+                await manager.clearPostApproveCompletion(transitioned.id);
+                if (previousStatus === 'review' && transitioned.qaAgentId) {
+                    await manager.releaseAgentForTask(transitioned.qaAgentId, transitioned.id, 'idle')
+                        .catch(err => console.error(`[EventHandler] max_rounds releaseAgentForTask(QA=${transitioned.qaAgentId}) failed:`, err));
+                }
+                if (transitioned.agentId) {
+                    await manager.releaseAgentForTask(transitioned.agentId, transitioned.id, 'idle')
+                        .catch(err => console.error(`[EventHandler] max_rounds releaseAgentForTask(dev=${transitioned.agentId}) failed:`, err));
+                }
+                try {
+                    await bus.emit({
+                        id: '',
+                        type: 'review.max_rounds',
+                        timestamp: new Date().toISOString(),
+                        projectId: transitioned.projectId,
+                        agentId: transitioned.agentId,
+                        taskId: transitioned.id,
+                        data: { reviewRound: transitioned.reviewRound },
+                    });
+                }
+                catch (emitErr) {
+                    console.warn(`[EventHandler] max_rounds emit failed:`, emitErr);
+                }
+                return;
+            }
+            const result = await manager.transitionTaskStatus(event.taskId, 'fixing', { fromStatus: ['review', 'approved'] }, { ...prPatch, reviewRound: nextRound });
+            if (!result)
+                return;
+            const { task: transitioned, previousStatus } = result;
+            await manager.clearPostApproveCompletion(transitioned.id);
+            let qaReleased = true;
+            if (previousStatus === 'review' && transitioned.qaAgentId) {
+                // outcome 到达 = QA turn 完成，allowAwaitingHuman 让 Held QA (ack_unknown / dev_wait_gate_failed) 也可放行。
+                qaReleased = await manager
+                    .releaseAgentForTask(transitioned.qaAgentId, transitioned.id, 'idle', { allowAwaitingHuman: true })
+                    .catch(err => {
+                    console.error(`[EventHandler] REQUEST_CHANGES releaseAgentForTask(QA=${transitioned.qaAgentId}) failed:`, err);
+                    return false;
+                });
+                if (!qaReleased) {
+                    await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                        phase: 'qa-release-failed-but-dev-dispatched',
+                        qaAgentId: transitioned.qaAgentId,
+                    });
+                }
+            }
+            // Explicit acquire short-circuits if a concurrent DELETE/restart-repl released the lock.
+            const acquired = await manager.acquireAgentForTask(transitioned.agentId, transitioned.id, 'fix');
+            if (!acquired) {
+                await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                    phase: 'dev-acquire-failed-fix',
+                    devAgentId: transitioned.agentId,
+                });
+                return;
+            }
+            let resumed = false;
+            let dispatchErr = null;
+            try {
+                resumed = await manager.continueSession(transitioned.id, transitioned.agentId, 'fix');
+            }
+            catch (err) {
+                dispatchErr = err;
+                console.error(`[EventHandler] REQUEST_CHANGES continueSession(dev=${transitioned.agentId}, fix) failed:`, err);
+            }
+            if (!resumed) {
+                console.warn(`[EventHandler] REQUEST_CHANGES dev=${transitioned.agentId} not resumable for task=${transitioned.id}; ` +
+                    `task remains in 'fixing' but no dev session is attached`);
+                if (dispatchErr instanceof DispatchTerminalError) {
+                    await manager.failTaskForDispatchError(transitioned.id, 'fix', transitioned.agentId, dispatchErr);
+                }
+                else {
+                    await manager.markAgentWaiting(transitioned.agentId, transitioned.id)
+                        .catch(err => {
+                        console.error(`[EventHandler] REQUEST_CHANGES markAgentWaiting(dev=${transitioned.agentId}) rollback failed:`, err);
+                        return false;
+                    });
+                    await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                        phase: 'fix-resume-failed',
+                        reviewRound: transitioned.reviewRound,
+                    });
+                }
+            }
+        }
+    });
+    bus.on('spec.ready', async (event) => {
+        if (!event.taskId)
+            return;
+        const task = await manager.getTask(event.taskId);
+        if (!task)
+            return;
+        // Freshness gate: 拒迟到 / scrollback 复活的 stale spec-ready marker。
+        // 期望 task 仍在 pre-spec 阶段 (phase undefined, status in_progress) 且 token 匹配。
+        const eventToken = event.data?.token;
+        const stale = task.phase !== undefined
+            || task.status !== 'in_progress'
+            || !eventToken
+            || eventToken !== task.specMarkerToken;
+        if (stale) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-ready-event-stale',
+                taskPhase: task.phase ?? null,
+                taskStatus: task.status,
+            });
+            return;
+        }
+        try {
+            await manager.dispatchSpecReviewToQa(event.taskId);
+        }
+        catch (err) {
+            console.error(`[EventHandler] spec.ready dispatchSpecReviewToQa(${event.taskId}) failed:`, err);
+            await emitIntervention(bus, event.projectId, event.agentId ?? '', event.taskId, {
+                phase: 'spec-ready-dispatch-failed',
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    });
+    bus.on('spec.review.submitted', async (event) => {
+        if (!event.taskId)
+            return;
+        const task = await manager.getTask(event.taskId);
+        if (!task)
+            return;
+        // Freshness gate: stale marker would inject old findings into a code-phase session.
+        const eventToken = event.data?.token;
+        const stale = task.phase !== 'spec'
+            || task.status !== 'review'
+            || !eventToken
+            || eventToken !== task.specMarkerToken;
+        if (stale) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-review-event-stale',
+                taskPhase: task.phase ?? null,
+                taskStatus: task.status,
+            });
+            return;
+        }
+        const round = task.specReviewRound ?? 1;
+        const fileName = `round-${round}-findings.json`;
+        let raw = null;
+        try {
+            raw = await manager.readSpecReviewFile(event.taskId, fileName);
+        }
+        catch (err) {
+            console.error(`[EventHandler] spec.review.submitted readSpecReviewFile(${event.taskId}) failed:`, err);
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-review-findings-read-failed',
+                round,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        if (raw === null) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-review-findings-missing',
+                round,
+                fileName,
+            });
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-review-findings-invalid-json',
+                round,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        // Round mismatch ⇒ QA wrote wrong-round content into current findings file.
+        if (typeof parsed.round !== 'number' || parsed.round !== round) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-review-findings-round-mismatch',
+                round,
+                parsedRound: parsed.round ?? null,
+            });
+            return;
+        }
+        if (parsed.verdict === 'approve') {
+            try {
+                await manager.transitionToCodePhase(task.id);
+            }
+            catch (err) {
+                console.error(`[EventHandler] spec.review approve transitionToCodePhase(${task.id}) failed:`, err);
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'spec-review-approve-transition-failed',
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return;
+        }
+        if (parsed.verdict !== 'changes-requested') {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-review-findings-unknown-verdict',
+                round,
+                verdict: parsed.verdict ?? null,
+            });
+            return;
+        }
+        const cap = config.review.rounds;
+        if (round >= cap) {
+            const result = await manager.transitionTaskStatus(event.taskId, 'max_rounds', { fromStatus: ['review'] });
+            if (!result)
+                return;
+            const { task: transitioned } = result;
+            manager.stopSpecMarkerWatcher(transitioned.id);
+            // release 失败时 binding 残留 → 后续 acquire 会拒；emit intervention 让 stale binding 可见。
+            if (transitioned.qaAgentId) {
+                const qaReleased = await manager
+                    .releaseAgentForTask(transitioned.qaAgentId, transitioned.id, 'idle')
+                    .catch(() => false);
+                if (!qaReleased) {
+                    await emitIntervention(bus, transitioned.projectId, transitioned.qaAgentId, transitioned.id, {
+                        phase: 'spec-review-max-rounds-qa-release-failed',
+                        qaAgentId: transitioned.qaAgentId,
+                    });
+                }
+            }
+            if (transitioned.agentId) {
+                const devReleased = await manager
+                    .releaseAgentForTask(transitioned.agentId, transitioned.id, 'idle')
+                    .catch(() => false);
+                if (!devReleased) {
+                    await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                        phase: 'spec-review-max-rounds-dev-release-failed',
+                        devAgentId: transitioned.agentId,
+                    });
+                }
+            }
+            await emitIntervention(bus, transitioned.projectId, transitioned.agentId, transitioned.id, {
+                phase: 'spec-review-max-rounds',
+                round,
+                cap,
+            });
+            return;
+        }
+        // changes-requested 必须有非空 findings — 提前 fail-loud。
+        if (!Array.isArray(parsed.findings) || parsed.findings.length === 0) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-review-findings-invalid-shape',
+                round,
+                findingsType: Array.isArray(parsed.findings) ? 'empty-array' : typeof parsed.findings,
+            });
+            return;
+        }
+        // 每条 finding 必须有唯一非空 id — coverage 校验依赖它。fail-closed。
+        const findingsArr = parsed.findings;
+        const idSet = new Set();
+        for (const f of findingsArr) {
+            const id = f?.id;
+            if (typeof id !== 'string' || id.length === 0) {
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'spec-review-findings-missing-id',
+                    round,
+                });
+                return;
+            }
+            if (idSet.has(id)) {
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'spec-review-findings-duplicate-id',
+                    round,
+                    duplicateId: id,
+                });
+                return;
+            }
+            idSet.add(id);
+        }
+        try {
+            await manager.dispatchSpecFixToDev(task.id, raw);
+        }
+        catch (err) {
+            console.error(`[EventHandler] spec.review dispatchSpecFixToDev(${task.id}) failed:`, err);
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-dispatch-failed',
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    });
+    bus.on('spec.fix.submitted', async (event) => {
+        if (!event.taskId)
+            return;
+        const task = await manager.getTask(event.taskId);
+        if (!task)
+            return;
+        // Freshness gate: stale marker may re-trigger dispatch after spec phase exit.
+        const eventToken = event.data?.token;
+        const stale = task.phase !== 'spec'
+            || task.status !== 'fixing'
+            || !eventToken
+            || eventToken !== task.specMarkerToken;
+        if (stale) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-event-stale',
+                taskPhase: task.phase ?? null,
+                taskStatus: task.status,
+            });
+            return;
+        }
+        const round = task.specReviewRound ?? 1;
+        const fileName = `round-${round}-response.json`;
+        let raw = null;
+        try {
+            raw = await manager.readSpecReviewFile(event.taskId, fileName);
+        }
+        catch (err) {
+            console.error(`[EventHandler] spec.fix.submitted readSpecReviewFile(${event.taskId}) failed:`, err);
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-response-read-failed',
+                round,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        if (raw === null) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-response-missing',
+                round,
+                fileName,
+            });
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (err) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-response-invalid-json',
+                round,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        if (typeof parsed.round !== 'number' || parsed.round !== round) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-response-round-mismatch',
+                round,
+                parsedRound: parsed.round ?? null,
+            });
+            return;
+        }
+        if (!Array.isArray(parsed.responses)) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-response-invalid-shape',
+                round,
+            });
+            return;
+        }
+        const responses = parsed.responses;
+        if (responses.length === 0) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-response-empty',
+                round,
+            });
+            return;
+        }
+        for (const r of responses) {
+            if (r?.action !== 'fix' && r?.action !== 'reject') {
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'spec-fix-response-invalid-action',
+                    round,
+                    action: r?.action ?? null,
+                });
+                return;
+            }
+        }
+        // Coverage check: response must cover every finding.id; all branches fail-closed
+        // (read/parse/round-mismatch all emit + return — fail-open would let all-reject sneak into code phase).
+        let findingsRaw;
+        try {
+            findingsRaw = await manager.readSpecReviewFile(event.taskId, `round-${round}-findings.json`);
+        }
+        catch (err) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-coverage-findings-read-failed',
+                round,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        if (findingsRaw === null) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-coverage-findings-missing',
+                round,
+            });
+            return;
+        }
+        let findingsParsed;
+        try {
+            findingsParsed = JSON.parse(findingsRaw);
+        }
+        catch (err) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-coverage-findings-invalid-json',
+                round,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        if (typeof findingsParsed.round !== 'number' || findingsParsed.round !== round) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-coverage-findings-round-mismatch',
+                round,
+                parsedRound: findingsParsed.round ?? null,
+            });
+            return;
+        }
+        // 独立 fail-closed schema 校验 — 上一阶段的校验对本 handler 不可信。
+        if (!Array.isArray(findingsParsed.findings) || findingsParsed.findings.length === 0) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-coverage-findings-invalid-shape',
+                round,
+                findingsType: Array.isArray(findingsParsed.findings)
+                    ? 'empty-array'
+                    : typeof findingsParsed.findings,
+            });
+            return;
+        }
+        const findingIdsList = [];
+        for (const f of findingsParsed.findings) {
+            const id = f?.id;
+            if (typeof id !== 'string' || id.length === 0) {
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'spec-fix-coverage-findings-missing-id',
+                    round,
+                });
+                return;
+            }
+            if (findingIdsList.includes(id)) {
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'spec-fix-coverage-findings-duplicate-id',
+                    round,
+                    duplicateId: id,
+                });
+                return;
+            }
+            findingIdsList.push(id);
+        }
+        const findingIds = new Set(findingIdsList);
+        const responseIds = new Set(responses
+            .map(r => r?.findingId)
+            .filter((id) => typeof id === 'string'));
+        const missing = [...findingIds].filter(id => !responseIds.has(id));
+        const unknown = [...responseIds].filter(id => !findingIds.has(id));
+        if (missing.length > 0 || unknown.length > 0) {
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-response-coverage-mismatch',
+                round,
+                missingFindingIds: missing,
+                unknownFindingIds: unknown,
+            });
+            return;
+        }
+        const hasAnyFix = responses.some(r => r.action === 'fix');
+        if (!hasAnyFix) {
+            // 全 reject → dev 直接进 code phase；不再 qa review。
+            try {
+                await manager.transitionToCodePhase(task.id);
+            }
+            catch (err) {
+                console.error(`[EventHandler] spec.fix all-reject transitionToCodePhase(${task.id}) failed:`, err);
+                await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                    phase: 'spec-fix-all-reject-transition-failed',
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return;
+        }
+        try {
+            await manager.dispatchSpecReviewToQa(task.id);
+        }
+        catch (err) {
+            console.error(`[EventHandler] spec.fix dispatchSpecReviewToQa(${task.id}) failed:`, err);
+            await emitIntervention(bus, task.projectId, task.agentId, task.id, {
+                phase: 'spec-fix-redispatch-failed',
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    });
+}
+//# sourceMappingURL=handlers.js.map