baxian 1.2.61 → 2.0.1

package/dist/event/server-handlers.js

@@ -1,7 +1,15 @@
-import { isSpecStagePhase } from '../shared/index.js';
-import { ReviewExchangeError } from '../agent/review-transport.js';
+import { isSpecStagePhase, taskGenerationGuard } from '../shared/index.js';
+import { ReviewExchangeError, } from '../agent/review-transport.js';
+import { settlePermitOf } from '../agent/phase-signal-watcher.js';
+import { computeBackoffMs } from '../timing/backoff.js';
+import { reviewFindingsDigest, serverResponseFailureSignature, } from '../state/review-store.js';
 const LEGACY_DIFF_LARGE_THRESHOLD = 2000;
 const FILE_HEADER_RE = /^diff --git a\/(.+?) b\//;
+const SERVER_HANDLER_ATTEMPTS = 3;
+const SERVER_HANDLER_BACKOFF = { baseMs: 10, maxMs: 20, factor: 2, jitter: 0 };
+const SERVER_SIGNAL_KINDS = new Set([
+    'code-done', 'code-reviewed', 'code-fixed', 'code-ready', 'spec-done', 'spec-reviewed', 'spec-fixed',
+]);
 function splitLegacyDiffByFile(diff) {
     if (diff.trim() === '')
         return [];
@@ -96,10 +104,14 @@ function aggregateBatchFindings(batches, round) {
 function coverageGaps(findings, responseIds) {
     const findingIds = new Set(findings.findings.map(f => f.id));
     return {
-        missing: [...findingIds].filter(id => !responseIds.has(id)),
-        unknown: [...responseIds].filter(id => !findingIds.has(id)),
+        missing: [...findingIds].filter(id => !responseIds.has(id)).sort(),
+        unknown: [...responseIds].filter(id => !findingIds.has(id)).sort(),
     };
 }
+function waitForHandlerRetry(attempt) {
+    const ms = computeBackoffMs(attempt, SERVER_HANDLER_BACKOFF);
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
 async function emitIntervention(bus, task, data) {
     try {
         await bus.emit({
@@ -129,7 +141,9 @@ async function gate(bus, manager, event, expect) {
     const token = event.data?.token;
     const phaseOk = expect.phase === 'any'
         || (expect.phase === 'spec' ? task.phase !== 'code' : !isSpecStagePhase(task.phase));
-    if (task.status !== expect.status || !phaseOk || !token || token !== task.signalToken) {
+    if (token && token !== task.signalToken)
+        return null;
+    if (task.status !== expect.status || !phaseOk || !token) {
         await emitIntervention(bus, task, {
             phase: `${event.type}-stale`,
             taskStatus: task.status,
@@ -137,7 +151,7 @@ async function gate(bus, manager, event, expect) {
         });
         return null;
     }
-    return { task };
+    return { task, expectedTask: taskGenerationGuard(task) };
 }
 export function registerServerEventHandlers(bus, manager) {
     const configured = manager.getReviewStore();
@@ -166,25 +180,225 @@ export function registerServerEventHandlers(bus, manager) {
                 .catch(err => console.error(`[ServerHandler] max_rounds clear agentId(${task.id}) failed:`, err));
         }
     }
-    async function putVerdictRound(task, agentId, kind, data) {
+    async function putVerdictRound(task, agentId, kind, data, opts = {}) {
+        let lastError;
+        for (let attempt = 1; attempt <= SERVER_HANDLER_ATTEMPTS; attempt++) {
+            try {
+                const stored = opts.expectedTask
+                    ? await manager.putReviewRoundIfCurrent(task.id, data, opts.expectedTask)
+                    : (await reviewStore.putRound(task.id, data.phase, data), true);
+                if (!stored)
+                    return false;
+                return true;
+            }
+            catch (err) {
+                lastError = err;
+                try {
+                    const stored = await reviewStore.getRound(task.id, data.phase, data.round);
+                    if (stored && JSON.stringify(stored) === JSON.stringify(data))
+                        return true;
+                }
+                catch (readBackError) {
+                    lastError = readBackError;
+                }
+                if (attempt < SERVER_HANDLER_ATTEMPTS)
+                    await waitForHandlerRetry(attempt);
+            }
+        }
+        return holdConsumedSignal(task, agentId, kind, 'verdict-store-failed', `server-${data.phase}-verdict-store-failed`, {
+            round: data.round,
+            error: lastError instanceof Error ? lastError.message : String(lastError),
+        }, opts.onSideEffect);
+    }
+    async function holdConsumedSignal(task, agentId, kind, reason, failurePhase, data = {}, onSideEffect) {
+        if (!SERVER_SIGNAL_KINDS.has(kind)) {
+            throw new Error(`unsupported consumed server signal kind: ${kind}`);
+        }
+        const phase = kind.startsWith('spec-') ? 'spec' : 'code';
+        const round = phase === 'spec' ? (task.specReviewRound ?? 0) : task.reviewRound;
+        const held = await manager.holdConsumedServerSignal(task, agentId, kind, { phase, round, reason, failurePhase });
+        if (!held)
+            return false;
+        onSideEffect?.();
+        await emitIntervention(bus, held, {
+            phase: failurePhase,
+            ...data,
+            successorToken: held.signalToken,
+        });
+        return false;
+    }
+    async function readResponseWithRetry(task, dev) {
+        let result;
+        for (let attempt = 1; attempt <= SERVER_HANDLER_ATTEMPTS; attempt++) {
+            result = await transport().readResponseWithRaw(task, dev);
+            if (result.kind !== 'unknown' || attempt === SERVER_HANDLER_ATTEMPTS)
+                return result;
+            await waitForHandlerRetry(attempt);
+        }
+        return result;
+    }
+    async function runConsumedSignal(task, agentId, kind, handler) {
         try {
-            await reviewStore.putRound(task.id, data.phase, data);
-            return true;
+            await handler();
         }
         catch (err) {
-            await emitIntervention(bus, task, {
-                phase: `server-${data.phase}-verdict-store-failed`,
-                round: data.round,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            await manager.setupPhaseSignal(task.id, agentId, kind, { skipSnapshot: true });
+            await holdConsumedSignal(task, agentId, kind, 'handler-failed', `server-${kind.startsWith('spec-') ? 'spec' : 'code'}-handler-failed`, { error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    async function deleteFindingsOrHold(task, qa, kind, expectedTask) {
+        try {
+            return await manager.deleteReviewExchangeIfCurrent(task.id, qa, 'findings', expectedTask);
+        }
+        catch (err) {
+            await holdConsumedSignal(task, qa.id, kind, 'handler-failed', `server-${kind.startsWith('spec-') ? 'spec' : 'code'}-findings-cleanup-failed`, { error: err instanceof Error ? err.message : String(err) });
             return false;
         }
     }
-    async function rearmOrHold(task, agentId, kind) {
-        const armed = await manager.setupPhaseSignal(task.id, agentId, kind, { skipSnapshot: true });
-        if (!armed)
-            await manager.holdAgentForUnarmedSignal(task.id, agentId, kind);
+    async function deleteResponseOrHold(task, dev, kind, opts) {
+        try {
+            const deleted = await manager.deleteReviewExchangeIfCurrent(task.id, dev, 'response', opts.expectedTask ?? taskGenerationGuard(task));
+            if (deleted)
+                opts.onSideEffect?.();
+            return deleted;
+        }
+        catch (err) {
+            return holdConsumedSignal(task, dev.id, kind, 'handler-failed', `server-${kind.startsWith('spec-') ? 'spec' : 'code'}-response-cleanup-failed`, { error: err instanceof Error ? err.message : String(err) }, opts.onSideEffect);
+        }
+    }
+    async function rejectServerResponse(task, dev, roundData, failure, onSideEffect) {
+        const phase = roundData.phase;
+        const signalKind = `${phase}-fixed`;
+        const sourceToken = task.signalToken;
+        if (!sourceToken)
+            return false;
+        const findingsDigest = reviewFindingsDigest(roundData.findings);
+        const missingFindingIds = [...(failure.missingFindingIds ?? [])].sort();
+        const unknownFindingIds = [...(failure.unknownFindingIds ?? [])].sort();
+        const schemaViolationCodes = [...(failure.schemaViolationCodes ?? [])].sort();
+        const failureSignature = serverResponseFailureSignature({
+            phase,
+            round: roundData.round,
+            findingsDigest,
+            reason: failure.reason,
+            missingFindingIds,
+            unknownFindingIds,
+            schemaViolationCodes,
+        });
+        const claimed = await manager.claimServerSignalRecovery(task, dev.id, signalKind, {
+            mode: 'classify-response',
+            phase,
+            round: roundData.round,
+            findingsDigest,
+            failureSignature,
+            reason: failure.reason,
+            failurePhase: failure.failurePhase,
+            missingFindingIds,
+            unknownFindingIds,
+            schemaViolationCodes,
+            ...(failure.responseDigest ? { responseDigest: failure.responseDigest } : {}),
+        });
+        if (!claimed?.signalToken)
+            return false;
+        onSideEffect?.();
+        let recorded;
+        try {
+            recorded = await reviewStore.recordServerResponseFailure(task.id, phase, roundData.round, {
+                signalKind,
+                sourceToken,
+                successorToken: claimed.signalToken,
+                failureSignature,
+                reason: failure.reason,
+                missingFindingIds,
+                unknownFindingIds,
+                schemaViolationCodes,
+                createdAt: new Date().toISOString(),
+                ...(failure.responseDigest ? { responseDigest: failure.responseDigest } : {}),
+                ...(failure.rawResponse !== undefined ? { rawResponse: failure.rawResponse } : {}),
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const held = await manager.holdServerSignalRecovery(task.id, dev.id, claimed.signalToken, `server-${phase}-response-audit-store-failed`, `${message}. The response file was preserved and the old token is retired.`);
+            if (!held)
+                return false;
+            await emitIntervention(bus, held, {
+                phase: `server-${phase}-response-audit-store-failed`,
+                round: roundData.round,
+                error: message,
+                successorToken: claimed.signalToken,
+            });
+            return false;
+        }
+        const nextMode = recorded.disposition === 'auto-correct' ? 'correct-response' : 'hold';
+        const finalized = await manager.setServerSignalRecoveryMode(task.id, claimed.signalToken, nextMode);
+        if (!finalized)
+            return false;
+        if (recorded.disposition !== 'auto-correct') {
+            const holdPhase = recorded.disposition === 'hold-repeated-signature'
+                ? 'server-feedback-response-repeated'
+                : 'server-feedback-correction-limit';
+            const held = await manager.holdServerSignalRecovery(task.id, dev.id, claimed.signalToken, holdPhase, `The ${phase} response failed with ${failure.reason}; automatic correction stopped `
+                + `(${recorded.disposition}). Rewrite it deliberately, then Restart or Cancel the task.`);
+            if (!held)
+                return false;
+            await emitIntervention(bus, held, {
+                phase: holdPhase,
+                reviewPhase: phase,
+                round: roundData.round,
+                reason: failure.reason,
+                disposition: recorded.disposition,
+                missingFindingIds,
+                unknownFindingIds,
+                findingsDigest,
+                successorToken: claimed.signalToken,
+            });
+            return false;
+        }
+        const beforeCleanup = await manager.getTask(task.id);
+        const currentRecovery = beforeCleanup?.serverSignalRecovery;
+        const currentRound = phase === 'spec' ? beforeCleanup?.specReviewRound : beforeCleanup?.reviewRound;
+        if (!beforeCleanup
+            || beforeCleanup.status !== task.status
+            || beforeCleanup.phase !== task.phase
+            || beforeCleanup.signalToken !== claimed.signalToken
+            || currentRound !== roundData.round
+            || currentRecovery?.mode !== 'correct-response'
+            || currentRecovery.sourceToken !== sourceToken
+            || currentRecovery.failureSignature !== failureSignature) {
+            return false;
+        }
+        try {
+            const deleted = await manager.deleteReviewExchangeIfCurrent(task.id, dev, 'response', taskGenerationGuard(beforeCleanup), currentRecovery);
+            if (!deleted)
+                return false;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const held = await manager.holdServerSignalRecovery(task.id, dev.id, claimed.signalToken, `server-${phase}-response-cleanup-failed`, `${message}. The rejected response is archived, but the live file could not be removed safely.`);
+            if (!held)
+                return false;
+            await emitIntervention(bus, held, {
+                phase: `server-${phase}-response-cleanup-failed`,
+                round: roundData.round,
+                error: message,
+                successorToken: claimed.signalToken,
+            });
+            return false;
+        }
+        await emitIntervention(bus, finalized, {
+            phase: failure.failurePhase,
+            round: roundData.round,
+            reason: failure.reason,
+            missingFindingIds,
+            unknownFindingIds,
+            schemaViolationCodes,
+            findingsDigest,
+            responseDigest: failure.responseDigest,
+            successorToken: claimed.signalToken,
+            ...failure.details,
+        });
+        await manager.dispatchServerFeedbackCorrection(task.id, JSON.stringify(roundData.findings));
+        return false;
     }
     function resolveActiveQa(task) {
         if (!task.qaAgentId)
@@ -192,28 +406,30 @@ export function registerServerEventHandlers(bus, manager) {
         const recorded = manager.getAgentConfig(task.qaAgentId);
         return recorded?.role === 'qa' ? recorded : undefined;
     }
-    async function pauseForUnavailableQa(task, entryKind, phase) {
+    async function pauseForUnavailableQa(task, entryKind, phase, onSideEffect) {
         if (!task.qaAgentId || resolveActiveQa(task))
             return false;
-        await emitIntervention(bus, task, { phase, qaAgentId: task.qaAgentId });
-        if (task.agentId)
-            await rearmOrHold(task, task.agentId, entryKind);
+        await holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', phase, { qaAgentId: task.qaAgentId }, onSideEffect);
         return true;
     }
-    async function autoApproveCode(task, entryKind = 'code-done') {
-        const afterDone = manager.resolveAfterDone(task);
-        if (task.afterDone === undefined) {
-            await manager.updateTask(task.id, { afterDone });
-        }
+    async function autoApproveCode(task, expectedTask, entryKind = 'code-done', onSideEffect) {
+        const afterDone = await manager.commitServerAfterDone(task.id, expectedTask);
+        onSideEffect?.();
         if (afterDone === null) {
-            const ready = await manager.transitionTaskStatus(task.id, 'ready', { fromStatus: ['in_progress', 'fixing'] });
-            if (!ready)
-                await emitIntervention(bus, task, { phase: 'server-code-auto-approve-transition-failed' });
+            const ready = await manager.transitionTaskStatus(task.id, 'ready', {
+                fromStatus: ['in_progress', 'fixing'],
+                ...(expectedTask !== undefined ? { expectTask: expectedTask } : {}),
+            });
+            if (ready)
+                onSideEffect?.();
+            if (!ready) {
+                await holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', 'server-code-auto-approve-transition-failed', {}, onSideEffect);
+            }
             return;
         }
         const dev = manager.getAgentConfig(task.agentId);
         if (!dev) {
-            await emitIntervention(bus, task, { phase: 'server-code-auto-approve-no-dev-agent' });
+            await holdConsumedSignal(task, task.agentId, entryKind, 'fix-no-dev-agent', 'server-code-auto-approve-no-dev-agent', {}, onSideEffect);
             return;
         }
         await manager.refreshWorkdirCacheFor(task.agentId);
@@ -222,73 +438,75 @@ export function registerServerEventHandlers(bus, manager) {
             reviewHeadAnchorSha = await transport().readHeadSha(dev);
         }
         catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-auto-approve-head-capture-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-            await manager.setupPhaseSignal(task.id, task.agentId, entryKind, { skipSnapshot: true });
+            await holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', 'server-code-auto-approve-head-capture-failed', { error: err instanceof Error ? err.message : String(err) }, onSideEffect);
             return;
         }
-        const approved = await manager.transitionTaskStatus(task.id, 'approved', { fromStatus: ['in_progress', 'fixing'] }, { reviewHeadAnchorSha });
+        const approved = await manager.transitionTaskStatus(task.id, 'approved', {
+            fromStatus: ['in_progress', 'fixing'],
+            ...(expectedTask !== undefined ? { expectTask: expectedTask } : {}),
+        }, { reviewHeadAnchorSha });
+        if (approved)
+            onSideEffect?.();
         if (!approved) {
-            await emitIntervention(bus, task, { phase: 'server-code-auto-approve-transition-failed' });
+            await holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', 'server-code-auto-approve-transition-failed', {}, onSideEffect);
             return;
         }
-        await manager.dispatchServerAfterDone(task.id, afterDone);
+        const dispatched = await manager.dispatchServerAfterDone(task.id, afterDone);
+        if (!dispatched) {
+            await holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', 'server-code-auto-approve-publish-dispatch-failed', {}, onSideEffect);
+        }
     }
     function specApprovalIsHuman(task) {
         return task.researchAgentId !== undefined
             || manager.getProjectConfig(task.projectId)?.specApproval === 'human';
     }
-    async function advanceApprovedSpec(task, failurePhase) {
+    async function advanceApprovedSpec(task, failurePhase, expectedTask) {
         try {
             const result = specApprovalIsHuman(task)
-                ? await manager.parkTaskAtSpecReady(task.id)
-                : await manager.transitionToCodePhase(task.id);
+                ? await manager.parkTaskAtSpecReady(task.id, {
+                    ...(expectedTask !== undefined ? { expectedTask } : {}),
+                })
+                : await manager.transitionToCodePhase(task.id, expectedTask);
             if (!result) {
-                await emitIntervention(bus, task, { phase: failurePhase });
+                await holdConsumedSignal(task, task.qaAgentId ?? task.agentId, 'spec-reviewed', 'handler-failed', failurePhase);
             }
         }
         catch (err) {
-            await emitIntervention(bus, task, {
-                phase: failurePhase,
-                error: err instanceof Error ? err.message : String(err),
-            });
+            await holdConsumedSignal(task, task.qaAgentId ?? task.agentId, 'spec-reviewed', 'handler-failed', failurePhase, { error: err instanceof Error ? err.message : String(err) });
         }
     }
-    async function autoApproveSpec(task) {
+    async function autoApproveSpec(task, expectedTask, onSideEffect) {
         try {
-            const result = await manager.transitionToCodePhase(task.id);
+            const result = await manager.transitionToCodePhase(task.id, expectedTask);
+            if (result)
+                onSideEffect?.();
             if (!result) {
-                await emitIntervention(bus, task, { phase: 'server-spec-auto-approve-transition-failed' });
+                await holdConsumedSignal(task, task.agentId, task.status === 'fixing' ? 'spec-fixed' : 'spec-done', 'handler-failed', 'server-spec-auto-approve-transition-failed', {}, onSideEffect);
                 return false;
             }
             return true;
         }
         catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-spec-auto-approve-transition-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
+            await holdConsumedSignal(task, task.agentId, task.status === 'fixing' ? 'spec-fixed' : 'spec-done', 'handler-failed', 'server-spec-auto-approve-transition-failed', { error: err instanceof Error ? err.message : String(err) }, onSideEffect);
             return false;
         }
     }
     async function prepareAndDispatchCodeReview(task, opts) {
         const dev = manager.getAgentConfig(task.agentId);
         if (!dev) {
-            await emitIntervention(bus, task, { phase: 'server-code-review-no-dev-agent' });
-            if (task.agentId) {
-                const kind = task.status === 'fixing' ? 'code-fixed' : 'code-done';
-                await rearmOrHold(task, task.agentId, kind);
-            }
-            return false;
+            const kind = task.status === 'fixing' ? 'code-fixed' : 'code-done';
+            return holdConsumedSignal(task, task.agentId, kind, 'fix-no-dev-agent', 'server-code-review-no-dev-agent', {}, opts.onSideEffect);
         }
         const cap = manager.getConfig().review.rounds + (task.maxRoundsContinues ?? 0);
-        const nextRound = task.reviewRound + 1;
+        const nextRound = opts.bumpRound === false ? task.reviewRound : task.reviewRound + 1;
         if (nextRound > cap) {
-            const capResult = await manager.transitionTaskStatus(task.id, 'max_rounds', { fromStatus: ['in_progress', 'fixing'] });
+            const capResult = await manager.transitionTaskStatus(task.id, 'max_rounds', {
+                fromStatus: ['in_progress', 'fixing'],
+                ...(opts.expectedTask !== undefined ? { expectTask: opts.expectedTask } : {}),
+            });
             if (!capResult)
                 return false;
+            opts.onSideEffect?.();
             const paused = capResult.task;
             if (paused.qaAgentId)
                 await releaseAtCap(paused, paused.qaAgentId, 'qaAgentId');
@@ -303,49 +521,50 @@ export function registerServerEventHandlers(bus, manager) {
             });
             return false;
         }
-        await manager.refreshWorkdirCacheFor(task.agentId);
         let content;
         let reviewHeadAnchorSha;
-        try {
-            content = await transport().readContent(task, dev, 'code');
-            if (!content.headSha)
-                throw new ReviewExchangeError('head-failed', 'review head missing from captured content');
-            reviewHeadAnchorSha = content.headSha;
-        }
-        catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-content-read-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-            const kind = task.status === 'fixing' ? 'code-fixed' : 'code-done';
-            await manager.setupPhaseSignal(task.id, task.agentId, kind, { skipSnapshot: true });
-            return false;
-        }
-        const rearmEntry = async () => {
-            const kind = task.status === 'fixing' ? 'code-fixed' : 'code-done';
-            await manager.setupPhaseSignal(task.id, task.agentId, kind, { skipSnapshot: true });
-        };
-        try {
-            const violation = await manager.findLineageViolation(task.id, content.baseSha);
-            if (violation) {
-                await emitIntervention(bus, task, {
-                    phase: 'server-code-lineage-violation',
-                    offendingTaskId: violation.taskId,
-                    offendingBranch: violation.branch,
-                    offendingSha: violation.sha,
-                    note: 'The task branch embeds another active task\'s commits — reviewing it would leak foreign work into this task. Have the dev rebase onto origin/HEAD and re-emit the signal.',
-                });
-                await rearmEntry();
-                return false;
+        if (opts.bumpRound === false) {
+            const stored = await reviewStore.getRound(task.id, 'code', nextRound);
+            if (!stored || stored.phase !== 'code' || !stored.headSha) {
+                throw new Error(`Task ${task.id} has no persisted code review round ${nextRound} to redispatch`);
             }
+            content = {
+                content: stored.content,
+                ...(stored.diffstat ? { diffstat: stored.diffstat } : {}),
+                ...(stored.baseSha ? { baseSha: stored.baseSha } : {}),
+                headSha: stored.headSha,
+                ...(stored.headTree ? { headTree: stored.headTree } : {}),
+            };
+            reviewHeadAnchorSha = stored.headSha;
         }
-        catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-lineage-check-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-            await rearmEntry();
-            return false;
+        else {
+            await manager.refreshWorkdirCacheFor(task.agentId);
+            try {
+                content = await transport().readContent(task, dev, 'code');
+                if (!content.headSha)
+                    throw new ReviewExchangeError('head-failed', 'review head missing from captured content');
+                reviewHeadAnchorSha = content.headSha;
+            }
+            catch (err) {
+                const kind = task.status === 'fixing' ? 'code-fixed' : 'code-done';
+                return holdConsumedSignal(task, task.agentId, kind, 'handler-failed', 'server-code-content-read-failed', { error: err instanceof Error ? err.message : String(err) }, opts.onSideEffect);
+            }
+            try {
+                const violation = await manager.findLineageViolation(task.id, content.baseSha);
+                if (violation) {
+                    const kind = task.status === 'fixing' ? 'code-fixed' : 'code-done';
+                    return holdConsumedSignal(task, task.agentId, kind, 'handler-failed', 'server-code-lineage-violation', {
+                        offendingTaskId: violation.taskId,
+                        offendingBranch: violation.branch,
+                        offendingSha: violation.sha,
+                        note: 'The task branch embeds another active task\'s commits — reviewing it would leak foreign work into this task. Have the dev rebase onto origin/HEAD and re-emit the signal.',
+                    }, opts.onSideEffect);
+                }
+            }
+            catch (err) {
+                const kind = task.status === 'fixing' ? 'code-fixed' : 'code-done';
+                return holdConsumedSignal(task, task.agentId, kind, 'handler-failed', 'server-code-lineage-check-failed', { error: err instanceof Error ? err.message : String(err) }, opts.onSideEffect);
+            }
         }
         const round = {
             round: nextRound,
@@ -357,21 +576,7 @@ export function registerServerEventHandlers(bus, manager) {
             ...(content.headTree ? { headTree: content.headTree } : {}),
             startedAt: new Date().toISOString(),
         };
-        const putEntryRound = async (data) => {
-            try {
-                await reviewStore.putRound(task.id, 'code', data);
-                return true;
-            }
-            catch (err) {
-                await emitIntervention(bus, task, {
-                    phase: 'server-code-round-store-failed',
-                    error: err instanceof Error ? err.message : String(err),
-                });
-                const kind = task.status === 'fixing' ? 'code-fixed' : 'code-done';
-                await manager.setupPhaseSignal(task.id, task.agentId, kind, { skipSnapshot: true });
-                return false;
-            }
-        };
+        const putEntryRound = (data) => putVerdictRound(task, task.agentId, task.status === 'fixing' ? 'code-fixed' : 'code-done', data, opts);
         const resolveRecheckInterdiff = async () => {
             if (!opts.recheck)
                 return undefined;
@@ -385,12 +590,13 @@ export function registerServerEventHandlers(bus, manager) {
                 return undefined;
             }
         };
-        if (!(await putEntryRound(round)))
+        if (opts.bumpRound !== false && !(await putEntryRound(round)))
             return false;
         const interdiff = await resolveRecheckInterdiff();
         const dispatched = await manager.dispatchServerReviewToQa(task.id, {
             phase: 'code',
             recheck: opts.recheck,
+            ...(opts.bumpRound !== undefined ? { bumpRound: opts.bumpRound } : {}),
             content: content.content,
             reviewHeadAnchorSha,
             ...(content.baseSha ? { baseSha: content.baseSha } : {}),
@@ -399,8 +605,15 @@ export function registerServerEventHandlers(bus, manager) {
             ...(content.diffstat ? { diffstat: content.diffstat } : {}),
             ...(opts.priorFindingsJson ? { priorFindingsJson: opts.priorFindingsJson } : {}),
             ...(opts.priorResponseJson ? { priorResponseJson: opts.priorResponseJson } : {}),
+            callerOwnsConsumedSignalFailure: true,
+            ...(opts.settlePermit !== undefined ? { settlePermit: opts.settlePermit } : {}),
+            ...(opts.expectedTask !== undefined ? { expectedTask: opts.expectedTask } : {}),
+            ...(opts.onSideEffect !== undefined ? { onSideEffect: opts.onSideEffect } : {}),
         });
-        return dispatched !== null;
+        if (dispatched)
+            return true;
+        const kind = task.status === 'fixing' ? 'code-fixed' : 'code-done';
+        return holdConsumedSignal(task, task.agentId, kind, 'handler-failed', 'server-code-review-dispatch-failed', {}, opts.onSideEffect);
     }
     async function dispatchLegacyBatch(taskId, batches, index, diffstat, opts) {
         const text = batches[index].map(f => f.text).join('\n');
@@ -413,6 +626,9 @@ export function registerServerEventHandlers(bus, manager) {
             batch: { index, total: batches.length },
             ...(opts.priorFindingsJson ? { priorFindingsJson: opts.priorFindingsJson } : {}),
             ...(opts.priorResponseJson ? { priorResponseJson: opts.priorResponseJson } : {}),
+            callerOwnsConsumedSignalFailure: true,
+            ...(opts.settlePermit !== undefined ? { settlePermit: opts.settlePermit } : {}),
+            ...(opts.expectedTask !== undefined ? { expectedTask: opts.expectedTask } : {}),
         });
         return dispatched !== null;
     }
@@ -423,137 +639,135 @@ export function registerServerEventHandlers(bus, manager) {
         const gated = await gate(bus, manager, event, { status: 'in_progress', phase: 'code', requireServerMode: true });
         if (!gated)
             return;
-        const { task } = gated;
-        if (await pauseForUnavailableQa(task, 'code-done', 'server-code-qa-unavailable'))
-            return;
-        if (!task.qaAgentId) {
-            await autoApproveCode(task);
-            return;
-        }
-        await prepareAndDispatchCodeReview(task, { recheck: false });
+        const { task, expectedTask } = gated;
+        await runConsumedSignal(task, task.agentId, 'code-done', async () => {
+            if (await pauseForUnavailableQa(task, 'code-done', 'server-code-qa-unavailable'))
+                return;
+            if (!task.qaAgentId) {
+                await autoApproveCode(task, expectedTask);
+                return;
+            }
+            await prepareAndDispatchCodeReview(task, { recheck: false, expectedTask, settlePermit: settlePermitOf(event) });
+        });
     });
     bus.on('server.code.review.submitted', async (event) => {
         const gated = await gate(bus, manager, event, { status: 'review', phase: 'code', requireServerMode: true });
         if (!gated)
             return;
-        const { task } = gated;
-        const qa = manager.getAgentConfig(task.qaAgentId ?? '');
-        if (!qa) {
-            await emitIntervention(bus, task, { phase: 'server-code-review-no-qa-agent' });
-            if (task.qaAgentId) {
-                await rearmOrHold(task, task.qaAgentId, 'code-reviewed');
-            }
-            return;
-        }
-        const round = Math.max(task.reviewRound, 1);
-        const roundData = await reviewStore.getRound(task.id, 'code', round);
-        if (!roundData) {
-            await emitIntervention(bus, task, { phase: 'server-code-review-round-missing', round });
-            await manager.setupPhaseSignal(task.id, qa.id, 'code-reviewed', { skipSnapshot: true });
-            return;
-        }
-        await manager.refreshWorkdirCacheFor(qa.id);
-        let findings;
-        try {
-            findings = await transport().readFindings(task, qa);
-        }
-        catch (err) {
-            const reason = err instanceof ReviewExchangeError ? err.reason : 'unknown';
-            await emitIntervention(bus, task, {
-                phase: 'server-code-findings-invalid',
-                reason,
-                error: err instanceof Error ? err.message : String(err),
-            });
-            await manager.setupPhaseSignal(task.id, qa.id, 'code-reviewed', { skipSnapshot: true });
-            return;
-        }
-        let current = roundData;
-        if (findings === null) {
-            const alreadyStored = task.batchTotal !== undefined
-                ? (roundData.batchFindings?.length ?? 0) > (task.batchIndex ?? 0)
-                : roundData.findings !== undefined;
-            if (!alreadyStored) {
-                await emitIntervention(bus, task, { phase: 'server-code-findings-missing', round });
-                await manager.setupPhaseSignal(task.id, qa.id, 'code-reviewed', { skipSnapshot: true });
+        const { task, expectedTask } = gated;
+        await runConsumedSignal(task, task.qaAgentId ?? task.agentId, 'code-reviewed', async () => {
+            const qa = manager.getAgentConfig(task.qaAgentId ?? '');
+            if (!qa) {
+                await holdConsumedSignal(task, task.qaAgentId ?? '', 'code-reviewed', 'handler-failed', 'server-code-review-no-qa-agent');
                 return;
             }
-        }
-        else if (findings.round !== round) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-findings-round-mismatch',
-                round,
-                payloadRound: findings.round,
-            });
-            await transport().deleteFindings(qa);
-            await manager.setupPhaseSignal(task.id, qa.id, 'code-reviewed', { skipSnapshot: true });
-            return;
-        }
-        else if (task.batchTotal !== undefined && task.batchIndex !== undefined) {
-            const batchFindings = [...(roundData.batchFindings ?? [])];
-            batchFindings[task.batchIndex] = findings;
-            current = { ...roundData, batchFindings };
-            if (!(await putVerdictRound(task, qa.id, 'code-reviewed', current)))
+            const round = Math.max(task.reviewRound, 1);
+            const roundData = await reviewStore.getRound(task.id, 'code', round);
+            if (!roundData) {
+                await holdConsumedSignal(task, qa.id, 'code-reviewed', 'handler-failed', 'server-code-review-round-missing', { round });
                 return;
-            await transport().deleteFindings(qa);
-        }
-        else {
-            current = { ...roundData, findings, completedAt: new Date().toISOString() };
-            if (!(await putVerdictRound(task, qa.id, 'code-reviewed', current)))
+            }
+            await manager.refreshWorkdirCacheFor(qa.id);
+            let findings;
+            try {
+                findings = await transport().readFindings(task, qa);
+            }
+            catch (err) {
+                const reason = err instanceof ReviewExchangeError ? err.reason : 'unknown';
+                await holdConsumedSignal(task, qa.id, 'code-reviewed', 'handler-failed', 'server-code-findings-invalid', { reason, error: err instanceof Error ? err.message : String(err) });
                 return;
-            await transport().deleteFindings(qa);
-        }
-        const isRecheck = round > 1;
-        if (task.batchTotal !== undefined && task.batchIndex !== undefined) {
-            const nextIndex = task.batchIndex + 1;
-            if (nextIndex < task.batchTotal) {
-                const prev = isRecheck ? await reviewStore.getRound(task.id, 'code', round - 1) : null;
-                await dispatchLegacyBatch(task.id, rebuildLegacyBatches(current), nextIndex, current.diffstat, {
-                    recheck: isRecheck,
-                    ...(prev?.findings ? { priorFindingsJson: JSON.stringify(prev.findings) } : {}),
-                    ...(prev?.response ? { priorResponseJson: JSON.stringify(prev.response) } : {}),
-                });
+            }
+            let current = roundData;
+            if (findings === null) {
+                const alreadyStored = task.batchTotal !== undefined
+                    ? (roundData.batchFindings?.length ?? 0) > (task.batchIndex ?? 0)
+                    : roundData.findings !== undefined;
+                if (!alreadyStored) {
+                    await holdConsumedSignal(task, qa.id, 'code-reviewed', 'handler-failed', 'server-code-findings-missing', { round });
+                    return;
+                }
+            }
+            else if (findings.round !== round) {
+                await holdConsumedSignal(task, qa.id, 'code-reviewed', 'handler-failed', 'server-code-findings-round-mismatch', { round, payloadRound: findings.round });
                 return;
             }
-            const aggregated = current.findings
-                ?? aggregateBatchFindings((current.batchFindings ?? []).filter(Boolean), round);
-            if (!current.findings) {
-                const stored = await putVerdictRound(task, qa.id, 'code-reviewed', {
-                    ...current,
-                    findings: aggregated,
-                    completedAt: new Date().toISOString(),
-                });
-                if (!stored)
+            else if (task.batchTotal !== undefined && task.batchIndex !== undefined) {
+                const batchFindings = [...(roundData.batchFindings ?? [])];
+                batchFindings[task.batchIndex] = findings;
+                current = { ...roundData, batchFindings };
+                if (!(await putVerdictRound(task, qa.id, 'code-reviewed', current, { expectedTask })))
+                    return;
+                if (!(await deleteFindingsOrHold(task, qa, 'code-reviewed', expectedTask)))
                     return;
             }
-            await manager.updateTask(task.id, { batchIndex: undefined, batchTotal: undefined });
-            await routeCodeVerdict({ ...task, batchIndex: undefined, batchTotal: undefined }, aggregated);
-            return;
-        }
-        await routeCodeVerdict(task, current.findings);
+            else {
+                current = { ...roundData, findings, completedAt: new Date().toISOString() };
+                if (!(await putVerdictRound(task, qa.id, 'code-reviewed', current, { expectedTask })))
+                    return;
+                if (!(await deleteFindingsOrHold(task, qa, 'code-reviewed', expectedTask)))
+                    return;
+            }
+            const isRecheck = round > 1;
+            if (task.batchTotal !== undefined && task.batchIndex !== undefined) {
+                const nextIndex = task.batchIndex + 1;
+                if (nextIndex < task.batchTotal) {
+                    const prev = isRecheck ? await reviewStore.getRound(task.id, 'code', round - 1) : null;
+                    const dispatched = await dispatchLegacyBatch(task.id, rebuildLegacyBatches(current), nextIndex, current.diffstat, {
+                        recheck: isRecheck,
+                        ...(prev?.findings ? { priorFindingsJson: JSON.stringify(prev.findings) } : {}),
+                        ...(prev?.response ? { priorResponseJson: JSON.stringify(prev.response) } : {}),
+                        expectedTask,
+                        settlePermit: settlePermitOf(event),
+                    });
+                    if (!dispatched) {
+                        await holdConsumedSignal(task, qa.id, 'code-reviewed', 'handler-failed', 'server-code-review-continuation-dispatch-failed');
+                    }
+                    return;
+                }
+                const aggregated = current.findings
+                    ?? aggregateBatchFindings((current.batchFindings ?? []).filter(Boolean), round);
+                if (!current.findings) {
+                    const stored = await putVerdictRound(task, qa.id, 'code-reviewed', {
+                        ...current,
+                        findings: aggregated,
+                        completedAt: new Date().toISOString(),
+                    }, { expectedTask });
+                    if (!stored)
+                        return;
+                }
+                const cleared = await manager.updateTaskIfStatus(task.id, expectedTask.status, { batchIndex: undefined, batchTotal: undefined }, expectedTask);
+                if (!cleared)
+                    return;
+                await routeCodeVerdict({ ...task, batchIndex: undefined, batchTotal: undefined }, aggregated, expectedTask);
+                return;
+            }
+            await routeCodeVerdict(task, current.findings, expectedTask);
+        });
     });
-    async function routeCodeVerdict(task, findings) {
+    async function routeCodeVerdict(task, findings, expectedTask) {
         if (findings.verdict === 'approve') {
-            const afterDone = manager.resolveAfterDone(task);
-            if (task.afterDone === undefined) {
-                await manager.updateTask(task.id, { afterDone });
-            }
+            const afterDone = await manager.commitServerAfterDone(task.id, expectedTask);
             if (afterDone === null) {
-                const ready = await manager.transitionTaskStatus(task.id, 'ready', { fromStatus: ['review'] });
-                if (!ready)
-                    await emitIntervention(bus, task, { phase: 'server-code-ready-transition-failed' });
+                const ready = await manager.transitionTaskStatus(task.id, 'ready', { fromStatus: ['review'], expectTask: expectedTask });
+                if (!ready) {
+                    await holdConsumedSignal(task, task.qaAgentId ?? task.agentId, 'code-reviewed', 'handler-failed', 'server-code-ready-transition-failed');
+                }
                 return;
             }
-            const approved = await manager.transitionTaskStatus(task.id, 'approved', { fromStatus: ['review'] });
+            const approved = await manager.transitionTaskStatus(task.id, 'approved', { fromStatus: ['review'], expectTask: expectedTask });
             if (!approved) {
-                await emitIntervention(bus, task, { phase: 'server-code-approved-transition-failed' });
+                await holdConsumedSignal(task, task.qaAgentId ?? task.agentId, 'code-reviewed', 'handler-failed', 'server-code-approved-transition-failed');
                 return;
             }
-            await manager.dispatchServerAfterDone(task.id, afterDone);
+            const dispatched = await manager.dispatchServerAfterDone(task.id, afterDone);
+            if (!dispatched) {
+                await holdConsumedSignal(task, task.qaAgentId ?? task.agentId, 'code-reviewed', 'handler-failed', 'server-code-publish-dispatch-failed');
+            }
             return;
         }
         const cap = manager.getConfig().review.rounds + (task.maxRoundsContinues ?? 0);
         if (task.reviewRound >= cap) {
-            const capResult = await manager.transitionTaskStatus(task.id, 'max_rounds', { fromStatus: ['review'] });
+            const capResult = await manager.transitionTaskStatus(task.id, 'max_rounds', { fromStatus: ['review'], expectTask: expectedTask });
             if (!capResult)
                 return;
             const paused = capResult.task;
@@ -571,173 +785,217 @@ export function registerServerEventHandlers(bus, manager) {
             });
             return;
         }
-        await manager.dispatchServerFixToDev(task.id, JSON.stringify(findings));
+        const dispatched = await manager.dispatchServerFixToDev(task.id, JSON.stringify(findings), { callerOwnsConsumedSignalFailure: true, expectedTask });
+        if (!dispatched) {
+            await holdConsumedSignal(task, task.qaAgentId ?? task.agentId, 'code-reviewed', 'handler-failed', 'server-code-fix-dispatch-failed');
+        }
     }
-    async function recheckCodeOrAutoApprove(task, priorFindingsJson, priorResponseJson) {
-        if (await pauseForUnavailableQa(task, 'code-fixed', 'server-code-qa-unavailable-after-fix')) {
+    async function recheckCodeOrAutoApprove(task, priorFindingsJson, priorResponseJson, opts = {}) {
+        if (await pauseForUnavailableQa(task, 'code-fixed', 'server-code-qa-unavailable-after-fix', opts.onSideEffect)) {
             return false;
         }
         if (!task.qaAgentId) {
-            await autoApproveCode(task, 'code-fixed');
+            await autoApproveCode(task, opts.expectedTask, 'code-fixed', opts.onSideEffect);
             return true;
         }
-        return prepareAndDispatchCodeReview(task, { recheck: true, priorFindingsJson, priorResponseJson });
+        return prepareAndDispatchCodeReview(task, {
+            recheck: true,
+            priorFindingsJson,
+            priorResponseJson,
+            ...opts,
+        });
     }
-    async function runCodeFixSubmission(task) {
+    async function runCodeFixSubmission(task, opts = {}) {
         const dev = manager.getAgentConfig(task.agentId);
         if (!dev) {
-            await emitIntervention(bus, task, { phase: 'server-code-fix-no-dev-agent' });
-            if (task.agentId) {
-                await rearmOrHold(task, task.agentId, 'code-fixed');
-            }
-            return false;
+            return holdConsumedSignal(task, task.agentId, 'code-fixed', 'fix-no-dev-agent', 'server-code-fix-no-dev-agent', {}, opts.onSideEffect);
         }
         const round = Math.max(task.reviewRound, 1);
         const roundData = await reviewStore.getRound(task.id, 'code', round);
         if (!roundData?.findings) {
-            await emitIntervention(bus, task, { phase: 'server-code-fix-findings-missing', round });
-            await manager.setupPhaseSignal(task.id, task.agentId, 'code-fixed', { skipSnapshot: true });
-            return false;
+            return holdConsumedSignal(task, task.agentId, 'code-fixed', 'fix-findings-missing', 'server-code-fix-findings-missing', { round }, opts.onSideEffect);
         }
         await manager.refreshWorkdirCacheFor(task.agentId);
-        let response;
+        let readResult;
         try {
-            response = await transport().readResponse(task, dev);
+            readResult = await readResponseWithRetry(task, dev);
         }
         catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-response-invalid',
+            return holdConsumedSignal(task, dev.id, 'code-fixed', 'response-read-failed', 'server-code-response-read-failed', {
+                reason: err instanceof ReviewExchangeError ? err.reason : 'read-failed',
                 error: err instanceof Error ? err.message : String(err),
-            });
-            await manager.setupPhaseSignal(task.id, dev.id, 'code-fixed', { skipSnapshot: true });
-            return false;
-        }
-        if (response === null) {
+            }, opts.onSideEffect);
+        }
+        if (readResult.kind === 'unknown') {
+            return holdConsumedSignal(task, dev.id, 'code-fixed', 'response-read-failed', 'server-code-response-read-failed', { reason: readResult.error.reason, error: readResult.error.message }, opts.onSideEffect);
+        }
+        if (readResult.kind === 'invalid') {
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'response-invalid',
+                failurePhase: 'server-code-response-invalid',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
+                schemaViolationCodes: readResult.schemaViolationCodes,
+                details: { error: readResult.error.message },
+            }, opts.onSideEffect);
+        }
+        if (readResult.kind === 'absent') {
             if (roundData.response === undefined) {
-                await emitIntervention(bus, task, { phase: 'server-code-response-missing', round });
-                await manager.setupPhaseSignal(task.id, dev.id, 'code-fixed', { skipSnapshot: true });
-                return false;
+                return rejectServerResponse(task, dev, roundData, {
+                    reason: 'response-missing',
+                    failurePhase: 'server-code-response-missing',
+                }, opts.onSideEffect);
             }
-            return recheckCodeOrAutoApprove(task, JSON.stringify(roundData.findings), JSON.stringify(roundData.response));
+            return recheckCodeOrAutoApprove(task, JSON.stringify(roundData.findings), JSON.stringify(roundData.response), opts);
         }
+        const { response } = readResult;
         if (response.round !== round) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-response-round-mismatch',
-                round,
-                payloadRound: response.round,
-            });
-            await transport().deleteResponse(dev);
-            await manager.setupPhaseSignal(task.id, dev.id, 'code-fixed', { skipSnapshot: true });
-            return false;
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'round-mismatch',
+                failurePhase: 'server-code-response-round-mismatch',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
+                details: { payloadRound: response.round },
+            }, opts.onSideEffect);
+        }
+        if (response.token !== task.signalToken) {
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'token-mismatch',
+                failurePhase: 'server-code-response-token-mismatch',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
+            }, opts.onSideEffect);
+        }
+        const findingsDigest = reviewFindingsDigest(roundData.findings);
+        if (response.findingsDigest !== findingsDigest) {
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'findings-digest-mismatch',
+                failurePhase: 'server-code-response-findings-digest-mismatch',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
+            }, opts.onSideEffect);
         }
         const gaps = coverageGaps(roundData.findings, new Set(response.responses.map(r => r.findingId)));
         if (gaps.missing.length > 0 || gaps.unknown.length > 0) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-response-coverage-gap',
-                round,
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'coverage-gap',
+                failurePhase: 'server-code-response-coverage-gap',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
                 missingFindingIds: gaps.missing,
                 unknownFindingIds: gaps.unknown,
-            });
-            await manager.setupPhaseSignal(task.id, dev.id, 'code-fixed', { skipSnapshot: true });
-            return false;
+            }, opts.onSideEffect);
         }
-        if (!(await putVerdictRound(task, dev.id, 'code-fixed', { ...roundData, response })))
+        if (!(await putVerdictRound(task, dev.id, 'code-fixed', { ...roundData, response }, opts)))
             return false;
-        await transport().deleteResponse(dev);
-        return recheckCodeOrAutoApprove(task, JSON.stringify(roundData.findings), JSON.stringify(response));
+        if (!(await deleteResponseOrHold(task, dev, 'code-fixed', opts)))
+            return false;
+        return recheckCodeOrAutoApprove(task, JSON.stringify(roundData.findings), JSON.stringify(response), opts);
     }
     bus.on('server.code.fix.submitted', async (event) => {
         const gated = await gate(bus, manager, event, { status: 'fixing', phase: 'code', requireServerMode: true });
         if (!gated)
             return;
-        await runCodeFixSubmission(gated.task);
+        await runConsumedSignal(gated.task, gated.task.agentId, 'code-fixed', async () => {
+            await runCodeFixSubmission(gated.task, { expectedTask: gated.expectedTask, settlePermit: settlePermitOf(event) });
+        });
     });
     bus.on('server.code.published', async (event) => {
         const gated = await gate(bus, manager, event, { status: 'approved', phase: 'code', requireServerMode: true });
         if (!gated)
             return;
         const { task } = gated;
-        const prNumber = typeof event.data?.prNumber === 'number' ? event.data.prNumber : undefined;
-        if (prNumber === undefined && manager.resolveAfterDone(task) === 'pr' && task.prNumber === undefined) {
-            await emitIntervention(bus, task, { phase: 'server-code-published-missing-pr-number' });
-            await manager.setupPhaseSignal(task.id, task.agentId, 'code-ready', { skipSnapshot: true });
-            return;
-        }
-        if (prNumber !== undefined) {
-            const verified = await manager.verifyPaneSignalPrNumber(task.id, prNumber);
-            if (!verified) {
-                await emitIntervention(bus, task, {
-                    phase: 'server-code-published-pr-number-unverified',
-                    prNumber,
+        await runConsumedSignal(task, task.agentId, 'code-ready', async () => {
+            const prNumber = typeof event.data?.prNumber === 'number' ? event.data.prNumber : task.prNumber;
+            if (prNumber === undefined && manager.resolveAfterDone(task) === 'pr') {
+                await holdConsumedSignal(task, task.agentId, 'code-ready', 'handler-failed', 'server-code-published-missing-pr-number');
+                return;
+            }
+            const dev = manager.getAgentConfig(task.agentId);
+            if (!dev) {
+                await holdConsumedSignal(task, task.agentId, 'code-ready', 'fix-no-dev-agent', 'server-code-published-no-dev-agent');
+                return;
+            }
+            await manager.refreshWorkdirCacheFor(task.agentId);
+            let publishedHead;
+            try {
+                publishedHead = await transport().readHeadSha(dev);
+            }
+            catch (err) {
+                await holdConsumedSignal(task, task.agentId, 'code-ready', 'handler-failed', 'server-code-published-head-capture-failed', { error: err instanceof Error ? err.message : String(err) });
+                return;
+            }
+            if (publishedHead !== task.reviewHeadAnchorSha) {
+                await holdConsumedSignal(task, task.agentId, 'code-ready', 'handler-failed', 'server-code-published-head-mismatch', {
+                    publishedHead,
+                    reviewedHead: task.reviewHeadAnchorSha ?? null,
                 });
-                await manager.setupPhaseSignal(task.id, task.agentId, 'code-ready', { skipSnapshot: true });
                 return;
             }
-            await manager.updateTask(task.id, { prNumber });
-        }
-        const dev = manager.getAgentConfig(task.agentId);
-        if (!dev) {
-            await emitIntervention(bus, task, { phase: 'server-code-published-no-dev-agent' });
-            return;
-        }
-        await manager.refreshWorkdirCacheFor(task.agentId);
-        let publishedHead;
-        try {
-            publishedHead = await transport().readHeadSha(dev);
-        }
-        catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-published-head-capture-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-            await manager.setupPhaseSignal(task.id, task.agentId, 'code-ready', { skipSnapshot: true });
-            return;
-        }
-        if (publishedHead !== task.reviewHeadAnchorSha) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-published-head-mismatch',
-                publishedHead,
-                reviewedHead: task.reviewHeadAnchorSha ?? null,
-            });
-            return;
-        }
-        try {
-            await manager.updateTask(task.id, { latestHeadSha: publishedHead });
-        }
-        catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-code-published-head-capture-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-            await manager.setupPhaseSignal(task.id, task.agentId, 'code-ready', { skipSnapshot: true });
-            return;
-        }
-        const ready = await manager.transitionTaskStatus(task.id, 'ready', { fromStatus: ['approved'] });
-        if (!ready)
-            await emitIntervention(bus, task, { phase: 'server-code-published-transition-failed' });
+            let verifiedBaseBranch;
+            if (prNumber !== undefined) {
+                const verified = await manager.verifyPaneSignalPrNumber(task.id, prNumber);
+                if (!verified) {
+                    await holdConsumedSignal(task, task.agentId, 'code-ready', 'handler-failed', 'server-code-published-pr-number-unverified', { prNumber });
+                    return;
+                }
+                if (verified.headSha !== publishedHead) {
+                    await holdConsumedSignal(task, task.agentId, 'code-ready', 'handler-failed', 'server-code-published-pr-head-mismatch', {
+                        prNumber,
+                        remoteHead: verified.headSha,
+                        publishedHead,
+                        reviewedHead: task.reviewHeadAnchorSha,
+                    });
+                    return;
+                }
+                verifiedBaseBranch = verified.targetBranch;
+            }
+            let ready;
+            try {
+                ready = await manager.transitionTaskStatus(task.id, 'ready', { fromStatus: ['approved'], expectTask: gated.expectedTask }, {
+                    ...(prNumber !== undefined ? { prNumber } : {}),
+                    ...(prNumber !== undefined
+                        && task.baseBranch === undefined
+                        && verifiedBaseBranch !== undefined
+                        ? { baseBranch: verifiedBaseBranch }
+                        : {}),
+                    latestHeadSha: publishedHead,
+                });
+            }
+            catch (err) {
+                await holdConsumedSignal(task, task.agentId, 'code-ready', 'handler-failed', 'server-code-published-head-capture-failed', { error: err instanceof Error ? err.message : String(err) });
+                return;
+            }
+            if (!ready) {
+                await holdConsumedSignal(task, task.agentId, 'code-ready', 'handler-failed', 'server-code-published-transition-failed');
+            }
+        });
     });
     bus.on('server.spec.ready', async (event) => {
         const gated = await gate(bus, manager, event, { status: 'in_progress', phase: 'spec', requireServerMode: false });
         if (!gated)
             return;
-        await dispatchSpecReview(gated.task);
+        await runConsumedSignal(gated.task, gated.task.agentId, 'spec-done', async () => {
+            await dispatchSpecReview(gated.task, undefined, { expectedTask: gated.expectedTask, settlePermit: settlePermitOf(event) });
+        });
     });
-    async function dispatchSpecReview(task, prior) {
+    async function dispatchSpecReview(task, prior, opts = {}) {
         const dev = manager.getAgentConfig(task.agentId);
         if (!dev) {
-            await emitIntervention(bus, task, { phase: 'server-spec-review-no-dev-agent' });
-            if (task.agentId) {
-                const kind = task.status === 'fixing' ? 'spec-fixed' : 'spec-done';
-                await rearmOrHold(task, task.agentId, kind);
-            }
-            return false;
+            const kind = task.status === 'fixing' ? 'spec-fixed' : 'spec-done';
+            return holdConsumedSignal(task, task.agentId, kind, 'fix-no-dev-agent', 'server-spec-review-no-dev-agent', {}, opts.onSideEffect);
         }
         const cap = manager.getConfig().review.rounds + (task.maxRoundsContinues ?? 0);
-        const nextRound = (task.specReviewRound ?? 0) + 1;
+        const currentRound = task.specReviewRound ?? 0;
+        const nextRound = opts.bumpRound === false ? currentRound : currentRound + 1;
         if (nextRound > cap) {
-            const capResult = await manager.transitionTaskStatus(task.id, 'max_rounds', { fromStatus: ['in_progress', 'fixing'] });
+            const capResult = await manager.transitionTaskStatus(task.id, 'max_rounds', {
+                fromStatus: ['in_progress', 'fixing'],
+                ...(opts.expectedTask !== undefined ? { expectTask: opts.expectedTask } : {}),
+            });
             if (!capResult)
                 return false;
+            opts.onSideEffect?.();
             const paused = capResult.task;
             if (paused.qaAgentId)
                 await releaseAtCap(paused, paused.qaAgentId, 'qaAgentId');
@@ -745,39 +1003,43 @@ export function registerServerEventHandlers(bus, manager) {
                 await releaseAtCap(paused, paused.agentId, 'agentId');
             return false;
         }
-        await manager.refreshWorkdirCacheFor(task.agentId);
         let content;
-        try {
-            content = await transport().readContent(task, dev, 'spec');
-        }
-        catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-spec-content-read-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-            const kind = task.status === 'fixing' ? 'spec-fixed' : 'spec-done';
-            await manager.setupPhaseSignal(task.id, task.agentId, kind, { skipSnapshot: true });
-            return false;
-        }
-        try {
-            if (!content.documents)
-                throw new Error('spec transport returned no documents');
-            await reviewStore.putRound(task.id, 'spec', {
-                round: nextRound,
-                phase: 'spec',
-                content: content.content,
-                documents: content.documents,
-                startedAt: new Date().toISOString(),
-            });
+        if (opts.bumpRound === false) {
+            const stored = await reviewStore.getRound(task.id, 'spec', nextRound);
+            if (!stored || stored.phase !== 'spec') {
+                throw new Error(`Task ${task.id} has no persisted spec review round ${nextRound} to redispatch`);
+            }
+            content = { content: stored.content, documents: stored.documents };
         }
-        catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-spec-round-store-failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-            const kind = task.status === 'fixing' ? 'spec-fixed' : 'spec-done';
-            await manager.setupPhaseSignal(task.id, task.agentId, kind, { skipSnapshot: true });
-            return false;
+        else {
+            await manager.refreshWorkdirCacheFor(task.agentId);
+            try {
+                content = await transport().readContent(task, dev, 'spec');
+            }
+            catch (err) {
+                const kind = task.status === 'fixing' ? 'spec-fixed' : 'spec-done';
+                return holdConsumedSignal(task, task.agentId, kind, 'handler-failed', 'server-spec-content-read-failed', { error: err instanceof Error ? err.message : String(err) }, opts.onSideEffect);
+            }
+            try {
+                if (!content.documents)
+                    throw new Error('spec transport returned no documents');
+                const roundData = {
+                    round: nextRound,
+                    phase: 'spec',
+                    content: content.content,
+                    documents: content.documents,
+                    startedAt: new Date().toISOString(),
+                };
+                const stored = opts.expectedTask
+                    ? await manager.putReviewRoundIfCurrent(task.id, roundData, opts.expectedTask)
+                    : (await reviewStore.putRound(task.id, 'spec', roundData), true);
+                if (!stored)
+                    return false;
+            }
+            catch (err) {
+                const kind = task.status === 'fixing' ? 'spec-fixed' : 'spec-done';
+                return holdConsumedSignal(task, task.agentId, kind, 'verdict-store-failed', 'server-spec-round-store-failed', { error: err instanceof Error ? err.message : String(err) }, opts.onSideEffect);
+            }
         }
         if (!resolveActiveQa(task)) {
             if (task.qaAgentId) {
@@ -787,175 +1049,208 @@ export function registerServerEventHandlers(bus, manager) {
                 });
             }
             if (specApprovalIsHuman(task) || task.qaAgentId) {
-                const parked = await manager.parkTaskAtSpecReady(task.id, { specReviewRound: nextRound });
-                if (!parked)
-                    await emitIntervention(bus, task, { phase: 'server-spec-park-transition-failed' });
+                const parked = await manager.parkTaskAtSpecReady(task.id, {
+                    specReviewRound: nextRound,
+                    ...(opts.expectedTask !== undefined ? { expectedTask: opts.expectedTask } : {}),
+                });
+                if (parked)
+                    opts.onSideEffect?.();
+                if (!parked) {
+                    await holdConsumedSignal(task, task.agentId, task.status === 'fixing' ? 'spec-fixed' : 'spec-done', 'handler-failed', 'server-spec-park-transition-failed', {}, opts.onSideEffect);
+                }
                 return !!parked;
             }
-            return autoApproveSpec(task);
+            return autoApproveSpec(task, opts.expectedTask, opts.onSideEffect);
         }
         const dispatched = await manager.dispatchServerReviewToQa(task.id, {
             phase: 'spec',
+            ...(opts.bumpRound !== undefined ? { bumpRound: opts.bumpRound } : {}),
             content: content.content,
             ...(prior ? { priorFindingsJson: prior.findingsJson } : {}),
             ...(prior?.responseJson ? { priorResponseJson: prior.responseJson } : {}),
+            callerOwnsConsumedSignalFailure: true,
+            ...(opts.settlePermit !== undefined ? { settlePermit: opts.settlePermit } : {}),
+            ...(opts.expectedTask !== undefined ? { expectedTask: opts.expectedTask } : {}),
+            ...(opts.onSideEffect !== undefined ? { onSideEffect: opts.onSideEffect } : {}),
         });
-        return dispatched !== null;
+        if (dispatched)
+            return true;
+        return holdConsumedSignal(task, task.agentId, task.status === 'fixing' ? 'spec-fixed' : 'spec-done', 'handler-failed', 'server-spec-review-dispatch-failed', {}, opts.onSideEffect);
     }
     bus.on('server.spec.review.submitted', async (event) => {
         const gated = await gate(bus, manager, event, { status: 'review', phase: 'spec', requireServerMode: false });
         if (!gated)
             return;
-        const { task } = gated;
-        const qa = manager.getAgentConfig(task.qaAgentId ?? '');
-        if (!qa) {
-            await emitIntervention(bus, task, { phase: 'server-spec-review-no-qa-agent' });
-            if (task.qaAgentId) {
-                await rearmOrHold(task, task.qaAgentId, 'spec-reviewed');
+        const { task, expectedTask } = gated;
+        await runConsumedSignal(task, task.qaAgentId ?? task.agentId, 'spec-reviewed', async () => {
+            const qa = manager.getAgentConfig(task.qaAgentId ?? '');
+            if (!qa) {
+                await holdConsumedSignal(task, task.qaAgentId ?? '', 'spec-reviewed', 'handler-failed', 'server-spec-review-no-qa-agent');
+                return;
             }
-            return;
-        }
-        const round = task.specReviewRound ?? 1;
-        const roundData = await reviewStore.getRound(task.id, 'spec', round);
-        if (!roundData) {
-            await emitIntervention(bus, task, { phase: 'server-spec-review-round-missing', round });
-            await manager.setupPhaseSignal(task.id, qa.id, 'spec-reviewed', { skipSnapshot: true });
-            return;
-        }
-        await manager.refreshWorkdirCacheFor(qa.id);
-        let findings;
-        try {
-            findings = await transport().readFindings(task, qa);
-        }
-        catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-spec-findings-invalid',
-                error: err instanceof Error ? err.message : String(err),
-            });
-            await manager.setupPhaseSignal(task.id, qa.id, 'spec-reviewed', { skipSnapshot: true });
-            return;
-        }
-        let effective = findings;
-        if (effective === null) {
-            if (roundData.findings === undefined) {
-                await emitIntervention(bus, task, { phase: 'server-spec-findings-missing', round });
-                await manager.setupPhaseSignal(task.id, qa.id, 'spec-reviewed', { skipSnapshot: true });
+            const round = task.specReviewRound ?? 1;
+            const roundData = await reviewStore.getRound(task.id, 'spec', round);
+            if (!roundData) {
+                await holdConsumedSignal(task, qa.id, 'spec-reviewed', 'handler-failed', 'server-spec-review-round-missing', { round });
                 return;
             }
-            effective = roundData.findings;
-        }
-        else if (effective.round !== round) {
-            await emitIntervention(bus, task, {
-                phase: 'server-spec-findings-round-mismatch',
-                round,
-                payloadRound: effective.round,
-            });
-            await transport().deleteFindings(qa);
-            await manager.setupPhaseSignal(task.id, qa.id, 'spec-reviewed', { skipSnapshot: true });
-            return;
-        }
-        else {
-            const stored = await putVerdictRound(task, qa.id, 'spec-reviewed', {
-                ...roundData,
-                findings: effective,
-                completedAt: new Date().toISOString(),
-            });
-            if (!stored)
+            await manager.refreshWorkdirCacheFor(qa.id);
+            let findings;
+            try {
+                findings = await transport().readFindings(task, qa);
+            }
+            catch (err) {
+                await holdConsumedSignal(task, qa.id, 'spec-reviewed', 'handler-failed', 'server-spec-findings-invalid', { error: err instanceof Error ? err.message : String(err) });
                 return;
-            await transport().deleteFindings(qa);
-        }
-        if (effective.verdict === 'approve') {
-            await advanceApprovedSpec(task, 'server-spec-approve-transition-failed');
-            return;
-        }
-        const cap = manager.getConfig().review.rounds + (task.maxRoundsContinues ?? 0);
-        if ((task.specReviewRound ?? 0) >= cap) {
-            const capResult = await manager.transitionTaskStatus(task.id, 'max_rounds', { fromStatus: ['review'] });
-            if (!capResult)
+            }
+            let effective = findings;
+            if (effective === null) {
+                if (roundData.findings === undefined) {
+                    await holdConsumedSignal(task, qa.id, 'spec-reviewed', 'handler-failed', 'server-spec-findings-missing', { round });
+                    return;
+                }
+                effective = roundData.findings;
+            }
+            else if (effective.round !== round) {
+                await holdConsumedSignal(task, qa.id, 'spec-reviewed', 'handler-failed', 'server-spec-findings-round-mismatch', { round, payloadRound: effective.round });
                 return;
-            const paused = capResult.task;
-            if (paused.qaAgentId)
-                await releaseAtCap(paused, paused.qaAgentId, 'qaAgentId');
-            if (paused.agentId)
-                await releaseAtCap(paused, paused.agentId, 'agentId');
-            return;
-        }
-        await manager.dispatchServerFixToDev(task.id, JSON.stringify(effective));
+            }
+            else {
+                const stored = await putVerdictRound(task, qa.id, 'spec-reviewed', {
+                    ...roundData,
+                    findings: effective,
+                    completedAt: new Date().toISOString(),
+                }, { expectedTask });
+                if (!stored)
+                    return;
+                if (!(await deleteFindingsOrHold(task, qa, 'spec-reviewed', expectedTask)))
+                    return;
+            }
+            if (effective.verdict === 'approve') {
+                await advanceApprovedSpec(task, 'server-spec-approve-transition-failed', expectedTask);
+                return;
+            }
+            const cap = manager.getConfig().review.rounds + (task.maxRoundsContinues ?? 0);
+            if ((task.specReviewRound ?? 0) >= cap) {
+                const capResult = await manager.transitionTaskStatus(task.id, 'max_rounds', {
+                    fromStatus: ['review'],
+                    expectTask: expectedTask,
+                });
+                if (!capResult)
+                    return;
+                const paused = capResult.task;
+                if (paused.qaAgentId)
+                    await releaseAtCap(paused, paused.qaAgentId, 'qaAgentId');
+                if (paused.agentId)
+                    await releaseAtCap(paused, paused.agentId, 'agentId');
+                return;
+            }
+            const dispatched = await manager.dispatchServerFixToDev(task.id, JSON.stringify(effective), { callerOwnsConsumedSignalFailure: true, expectedTask });
+            if (!dispatched) {
+                await holdConsumedSignal(task, task.qaAgentId ?? task.agentId, 'spec-reviewed', 'handler-failed', 'server-spec-fix-dispatch-failed');
+            }
+        });
     });
-    async function runSpecFixSubmission(task) {
+    async function runSpecFixSubmission(task, opts = {}) {
         const dev = manager.getAgentConfig(task.agentId);
         if (!dev) {
-            await emitIntervention(bus, task, { phase: 'server-spec-fix-no-dev-agent' });
-            if (task.agentId) {
-                await rearmOrHold(task, task.agentId, 'spec-fixed');
-            }
-            return false;
+            return holdConsumedSignal(task, task.agentId, 'spec-fixed', 'fix-no-dev-agent', 'server-spec-fix-no-dev-agent', {}, opts.onSideEffect);
         }
         const round = task.specReviewRound ?? 1;
         const roundData = await reviewStore.getRound(task.id, 'spec', round);
         if (!roundData?.findings) {
-            await emitIntervention(bus, task, { phase: 'server-spec-fix-findings-missing', round });
-            await manager.setupPhaseSignal(task.id, task.agentId, 'spec-fixed', { skipSnapshot: true });
-            return false;
+            return holdConsumedSignal(task, task.agentId, 'spec-fixed', 'fix-findings-missing', 'server-spec-fix-findings-missing', { round }, opts.onSideEffect);
         }
         await manager.refreshWorkdirCacheFor(task.agentId);
-        let response;
+        let readResult;
         try {
-            response = await transport().readResponse(task, dev);
+            readResult = await readResponseWithRetry(task, dev);
         }
         catch (err) {
-            await emitIntervention(bus, task, {
-                phase: 'server-spec-response-invalid',
+            return holdConsumedSignal(task, dev.id, 'spec-fixed', 'response-read-failed', 'server-spec-response-read-failed', {
+                reason: err instanceof ReviewExchangeError ? err.reason : 'read-failed',
                 error: err instanceof Error ? err.message : String(err),
-            });
-            await manager.setupPhaseSignal(task.id, dev.id, 'spec-fixed', { skipSnapshot: true });
-            return false;
-        }
-        if (response === null) {
+            }, opts.onSideEffect);
+        }
+        if (readResult.kind === 'unknown') {
+            return holdConsumedSignal(task, dev.id, 'spec-fixed', 'response-read-failed', 'server-spec-response-read-failed', { reason: readResult.error.reason, error: readResult.error.message }, opts.onSideEffect);
+        }
+        if (readResult.kind === 'invalid') {
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'response-invalid',
+                failurePhase: 'server-spec-response-invalid',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
+                schemaViolationCodes: readResult.schemaViolationCodes,
+                details: { error: readResult.error.message },
+            }, opts.onSideEffect);
+        }
+        if (readResult.kind === 'absent') {
             if (roundData.response === undefined) {
-                await emitIntervention(bus, task, { phase: 'server-spec-response-missing', round });
-                await manager.setupPhaseSignal(task.id, dev.id, 'spec-fixed', { skipSnapshot: true });
-                return false;
+                return rejectServerResponse(task, dev, roundData, {
+                    reason: 'response-missing',
+                    failurePhase: 'server-spec-response-missing',
+                }, opts.onSideEffect);
             }
             return dispatchSpecReview(task, {
                 findingsJson: JSON.stringify(roundData.findings),
                 responseJson: JSON.stringify(roundData.response),
-            });
+            }, opts);
         }
+        const { response } = readResult;
         if (response.round !== round) {
-            await emitIntervention(bus, task, {
-                phase: 'server-spec-response-round-mismatch',
-                round,
-                payloadRound: response.round,
-            });
-            await transport().deleteResponse(dev);
-            await manager.setupPhaseSignal(task.id, dev.id, 'spec-fixed', { skipSnapshot: true });
-            return false;
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'round-mismatch',
+                failurePhase: 'server-spec-response-round-mismatch',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
+                details: { payloadRound: response.round },
+            }, opts.onSideEffect);
+        }
+        if (response.token !== task.signalToken) {
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'token-mismatch',
+                failurePhase: 'server-spec-response-token-mismatch',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
+            }, opts.onSideEffect);
+        }
+        const findingsDigest = reviewFindingsDigest(roundData.findings);
+        if (response.findingsDigest !== findingsDigest) {
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'findings-digest-mismatch',
+                failurePhase: 'server-spec-response-findings-digest-mismatch',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
+            }, opts.onSideEffect);
         }
         const gaps = coverageGaps(roundData.findings, new Set(response.responses.map(r => r.findingId)));
         if (gaps.missing.length > 0 || gaps.unknown.length > 0) {
-            await emitIntervention(bus, task, {
-                phase: 'server-spec-response-coverage-gap',
-                round,
+            return rejectServerResponse(task, dev, roundData, {
+                reason: 'coverage-gap',
+                failurePhase: 'server-spec-response-coverage-gap',
+                rawResponse: readResult.raw,
+                responseDigest: readResult.responseDigest,
                 missingFindingIds: gaps.missing,
                 unknownFindingIds: gaps.unknown,
-            });
-            await manager.setupPhaseSignal(task.id, dev.id, 'spec-fixed', { skipSnapshot: true });
-            return false;
+            }, opts.onSideEffect);
         }
