baxian 2.0.7 → 2.0.9

package/dist/agent/manager.js

@@ -18,7 +18,7 @@ import { AGENT_STORE_NOOP } from '../state/agent-store.js';
 import { createRunner, LocalRunner, shellQuote, resolveAgentHost, workdirHostGroupKey, } from './runner.js';
 import { isTransientNetworkFailure } from './net-exec.js';
 import { imageFilename, agentHostPath, writeImageToHost } from './image-input.js';
-import { TmuxManager, ReplNotReadyError, detectStartupDialog, detectRuntimeMenu, runtimeBusyCheck, hasRuntimeReadyView, hasReplProcTitle, hasOscTitleWorking, hasOscTitleIdle, screenAllowsTitleIdle, PaneGoneError, } from './tmux.js';
+import { TmuxManager, ReplNotReadyError, detectStartupDialog, detectRuntimeMenu, runtimeBusyCheck, hasRuntimeReadyView, hasReplProcTitle, isShellProcTitle, hasOscTitleWorking, hasOscTitleIdle, screenAllowsTitleIdle, PaneGoneError, } from './tmux.js';
 import { BranchManager, DirtyWorkdirError, ReviewHeadMismatchError, isAutoDeletableTaskBranch } from './branch.js';
 import { RepoStore, createRepoStoreCache } from './repo-store.js';
 import { PhaseSignalWatcher, } from './phase-signal-watcher.js';
@@ -195,6 +195,10 @@ function cancelPhaseDowngrades(prev, next) {
     return cancelPhaseRank(next) < cancelPhaseRank(prev);
 }
 const REGREET_REQUIRED_HOLD_PHASES = new Set(['greeting_failed']);
