baxian 1.2.52 → 1.2.53

package/dist/agent/manager.js

@@ -35,12 +35,6 @@ export class CleanupFailedError extends Error {
         this.name = 'CleanupFailedError';
     }
 }
-export class DispatchTransientError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'DispatchTransientError';
-    }
-}
 export class DispatchTerminalError extends Error {
     reason;
     replDrained;
@@ -101,7 +95,7 @@ function cancelPhaseDowngrades(prev, next) {
     return cancelPhaseRank(next) < cancelPhaseRank(prev);
 }
 const REGREET_REQUIRED_HOLD_PHASES = new Set(['greeting_failed']);
-export function shouldReleaseHeldBinding(state, boundTask) {
+function shouldReleaseHeldBinding(state, boundTask) {
     if (state.awaitingPhase != null && REGREET_REQUIRED_HOLD_PHASES.has(state.awaitingPhase))
         return false;
     const taskIsTerminal = !!boundTask && TERMINAL_STATUSES.includes(boundTask.status);
@@ -147,6 +141,7 @@ export class AgentManager {
     manualReviewInFlight = new Set();
     markCompleteInFlight = new Set();
     specVerdictInFlight = new Set();
+    codeVerdictInFlight = new Set();
     // 引用计数：cancelTask 与 startCreatedTaskSession 的清理段可合法并存（启动期 Stop），先完成者不得清掉后者的 guard。
     cancelCleanupInFlight = new Map();
     deletionInFlight = new Set();
@@ -240,6 +235,17 @@ export class AgentManager {
             console.warn(`[AgentManager] safeEmit ${event.type} failed (audit log loss; state machine unaffected):`, err);
         }
     }
+    async emitIntervention(projectId, agentId, taskId, data) {
+        await this.safeEmit({
+            id: '',
+            type: 'human.intervention',
+            timestamp: new Date().toISOString(),
+            projectId,
+            ...(agentId ? { agentId } : {}),
+            ...(taskId ? { taskId } : {}),
+            data,
+        });
+    }
     async recordError(input) {
         if (!this.errorRecordStore)
             return;
@@ -591,14 +597,7 @@ export class AgentManager {
         });
         if (!wrote)
             return;
-        await this.safeEmit({
-            id: '',
-            type: 'human.intervention',
-            timestamp: now,
-            projectId: existing.projectId,
-            agentId,
-            data: { phase: 'greeting_failed', reason },
-        });
+        await this.emitIntervention(existing.projectId, agentId, undefined, { phase: 'greeting_failed', reason });
     }
     async regreetHeldAgent(agentId) {
         const agent = this.getAgentConfig(agentId);
@@ -696,17 +695,9 @@ export class AgentManager {
         });
         if (!wrote)
             return;
-        await this.safeEmit({
-            id: '',
-            type: 'human.intervention',
-            timestamp: now,
-            projectId: projectIdForEmit,
-            agentId,
-            ...(taskIdForEmit ? { taskId: taskIdForEmit } : {}),
-            data: {
-                phase: 'agent_dialog_pending',
-                reason: 'Agent REPL launched but blocked on a startup dialog (e.g. CLI update notice). Operator should attach via web terminal and dismiss it; baxian will auto-detect ready and resume.',
-            },
+        await this.emitIntervention(projectIdForEmit, agentId, taskIdForEmit, {
+            phase: 'agent_dialog_pending',
+            reason: 'Agent REPL launched but blocked on a startup dialog (e.g. CLI update notice). Operator should attach via web terminal and dismiss it; baxian will auto-detect ready and resume.',
         });
     }
     async markBootstrapFailed(agentId, creationToken, errorMessage) {
@@ -917,16 +908,9 @@ export class AgentManager {
                 });
             }
             else {
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: now,
-                    projectId: projectIdForEmit,
-                    agentId,
-                    data: {
-                        phase: 'agent_dialog_resolved_runtime',
-                        note: 'Runtime dialog resolved; agent REPL ready. Click Resume to continue.',
-                    },
+                await this.emitIntervention(projectIdForEmit, agentId, undefined, {
+                    phase: 'agent_dialog_resolved_runtime',
+                    note: 'Runtime dialog resolved; agent REPL ready. Click Resume to continue.',
                 });
             }
             return;
@@ -990,18 +974,9 @@ export class AgentManager {
             const onMenu = detectRuntimeMenu(stripped);
             if (onMenu && !pendingMenu) {
                 pendingMenu = true;
-                const now = new Date().toISOString();
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: now,
-                    projectId: fresh.projectId,
-                    agentId,
-                    taskId: fresh.taskId,
-                    data: {
-                        phase: 'agent_runtime_menu_pending',
-                        note: 'Agent paused on an interactive menu mid-task. Attach via web terminal and respond; baxian will auto-clear once the menu closes.',
-                    },
+                await this.emitIntervention(fresh.projectId, agentId, fresh.taskId, {
+                    phase: 'agent_runtime_menu_pending',
+                    note: 'Agent paused on an interactive menu mid-task. Attach via web terminal and respond; baxian will auto-clear once the menu closes.',
                 });
             }
             else if (!onMenu && pendingMenu) {
@@ -1349,17 +1324,9 @@ export class AgentManager {
         });
         if (!wrote)
             return;
-        await this.safeEmit({
-            id: '',
-            type: 'human.intervention',
-            timestamp: now,
-            projectId,
-            agentId,
-            ...(taskId ? { taskId } : {}),
-            data: {
-                phase,
-                reason,
-            },
+        await this.emitIntervention(projectId, agentId, taskId, {
+            phase,
+            reason,
         });
     }
     async markAwaitingIfAckUnknown(agentId, err, expectedTaskId) {
@@ -1480,18 +1447,10 @@ export class AgentManager {
             if (shouldReleaseBinding) {
                 await this.lockManager.release(agentId);
             }
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: now,
-                projectId: state.projectId,
-                agentId,
-                ...(state.taskId ? { taskId: state.taskId } : {}),
-                data: {
-                    phase: 'resumed',
-                    previousPhase: state.awaitingPhase,
-                    releasedBinding: shouldReleaseBinding,
-                },
+            await this.emitIntervention(state.projectId, agentId, state.taskId, {
+                phase: 'resumed',
+                previousPhase: state.awaitingPhase,
+                releasedBinding: shouldReleaseBinding,
             });
             return { resumed: true, releasedBinding: shouldReleaseBinding };
         });
@@ -1686,19 +1645,11 @@ export class AgentManager {
         catch (releaseErr) {
             console.warn(`[AgentManager] failTaskForDispatchError: releaseAgentForTask(${agentId}) failed:`, releaseErr);
         }
-        await this.safeEmit({
-            id: '',
-            type: 'human.intervention',
-            timestamp: new Date().toISOString(),
-            projectId: transitioned?.task.projectId ?? '',
-            agentId,
-            taskId,
-            data: {
-                phase: `dispatch-failed:${err.reason}`,
-                reason: err.reason,
-                message: err.message,
-                replDrained: err.replDrained,
-            },
+        await this.emitIntervention(transitioned?.task.projectId ?? '', agentId, taskId, {
+            phase: `dispatch-failed:${err.reason}`,
+            reason: err.reason,
+            message: err.message,
+            replDrained: err.replDrained,
         });
     }
     async failTasksForAgent(agentId, reason, opts = {}) {
@@ -2081,6 +2032,10 @@ export class AgentManager {
             const scanSnapshotOnRecover = isServerProtocol
                 || (task.phase === undefined && task.status === 'in_progress')
                 || (task.phase !== 'spec' && (task.status === 'review' || task.status === 'fixing'));
+            const allowRecoveredReadFile = task.status === 'review'
+                && (task.phase === 'spec'
+                    || (task.reviewMode === 'server' && task.batchTotal !== undefined)
+                    || (task.reviewMode === 'server' && task.reviewWorktreeMode === 'base'));
             try {
                 await this.startPhaseSignalWatch({
                     taskId: task.id,
@@ -2090,23 +2045,15 @@ export class AgentManager {
                     token: task.signalToken,
                     skipSnapshot: !scanSnapshotOnRecover,
                     recovered: true,
-                    ...(isServerProtocol && task.status === 'review'
+                    ...(allowRecoveredReadFile
                         ? { onReadFile: (req) => { void this.handleReadFileRequest(task.id, agentId, req); } }
                         : {}),
                 });
                 if (interventionKindLabel) {
-                    await this.safeEmit({
-                        id: '',
-                        type: 'human.intervention',
-                        timestamp: new Date().toISOString(),
-                        projectId: task.projectId,
-                        agentId,
-                        taskId: task.id,
-                        data: {
-                            phase: 'spec-signal-setup-during-recovery',
-                            kind: interventionKindLabel,
-                            note: 'Task is waiting for a spec signal after server recovery; if no signal arrives, the prompt may not have been fully delivered before the previous crash. Inspect the agent pane and consider manual retry or transition.',
-                        },
+                    await this.emitIntervention(task.projectId, agentId, task.id, {
+                        phase: 'spec-signal-setup-during-recovery',
+                        kind: interventionKindLabel,
+                        note: 'Task is waiting for a spec signal after server recovery; if no signal arrives, the prompt may not have been fully delivered before the previous crash. Inspect the agent pane and consider manual retry or transition.',
                     });
                 }
             }
@@ -2318,18 +2265,10 @@ export class AgentManager {
             rolledBack = { projectId: task.projectId };
         });
         if (rolledBack && reason) {
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId: rolledBack.projectId,
-                agentId,
-                taskId,
-                data: {
-                    phase: reason.phase,
-                    message: reason.message,
-                    note: 'Dispatch failed; the task is back in pending — re-dispatch it once the cause is resolved.',
-                },
+            await this.emitIntervention(rolledBack.projectId, agentId, taskId, {
+                phase: reason.phase,
+                message: reason.message,
+                note: 'Dispatch failed; the task is back in pending — re-dispatch it once the cause is resolved.',
             });
         }
         const existing = await this.agentStore.get(agentId);
@@ -2944,14 +2883,23 @@ export class AgentManager {
         const worktree = new WorktreeManager(runner);
         const tmux = new TmuxManager(runner);
         const isServerQaPhase = phase === 'server-review' || phase === 'server-recheck' || phase === 'server-spec-review';
+        const isServerCodeReviewPhase = phase === 'server-review' || phase === 'server-recheck';
         const customBranch = task.branch && !task.branch.startsWith(BRANCH_PREFIX) ? task.branch : undefined;
-        // review/recheck check out the PR branch detached and never touch origin/HEAD,
-        // so the fail-fast base resolution only runs where the default base is used.
-        const worktreePath = isServerQaPhase
+        // Server code reviews materialize the captured head; other QA modes stay off origin/HEAD.
+        // The fail-fast base resolution only runs where the default base is used.
+        const reviewWorktree = isServerCodeReviewPhase && opts.serverContent !== undefined
+            ? await worktree.createDetachedForReviewHead(workdir, taskId, {
+                patch: opts.serverContent,
+                baseSha: opts.serverBaseSha,
+                headSha: opts.serverHeadSha,
+                headTree: opts.serverHeadTree,
+            })
+            : undefined;
+        const worktreePath = reviewWorktree?.path ?? (isServerQaPhase
             ? await worktree.createDetachedAtBase(workdir, taskId)
             : phase === 'review' || phase === 'recheck'
                 ? await worktree.createDetached(workdir, taskId, task.branch)
-                : await worktree.create(workdir, taskId, agent.workdir ? undefined : await this.resolveAutoBaseRef(runner, workdir), customBranch);
+                : await worktree.create(workdir, taskId, agent.workdir ? undefined : await this.resolveAutoBaseRef(runner, workdir), customBranch));
         await this.agentStore.update(agentId, (stateNow) => {
             if (!stateNow || stateNow.taskId !== taskId)
                 return AGENT_STORE_NOOP;
@@ -2972,7 +2920,7 @@ export class AgentManager {
         try {
             const imagePaths = await this.imagePathsForDispatch(runner, task, phase);
             let payloadOpts = {};
-            if (opts.serverContent !== undefined || opts.serverPriorFindings || opts.serverPriorResponse) {
+            if (opts.serverContent !== undefined || opts.serverDiffstat !== undefined || opts.serverInterdiff !== undefined || opts.serverPriorFindings || opts.serverPriorResponse) {
                 payloadOpts = await resolveServerPayloads(this.getReviewTransport(), agent, worktreePath, {
                     phase,
                     ...(task.phase ? { taskPhase: task.phase } : {}),
@@ -2980,6 +2928,9 @@ export class AgentManager {
                     reviewRound: task.reviewRound,
                     ...(opts.serverBatch ? { batch: opts.serverBatch } : {}),
                     ...(opts.serverContent !== undefined ? { serverContent: opts.serverContent } : {}),
+                    ...(reviewWorktree?.mode === 'head' ? { forceContentFile: true } : {}),
+                    ...(opts.serverDiffstat !== undefined ? { serverDiffstat: opts.serverDiffstat } : {}),
+                    ...(opts.serverInterdiff !== undefined ? { serverInterdiff: opts.serverInterdiff } : {}),
                     ...(opts.serverPriorFindings ? { serverPriorFindings: opts.serverPriorFindings } : {}),
                     ...(opts.serverPriorResponse ? { serverPriorResponse: opts.serverPriorResponse } : {}),
                 });
@@ -2994,7 +2945,11 @@ export class AgentManager {
                 ...(promptSignalToken ? { signalToken: promptSignalToken } : {}),
                 ...(promptSpecRound !== undefined ? { currentSpecRound: promptSpecRound } : {}),
                 ...(imagePaths.length ? { imagePaths } : {}),
-                ...(opts.serverDiffstat !== undefined ? { serverDiffstat: opts.serverDiffstat } : {}),
+                ...(reviewWorktree ? { serverReviewWorktree: reviewWorktree.mode } : {}),
+                ...(reviewWorktree?.fallbackReason ? { serverReviewFallbackReason: reviewWorktree.fallbackReason } : {}),
+                ...(opts.serverBaseSha !== undefined ? { serverBaseSha: opts.serverBaseSha } : {}),
+                ...(opts.serverHeadSha !== undefined ? { serverHeadSha: opts.serverHeadSha } : {}),
+                ...(opts.serverHeadTree !== undefined ? { serverHeadTree: opts.serverHeadTree } : {}),
                 ...(opts.serverBatch ? { serverBatch: opts.serverBatch } : {}),
                 ...payloadOpts,
             });
@@ -3060,7 +3015,7 @@ export class AgentManager {
             catch { }
             return false;
         }
-        if (opts.armBeforeInject && !(await opts.armBeforeInject())) {
+        if (opts.armBeforeInject && !(await opts.armBeforeInject({ serverReviewWorktree: reviewWorktree?.mode }))) {
             try {
                 await worktree.removeWithBranch(workdir, worktreePath, customBranch);
             }
@@ -3244,21 +3199,13 @@ export class AgentManager {
             }
             console.warn(`[AgentManager] dispatch ack timeout for pane ${paneId} agent ${agentId}: ${message}`);
             const state = await this.agentStore.get(agentId).catch(() => null);
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId: state?.projectId ?? '',
-                agentId,
-                ...(state?.taskId ? { taskId: state.taskId } : {}),
-                data: {
-                    phase: 'dispatch-ack-timeout',
-                    paneId,
-                    message,
-                    note: 'REPL did not acknowledge the pasted prompt within timeout. ' +
-                        'baxian intentionally did NOT send C-c — the input may still be queued. ' +
-                        'Attach via web terminal to verify and resolve.',
-                },
+            await this.emitIntervention(state?.projectId ?? '', agentId, state?.taskId, {
+                phase: 'dispatch-ack-timeout',
+                paneId,
+                message,
+                note: 'REPL did not acknowledge the pasted prompt within timeout. ' +
+                    'baxian intentionally did NOT send C-c — the input may still be queued. ' +
+                    'Attach via web terminal to verify and resolve.',
             });
             const composerDelivered = !/pane already busy at baseline/.test(message);
             return { acked: false, composerDelivered };
@@ -3345,7 +3292,7 @@ export class AgentManager {
                 && !ensure.freshRuntime;
             const imagePaths = await this.imagePathsForDispatch(runner, task, phase);
             let payloadOpts = {};
-            if (opts.serverContent !== undefined || opts.serverPriorFindings || opts.serverPriorResponse) {
+            if (opts.serverContent !== undefined || opts.serverDiffstat !== undefined || opts.serverInterdiff !== undefined || opts.serverPriorFindings || opts.serverPriorResponse) {
                 payloadOpts = await resolveServerPayloads(this.getReviewTransport(), agent, worktreePath, {
                     phase,
                     ...(task.phase ? { taskPhase: task.phase } : {}),
@@ -3353,6 +3300,8 @@ export class AgentManager {
                     reviewRound: task.reviewRound,
                     ...(opts.serverBatch ? { batch: opts.serverBatch } : {}),
                     ...(opts.serverContent !== undefined ? { serverContent: opts.serverContent } : {}),
+                    ...(opts.serverDiffstat !== undefined ? { serverDiffstat: opts.serverDiffstat } : {}),
+                    ...(opts.serverInterdiff !== undefined ? { serverInterdiff: opts.serverInterdiff } : {}),
                     ...(opts.serverPriorFindings ? { serverPriorFindings: opts.serverPriorFindings } : {}),
                     ...(opts.serverPriorResponse ? { serverPriorResponse: opts.serverPriorResponse } : {}),
                 });
@@ -3369,7 +3318,6 @@ export class AgentManager {
                     : {}),
                 ...(promptSpecRound !== undefined ? { currentSpecRound: promptSpecRound } : {}),
                 ...(imagePaths.length ? { imagePaths } : {}),
-                ...(opts.serverDiffstat !== undefined ? { serverDiffstat: opts.serverDiffstat } : {}),
                 ...(opts.serverBatch ? { serverBatch: opts.serverBatch } : {}),
                 ...(opts.serverAfterDone ? { serverAfterDone: opts.serverAfterDone } : {}),
                 ...payloadOpts,
@@ -3415,7 +3363,7 @@ export class AgentManager {
                 return false;
             }
         }
-        if (opts.armBeforeInject && !(await opts.armBeforeInject())) {
+        if (opts.armBeforeInject && !(await opts.armBeforeInject({}))) {
             return false;
         }
         const now = new Date().toISOString();
@@ -3524,9 +3472,7 @@ export class AgentManager {
                 const boundTask = state.taskId ? await this.taskStore.get(state.taskId) : null;
                 if (state.taskId
                     && boundTask?.id === state.taskId
-                    && boundTask.status === 'merged'
-                    && boundTask.prNumber != null
-                    && boundTask.branch
+                    && (boundTask.status === 'merged' || boundTask.status === 'done')
                     && !state.creationToken
                     && state.status !== 'awaiting_human') {
                     try {
@@ -3544,11 +3490,15 @@ export class AgentManager {
                             || recovered.status === 'awaiting_human') {
                             continue;
                         }
-                        await this.dispatchPostMergeCleanup(state.id, {
-                            taskId: boundTask.id,
-                            branch: boundTask.branch,
-                        });
-                        continue;
+                        if (boundTask.status === 'merged' && boundTask.prNumber != null && boundTask.branch) {
+                            await this.dispatchPostMergeCleanup(state.id, {
+                                taskId: boundTask.id,
+                                branch: boundTask.branch,
+                            });
+                            continue;
+                        }
+                        if (this.startCompactionThenRelease(recovered.id, recovered, boundTask.id))
+                            continue;
                     }
                     catch (cleanupErr) {
                         console.warn(`[recover] dispatchPostMergeCleanup(${state.id}, ${boundTask.id}) failed:`, cleanupErr);
@@ -3659,15 +3609,7 @@ export class AgentManager {
                     observation: { phase: 'recovery-failed' },
                     recommendation: 'Inspect or recreate the tmux session, then retry the affected task.',
                 });
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: new Date().toISOString(),
-                    projectId: state.projectId,
-                    agentId: state.id,
-                    taskId: state.taskId ?? '',
-                    data: { phase: 'recovery-failed', error: message },
-                });
+                await this.emitIntervention(state.projectId, state.id, state.taskId, { phase: 'recovery-failed', error: message });
             }
         }
         for (const c of deferredCleanups) {
@@ -3847,19 +3789,12 @@ export class AgentManager {
         }
         if (publishedCleanup) {
             if (publishedCleanup.mayBeInFlight && !devStopConfirmed) {
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: new Date().toISOString(),
-                    projectId: result.projectId,
-                    taskId,
-                    data: {
-                        phase: 'cancel-published-artifact-cleanup-skipped',
-                        afterDone: publishedCleanup.afterDone,
-                        branch: publishedCleanup.branch,
-                        ...(publishedCleanup.prNumber !== undefined ? { prNumber: publishedCleanup.prNumber } : {}),
-                        reason: 'dev pane stop unconfirmed; the publish prompt may still be running and would recreate the remote artifacts',
-                    },
+                await this.emitIntervention(result.projectId, undefined, taskId, {
+                    phase: 'cancel-published-artifact-cleanup-skipped',
+                    afterDone: publishedCleanup.afterDone,
+                    branch: publishedCleanup.branch,
+                    ...(publishedCleanup.prNumber !== undefined ? { prNumber: publishedCleanup.prNumber } : {}),
+                    reason: 'dev pane stop unconfirmed; the publish prompt may still be running and would recreate the remote artifacts',
                 });
                 return result;
             }
@@ -3896,19 +3831,12 @@ export class AgentManager {
             }
             catch (err) {
                 console.warn(`[AgentManager] cancelTask remote retirement failed for ${taskId}:`, err);
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: new Date().toISOString(),
-                    projectId: result.projectId,
-                    taskId,
-                    data: {
-                        phase: 'cancel-published-artifact-cleanup-failed',
-                        afterDone: publishedCleanup.afterDone,
-                        branch: publishedCleanup.branch,
-                        ...(publishedCleanup.prNumber !== undefined ? { prNumber: publishedCleanup.prNumber } : {}),
-                        error: err instanceof Error ? err.message : String(err),
-                    },
+                await this.emitIntervention(result.projectId, undefined, taskId, {
+                    phase: 'cancel-published-artifact-cleanup-failed',
+                    afterDone: publishedCleanup.afterDone,
+                    branch: publishedCleanup.branch,
+                    ...(publishedCleanup.prNumber !== undefined ? { prNumber: publishedCleanup.prNumber } : {}),
+                    error: err instanceof Error ? err.message : String(err),
                 });
             }
         }
@@ -4420,18 +4348,10 @@ export class AgentManager {
         const cur = await this.agentStore.get(agentId);
         if (!cur || cur.taskId !== expectedTaskId)
             return;
-        await this.safeEmit({
-            id: '',
-            type: 'human.intervention',
-            timestamp: new Date().toISOString(),
-            projectId: cur.projectId,
-            agentId,
-            taskId: expectedTaskId,
-            data: {
-                phase: 'manual-review-dev-parked-qa-failed',
-                note: 'Manual QA dispatch parked the dev agent into waiting; QA then failed to start. ' +
-                    'Dev binding is kept but no new prompt is running — re-dispatch the manual review or cancel the task.',
-            },
+        await this.emitIntervention(cur.projectId, agentId, expectedTaskId, {
+            phase: 'manual-review-dev-parked-qa-failed',
+            note: 'Manual QA dispatch parked the dev agent into waiting; QA then failed to start. ' +
+                'Dev binding is kept but no new prompt is running — re-dispatch the manual review or cancel the task.',
         });
     }
     async retryTask(taskId) {
@@ -5008,30 +4928,14 @@ export class AgentManager {
         if (task.agentId) {
             const devOk = await this.markAgentWaiting(task.agentId, taskId).catch(() => false);
             if (!devOk) {
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: new Date().toISOString(),
-                    projectId: task.projectId,
-                    agentId: task.agentId,
-                    taskId,
-                    data: { phase: 'spec-ready-dev-park-failed', devAgentId: task.agentId },
-                });
+                await this.emitIntervention(task.projectId, task.agentId, taskId, { phase: 'spec-ready-dev-park-failed', devAgentId: task.agentId });
             }
         }
         if (task.qaAgentId) {
             const released = await this.releaseAgentForTask(task.qaAgentId, taskId, 'idle')
                 .catch(() => false);
             if (!released) {
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: new Date().toISOString(),
-                    projectId: task.projectId,
-                    agentId: task.qaAgentId,
-                    taskId,
-                    data: { phase: 'spec-ready-qa-release-failed', qaAgentId: task.qaAgentId },
-                });
+                await this.emitIntervention(task.projectId, task.qaAgentId, taskId, { phase: 'spec-ready-qa-release-failed', qaAgentId: task.qaAgentId });
             }
         }
         return transition.task;
@@ -5103,6 +5007,111 @@ export class AgentManager {
             throw new ApiError(500, `Failed to dispatch spec fix for task ${taskId}`);
         return dispatched;
     }
+    async submitCodeVerdict(taskId, comments) {
+        const trimmed = comments?.trim();
+        if (!trimmed) {
+            throw new ApiError(400, 'comments is required for request-changes');
+        }
+        const task = await this.withTaskLock(async () => {
+            const fresh = await this.taskStore.get(taskId);
+            if (!fresh)
+                throw new ApiError(404, `Task ${taskId} not found`);
+            if (fresh.status !== 'ready') {
+                throw new ApiError(409, `Task ${taskId} is ${fresh.status}; code verdict requires ready`);
+            }
+            if (fresh.phase === 'spec') {
+                throw new ApiError(409, `Task ${taskId} is in the spec phase; reject the spec via the spec verdict instead`);
+            }
+            if (fresh.reviewMode !== 'server') {
+                throw new ApiError(409, `Task ${taskId} is not in server review mode; request changes on the PR instead`);
+            }
+            if (!fresh.agentId) {
+                throw new ApiError(400, `Task ${taskId} has no dev agent; cannot request changes`);
+            }
+            if (this.markCompleteInFlight.has(taskId)) {
+                throw new ApiError(409, `Task ${taskId} is being completed (merge in progress); try again shortly`);
+            }
+            if (this.codeVerdictInFlight.has(taskId)) {
+                throw new ApiError(409, `Task ${taskId} code verdict is already being processed`);
+            }
+            this.codeVerdictInFlight.add(taskId);
+            return fresh;
+        });
+        try {
+            return await this.executeCodeVerdict(task, trimmed);
+        }
+        finally {
+            this.codeVerdictInFlight.delete(taskId);
+        }
+    }
+    async executeCodeVerdict(task, trimmed) {
+        const taskId = task.id;
+        const store = this.getReviewStore();
+        if (!store)
+            throw new ApiError(500, 'Review store unavailable');
+        const round = Math.max(task.reviewRound, 1);
+        const at = new Date().toISOString();
+        // 打回消耗一轮修订；到达上限时拒绝而非派发注定进 max_rounds 的修订，让用户当场决策
+        const cap = this.getConfig().review.rounds + (task.maxRoundsContinues ?? 0);
+        if (round >= cap) {
+            throw new ApiError(409, `Task ${taskId} has reached the code review round cap (${cap}); `
+                + 'confirm completion, or cancel the task');
+        }
+        const roundData = await store.getRound(taskId, 'code', round);
+        // 无 QA 项目经 autoApproveCode 到达 ready 时从未存轮；补底轮次保证 userDecision 留痕与 fix 闭环
+        const base = roundData ?? await this.synthesizeEmptyCodeRound(task, round, at);
+        // runCodeFixSubmission 按 Math.max(reviewRound,1) 读轮、recheck 按 reviewRound+1 存新轮；
+        // reviewRound 停在 0 会让 recheck 覆写本轮，故落库为 1 对齐两侧
+        if (task.reviewRound === 0) {
+            await this.withTaskLock(async () => {
+                const fresh = await this.taskStore.get(taskId);
+                if (!fresh)
+                    return;
+                fresh.reviewRound = 1;
+                fresh.updatedAt = new Date().toISOString();
+                await this.taskStore.set(fresh);
+            });
+        }
+        const priorFindings = base.findings?.findings ?? [];
+        const nextUserId = `u-${priorFindings.filter(f => f.id.startsWith('u-')).length + 1}`;
+        const mergedFindings = {
+            round,
+            verdict: 'request-changes',
+            findings: [...priorFindings, { id: nextUserId, severity: 'major', message: trimmed }],
+        };
+        await store.putRound(taskId, 'code', {
+            ...base,
+            findings: mergedFindings,
+            userDecision: { verdict: 'request-changes', comments: trimmed, at },
+        });
+        const dispatched = await this.dispatchServerFixToDev(taskId, JSON.stringify(mergedFindings));
+        if (!dispatched)
+            throw new ApiError(500, `Failed to dispatch code fix for task ${taskId}`);
+        return dispatched;
+    }
+    async synthesizeEmptyCodeRound(task, round, at) {
+        const empty = { round, phase: 'code', content: '', startedAt: at };
+        const dev = task.agentId ? this.getAgentConfig(task.agentId) : undefined;
+        if (!dev || !task.agentId)
+            return empty;
+        // 读取失败不阻断打回：留痕与 fix 闭环优先于 diff 展示
+        try {
+            await this.refreshWorktreeCacheFor(task.agentId);
+            const content = await this.getReviewTransport().readContent(task, dev, 'code');
+            return {
+                round,
+                phase: 'code',
+                content: content.content,
+                ...(content.diffstat ? { diffstat: content.diffstat } : {}),
+                ...(content.baseSha ? { baseSha: content.baseSha } : {}),
+                startedAt: at,
+            };
+        }
+        catch (err) {
+            console.warn(`[AgentManager] submitCodeVerdict: code content read failed for ${task.id}; using empty round:`, err);
+            return empty;
+        }
+    }
     async transitionToCodePhase(taskId) {
         const task = await this.taskStore.get(taskId);
         if (!task)
@@ -5125,29 +5134,13 @@ export class AgentManager {
             const released = await this.releaseAgentForTask(task.qaAgentId, taskId, 'idle')
                 .catch(() => false);
             if (!released) {
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: new Date().toISOString(),
-                    projectId: task.projectId,
-                    agentId: task.qaAgentId,
-                    taskId,
-                    data: { phase: 'code-phase-qa-release-failed', qaAgentId: task.qaAgentId },
-                });
+                await this.emitIntervention(task.projectId, task.qaAgentId, taskId, { phase: 'code-phase-qa-release-failed', qaAgentId: task.qaAgentId });
             }
         }
         const acquired = await this.acquireAgentForTask(devAgentId, taskId, 'code');
         if (!acquired) {
             await this.markAwaitingHuman(devAgentId, 'code-dispatch-failed', 'Dev could not be acquired for the code phase after spec approval; the task looks in_progress but the code prompt was never dispatched. Resume the agent to redispatch or cancel the task.', { expectedTaskId: taskId }).catch(() => undefined);
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId: task.projectId,
-                agentId: devAgentId,
-                taskId,
-                data: { phase: 'code-dev-acquire-failed', devAgentId },
-            });
+            await this.emitIntervention(task.projectId, devAgentId, taskId, { phase: 'code-dev-acquire-failed', devAgentId });
             return null;
         }
         let resumed = false;
@@ -5166,15 +5159,7 @@ export class AgentManager {
         }
         if (!resumed) {
             await this.markAwaitingHuman(devAgentId, 'code-dispatch-failed', 'Code-phase prompt was not delivered after spec approval; the task looks in_progress but the dev never received it. Resume/restart the agent or cancel the task.', { expectedTaskId: taskId }).catch(() => undefined);
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId: task.projectId,
-                agentId: devAgentId,
-                taskId,
-                data: { phase: 'code-resume-failed', devAgentId },
-            });
+            await this.emitIntervention(task.projectId, devAgentId, taskId, { phase: 'code-resume-failed', devAgentId });
             return null;
         }
         return await this.taskStore.get(taskId);
@@ -5203,15 +5188,7 @@ export class AgentManager {
                     ? (opts.phase === 'spec' ? 'spec-fixed' : 'code-fixed')
                     : (opts.phase === 'spec' ? 'spec-done' : 'code-done');
                 await this.setupPhaseSignal(taskId, task.agentId, entryKind, { skipSnapshot: true });
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: new Date().toISOString(),
-                    projectId: task.projectId,
-                    agentId: task.agentId,
-                    taskId,
-                    data: { phase: 'server-review-no-qa-partner', devAgentId: task.agentId },
-                });
+                await this.emitIntervention(task.projectId, task.agentId, taskId, { phase: 'server-review-no-qa-partner', devAgentId: task.agentId });
                 return null;
             }
             const roundField = opts.phase === 'spec' ? (task.specReviewRound ?? 0) : task.reviewRound;
@@ -5261,15 +5238,7 @@ export class AgentManager {
             const acquired = await this.acquireAgentForTask(qaId, taskId, dispatchPhase);
             if (!acquired) {
                 await rearmEntrySignal();
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: new Date().toISOString(),
-                    projectId,
-                    agentId: qaId,
-                    taskId,
-                    data: { phase: 'server-review-qa-acquire-failed', qaAgentId: qaId },
-                });
+                await this.emitIntervention(projectId, qaId, taskId, { phase: 'server-review-qa-acquire-failed', qaAgentId: qaId });
                 return null;
             }
             if (devAgentId) {
@@ -5277,19 +5246,19 @@ export class AgentManager {
                 if (!devOk) {
                     await this.releaseAgentForTask(qaId, taskId, 'idle').catch(() => undefined);
                     await rearmEntrySignal();
-                    await this.safeEmit({
-                        id: '',
-                        type: 'human.intervention',
-                        timestamp: new Date().toISOString(),
-                        projectId,
-                        agentId: devAgentId,
-                        taskId,
-                        data: { phase: 'server-review-dev-park-failed', devAgentId },
-                    });
+                    await this.emitIntervention(projectId, devAgentId, taskId, { phase: 'server-review-dev-park-failed', devAgentId });
                     return null;
                 }
             }
         }
+        else {
+            const qaState = await this.agentStore.get(qaId);
+            if (qaState?.taskId !== taskId) {
+                await this.setupPhaseSignal(taskId, qaId, expectedKind, { skipSnapshot: true });
+                await this.emitIntervention(projectId, qaId, taskId, { phase: 'server-review-continuation-qa-not-bound', qaAgentId: qaId });
+                return null;
+            }
+        }
         const roundPatch = opts.phase === 'spec'
             ? { specReviewRound: newRound, phase: 'spec' }
             : { reviewRound: newRound };
@@ -5301,33 +5270,38 @@ export class AgentManager {
             ...(opts.batch
                 ? { batchIndex: opts.batch.index, batchTotal: opts.batch.total }
                 : { batchIndex: undefined, batchTotal: undefined }),
+            // Fresh dispatch: clear any stale mode until startSession materializes the worktree,
+            // so a crash in this window recovers conservatively (no read-file) rather than
+            // re-arming it for what might be a head-mode review.
+            ...(opts.continuation ? {} : { reviewWorktreeMode: undefined }),
             ...roundPatch,
         });
         if (!transition) {
             if (!opts.continuation) {
                 await this.releaseAgentForTask(qaId, taskId, 'idle').catch(() => undefined);
             }
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId,
-                agentId: qaId,
-                taskId,
-                data: { phase: 'server-review-transition-failed', qaAgentId: qaId },
-            });
+            await this.emitIntervention(projectId, qaId, taskId, { phase: 'server-review-transition-failed', qaAgentId: qaId });
             return null;
         }
+        let dispatchedWorktreeMode;
         const sessionOpts = {
             bypassTaskStatusGate: true,
             signalToken: newToken,
             serverContent: opts.content,
+            ...(opts.interdiff !== undefined ? { serverInterdiff: opts.interdiff } : {}),
             ...(opts.diffstat !== undefined ? { serverDiffstat: opts.diffstat } : {}),
+            ...(opts.baseSha !== undefined ? { serverBaseSha: opts.baseSha } : {}),
+            ...(opts.reviewHeadAnchorSha !== undefined ? { serverHeadSha: opts.reviewHeadAnchorSha } : {}),
+            ...(opts.headTree !== undefined ? { serverHeadTree: opts.headTree } : {}),
             ...(opts.batch ? { serverBatch: opts.batch } : {}),
             ...(opts.priorFindingsJson ? { serverPriorFindings: opts.priorFindingsJson } : {}),
             ...(opts.priorResponseJson ? { serverPriorResponse: opts.priorResponseJson } : {}),
             ...(opts.phase === 'spec' ? { currentSpecRound: newRound } : {}),
-            armBeforeInject: () => this.setupPhaseSignalWatcher(taskId, qaId, expectedKind, newToken, false, (req) => { void this.handleReadFileRequest(taskId, qaId, req); }),
+            armBeforeInject: (ctx) => {
+                dispatchedWorktreeMode = ctx.serverReviewWorktree;
+                const allowReadFile = opts.phase === 'spec' || opts.continuation || ctx.serverReviewWorktree === 'base';
+                return this.setupPhaseSignalWatcher(taskId, qaId, expectedKind, newToken, false, allowReadFile ? (req) => { void this.handleReadFileRequest(taskId, qaId, req); } : undefined);
+            },
         };
         const rearmConsumedSignal = async () => {
             if (opts.continuation) {
@@ -5366,17 +5340,14 @@ export class AgentManager {
                 await this.releaseAgentForTask(qaId, taskId, 'idle').catch(() => undefined);
             }
             await rearmConsumedSignal();
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId,
-                agentId: qaId,
-                taskId,
-                data: { phase: 'server-review-start-failed', qaAgentId: qaId },
-            });
+            await this.emitIntervention(projectId, qaId, taskId, { phase: 'server-review-start-failed', qaAgentId: qaId });
             return null;
         }
+        // Persist the materialized worktree mode so a restart can re-arm read-file for a base
+        // fallback review (whose prompt depends on it) but not for a head-mode one.
+        if (opts.phase !== 'spec' && !opts.continuation) {
+            await this.updateTask(taskId, { reviewWorktreeMode: dispatchedWorktreeMode }).catch(() => { });
+        }
         return await this.taskStore.get(taskId);
     }
     async dispatchServerFixToDev(taskId, findingsJson) {
@@ -5416,15 +5387,7 @@ export class AgentManager {
         const acquired = await this.acquireAgentForTask(devAgentId, taskId, 'server-feedback');
         if (!acquired) {
             await rearmReviewedSignal();
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId,
-                agentId: devAgentId,
-                taskId,
-                data: { phase: 'server-fix-dev-acquire-failed', devAgentId },
-            });
+            await this.emitIntervention(projectId, devAgentId, taskId, { phase: 'server-fix-dev-acquire-failed', devAgentId });
             return null;
         }
         if (qaAgentId) {
@@ -5432,29 +5395,13 @@ export class AgentManager {
                 .catch(() => false);
             if (!released) {
                 await rearmReviewedSignal();
-                await this.safeEmit({
-                    id: '',
-                    type: 'human.intervention',
-                    timestamp: new Date().toISOString(),
-                    projectId,
-                    agentId: qaAgentId,
-                    taskId,
-                    data: { phase: 'server-fix-qa-release-failed', qaAgentId },
-                });
+                await this.emitIntervention(projectId, qaAgentId, taskId, { phase: 'server-fix-qa-release-failed', qaAgentId });
                 return null;
             }
         }
-        const transition = await this.transitionTaskStatus(taskId, 'fixing', { fromStatus: ['review', 'max_rounds', 'spec-ready'] }, { signalToken: newToken, fixDispatchedAt: new Date().toISOString() });
+        const transition = await this.transitionTaskStatus(taskId, 'fixing', { fromStatus: ['review', 'max_rounds', 'spec-ready', 'ready'] }, { signalToken: newToken, fixDispatchedAt: new Date().toISOString() });
         if (!transition) {
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId,
-                agentId: devAgentId,
-                taskId,
-                data: { phase: 'server-fix-transition-failed', devAgentId },
-            });
+            await this.emitIntervention(projectId, devAgentId, taskId, { phase: 'server-fix-transition-failed', devAgentId });
             return null;
         }
         let resumed = false;
@@ -5485,15 +5432,7 @@ export class AgentManager {
             await rollbackToEntry();
             await this.releaseAgentForTask(devAgentId, taskId, 'idle').catch(() => undefined);
             await rearmReviewedSignal();
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId,
-                agentId: devAgentId,
-                taskId,
-                data: { phase: 'server-fix-resume-failed', devAgentId },
-            });
+            await this.emitIntervention(projectId, devAgentId, taskId, { phase: 'server-fix-resume-failed', devAgentId });
             return null;
         }
         await this.armPostDispatchSignalOrHold(taskId, devAgentId, expectedKind, newToken);
@@ -5510,6 +5449,33 @@ export class AgentManager {
             return `git:${parsed.host.toLowerCase()}/${parsed.path}`;
         return `raw:${repo.trim()}`;
     }
+    async computeCodeInterdiff(taskId, round) {
+        const store = this.getReviewStore();
+        if (!store || !Number.isInteger(round) || round < 2)
+            return { ok: false, reason: 'no-anchor' };
+        const [cur, prev] = await Promise.all([
+            store.getRound(taskId, 'code', round),
+            store.getRound(taskId, 'code', round - 1),
+        ]);
+        const curSha = cur?.headSha;
+        const prevSha = prev?.headSha;
+        if (!curSha || !prevSha)
+            return { ok: false, reason: 'no-anchor' };
+        const task = await this.taskStore.get(taskId);
+        if (!task?.agentId)
+            return { ok: false, reason: 'released' };
+        const agent = this.getAgentConfig(task.agentId);
+        const agentState = await this.agentStore.get(task.agentId);
+        // A rebound agent's worktree belongs to its new task — its git state describes
+        // another branch, so the interdiff would be meaningless. Same skip rule as
+        // findLineageViolation: worktree must still be bound to THIS task.
+        if (!agent || agentState?.taskId !== taskId || !agentState.worktreePath) {
+            return { ok: false, reason: 'released' };
+        }
+        await this.refreshWorktreeCacheFor(task.agentId);
+        const diff = await this.getReviewTransport().readInterdiff(agent, prevSha, curSha);
+        return { ok: true, diff };
+    }
     async findLineageViolation(taskId, baseSha) {
         const task = await this.taskStore.get(taskId);
         if (!task?.agentId)
@@ -5567,36 +5533,20 @@ export class AgentManager {
             violation = await this.findLineageViolation(taskId);
         }
         catch (err) {
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId: task.projectId,
-                agentId: devAgentId,
-                taskId,
-                data: {
-                    phase: 'server-after-done-lineage-check-failed',
-                    error: err instanceof Error ? err.message : String(err),
-                    note: 'Publish was not dispatched; mark-complete retries it once the repo state is fixed.',
-                },
+            await this.emitIntervention(task.projectId, devAgentId, taskId, {
+                phase: 'server-after-done-lineage-check-failed',
+                error: err instanceof Error ? err.message : String(err),
+                note: 'Publish was not dispatched; mark-complete retries it once the repo state is fixed.',
             });
             return null;
         }
         if (violation) {
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId: task.projectId,
-                agentId: devAgentId,
-                taskId,
-                data: {
-                    phase: 'server-after-done-lineage-violation',
-                    offendingTaskId: violation.taskId,
-                    offendingBranch: violation.branch,
-                    offendingSha: violation.sha,
-                    note: 'The task branch embeds another active task\'s commits; publishing would leak them into this PR. Rebase the branch onto origin/HEAD, then mark-complete to retry the publish.',
-                },
+            await this.emitIntervention(task.projectId, devAgentId, taskId, {
+                phase: 'server-after-done-lineage-violation',
+                offendingTaskId: violation.taskId,
+                offendingBranch: violation.branch,
+                offendingSha: violation.sha,
+                note: 'The task branch embeds another active task\'s commits; publishing would leak them into this PR. Rebase the branch onto origin/HEAD, then mark-complete to retry the publish.',
             });
             return null;
         }
@@ -5611,15 +5561,7 @@ export class AgentManager {
         const acquired = await this.acquireAgentForTask(devAgentId, taskId, 'server-after-done');
         if (!acquired) {
             await rollbackToken();
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId: task.projectId,
-                agentId: devAgentId,
-                taskId,
-                data: { phase: 'server-after-done-dev-acquire-failed', devAgentId },
-            });
+            await this.emitIntervention(task.projectId, devAgentId, taskId, { phase: 'server-after-done-dev-acquire-failed', devAgentId });
             return null;
         }
         await this.updateTask(taskId, { publishDispatchedAt: new Date().toISOString() });
@@ -5642,18 +5584,10 @@ export class AgentManager {
         }
         if (!resumed) {
             await rollbackToken();
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId: task.projectId,
-                agentId: devAgentId,
-                taskId,
-                data: {
-                    phase: 'server-after-done-resume-failed',
-                    devAgentId,
-                    note: 'Publish prompt was not delivered; mark-complete retries the publish dispatch.',
-                },
+            await this.emitIntervention(task.projectId, devAgentId, taskId, {
+                phase: 'server-after-done-resume-failed',
+                devAgentId,
+                note: 'Publish prompt was not delivered; mark-complete retries the publish dispatch.',
             });
             return null;
         }
@@ -5792,6 +5726,9 @@ export class AgentManager {
             if (this.markCompleteInFlight.has(taskId)) {
                 throw new ApiError(409, `Task ${taskId} is already being completed`);
             }
+            if (this.codeVerdictInFlight.has(taskId)) {
+                throw new ApiError(409, `Task ${taskId} code verdict is already being processed`);
+            }
             this.markCompleteInFlight.add(taskId);
             return fresh;
         });
@@ -5802,18 +5739,11 @@ export class AgentManager {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            await this.safeEmit({
-                id: '',
-                type: 'human.intervention',
-                timestamp: new Date().toISOString(),
-                projectId: task.projectId,
-                taskId: task.id,
-                data: {
-                    phase: 'confirm-merge-failed',
-                    gate: task.status,
-                    error: message,
-                    note: 'Task stays at the gate: Confirm again to retry, or Cancel to retire the published artifact.',
-                },
+            await this.emitIntervention(task.projectId, undefined, task.id, {
+                phase: 'confirm-merge-failed',
+                gate: task.status,
+                error: message,
+                note: 'Task stays at the gate: Confirm again to retry, or Cancel to retire the published artifact.',
             });
             throw new ApiError(409, `Merge failed for task ${task.id}: ${message}`);
         }
@@ -5836,12 +5766,26 @@ export class AgentManager {
             const state = await this.agentStore.get(id);
             if (!state || state.taskId !== taskId)
                 continue;
+            if (this.startCompactionThenRelease(id, state, taskId))
+                continue;
             await this.releaseAgentForTask(id, taskId, 'idle', { allowAwaitingHuman: true })
                 .catch(err => {
                 console.warn(`[AgentManager] confirm release ${id} failed:`, err);
             });
         }
     }
+    startCompactionThenRelease(agentId, state, taskId) {
+        // 人工介入/重建中的 pane 不发 /clear;confirm 语义要求解绑,落回直接释放
+        if (!state.paneId || state.status === 'awaiting_human' || state.creationToken)
+            return false;
+        const cfg = this.getAgentConfig(agentId);
+        if (!cfg)
+            return false;
+        const tmux = new TmuxManager(this.createRunnerFor(cfg));
+        void this.runPostMergeCompaction(tmux, state.paneId, agentId, taskId, agentRuntimeKindFor(cfg))
+            .catch(err => console.warn(`[AgentManager] releaseTaskAgents compaction(${agentId}) failed:`, err));
+        return true;
+    }
     repoMergeQueue = new Map();
     async ffMergeBranch(task) {
         const dev = this.getAgentConfig(task.agentId);