baxian 2.0.0 → 2.0.1

package/dist/event/server-handlers.js

@@ -1,5 +1,6 @@
-import { isSpecStagePhase } from '../shared/index.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;
@@ -150,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();
@@ -179,11 +180,15 @@ 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 {
-                await reviewStore.putRound(task.id, data.phase, data);
+                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) {
@@ -203,9 +208,9 @@ export function registerServerEventHandlers(bus, manager) {
         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 = {}) {
+    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}`);
         }
@@ -214,6 +219,7 @@ export function registerServerEventHandlers(bus, manager) {
         const held = await manager.holdConsumedServerSignal(task, agentId, kind, { phase, round, reason, failurePhase });
         if (!held)
             return false;
+        onSideEffect?.();
         await emitIntervention(bus, held, {
             phase: failurePhase,
             ...data,
@@ -239,17 +245,27 @@ export function registerServerEventHandlers(bus, manager) {
             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) {
+    async function deleteFindingsOrHold(task, qa, kind, expectedTask) {
         try {
-            await transport().deleteFindings(qa);
-            return true;
+            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 rejectServerResponse(task, dev, roundData, failure) {
+    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;
@@ -283,6 +299,7 @@ export function registerServerEventHandlers(bus, manager) {
         });
         if (!claimed?.signalToken)
             return false;
+        onSideEffect?.();
         let recorded;
         try {
             recorded = await reviewStore.recordServerResponseFailure(task.id, phase, roundData.round, {
@@ -351,7 +368,9 @@ export function registerServerEventHandlers(bus, manager) {
             return false;
         }
         try {
-            await transport().deleteResponse(dev);
+            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);
@@ -387,24 +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 holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', phase, { qaAgentId: task.qaAgentId });
+        await holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', phase, { qaAgentId: task.qaAgentId }, onSideEffect);
         return true;
     }
-    async function autoApproveCode(task, entryKind = 'code-done') {
-        const afterDone = await manager.commitServerAfterDone(task.id);
+    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'] });
+            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');
+                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 holdConsumedSignal(task, task.agentId, entryKind, 'fix-no-dev-agent', '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);
@@ -413,28 +438,35 @@ export function registerServerEventHandlers(bus, manager) {
             reviewHeadAnchorSha = await transport().readHeadSha(dev);
         }
         catch (err) {
-            await holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', 'server-code-auto-approve-head-capture-failed', { error: err instanceof Error ? err.message : String(err) });
+            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 holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', 'server-code-auto-approve-transition-failed');
+            await holdConsumedSignal(task, task.agentId, entryKind, 'handler-failed', 'server-code-auto-approve-transition-failed', {}, onSideEffect);
             return;
         }
         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');
+            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 holdConsumedSignal(task, task.qaAgentId ?? task.agentId, 'spec-reviewed', 'handler-failed', failurePhase);
             }
@@ -443,17 +475,19 @@ export function registerServerEventHandlers(bus, manager) {
             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 holdConsumedSignal(task, task.agentId, task.status === 'fixing' ? 'spec-fixed' : 'spec-done', 'handler-failed', '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 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) });
+            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;
         }
     }
@@ -461,14 +495,18 @@ export function registerServerEventHandlers(bus, manager) {
         const dev = manager.getAgentConfig(task.agentId);
         if (!dev) {
             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');
+            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 = 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');
@@ -509,7 +547,7 @@ export function registerServerEventHandlers(bus, manager) {
             }
             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) });
+                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);
@@ -520,12 +558,12 @@ export function registerServerEventHandlers(bus, manager) {
                         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) });
+                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 = {
@@ -538,7 +576,7 @@ export function registerServerEventHandlers(bus, manager) {
             ...(content.headTree ? { headTree: content.headTree } : {}),
             startedAt: new Date().toISOString(),
         };
-        const putEntryRound = (data) => putVerdictRound(task, task.agentId, task.status === 'fixing' ? 'code-fixed' : 'code-done', data);
+        const putEntryRound = (data) => putVerdictRound(task, task.agentId, task.status === 'fixing' ? 'code-fixed' : 'code-done', data, opts);
         const resolveRecheckInterdiff = async () => {
             if (!opts.recheck)
                 return undefined;
@@ -558,7 +596,7 @@ export function registerServerEventHandlers(bus, manager) {
         const dispatched = await manager.dispatchServerReviewToQa(task.id, {
             phase: 'code',
             recheck: opts.recheck,
-            ...(opts.bumpRound === false ? { bumpRound: false } : {}),
+            ...(opts.bumpRound !== undefined ? { bumpRound: opts.bumpRound } : {}),
             content: content.content,
             reviewHeadAnchorSha,
             ...(content.baseSha ? { baseSha: content.baseSha } : {}),
@@ -568,11 +606,14 @@ export function registerServerEventHandlers(bus, manager) {
             ...(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 } : {}),
         });
         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');
+        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');
@@ -586,6 +627,8 @@ export function registerServerEventHandlers(bus, manager) {
             ...(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;
     }
@@ -596,22 +639,22 @@ 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;
+        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);
+                await autoApproveCode(task, expectedTask);
                 return;
             }
-            await prepareAndDispatchCodeReview(task, { recheck: false });
+            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 { task, expectedTask } = gated;
         await runConsumedSignal(task, task.qaAgentId ?? task.agentId, 'code-reviewed', async () => {
             const qa = manager.getAgentConfig(task.qaAgentId ?? '');
             if (!qa) {
@@ -652,16 +695,16 @@ export function registerServerEventHandlers(bus, manager) {
                 const batchFindings = [...(roundData.batchFindings ?? [])];
                 batchFindings[task.batchIndex] = findings;
                 current = { ...roundData, batchFindings };
-                if (!(await putVerdictRound(task, qa.id, 'code-reviewed', current)))
+                if (!(await putVerdictRound(task, qa.id, 'code-reviewed', current, { expectedTask })))
                     return;
-                if (!(await deleteFindingsOrHold(task, qa, 'code-reviewed')))
+                if (!(await deleteFindingsOrHold(task, qa, 'code-reviewed', expectedTask)))
                     return;
             }
             else {
                 current = { ...roundData, findings, completedAt: new Date().toISOString() };
-                if (!(await putVerdictRound(task, qa.id, 'code-reviewed', current)))
+                if (!(await putVerdictRound(task, qa.id, 'code-reviewed', current, { expectedTask })))
                     return;
-                if (!(await deleteFindingsOrHold(task, qa, 'code-reviewed')))
+                if (!(await deleteFindingsOrHold(task, qa, 'code-reviewed', expectedTask)))
                     return;
             }
             const isRecheck = round > 1;
@@ -673,6 +716,8 @@ export function registerServerEventHandlers(bus, manager) {
                         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');
@@ -686,28 +731,30 @@ export function registerServerEventHandlers(bus, manager) {
                         ...current,
                         findings: aggregated,
                         completedAt: new Date().toISOString(),
-                    });
+                    }, { expectedTask });
                     if (!stored)
                         return;
                 }
-                await manager.updateTask(task.id, { batchIndex: undefined, batchTotal: undefined });
-                await routeCodeVerdict({ ...task, batchIndex: undefined, batchTotal: undefined }, aggregated);
+                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);
+            await routeCodeVerdict(task, current.findings, expectedTask);
         });
     });
-    async function routeCodeVerdict(task, findings) {
+    async function routeCodeVerdict(task, findings, expectedTask) {
         if (findings.verdict === 'approve') {
-            const afterDone = await manager.commitServerAfterDone(task.id);
+            const afterDone = await manager.commitServerAfterDone(task.id, expectedTask);
             if (afterDone === null) {
-                const ready = await manager.transitionTaskStatus(task.id, 'ready', { fromStatus: ['review'] });
+                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 holdConsumedSignal(task, task.qaAgentId ?? task.agentId, 'code-reviewed', 'handler-failed', 'server-code-approved-transition-failed');
                 return;
@@ -720,7 +767,7 @@ export function registerServerEventHandlers(bus, manager) {
         }
         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;
@@ -738,30 +785,35 @@ export function registerServerEventHandlers(bus, manager) {
             });
             return;
         }
-        const dispatched = await manager.dispatchServerFixToDev(task.id, JSON.stringify(findings), { callerOwnsConsumedSignalFailure: true });
+        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) {
-            return holdConsumedSignal(task, task.agentId, 'code-fixed', 'fix-no-dev-agent', 'server-code-fix-no-dev-agent');
+            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) {
-            return holdConsumedSignal(task, task.agentId, 'code-fixed', 'fix-findings-missing', 'server-code-fix-findings-missing', { round });
+            return holdConsumedSignal(task, task.agentId, 'code-fixed', 'fix-findings-missing', 'server-code-fix-findings-missing', { round }, opts.onSideEffect);
         }
         await manager.refreshWorkdirCacheFor(task.agentId);
         let readResult;
@@ -772,10 +824,10 @@ export function registerServerEventHandlers(bus, manager) {
             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),
-            });
+            }, 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 });
+            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, {
@@ -785,16 +837,16 @@ export function registerServerEventHandlers(bus, manager) {
                 responseDigest: readResult.responseDigest,
                 schemaViolationCodes: readResult.schemaViolationCodes,
                 details: { error: readResult.error.message },
-            });
+            }, opts.onSideEffect);
         }
         if (readResult.kind === 'absent') {
             if (roundData.response === undefined) {
                 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) {
@@ -804,7 +856,7 @@ export function registerServerEventHandlers(bus, manager) {
                 rawResponse: readResult.raw,
                 responseDigest: readResult.responseDigest,
                 details: { payloadRound: response.round },
-            });
+            }, opts.onSideEffect);
         }
         if (response.token !== task.signalToken) {
             return rejectServerResponse(task, dev, roundData, {
@@ -812,7 +864,7 @@ export function registerServerEventHandlers(bus, manager) {
                 failurePhase: 'server-code-response-token-mismatch',
                 rawResponse: readResult.raw,
                 responseDigest: readResult.responseDigest,
-            });
+            }, opts.onSideEffect);
         }
         const findingsDigest = reviewFindingsDigest(roundData.findings);
         if (response.findingsDigest !== findingsDigest) {
@@ -821,7 +873,7 @@ export function registerServerEventHandlers(bus, manager) {
                 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) {
@@ -832,24 +884,20 @@ export function registerServerEventHandlers(bus, manager) {
                 responseDigest: readResult.responseDigest,
                 missingFindingIds: gaps.missing,
                 unknownFindingIds: gaps.unknown,
-            });
+            }, 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;
-        try {
-            await transport().deleteResponse(dev);
-        }
-        catch (err) {
-            return holdConsumedSignal(task, dev.id, 'code-fixed', 'handler-failed', 'server-code-response-cleanup-failed', { error: err instanceof Error ? err.message : String(err) });
-        }
-        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 runConsumedSignal(gated.task, gated.task.agentId, 'code-fixed', async () => {
-            await runCodeFixSubmission(gated.task);
+            await runCodeFixSubmission(gated.task, { expectedTask: gated.expectedTask, settlePermit: settlePermitOf(event) });
         });
     });
     bus.on('server.code.published', async (event) => {
@@ -884,6 +932,7 @@ export function registerServerEventHandlers(bus, manager) {
                 });
                 return;
             }
+            let verifiedBaseBranch;
             if (prNumber !== undefined) {
                 const verified = await manager.verifyPaneSignalPrNumber(task.id, prNumber);
                 if (!verified) {
@@ -899,19 +948,24 @@ export function registerServerEventHandlers(bus, manager) {
                     });
                     return;
                 }
-                await manager.updateTask(task.id, {
-                    prNumber,
-                    ...(task.baseBranch === undefined ? { baseBranch: verified.targetBranch } : {}),
-                });
+                verifiedBaseBranch = verified.targetBranch;
             }
+            let ready;
             try {
-                await manager.updateTask(task.id, { latestHeadSha: publishedHead });
+                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;
             }
-            const ready = await manager.transitionTaskStatus(task.id, 'ready', { fromStatus: ['approved'] });
             if (!ready) {
                 await holdConsumedSignal(task, task.agentId, 'code-ready', 'handler-failed', 'server-code-published-transition-failed');
             }
@@ -922,22 +976,26 @@ export function registerServerEventHandlers(bus, manager) {
         if (!gated)
             return;
         await runConsumedSignal(gated.task, gated.task.agentId, 'spec-done', async () => {
-            await dispatchSpecReview(gated.task);
+            await dispatchSpecReview(gated.task, undefined, { expectedTask: gated.expectedTask, settlePermit: settlePermitOf(event) });
         });
     });
     async function dispatchSpecReview(task, prior, opts = {}) {
         const dev = manager.getAgentConfig(task.agentId);
         if (!dev) {
             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');
+            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 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');
@@ -960,22 +1018,27 @@ export function registerServerEventHandlers(bus, manager) {
             }
             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) });
+                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');
-                await reviewStore.putRound(task.id, 'spec', {
+                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) });
+                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)) {
@@ -986,31 +1049,39 @@ export function registerServerEventHandlers(bus, manager) {
                 });
             }
             if (specApprovalIsHuman(task) || task.qaAgentId) {
-                const parked = await manager.parkTaskAtSpecReady(task.id, { specReviewRound: nextRound });
+                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');
+                    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 === false ? { bumpRound: false } : {}),
+            ...(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 } : {}),
         });
         if (dispatched)
             return true;
-        return holdConsumedSignal(task, task.agentId, task.status === 'fixing' ? 'spec-fixed' : 'spec-done', 'handler-failed', 'server-spec-review-dispatch-failed');
+        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 { task, expectedTask } = gated;
         await runConsumedSignal(task, task.qaAgentId ?? task.agentId, 'spec-reviewed', async () => {
             const qa = manager.getAgentConfig(task.qaAgentId ?? '');
             if (!qa) {
@@ -1049,19 +1120,22 @@ export function registerServerEventHandlers(bus, manager) {
                     ...roundData,
                     findings: effective,
                     completedAt: new Date().toISOString(),
-                });
+                }, { expectedTask });
                 if (!stored)
                     return;
-                if (!(await deleteFindingsOrHold(task, qa, 'spec-reviewed')))
+                if (!(await deleteFindingsOrHold(task, qa, 'spec-reviewed', expectedTask)))
                     return;
             }
             if (effective.verdict === 'approve') {
-                await advanceApprovedSpec(task, 'server-spec-approve-transition-failed');
+                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'] });
+                const capResult = await manager.transitionTaskStatus(task.id, 'max_rounds', {
+                    fromStatus: ['review'],
+                    expectTask: expectedTask,
+                });
                 if (!capResult)
                     return;
                 const paused = capResult.task;
@@ -1071,21 +1145,21 @@ export function registerServerEventHandlers(bus, manager) {
                     await releaseAtCap(paused, paused.agentId, 'agentId');
                 return;
             }
-            const dispatched = await manager.dispatchServerFixToDev(task.id, JSON.stringify(effective), { callerOwnsConsumedSignalFailure: true });
+            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) {
-            return holdConsumedSignal(task, task.agentId, 'spec-fixed', 'fix-no-dev-agent', 'server-spec-fix-no-dev-agent');
+            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) {
-            return holdConsumedSignal(task, task.agentId, 'spec-fixed', 'fix-findings-missing', 'server-spec-fix-findings-missing', { round });
+            return holdConsumedSignal(task, task.agentId, 'spec-fixed', 'fix-findings-missing', 'server-spec-fix-findings-missing', { round }, opts.onSideEffect);
         }
         await manager.refreshWorkdirCacheFor(task.agentId);
         let readResult;
@@ -1096,10 +1170,10 @@ export function registerServerEventHandlers(bus, manager) {
             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),
-            });
+            }, 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 });
+            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, {
@@ -1109,19 +1183,19 @@ export function registerServerEventHandlers(bus, manager) {
                 responseDigest: readResult.responseDigest,
                 schemaViolationCodes: readResult.schemaViolationCodes,
                 details: { error: readResult.error.message },
-            });
+            }, opts.onSideEffect);
         }
         if (readResult.kind === 'absent') {
             if (roundData.response === undefined) {
                 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) {
@@ -1131,7 +1205,7 @@ export function registerServerEventHandlers(bus, manager) {
                 rawResponse: readResult.raw,
                 responseDigest: readResult.responseDigest,
                 details: { payloadRound: response.round },
-            });
+            }, opts.onSideEffect);
         }
         if (response.token !== task.signalToken) {
             return rejectServerResponse(task, dev, roundData, {
@@ -1139,7 +1213,7 @@ export function registerServerEventHandlers(bus, manager) {
                 failurePhase: 'server-spec-response-token-mismatch',
                 rawResponse: readResult.raw,
                 responseDigest: readResult.responseDigest,
-            });
+            }, opts.onSideEffect);
         }
         const findingsDigest = reviewFindingsDigest(roundData.findings);
         if (response.findingsDigest !== findingsDigest) {
@@ -1148,7 +1222,7 @@ export function registerServerEventHandlers(bus, manager) {
                 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) {
@@ -1159,27 +1233,23 @@ export function registerServerEventHandlers(bus, manager) {
                 responseDigest: readResult.responseDigest,
                 missingFindingIds: gaps.missing,
                 unknownFindingIds: gaps.unknown,
-            });
+            }, 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;
-        try {
-            await transport().deleteResponse(dev);
-        }
-        catch (err) {
-            return holdConsumedSignal(task, dev.id, 'spec-fixed', 'handler-failed', 'server-spec-response-cleanup-failed', { error: err instanceof Error ? err.message : String(err) });
-        }
         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 runConsumedSignal(gated.task, gated.task.agentId, 'spec-fixed', async () => {
-            await runSpecFixSubmission(gated.task);
+            await runSpecFixSubmission(gated.task, { expectedTask: gated.expectedTask, settlePermit: settlePermitOf(event) });
         });
     });
     async function latestVerdictRound(taskId, phase, fromRound) {
@@ -1195,18 +1265,21 @@ export function registerServerEventHandlers(bus, manager) {
     manager.setServerReviewDriver({
         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 === false ? { bumpRound: false } : {}),
+                ...(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, opts = {}) => {
             if (task.status === 'fixing')
-                return runSpecFixSubmission(task);
+                return runSpecFixSubmission(task, opts);
             const prior = await latestVerdictRound(task.id, 'spec', task.specReviewRound ?? 0);
             const priorContext = prior?.findings
                 ? {