+const RECOVERY_FAILED_AGENT_RUNBOOK = 'Fix the agent Workdir (or wait for the transient failure to clear), then Resume the agent.';
+const RECOVERY_FAILED_TASK_RUNBOOK = 'Fix the agent Workdir (or wait for the transient failure to clear), '
+    + 'then Resume the agent and use the recommended action on the task page.';
+const RECOVERY_FAILED_UNBOUND_RUNBOOK = 'Inspect or recreate the agent runtime before dispatching work to it.';
 const CHECKOUT_HOLD_PHASES = new Set([
     'dirty-workdir',
     'checkout-preparation-failed',
@@ -699,7 +703,7 @@ export class AgentManager {
         }
         catch (err) {
             console.warn(`[AgentManager] prompt for ${agentId}/${taskId} was delivered, but its context marker could not be saved; ` +
-                `the next phase will clear once and resend the full task:`, err);
+                `the next phase will resend the full task context:`, err);
         }
     }
     async resolveClaimedPane(tmux, agentId, expectedPaneId) {
@@ -1730,7 +1734,7 @@ export class AgentManager {
                 };
                 try {
                     await this.assertTaskGeneration(agentId, expectedTaskId, lockToken, releaseWorkdir);
-                    const runtime = await this.inspectReleaseRuntime(tmux, agentId);
+                    const runtime = await this.inspectReleaseRuntime(tmux, agentId, agentRuntimeKindFor(cfg));
                     if (runtime.kind === 'hold')
                         return hold(runtime.reason);
                     await this.assertTaskGeneration(agentId, expectedTaskId, lockToken, releaseWorkdir);
@@ -2689,7 +2693,11 @@ export class AgentManager {
                 return { resumed: false, releasedBinding: false, reason };
             }
             const now = new Date().toISOString();
-            const shouldReleaseBinding = shouldReleaseHeldBinding(state, boundTask);
+            const pendingRecoveryBootstrap = state.awaitingPhase === 'recovery-failed'
+                && state.taskId !== undefined
+                && state.bootstrappingTaskId === state.taskId
+                && boundTask?.status === 'pending';
+            const shouldReleaseBinding = pendingRecoveryBootstrap || shouldReleaseHeldBinding(state, boundTask);
             if (shouldReleaseBinding && state.taskId) {
                 return {
                     resumed: true,
@@ -2916,7 +2924,7 @@ export class AgentManager {
             return null;
         }
     }
-    async inspectReleaseRuntime(tmux, agentId) {
+    async inspectReleaseRuntime(tmux, agentId, runtime) {
         let sessionAlive;
         try {
             sessionAlive = await tmux.hasSession(agentId);
@@ -2930,8 +2938,9 @@ export class AgentManager {
         }
         if (!sessionAlive)
             return { kind: 'absent' };
+        let pane;
         try {
-            return { kind: 'pane', pane: await this.resolveClaimedPane(tmux, agentId) };
+            pane = await this.resolveClaimedPane(tmux, agentId);
         }
         catch (err) {
             if (err instanceof PaneGoneError) {
@@ -2946,6 +2955,22 @@ export class AgentManager {
                     `${err instanceof Error ? err.message : String(err)}`,
             };
         }
+        try {
+            const proc = await tmux.displayMessage(pane, '#{pane_current_command}');
+            if (!hasReplProcTitle(proc, runtime)) {
+                if (isShellProcTitle(proc))
+                    return { kind: 'absent' };
+                return {
+                    kind: 'hold',
+                    reason: `Runtime pane is running a non-runtime foreground process (${proc}); ` +
+                        `refusing checkout cleanup while the Workdir may be in use`,
+                };
+            }
+        }
+        catch {
+            // proc probe unavailable: fall through to the pane path; the idle wait decides
+        }
+        return { kind: 'pane', pane };
     }
     async interruptPaneAndWaitReady(state, cfg) {
         const pane = await this.resolveClaimedPaneOrNull(state, cfg);
@@ -3150,7 +3175,7 @@ export class AgentManager {
             replDrained: err.replDrained,
         });
     }
-    async failTasksForAgent(agentId, reason, opts = {}) {
+    async failTasksForAgent(agentId, reason) {
         const failed = await this.withTaskLock(async () => {
             const tasks = await this.taskStore.list({});
             const out = [];
@@ -3180,9 +3205,7 @@ export class AgentManager {
         }
         const failedTaskIds = failed.map(t => t.id);
         const projectIds = [...new Set(failed.map(t => t.projectId))];
-        if (!opts.deferPartnerCleanup) {
-            await this.releasePartnersAndDrain(agentId, failedTaskIds, projectIds);
-        }
+        await this.releasePartnersAndDrain(agentId, failedTaskIds, projectIds);
         return { failedTaskIds, projectIds };
     }
     async releasePartnersAndDrain(excludeAgentId, failedTaskIds, _projectIds) {
@@ -3849,6 +3872,8 @@ export class AgentManager {
                     ? event.data.reason
                     : 'human-intervention';
             const reason = reasonValue.trim() || 'human-intervention';
+            if (reason === 'recovery-failed' && TERMINAL_STATUSES.includes(task.status))
+                return;
             const previousPhase = typeof event.data.previousPhase === 'string'
                 ? event.data.previousPhase.trim()
                 : '';
@@ -3863,6 +3888,15 @@ export class AgentManager {
                 if (task.attention?.reason !== clearedReason
                     || Date.parse(event.timestamp) < Date.parse(task.attention.occurredAt))
                     return;
+                for (const participantId of [task.agentId, task.qaAgentId]) {
+                    if (!participantId || participantId === event.agentId)
+                        continue;
+                    const participant = await this.agentStore.get(participantId);
+                    if (participant?.taskId === task.id
+                        && participant.status === 'awaiting_human'
+                        && participant.awaitingPhase === clearedReason)
+                        return;
+                }
                 const next = { ...task, updatedAt: new Date().toISOString() };
                 delete next.attention;
                 await this.taskStore.set(next);
@@ -3898,9 +3932,14 @@ export class AgentManager {
                     : ['retry'];
             }
             else if (task.status === 'review') {
+                const qa = task.qaAgentId ? await this.agentStore.get(task.qaAgentId) : null;
+                const qaBound = qa?.taskId === task.id;
+                const qaAdvanceable = !qaBound
+                    || (qa.status === 'awaiting_human'
+                        && (qa.awaitingPhase === 'recovery-failed' || isRecoverableQaDispatchHold(qa)));
                 recommendedActions = isSpecStagePhase(task.phase)
-                    ? ['advance', 'cancel']
-                    : ['advance', 'verdict', 'cancel'];
+                    ? (qaAdvanceable ? ['advance', 'cancel'] : ['cancel'])
+                    : (qaAdvanceable ? ['advance', 'verdict', 'cancel'] : ['verdict', 'cancel']);
             }
             else if (task.status === 'spec-ready' || task.status === 'merge-ready') {
                 recommendedActions = ['verdict', 'cancel'];
@@ -3914,6 +3953,8 @@ export class AgentManager {
             if (task.attention
                 && task.attention.reason === reason
                 && task.attention.runbook === runbook
+                && task.attention.recommendedActions.length === recommendedActions.length
+                && task.attention.recommendedActions.every((action, index) => action === recommendedActions[index])
                 && Date.parse(task.attention.occurredAt) >= Date.parse(occurredAt))
                 return;
             await this.taskStore.set({
@@ -5808,6 +5849,7 @@ export class AgentManager {
                     projectId,
                     taskId: undefined,
                     lockToken: undefined,
+                    bootstrappingTaskId: undefined,
                     updatedAt: now,
                 };
             });
@@ -6306,34 +6348,6 @@ export class AgentManager {
             `${phase} queued for redispatch when idle (${(err.message.split('\n')[0])})`);
         return new EnsureSessionError({ createdSession, agentId, handled: true, busyPending: true }, `QA REPL busy; ${phase} dispatch for task ${taskId} queued for redispatch when idle`);
     }
-    async clearRuntimeForDispatchBoundary(tmux, pane, agentId, runtime, sessionRef, revalidate) {
-        await this.acquireCompactGuard(agentId);
-        try {
-            await this.waitForReplPromptReady(tmux, pane, runtime, this.cleanComposerWaitMs, { stableIdle: true });
-            await revalidate();
-            await tmux.clearComposerDraft(pane);
-            const baseline = await tmux.captureSettledSnapshot(pane, {
-                timeoutMs: this.dispatchSettleTimeoutMs,
-            });
-            const baselineTitle = await tmux.readPaneTitle(pane);
-            await this.setSessionOptions(tmux, agentId, sessionRef, [[TASK_CONTEXT_SESSION_OPTION, '']]);
-            await tmux.sendKeysLiteral(pane, '/clear');
-            await tmux.sendEnter(pane);
-            await tmux.waitSubmitAck(pane, baseline, runtime, {
-                timeoutMs: this.dispatchAckTimeoutMs,
-                baselineTitle,
-                acceptComposerChange: true,
-            });
-            await this.waitForReplPromptReady(tmux, pane, runtime, this.dispatchAckTimeoutMs, { stableIdle: true });
-            if (await this.hasRuntimeSlashCommandRejection(tmux, pane, '/clear')) {
-                throw new Error('Runtime rejected /clear at the dispatch boundary; refusing to reuse prior context');
-            }
-            await revalidate();
-        }
-        finally {
-            this.compactInFlight.delete(agentId);
-        }
-    }
     async persistTaskImages(taskId, images) {
         const dir = join(this.imageStagingRoot, taskId);
         await mkdir(dir, { recursive: true });
@@ -6742,9 +6756,6 @@ export class AgentManager {
                     await this.clearBranchLocalCleaned(taskId);
             }
             await assertOwner();
-            if (!ensure.freshRuntime && !reuseTaskContext) {
-                await this.clearRuntimeForDispatchBoundary(tmux, pane, agentId, agent.runtime, ensure.sessionRef, assertOwner);
-            }
         }
         catch (err) {
             const busyPend = await this.queueQaBusyPendingRetry(taskId, agentId, phase, ensure.createdSession, err, { passToken: opts.dispatchPassToken, pendingBudget: opts.dispatchPendingBudget });
@@ -7401,31 +7412,6 @@ export class AgentManager {
             return false;
         }
         const guardBeforeInject = opts.guardBeforeInject ?? (phase === 'post-approve' ? postApprovePassStillLive : undefined);
-        if (!ensure.freshRuntime && !reuseTaskContext) {
-            const revalidateContextReset = async () => {
-                const [currentTask, currentAgent] = await Promise.all([
-                    this.taskStore.get(taskId),
-                    this.agentStore.get(agentId),
-                ]);
-                const taskStillDispatchable = currentTask !== null
-                    && !TERMINAL_STATUSES.includes(currentTask.status)
-                    && (opts.bypassTaskStatusGate || expectedStatuses.includes(currentTask.status));
-                const bindingStillDispatchable = PHASE_REQUIRES_AGENT_BOUND_TO_TASK[phase]
-                    ? currentAgent?.taskId === taskId
-                    : currentAgent?.taskId === undefined || currentAgent.taskId === taskId;
-                if (!taskStillDispatchable
-                    || !bindingStillDispatchable
-                    || currentAgent?.lockToken !== lockToken
-                    || currentAgent.workdir !== verifiedWorkdir) {
-                    throw new Error(`Task or agent ownership changed while resetting context for ${phase} dispatch`);
-                }
-                await this.assertTaskLockOwner(agentId, taskId, lockToken);
-                if (guardBeforeInject && !(await guardBeforeInject())) {
-                    throw new Error(`Task generation changed while resetting context for ${phase} dispatch`);
-                }
-            };
-            await this.clearRuntimeForDispatchBoundary(tmux, pane, agentId, agent.runtime, ensure.sessionRef, revalidateContextReset);
-        }
         if (opts.armBeforeInject && !(await opts.armBeforeInject())) {
             return false;
         }
@@ -7472,6 +7458,37 @@ export class AgentManager {
         }
         return true;
     }
+    async clearRecoveredBootstrapHold(state) {
+        if (!state.taskId || !state.awaitingPhase)
+            return;
+        let cleared = false;
+        await this.agentStore.update(state.id, (latest) => {
+            if (!latest || latest.taskId !== undefined)
+                return AGENT_STORE_NOOP;
+            if (latest.awaitingPhase !== state.awaitingPhase
+                || latest.awaitingSince !== state.awaitingSince
+                || latest.awaitingNonce !== state.awaitingNonce)
+                return AGENT_STORE_NOOP;
+            const { status: _status, awaitingPhase: _phase, awaitingReason: _reason, awaitingSince: _since, awaitingNonce: _nonce, ...ready } = latest;
+            cleared = true;
+            return { ...ready, updatedAt: new Date().toISOString() };
+        });
+        if (!cleared)
+            return;
+        const intervention = {
+            id: '',
+            type: 'human.intervention',
+            timestamp: new Date().toISOString(),
+            projectId: state.projectId,
+            agentId: state.id,
+            taskId: state.taskId,
+            data: { phase: 'resumed', previousPhase: state.awaitingPhase, releasedBinding: true },
+        };
+        await this.safeEmit(intervention);
+        await this.recordTaskAttention(intervention).catch(err => {
+            console.warn(`[recover] could not clear ${state.awaitingPhase} attention for ${state.id}/${state.taskId}:`, err);
+        });
+    }
     async rollbackUndeliveredBootstrap(state) {
         if (!state.taskId
             || state.bootstrappingTaskId !== state.taskId
@@ -7481,6 +7498,14 @@ export class AgentManager {
         const boundTask = await this.taskStore.get(state.taskId);
         if (!boundTask)
             return false;
+        if (boundTask.status === 'pending') {
+            console.warn(`[recover] agent ${state.id} retained a pending bootstrap binding for ${state.taskId}; releasing it`);
+            await this.rollbackFailedDispatch(state.taskId, state.id, undefined, state.lockToken);
+            const released = (await this.agentStore.get(state.id))?.taskId !== state.taskId;
+            if (released)
+                await this.clearRecoveredBootstrapHold(state);
+            return released;
+        }
         if (boundTask.status === 'spec-ready' && isSpecStagePhase(boundTask.phase)) {
             if (state.id === boundTask.devAgentId && state.id !== boundTask.agentId) {
                 const lockToken = state.lockToken;
@@ -7521,12 +7546,7 @@ export class AgentManager {
         console.warn(`[recover] agent ${state.id} was mid-bootstrap for in_progress task ${state.taskId} ` +
             `(prompt never ack'd); rolling the task back to pending`);
         await this.rollbackFailedDispatch(state.taskId, state.id, undefined, state.lockToken);
-        await this.agentStore.update(state.id, (latest) => {
-            if (!latest || latest.status !== 'awaiting_human')
-                return AGENT_STORE_NOOP;
-            const { status: _s, awaitingPhase: _p, awaitingReason: _r, awaitingSince: _a, ...rest } = latest;
-            return { ...rest, updatedAt: new Date().toISOString() };
-        });
+        await this.clearRecoveredBootstrapHold(state);
         return true;
     }
     async bootstrapPromptWasDelivered(taskId, createdAtIso, agentId, phase) {
@@ -7617,7 +7637,6 @@ export class AgentManager {
         });
         const states = await this.agentStore.list();
         await this.releaseOrphanedLocks(states);
-        const deferredCleanups = [];
         for (const state of states) {
             const agentConfig = this.getAgentConfig(state.id);
             if (!agentConfig)
@@ -7692,18 +7711,11 @@ export class AgentManager {
                             || recovered.status === 'awaiting_human') {
                             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;
+                        await this.releaseAgentForTask(state.id, boundTask.id, 'idle');
+                        continue;
                     }
                     catch (cleanupErr) {
-                        console.warn(`[recover] dispatchPostMergeCleanup(${state.id}, ${boundTask.id}) failed:`, cleanupErr);
+                        console.warn(`[recover] releaseAgentForTask(${state.id}, ${boundTask.id}) failed:`, cleanupErr);
                     }
                 }
                 const cancelHold = isCancelCleanupHold(state);
@@ -7774,6 +7786,17 @@ export class AgentManager {
                 }
                 const message = err instanceof Error ? err.message : String(err);
                 console.warn(`[recover] ensureSession failed for agent=${state.id}: ${message}`);
+                const boundTask = state.taskId ? await this.taskStore.get(state.taskId) : null;
+                const attentionTaskId = state.taskId
+                    && boundTask
+                    && !TERMINAL_STATUSES.includes(boundTask.status)
+                    ? state.taskId
+                    : undefined;
+                const runbook = attentionTaskId
+                    ? RECOVERY_FAILED_TASK_RUNBOOK
+                    : state.taskId
+                        ? RECOVERY_FAILED_AGENT_RUNBOOK
+                        : RECOVERY_FAILED_UNBOUND_RUNBOOK;
                 await this.agentStore.update(state.id, (latest) => {
                     if (!latest)
                         return AGENT_STORE_NOOP;
@@ -7790,12 +7813,6 @@ export class AgentManager {
                         updatedAt: new Date().toISOString(),
                     };
                 });
-                const cleanup = await this.failTasksForAgent(state.id, `recovery: ${message}`, { deferPartnerCleanup: true });
-                deferredCleanups.push({
-                    failingAgentId: state.id,
-                    failedTaskIds: cleanup.failedTaskIds,
-                    projectIds: cleanup.projectIds,
-                });
                 await this.recordError({
                     agentId: state.id,
                     projectId: state.projectId,
@@ -7804,14 +7821,25 @@ export class AgentManager {
                     reason: 'RECOVERY_ENSURE_SESSION_FAILED',
                     message,
                     observation: { phase: 'recovery-failed' },
-                    recommendation: 'Inspect or recreate the tmux session, then retry the affected task.',
+                    recommendation: runbook,
                 });
-                await this.emitIntervention(state.projectId, state.id, state.taskId, { phase: 'recovery-failed', error: message });
+                const intervention = {
+                    id: '',
+                    type: 'human.intervention',
+                    timestamp: new Date().toISOString(),
+                    projectId: state.projectId,
+                    agentId: state.id,
+                    ...(attentionTaskId ? { taskId: attentionTaskId } : {}),
+                    data: { phase: 'recovery-failed', error: message, note: runbook },
+                };
+                await this.safeEmit(intervention);
+                if (attentionTaskId) {
+                    await this.recordTaskAttention(intervention).catch(attentionErr => {
+                        console.warn(`[recover] recordTaskAttention for ${state.id}/${attentionTaskId} failed:`, attentionErr);
+                    });
+                }
             }
         }
-        for (const c of deferredCleanups) {
-            await this.releasePartnersAndDrain(c.failingAgentId, c.failedTaskIds, c.projectIds);
-        }
         await this.recoverClaimedGitReviewDispatches().catch(err => {
             console.warn('[AgentManager] recover: claimed git review recovery failed:', err);
         });
@@ -8889,108 +8917,18 @@ export class AgentManager {
         if (!dev)
             return;
         this.phaseSignalWatcher?.stop(taskId);
-        if (task.prNumber && task.branch) {
-            const ctx = {
-                taskId: task.id,
-                branch: task.branch,
-            };
-            await this.dispatchPostMergeCleanup(task.agentId, ctx).catch(err => console.warn(`[AgentManager] cleanupAfterMerge: dispatchPostMergeCleanup(${task.agentId}) failed:`, err));
-        }
-        else {
-            await this.releaseAgentForTask(task.agentId, taskId, 'idle').catch(err => console.warn(`[AgentManager] cleanupAfterMerge: releaseAgentForTask(${task.agentId}, ${taskId}) failed:`, err));
-        }
+        this.startTaskAgentRelease(task.agentId, taskId);
     }
-    async dispatchPostMergeCleanup(agentId, ctx) {
-        const agent = this.getAgentConfig(agentId);
-        if (!agent)
-            return;
-        const genAtEntry = this.deletionGenerationOf(agentId);
-        const state = await this.agentStore.get(agentId);
-        if (!state)
-            return;
-        if (state.taskId && state.taskId !== ctx.taskId)
-            return;
-        if (state.creationToken)
-            return;
-        if (state.status === 'awaiting_human')
-            return;
-        if (!state.paneId) {
-            await this.releasePostMergeAgent(agentId, ctx.taskId);
-            return;
-        }
-        if (!state.taskId) {
-            if (this.isDeletionInFlight(agentId))
-                return;
-            const lockToken = await this.lockManager.acquire(agentId, ctx.taskId);
-            if (!lockToken)
-                return;
-            const commit = await this.agentStore.update(agentId, (existing) => {
-                if (!existing)
-                    return AGENT_STORE_NOOP;
-                if (!this.deletionGateOpen(agentId, genAtEntry))
-                    return AGENT_STORE_NOOP;
-                if (existing.taskId && existing.taskId !== ctx.taskId)
-                    return AGENT_STORE_NOOP;
-                if (existing.creationToken)
-                    return AGENT_STORE_NOOP;
-                if (existing.status === 'awaiting_human')
-                    return AGENT_STORE_NOOP;
-                if (existing.paneId !== state.paneId)
-                    return AGENT_STORE_NOOP;
-                return {
-                    ...existing,
-                    taskId: ctx.taskId,
-                    lockToken,
-                    updatedAt: new Date().toISOString(),
-                };
-            }).catch(async (err) => {
-                await this.lockManager.releaseIfOwner(agentId, ctx.taskId, lockToken).catch((releaseErr) => {
-                    console.warn(`[AgentManager] postMergeCleanup(${agentId}): lock release after commit failure also failed:`, releaseErr);
-                });
-                throw err;
-            });
-            if (commit !== 'committed') {
-                await this.lockManager.releaseIfOwner(agentId, ctx.taskId, lockToken);
-                return;
+    startTaskAgentRelease(agentId, taskId, opts = {}) {
+        void (async () => {
+            await this.acquireCompactGuard(agentId);
+            try {
+                await this.releaseAgentForTask(agentId, taskId, 'idle', opts);
             }
-            const fresh = await this.agentStore.get(agentId);
-            if (fresh?.taskId !== ctx.taskId || fresh.lockToken !== lockToken) {
-                await this.lockManager.releaseIfOwner(agentId, ctx.taskId, lockToken);
-                return;
+            finally {
+                this.compactInFlight.delete(agentId);
             }
-        }
-        if (!this.deletionGateOpen(agentId, genAtEntry))
-            return;
-        const runner = this.createRunnerFor(agent);
-        const tmux = new TmuxManager(runner);
-        const runtime = agentRuntimeKindFor(agent);
-        const expectedPaneId = state.paneId;
-        void (async () => {
-            if (!this.deletionGateOpen(agentId, genAtEntry))
-                return;
-            const pane = await this.resolveClaimedPane(tmux, agentId, expectedPaneId);
-            await this.runPostMergeCompaction(tmux, pane, agentId, ctx.taskId, runtime);
-        })().catch(err => console.warn(`[AgentManager] runPostMergeCompaction(${agentId}) failed:`, err));
-    }
-    async releasePostMergeAgent(agentId, taskId) {
-        const state = await this.agentStore.get(agentId);
-        if (state?.taskId !== taskId)
-            return;
-        try {
-            await this.releaseAgentForTask(agentId, taskId, 'idle');
-        }
-        catch (err) {
-            console.warn(`[AgentManager] releasePostMergeAgent: releaseAgentForTask(${agentId}, ${taskId}) failed:`, err);
-        }
-    }
-    async runPostMergeCompaction(tmux, pane, agentId, originalTaskId, runtime) {
-        await this.acquireCompactGuard(agentId);
-        try {
-            await this.runPostMergeCompactionSteps(tmux, pane, agentId, originalTaskId, runtime);
-        }
-        finally {
-            this.compactInFlight.delete(agentId);
-        }
+        })().catch(err => console.warn(`[AgentManager] background release(${agentId}, ${taskId}) failed:`, err));
     }
     async acquireCompactGuard(agentId) {
         while (!this.tryAcquireCompactGuard(agentId)) {
@@ -9012,144 +8950,6 @@ export class AgentManager {
         this.compactInFlight.add(agentId);
         return true;
     }
-    async runPostMergeCompactionSteps(tmux, pane, agentId, originalTaskId, runtime) {
-        const paneId = pane.paneId;
-        const initial = await this.agentStore.get(agentId);
-        if (!initial || initial.taskId !== originalTaskId || initial.paneId !== paneId)
-            return;
-        const lockToken = await this.resolveTaskLockToken(initial, originalTaskId);
-        if (!lockToken)
-            return;
-        const bindingStillOurs = async () => {
-            const s = await this.agentStore.get(agentId);
-            return !!s
-                && s.taskId === originalTaskId
-                && s.lockToken === lockToken
-                && s.paneId === paneId
-                && await this.lockManager.isOwner(agentId, originalTaskId, lockToken);
-        };
-        if (!await bindingStillOurs())
-            return;
-        let cleared = false;
-        let clearError;
-        try {
-            cleared = await this.sendPostMergeSlashCommand(tmux, pane, agentId, runtime, bindingStillOurs);
-        }
-        catch (err) {
-            clearError = err;
-        }
-        if (!cleared) {
-            if (await this.recoverPostMergeExitedRuntime(tmux, pane, agentId, originalTaskId, lockToken, runtime)) {
-                cleared = true;
-            }
-            else if (!await bindingStillOurs()) {
-                return;
-            }
-            else if (clearError instanceof Error
-                && clearError.message.includes('runtime rejected /clear')) {
-                try {
-                    await this.waitForReplPromptReady(tmux, pane, runtime, this.compactIdleWaitMs);
-                }
-                catch (err) {
-                    clearError = err;
-                }
-                if (clearError instanceof Error && !clearError.message.includes('runtime rejected /clear')) {
-                    await this.markAwaitingHuman(agentId, 'post-merge-cleanup-not-idle', `Task finished, but the runtime could not be proven idle after /clear: ${clearError.message}`, { expectedTaskId: originalTaskId });
-                    return;
-                }
-            }
-            else {
-                const reason = clearError instanceof Error ? clearError.message : String(clearError ?? 'unknown error');
-                await this.markAwaitingHuman(agentId, 'post-merge-cleanup-not-idle', `Task finished, but /clear and the runtime idle check did not complete safely: ${reason}`, { expectedTaskId: originalTaskId });
-                return;
-            }
-        }
-        await this.releasePostMergeAgent(agentId, originalTaskId);
-    }
-    async recoverPostMergeExitedRuntime(tmux, pane, agentId, taskId, lockToken, runtime) {
-        const paneId = pane.paneId;
-        let paneExists = true;
-        try {
-            if (hasReplProcTitle(await tmux.displayMessage(pane, '#{pane_current_command}'), runtime))
-                return false;
-        }
-        catch (err) {
-            const detail = err instanceof Error ? err.message : String(err);
-            if (!/no server running|session not found|can't find (?:pane|session)|no such (?:pane|session)/i.test(detail)) {
-                return false;
-            }
-            paneExists = false;
-        }
-        const state = await this.agentStore.get(agentId);
-        if (!state
-            || state.taskId !== taskId
-            || state.lockToken !== lockToken
-            || state.paneId !== paneId
-            || !(await this.lockManager.isOwner(agentId, taskId, lockToken)))
-            return false;
-        try {
-            if (paneExists)
-                await tmux.sendKeysToPane(pane, 'C-c');
-            const ensure = await this.ensureSession(agentId, 'runtime');
-            if (!ensure.freshRuntime)
-                return false;
-            await this.agentStore.update(agentId, (existing) => {
-                if (!existing || existing.taskId !== taskId || existing.lockToken !== lockToken) {
-                    return AGENT_STORE_NOOP;
-                }
-                if (existing.paneId === ensure.paneId && existing.workdir === ensure.workdir) {
-                    return AGENT_STORE_NOOP;
-                }
-                return {
-                    ...existing,
-                    paneId: ensure.paneId,
-                    workdir: ensure.workdir,
-                    updatedAt: new Date().toISOString(),
-                };
-            });
-            const current = await this.agentStore.get(agentId);
-            return current?.taskId === taskId
-                && current.lockToken === lockToken
-                && current.paneId === ensure.paneId
-                && await this.lockManager.isOwner(agentId, taskId, lockToken);
-        }
-        catch (err) {
-            console.warn(`[AgentManager] recoverPostMergeExitedRuntime(${agentId}, ${taskId}) failed:`, err);
-            return false;
-        }
-    }
-    async sendPostMergeSlashCommand(tmux, pane, agentId, runtime, bindingStillOurs) {
-        let rejection;
-        for (let attempt = 1; attempt <= 2; attempt++) {
-            if (!await bindingStillOurs())
-                return false;
-            await tmux.clearComposerDraft(pane);
-            await this.waitForReplPromptReady(tmux, pane, runtime, this.compactIdleWaitMs);
-            if (!await bindingStillOurs())
-                return false;
-            await tmux.sendKeysLiteral(pane, '/clear');
-            await tmux.sendEnter(pane);
-            await new Promise(r => setTimeout(r, this.compactIdlePollMs));
-            await this.waitForReplPromptReady(tmux, pane, runtime, this.compactIdleWaitMs);
-            if (!await bindingStillOurs())
-                return false;
-            if (!await this.hasRuntimeSlashCommandRejection(tmux, pane, '/clear'))
-                return true;
-            rejection = new Error('runtime rejected /clear because a task is still in progress');
-            if (attempt < 2) {
-                console.warn(`[AgentManager] runPostMergeCompaction(${agentId}) /clear rejected; retrying`);
-                await new Promise(r => setTimeout(r, this.compactIdlePollMs));
-            }
-        }
-        throw rejection ?? new Error('runtime rejected /clear');
-    }
-    async hasRuntimeSlashCommandRejection(tmux, pane, command) {
-        const cap = await tmux.capturePaneById(pane, { ansi: false, scrollback: 0 });
-        return this.runtimeSlashCommandRejectedPattern(command).test(cap);
-    }
-    runtimeSlashCommandRejectedPattern(command) {
-        return new RegExp(`["'“”‘’]?${command}["'“”‘’]?\\s+is disabled while a task is in progress\\.`, 'gi');
-    }
     async waitForReplPromptReady(tmux, pane, runtime, timeoutMs, opts = {}) {
         if (opts.stableIdle) {
             return this.waitForReplPromptStableIdle(tmux, pane, runtime, timeoutMs);
@@ -10224,28 +10024,9 @@ 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);
-            });
+            this.startTaskAgentRelease(id, taskId, { allowAwaitingHuman: true });
         }
     }
-    startCompactionThenRelease(agentId, state, taskId) {
-        const expectedPaneId = state.paneId;
-        if (!expectedPaneId || 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 (async () => {
-            const pane = await this.resolveClaimedPane(tmux, agentId, expectedPaneId);
-            await this.runPostMergeCompaction(tmux, pane, agentId, taskId, agentRuntimeKindFor(cfg));
-        })().catch(err => console.warn(`[AgentManager] releaseTaskAgents compaction(${agentId}) failed:`, err));
-        return true;
-    }
 }
 function buildAgentIndex(config) {
     const index = new Map();