-        if (!(await putVerdictRound(task, dev.id, 'spec-fixed', { ...roundData, response })))
+        if (!(await putVerdictRound(task, dev.id, 'spec-fixed', { ...roundData, response }, opts)))
+            return false;
+        if (!(await deleteResponseOrHold(task, dev, 'spec-fixed', opts)))
             return false;
-        await transport().deleteResponse(dev);
         return dispatchSpecReview(task, {
             findingsJson: JSON.stringify(roundData.findings),
             responseJson: JSON.stringify(response),
-        });
+        }, opts);
     }
     bus.on('server.spec.fix.submitted', async (event) => {
         const gated = await gate(bus, manager, event, { status: 'fixing', phase: 'spec', requireServerMode: false });
         if (!gated)
             return;
-        await runSpecFixSubmission(gated.task);
+        await runConsumedSignal(gated.task, gated.task.agentId, 'spec-fixed', async () => {
+            await runSpecFixSubmission(gated.task, { expectedTask: gated.expectedTask, settlePermit: settlePermitOf(event) });
+        });
     });
     async function latestVerdictRound(taskId, phase, fromRound) {
         for (let r = fromRound; r >= 1; r--) {
@@ -968,26 +1263,31 @@ export function registerServerEventHandlers(bus, manager) {
     // 手工发起复用自然入口的完整协议：fixing 走 fix-submission（读/校验 dev 的 response 后派 recheck，
     // 缺 response 拒绝）；其余状态按最近结论轮携带 prior 上下文，否则 QA 无从核对上一轮 findings
     manager.setServerReviewDriver({
-        dispatchCodeReview: async (task) => {
+        dispatchCodeReview: async (task, opts = {}) => {
             if (task.status === 'fixing')
-                return runCodeFixSubmission(task);
+                return runCodeFixSubmission(task, opts);
             const prior = await latestVerdictRound(task.id, 'code', task.reviewRound);
             return prepareAndDispatchCodeReview(task, {
                 recheck: prior !== null,
+                ...(opts.bumpRound !== undefined ? { bumpRound: opts.bumpRound } : {}),
+                ...(opts.expectedTask !== undefined ? { expectedTask: opts.expectedTask } : {}),
+                ...(opts.onSideEffect !== undefined ? { onSideEffect: opts.onSideEffect } : {}),
+                ...(opts.settlePermit !== undefined ? { settlePermit: opts.settlePermit } : {}),
                 ...(prior?.findings ? { priorFindingsJson: JSON.stringify(prior.findings) } : {}),
                 ...(prior?.response ? { priorResponseJson: JSON.stringify(prior.response) } : {}),
             });
         },
-        dispatchSpecReview: async (task) => {
+        dispatchSpecReview: async (task, opts = {}) => {
             if (task.status === 'fixing')
-                return runSpecFixSubmission(task);
+                return runSpecFixSubmission(task, opts);
             const prior = await latestVerdictRound(task.id, 'spec', task.specReviewRound ?? 0);
-            return dispatchSpecReview(task, prior?.findings
+            const priorContext = prior?.findings
                 ? {
                     findingsJson: JSON.stringify(prior.findings),
                     ...(prior.response ? { responseJson: JSON.stringify(prior.response) } : {}),
                 }
-                : undefined);
+                : undefined;
+            return dispatchSpecReview(task, priorContext, opts);
         },
     });
 }