baxian 2.0.28 → 2.0.30

package/dist/agent/manager.js

@@ -15,11 +15,11 @@ import { prReviewCacheRevision } from '../platform/pr-conversation-cache.js';
 import { deadTokens, liveVerdictVeto } from '../platform/verdict-engine.js';
 import { platformBindingMismatch, taskNeedsPlatformBindingAudit, } from '../platform/startup.js';
 import { AGENT_STORE_NOOP } from '../state/agent-store.js';
-import { createRunner, LocalRunner, shellQuote, resolveAgentHost, workdirHostGroupKey, } from './runner.js';
+import { createRunner, ExecNotStartedError, LocalRunner, shellQuote, hostGroupKey, resolveAgentHost, workdirHostGroupKey, } from './runner.js';
 import { isTransientNetworkFailure } from './net-exec.js';
 import { classifyScreen, isMenuRule } from './detect/classify.js';
 import { imageFilename, agentHostPath, writeImageToHost } from './image-input.js';
-import { TmuxManager, ReplNotReadyError, isBlockedOnStartupDialog, hasRuntimeReadyView, hasReplProcTitle, isShellProcTitle, PaneGoneError, } from './tmux.js';
+import { TmuxManager, TmuxOutcomeUnknownError, ReplNotReadyError, isBlockedOnStartupDialog, hasRuntimeReadyView, hasReplProcTitle, isShellProcTitle, 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';
@@ -149,6 +149,8 @@ const DEFAULT_DISPATCH_ACK_TIMEOUT_MS = 30_000;
 const DEFAULT_NEED_INPUT_RETRY_INTERVAL_MS = 5_000;
 const DEFAULT_DISPATCH_SETTLE_TIMEOUT_MS = 3_000;
 const DELETE_CLEANUP_TIMEOUT_MS = 15_000;
+const MANUAL_CONTEXT_COMMAND_TIMEOUT_MS = 5_000;
+const MANUAL_CONTEXT_TIMEOUT_MS = 15_000;
 const PLATFORM_HEAD_SHA_RE = new RegExp(`^${SHA_HEX_SOURCE}$`);
 function branchCleanupIdentity(task) {
     return {
@@ -262,6 +264,8 @@ export class AgentManager {
     compactIdleWaitMs = 5 * 60_000;
     compactIdlePollMs = 2_000;
     manualCompactWaitMs = 5_000;
+    restartInterruptWaitMs = 10_000;
+    replExitWaitMs = 30_000;
     runtimeLivenessProbeMs = 700;
     cleanComposerWaitMs = 5_000;
     platformVerificationRetryDelayMs = 2_000;
@@ -278,6 +282,7 @@ export class AgentManager {
     divergedAgents = new Set();
     deletionGeneration = new Map();
     compactInFlight = new Set();
+    maintenanceInFlight = new Set();
     platformBindingInterventionKeys = new Set();
     constructor(deps) {
         const config = prepareConfig(deps.config);
@@ -305,7 +310,17 @@ export class AgentManager {
         this.needInputRetryIntervalMs = deps.needInputRetryIntervalMs ?? DEFAULT_NEED_INPUT_RETRY_INTERVAL_MS;
         this.dispatchAckTimeoutMs = deps.dispatchAckTimeoutMs ?? DEFAULT_DISPATCH_ACK_TIMEOUT_MS;
         this.dispatchSettleTimeoutMs = deps.dispatchSettleTimeoutMs ?? DEFAULT_DISPATCH_SETTLE_TIMEOUT_MS;
-        this.cancelInterruptGuardWaitMs = this.dispatchAckTimeoutMs + 5_000;
+        this.cancelInterruptGuardWaitMs = deps.cancelInterruptGuardWaitMs ?? this.dispatchAckTimeoutMs + 5_000;
+        this.restartInterruptWaitMs = deps.restartInterruptWaitMs ?? this.restartInterruptWaitMs;
+        this.replExitWaitMs = deps.replExitWaitMs ?? this.replExitWaitMs;
+        this.dispatchAckResendIntervalMs = deps.dispatchAckResendIntervalMs ?? this.dispatchAckResendIntervalMs;
+        this.compactIdleWaitMs = deps.compactIdleWaitMs ?? this.compactIdleWaitMs;
+        this.manualCompactWaitMs = deps.manualCompactWaitMs ?? this.manualCompactWaitMs;
+        this.runtimeMenuPollIntervalMs = deps.runtimeMenuPollIntervalMs ?? this.runtimeMenuPollIntervalMs;
+        this.runtimeLivenessProbeMs = deps.runtimeLivenessProbeMs ?? this.runtimeLivenessProbeMs;
+        this.cleanComposerWaitMs = deps.cleanComposerWaitMs ?? this.cleanComposerWaitMs;
+        this.compactIdlePollMs = deps.compactIdlePollMs ?? this.compactIdlePollMs;
+        this.readyStableSpacingMs = deps.readyStableSpacingMs ?? this.readyStableSpacingMs;
         this.agentIndex = buildAgentIndex(config);
         this.platformRunner = deps.platformRunner ?? new LocalRunner();
         this.platformDriverExec = makeDriverExec(this.platformRunner);
@@ -897,7 +912,7 @@ export class AgentManager {
             console.warn(`[bootstrap] greeting attempt ${attempt}/${this.greetingMaxAttempts} for ${agentId}: ${outcome}`);
             if (outcome === 'no-agent')
                 break;
-            if (attempt < this.greetingMaxAttempts && !(await this.clearComposerForReuse(tmux, pane, agentId))) {
+            if (attempt < this.greetingMaxAttempts && !(await this.clearComposerForReuse(tmux, pane, agentId, agent.runtime))) {
                 break;
             }
         }
@@ -3144,7 +3159,7 @@ export class AgentManager {
     }
     async clearComposerAndConfirmReady(tmux, pane, runtime) {
         try {
-            await tmux.clearComposerDraft(pane);
+            await tmux.clearComposerDraft(pane, runtime);
         }
         catch (err) {
             console.warn(`[AgentManager] interruptPaneAndWaitReady: composer clear failed for pane ${pane.paneId}:`, err);
@@ -3214,10 +3229,10 @@ export class AgentManager {
         }
         return true;
     }
-    async paneReachedReplReady(tmux, pane, runtime, timeoutMs) {
+    async paneReachedReplReady(tmux, pane, runtime, timeoutMs, opts = {}) {
         const paneId = pane.paneId;
         try {
-            await tmux.waitReplReady(pane, runtime, { timeoutMs, scrollback: 0, titleIdleFastPath: true });
+            await tmux.waitReplReady(pane, runtime, { timeoutMs, scrollback: 0, titleIdleFastPath: true, ...opts });
             return true;
         }
         catch (err) {
@@ -3323,23 +3338,28 @@ export class AgentManager {
         });
     }
     async failTasksForAgent(agentId, reason) {
-        const failed = await this.withTaskLock(async () => {
-            const tasks = await this.taskStore.list({});
-            const out = [];
-            for (const t of tasks) {
-                const bound = t.agentId === agentId || t.qaAgentId === agentId;
-                if (t.status === 'merge-ready')
-                    continue;
-                if (ACTIVE_TASK_STATUSES.has(t.status) && bound) {
-                    const failedTask = this.stripGitStatusScopedState(t, 'failed');
-                    failedTask.status = 'failed';
-                    failedTask.updatedAt = new Date().toISOString();
-                    await this.taskStore.set(failedTask);
-                    out.push(failedTask);
-                }
+        const failed = await this.withTaskLock(() => this.failBoundTasksLocked(agentId));
+        return this.publishFailedTasks(agentId, reason, failed);
+    }
+    async failBoundTasksLocked(agentId) {
+        const tasks = await this.taskStore.list({});
+        const out = [];
+        for (const t of tasks) {
+            const bound = t.agentId === agentId || t.qaAgentId === agentId;
+            if (t.status === 'merge-ready')
+                continue;
+            if (ACTIVE_TASK_STATUSES.has(t.status) && bound) {
+                const failedTask = this.stripGitStatusScopedState(t, 'failed');
+                failedTask.status = 'failed';
+                failedTask.updatedAt = new Date().toISOString();
+                await this.taskStore.set(failedTask);
+                out.push(failedTask);
             }
-            return out;
-        });
+        }
+        return out;
+    }
+    // 事件与伙伴释放/排空留在 task lock 外:排空可能等待需要 task lock 的操作
+    async publishFailedTasks(agentId, reason, failed) {
         for (const t of failed) {
             await this.safeEmit({
                 id: '',
@@ -3378,22 +3398,103 @@ export class AgentManager {
     }
     async pollPaneCommandStable(tmux, pane, opts) {
         const deadline = Date.now() + opts.timeoutMs;
-        const SHELL = /^(?:zsh|bash|sh|fish)$/;
         let last = '';
         while (Date.now() < deadline) {
             await new Promise(r => setTimeout(r, 100));
             const raw = await tmux.displayMessage(pane, '#{pane_current_command}');
             last = raw.trim();
-            if (opts.expectShell ? SHELL.test(last) : last !== '')
+            if (opts.expectShell ? isShellProcTitle(last) : last !== '')
                 return last;
         }
         return last;
     }
+    // 不盲发 C-c:空 composer 上的 C-c 会让 codex 立即退出并花数秒生成 recap,之后的 /quit 与重启命令全都打进正在退出的 TUI
+    async exitReplForRestart(tmux, pane, cfg) {
+        const runtime = agentRuntimeKindFor(cfg);
+        // 已空闲就不发 Escape:codex 上它会武装 backtrack 提示,vim Insert 模式下会切到 Normal;只有 turn 进行中才需要打断
+        let foreground = await this.waitIdleOrShell(tmux, pane, runtime);
+        if (foreground === 'busy') {
+            if (await this.reachedRuntime(() => tmux.sendKeysToRuntime(pane, runtime, 'Escape'))) {
+                await new Promise(r => setTimeout(r, 200));
+            }
+            foreground = await this.waitIdleOrShell(tmux, pane, runtime);
+            if (foreground === 'busy') {
+                throw new Error(`restart-repl: ${runtime} in pane ${pane.paneId} did not return to an idle prompt after Escape; ` +
+                    'interrupt or finish the running turn via the web terminal, then retry');
+            }
+        }
+        if (foreground === 'shell')
+            return;
+        await tmux.clearComposerDraft(pane, runtime);
+        // 退出文本与 Enter 是同一条守卫命令:到达前 runtime 已退到 shell 就整组不发(/exit 不会被 shell 当命令执行),前台是 vim 这类进程也不会只留半行在 composer
+        try {
+            if (!await this.reachedRuntime(() => tmux.submitToRuntime(pane, runtime, REPL_EXIT_COMMAND[cfg.runtime])))
+                return;
+        }
+        catch (err) {
+            if (!(err instanceof TmuxOutcomeUnknownError))
+                throw err;
+            console.warn(`[AgentManager] restart-repl: exit outcome unknown for ${cfg.id}; checking for shell before relaunch`, err);
+        }
+        const after = await this.pollPaneCommandStable(tmux, pane, { timeoutMs: this.replExitWaitMs, expectShell: true });
+        if (!isShellProcTitle(after)) {
+            throw new Error(`restart-repl: ${runtime} in pane ${pane.paneId} did not exit within ${this.replExitWaitMs}ms ` +
+                `(pane_current_command=${after || 'unknown'}); not relaunching over a live runtime`);
+        }
+    }
+    // 服务端因前台已是 shell 而拒绝的 runtime 写不是失败:runtime 在按键到达前自己退了,交回按 shell 处理的分支;其他前台进程的拒绝照常抛出
+    async reachedRuntime(write) {
+        try {
+            await write();
+            return true;
+        }
+        catch (err) {
+            if (err instanceof ReplNotReadyError && err.shellForeground)
+                return false;
+            throw err;
+        }
+    }
+    // 等待期间 runtime 可能自行退到 shell(例如被误杀后 recap 刚结束):此时 Escape/退出命令都会打进 shell,应直接交回 relaunch
+    async waitIdleOrShell(tmux, pane, runtime) {
+        if (await this.paneReachedReplReady(tmux, pane, runtime, this.restartInterruptWaitMs, { failFastOnShell: true, runtimeSeen: true })) {
+            return 'idle';
+        }
+        const current = (await tmux.displayMessage(pane, '#{pane_current_command}')).trim();
+        return isShellProcTitle(current) ? 'shell' : 'busy';
+    }
+    // restart-repl / retry 从退出/重建到就绪后的清理与任务提示词 replay 是一段维护操作:两段并发会各自对同一个新 runtime replay 一次
+    tryBeginMaintenance(agentId) {
+        if (this.maintenanceInFlight.has(agentId))
+            return false;
+        this.maintenanceInFlight.add(agentId);
+        return true;
+    }
+    endMaintenance(agentId) {
+        this.maintenanceInFlight.delete(agentId);
+    }
+    isMaintenanceInFlight(agentId) {
+        return this.maintenanceInFlight.has(agentId);
+    }
     async restartReplOnly(agentId, opts = {}) {
         const genAtEntry = opts.expectedGeneration ?? this.deletionGenerationOf(agentId);
         if (!this.deletionGateOpen(agentId, genAtEntry)) {
             throw new Error(`restart-repl: agent ${agentId} is being deleted or was recreated; aborting`);
         }
+        if (!this.getAgentConfig(agentId))
+            throw new Error(`Unknown agent: ${agentId}`);
+        // 退出/重启是一整段状态机,只有最后的 relaunch 在服务端原子:整段与 compact/注入/上传共用 pane 互斥,与 retry/删除共用会话生命周期链
+        if (!this.tryAcquireCompactGuard(agentId)) {
+            throw new ApiError(409, `Agent ${agentId} pane is busy (compact, upload, dispatch or another restart in progress); retry shortly`);
+        }
+        try {
+            await this.runUnderSessionLifecycle(agentId, () => this.restartReplOnlyLocked(agentId, genAtEntry));
+        }
+        finally {
+            this.compactInFlight.delete(agentId);
+        }
+    }
+    async restartReplOnlyLocked(agentId, genAtEntry) {
+        // 配置在拿到生命周期链之后才解析:排队期间的热更新可能改了 runtime/model 等启动参数,入口捕获的旧值会拉起旧 runtime
         const cfg = this.getAgentConfig(agentId);
         if (!cfg)
             throw new Error(`Unknown agent: ${agentId}`);
@@ -3410,23 +3511,22 @@ export class AgentManager {
             throw new Error(`restart-repl: agent ${agentId} is being deleted or was recreated; aborting`);
         }
         const pane = await tmux.getSinglePaneByRef(snapshot.ref, agentId);
-        await tmux.sendKeysToPane(pane, 'C-c');
-        const cmd = await this.pollPaneCommandStable(tmux, pane, { timeoutMs: 2_000 });
         const RUNTIME = /^(?:claude|codex|node|opencode|qodercli(?:-[\d.]+)?|\d+\.\d+\.\d+)$/;
-        const SHELL = /^(?:zsh|bash|sh|fish)$/;
-        if (RUNTIME.test(cmd)) {
-            await tmux.sendKeysToPane(pane, REPL_EXIT_COMMAND[cfg.runtime], 'Enter');
-            await this.pollPaneCommandStable(tmux, pane, { timeoutMs: 2_000, expectShell: true });
-        }
-        else if (!SHELL.test(cmd)) {
-            throw new Error(`restart-repl precondition failed: unexpected pane state "${cmd}"`);
-        }
+        const readForeground = async () => {
+            const cmd = (await tmux.displayMessage(pane, '#{pane_current_command}')).trim();
+            if (!RUNTIME.test(cmd) && !isShellProcTitle(cmd)) {
+                throw new Error(`restart-repl precondition failed: unexpected pane state "${cmd}"`);
+            }
+            return cmd;
+        };
+        await readForeground();
         const project = this.getProjectConfig(cfg.projectId);
         if (!project)
             throw new Error(`restart-repl: project ${cfg.projectId} does not exist`);
         if (!this.deletionGateOpen(agentId, genAtEntry)) {
             throw new Error(`restart-repl: agent ${agentId} is being deleted or was recreated; aborting`);
         }
+        // 可能耗时或失败的准备(fetch、Workdir 核对)都放在退出 REPL 之前:失败时 REPL 仍活着,pane 停在 shell 的窗口只剩 relaunch 一瞬
         const { workdir } = await this.ensureWorkdir(cfg, project, runner);
         const paneWorkdir = await tmux.getPaneCurrentPath(pane);
         if (!await sameDirOnHost(runner, paneWorkdir, workdir)) {
@@ -3437,10 +3537,25 @@ export class AgentManager {
             throw new Error(`restart-repl: agent ${agentId} is being deleted or was recreated; aborting`);
         }
         await this.setSessionOptions(tmux, agentId, snapshot.ref, [[WORKDIR_SESSION_OPTION, workdir]]);
+        // 热更新不在这条链上:退出与 relaunch 之间启动参数或连接目标又变了就停下,不能按一套配置退出、按另一套(或在另一台机器上)拉起
+        const launchCommand = launchCommandIn(workdir, cfg);
+        const restartTarget = (agent) => `${hostGroupKey(agent.mode, resolveAgentHost(this.config.host, agent.host))} ${launchCommandIn(workdir, agent)}`;
+        const target = restartTarget(cfg);
+        const assertTargetUnchanged = (stage) => {
+            const now = this.getAgentConfig(agentId);
+            if (!now || restartTarget(now) !== target) {
+                throw new Error(`restart-repl: agent ${agentId} config changed while ${stage}; run Restart REPL again against the current config`);
+            }
+        };
+        assertTargetUnchanged('preparing the restart');
+        if (RUNTIME.test(await readForeground())) {
+            await this.exitReplForRestart(tmux, pane, cfg);
+        }
+        assertTargetUnchanged('exiting the runtime');
         const runtime = agentRuntimeKindFor(cfg);
         const relaunch = async () => {
-            await tmux.sendKeysLiteral(pane, launchCommandIn(workdir, cfg));
-            await tmux.sendEnter(pane);
+            // C-c 只丢弃 shell readline 里的残留输入(操作员误键、晚到的弄脏键),启动命令不能接在残留文本后面执行;前台不是 shell 则整组按键都不发
+            await tmux.submitCommandOnShell(pane, launchCommand);
             await tmux.handleTrustDialog(pane, runtime, {
                 timeoutMs: this.bootstrapTimeoutsMs.trustDialog,
             });
@@ -6339,7 +6454,7 @@ export class AgentManager {
             const tmux = new TmuxManager(runner);
             const pane = await this.resolveClaimedPane(tmux, agentId, paneId);
             await assertUploadStillValid();
-            await tmux.injectPrompt(pane, `${path} `, agentId);
+            await tmux.injectPrompt(pane, `${path} `, agentId, cfg.runtime);
             return { path };
         }
         finally {
@@ -6354,6 +6469,21 @@ export class AgentManager {
             throw new ApiError(409, `Agent ${agentId} compact or upload already in progress`);
         }
         let guardHandedOff = false;
+        const startedAt = performance.now();
+        let deadline = startedAt + MANUAL_CONTEXT_TIMEOUT_MS;
+        const timings = {};
+        let stage = 'session';
+        let outcome = 'failed';
+        const timed = async (name, fn) => {
+            stage = name;
+            const start = performance.now();
+            try {
+                return await fn();
+            }
+            finally {
+                timings[name] = Math.round(performance.now() - start);
+            }
+        };
         try {
             const state = await this.agentStore.get(agentId);
             const paneId = state?.paneId;
@@ -6370,28 +6500,61 @@ export class AgentManager {
                     throw new ApiError(409, `Agent ${agentId} session changed while waiting; ${command} aborted`);
                 }
             };
-            const tmux = new TmuxManager(this.createRunnerFor(cfg));
-            const pane = await this.resolveClaimedPane(tmux, agentId, paneId);
-            const waitReady = async () => {
+            const runner = this.createRunnerFor(cfg);
+            const tmux = new TmuxManager({
+                exec: (cmd, options) => {
+                    const remaining = Math.ceil(deadline - performance.now());
+                    if (remaining <= 0)
+                        throw new ExecNotStartedError(`Context command deadline exceeded during ${guardHandedOff ? 'post idle wait' : stage}`);
+                    const timeout = Math.min(options?.timeout ?? MANUAL_CONTEXT_COMMAND_TIMEOUT_MS, remaining, MANUAL_CONTEXT_COMMAND_TIMEOUT_MS);
+                    return runner.exec(cmd, { ...options, timeout });
+                },
+                execWithStdin: runner.execWithStdin.bind(runner),
+                writeFile: runner.writeFile.bind(runner),
+            });
+            const pane = await timed('session', () => this.resolveClaimedPane(tmux, agentId, paneId));
+            const waitReady = async (label) => {
                 try {
-                    await this.waitForReplPromptReady(tmux, pane, cfg.runtime, this.manualCompactWaitMs);
+                    await this.waitForReplPromptStableIdle(tmux, pane, cfg.runtime, this.manualCompactWaitMs, { manual: true });
                 }
                 catch (err) {
+                    if (err instanceof ExecNotStartedError)
+                        throw err;
+                    console.warn(`[AgentManager] sendSlashCommand(${agentId}, ${command}) ${label}: runtime not at an idle prompt:`, err);
                     const detail = err instanceof Error ? err.message : String(err);
                     throw new ApiError(409, `Agent ${agentId} runtime is not at an idle REPL prompt: ${detail}`);
                 }
             };
-            await waitReady();
+            await timed('readyBeforeClear', () => waitReady('before composer clear'));
             await assertSessionUnchanged();
-            await tmux.clearComposerDraft(pane);
-            await waitReady();
+            try {
+                await timed('composerClear', () => tmux.clearComposerDraft(pane, cfg.runtime));
+            }
+            catch (err) {
+                console.warn(`[AgentManager] sendSlashCommand(${agentId}, ${command}) composer clear failed:`, err);
+                if (err instanceof ReplNotReadyError || err instanceof PaneGoneError) {
+                    throw new ApiError(409, `Agent ${agentId} composer could not be cleared before ${command}: ${err.message}`);
+                }
+                throw err;
+            }
+            await timed('readyAfterClear', () => waitReady('after composer clear'));
             await assertSessionUnchanged();
             if (command === '/clear') {
-                await this.setSessionOptions(tmux, agentId, pane.session, [[TASK_CONTEXT_SESSION_OPTION, '']]);
+                await timed('contextMarker', () => this.setSessionOptions(tmux, agentId, pane.session, [[TASK_CONTEXT_SESSION_OPTION, '']]));
+            }
+            let submitError;
+            try {
+                await timed('submit', () => tmux.submitToRuntime(pane, cfg.runtime, command));
+                outcome = 'submitted';
+            }
+            catch (err) {
+                if (!(err instanceof TmuxOutcomeUnknownError))
+                    throw err;
+                submitError = err;
+                outcome = 'unknown';
             }
-            await tmux.sendKeysLiteral(pane, command);
-            await tmux.sendEnter(pane);
             guardHandedOff = true;
+            deadline = performance.now() + this.compactIdleWaitMs;
             void this.outsideTaskMutationScope(() => this.waitForReplPromptReady(tmux, pane, cfg.runtime, this.compactIdleWaitMs))
                 .catch(err => {
                 console.warn(`[AgentManager] sendSlashCommand(${agentId}, ${command}) post idle wait failed:`, err);
@@ -6399,10 +6562,22 @@ export class AgentManager {
                 .finally(() => {
                 this.compactInFlight.delete(agentId);
             });
+            if (submitError)
+                throw new ApiError(504, `${command} execution outcome unknown; inspect the agent terminal before retrying: ${submitError.message}`);
+        }
+        catch (err) {
+            if (!guardHandedOff && (err instanceof ExecNotStartedError
+                || (err instanceof Error && isTransientNetworkFailure(err.message)))) {
+                throw new ApiError(409, `Agent ${agentId} could not prepare ${command} during ${stage}; ${command} was not submitted: ${err.message}`);
+            }
+            throw err;
         }
         finally {
             if (!guardHandedOff)
                 this.compactInFlight.delete(agentId);
+            console.info(`[AgentManager] sendSlashCommand(${agentId}, ${command}) timing:`, {
+                outcome, stage, totalMs: Math.round(performance.now() - startedAt), ...timings,
+            });
         }
     }
     async compactAgent(agentId) {
@@ -7224,8 +7399,8 @@ export class AgentManager {
                     if (!(await guardBeforePaste()))
                         return false;
                     if (!paneWorking)
-                        await tmux.clearComposerDraft(pane);
-                    await tmux.pasteStagedBuffer(paneId, staged.buf);
+                        await tmux.clearComposerDraft(pane, runtime);
+                    await tmux.pasteStagedBuffer(pane, staged.buf, runtime);
                     return true;
                 });
             }
@@ -7244,7 +7419,7 @@ export class AgentManager {
                         throw new DispatchTerminalError('ack_unknown', `paste outcome unknown on working pane ${paneId}; composer left untouched to keep the live turn intact: ${message}`);
                     }
                     try {
-                        await tmux.clearComposerDraft(pane);
+                        await tmux.clearComposerDraft(pane, runtime);
                     }
                     catch (clearErr) {
                         console.warn(`[AgentManager] composer scrub after unknown paste outcome failed for pane ${paneId}:`, clearErr);
@@ -7264,9 +7439,9 @@ export class AgentManager {
         }
         else {
             if (!paneWorking)
-                await tmux.clearComposerDraft(pane);
+                await tmux.clearComposerDraft(pane, runtime);
             await revalidate?.();
-            await tmux.injectPrompt(pane, prompt, agentId);
+            await tmux.injectPrompt(pane, prompt, agentId, runtime);
         }
         let baseline;
         let baselineTitle = '';
@@ -7277,7 +7452,7 @@ export class AgentManager {
                 const submitted = await this.withTaskLock(async () => {
                     if (!(await guardBeforePaste()))
                         return false;
-                    await tmux.sendEnter(pane);
+                    await tmux.sendEnter(pane, runtime);
                     return true;
                 });
                 if (!submitted) {
@@ -7285,7 +7460,7 @@ export class AgentManager {
                         throw new Error(`fence-rejected prompt stays in the composer of working pane ${paneId}`);
                     }
                     try {
-                        await tmux.clearComposerDraft(pane);
+                        await tmux.clearComposerDraft(pane, runtime);
                     }
                     catch (err) {
                         const message = err instanceof Error ? err.message : String(err);
@@ -7295,7 +7470,7 @@ export class AgentManager {
                 }
             }
             else {
-                await tmux.sendEnter(pane);
+                await tmux.sendEnter(pane, runtime);
             }
         }
         catch (preAckErr) {
@@ -7304,7 +7479,7 @@ export class AgentManager {
             if (paneWorking) {
                 throw new DispatchTerminalError('ack_unknown', `pre-ack failure left an unconfirmed composer on working pane ${paneId}: ${message}`);
             }
-            if (await this.clearComposerForReuse(tmux, pane, agentId))
+            if (await this.clearComposerForReuse(tmux, pane, agentId, runtime))
                 throw preAckErr;
             throw new DispatchTerminalError('ack_unknown', `pre-ack failure left an unconfirmed composer on live pane ${paneId}: ${message}`);
         }
@@ -7321,13 +7496,13 @@ export class AgentManager {
                         const resent = await this.withTaskLock(async () => {
                             if (!(await guardBeforePaste()))
                                 return false;
-                            await tmux.sendEnter(pane);
+                            await tmux.sendEnter(pane, runtime);
                             return true;
                         });
                         if (!resent)
                             staleDuringResend = true;
                     }
-                    : () => tmux.sendEnter(pane),
+                    : () => tmux.sendEnter(pane, runtime),
                 resendIntervalMs: this.dispatchAckResendIntervalMs,
             });
             return { acked: true, composerDelivered: true };
@@ -7339,7 +7514,7 @@ export class AgentManager {
             }
             if (staleDuringResend) {
                 try {
-                    await tmux.clearComposerDraft(pane);
+                    await tmux.clearComposerDraft(pane, runtime);
                 }
                 catch (scrubErr) {
                     const scrubMessage = scrubErr instanceof Error ? scrubErr.message : String(scrubErr);
@@ -7360,10 +7535,10 @@ export class AgentManager {
             return { acked: false, composerDelivered: true };
         }
     }
-    async clearComposerForReuse(tmux, pane, agentId) {
+    async clearComposerForReuse(tmux, pane, agentId, runtime) {
         const paneId = pane.paneId;
         try {
-            await tmux.clearComposerDraft(pane);
+            await tmux.clearComposerDraft(pane, runtime);
             return true;
         }
         catch (err) {
@@ -8014,58 +8189,65 @@ export class AgentManager {
             console.warn('[AgentManager] recover: pending git review retry failed:', err);
         });
     }
-    async reconcileFailedAgent(agentId) {
-        const reconciled = await this.withTaskLock(async () => {
-            let projectId = '';
-            let timestamp = '';
-            let hadBinding = false;
-            let changed = false;
-            let taskId;
-            await this.agentStore.update(agentId, (existing) => {
-                if (!existing)
-                    return AGENT_STORE_NOOP;
-                if (existing.creationToken)
-                    return AGENT_STORE_NOOP;
-                if (existing.awaitingPhase != null && REGREET_REQUIRED_HOLD_PHASES.has(existing.awaitingPhase)) {
-                    return AGENT_STORE_NOOP;
-                }
-                timestamp = new Date().toISOString();
-                projectId = existing.projectId;
-                hadBinding = !!existing.taskId;
-                taskId = existing.taskId;
-                if (!existing.taskId
-                    && !existing.startedAt
-                    && !existing.paneId
-                    && !existing.creationToken) {
-                    return AGENT_STORE_NOOP;
-                }
-                changed = true;
-                if (existing.taskId) {
+    // absent 结论在等锁期间可能已过期:与 retry/删除的会话重建同处一条生命周期链,链内重探仍 absent、binding 写入时 stillCurrent 仍真,binding 与任务才在同一临界区内一起落下
+    async reconcileFailedAgent(agentId, opts = {}) {
+        const stillCurrent = opts.stillCurrent ?? (() => true);
+        const reconciled = await this.runUnderSessionLifecycle(agentId, async () => {
+            if (!(await this.sessionStillAbsent(agentId)))
+                return null;
+            return this.withTaskLock(async () => {
+                let projectId = '';
+                let timestamp = '';
+                let hadBinding = false;
+                let changed = false;
+                let taskId;
+                await this.agentStore.update(agentId, (existing) => {
+                    if (!existing || !stillCurrent())
+                        return AGENT_STORE_NOOP;
+                    if (existing.creationToken)
+                        return AGENT_STORE_NOOP;
+                    if (existing.awaitingPhase != null && REGREET_REQUIRED_HOLD_PHASES.has(existing.awaitingPhase)) {
+                        return AGENT_STORE_NOOP;
+                    }
+                    timestamp = new Date().toISOString();
+                    projectId = existing.projectId;
+                    hadBinding = !!existing.taskId;
+                    taskId = existing.taskId;
+                    if (!existing.taskId
+                        && !existing.startedAt
+                        && !existing.paneId
+                        && !existing.creationToken) {
+                        return AGENT_STORE_NOOP;
+                    }
+                    changed = true;
+                    if (existing.taskId) {
+                        return {
+                            ...existing,
+                            paneId: undefined,
+                            status: 'awaiting_human',
+                            awaitingPhase: 'runtime-missing',
+                            awaitingReason: 'The tmux session is missing; restart the REPL before releasing this task binding.',
+                            awaitingSince: timestamp,
+                            updatedAt: timestamp,
+                        };
+                    }
                     return {
-                        ...existing,
-                        paneId: undefined,
-                        status: 'awaiting_human',
-                        awaitingPhase: 'runtime-missing',
-                        awaitingReason: 'The tmux session is missing; restart the REPL before releasing this task binding.',
-                        awaitingSince: timestamp,
+                        id: existing.id,
+                        projectId: existing.projectId,
+                        ...(existing.workdir !== undefined ? { workdir: existing.workdir } : {}),
                         updatedAt: timestamp,
                     };
-                }
-                return {
-                    id: existing.id,
-                    projectId: existing.projectId,
-                    ...(existing.workdir !== undefined ? { workdir: existing.workdir } : {}),
-                    updatedAt: timestamp,
-                };
+                });
+                if (!projectId || !changed)
+                    return null;
+                const failed = hadBinding ? await this.failBoundTasksLocked(agentId) : [];
+                return { projectId, timestamp, hadBinding, taskId, failed };
             });
-            if (!projectId || !changed)
-                return null;
-            return { projectId, timestamp, hadBinding, taskId };
         });
         if (!reconciled)
             return false;
         if (reconciled.hadBinding) {
-            await this.failTasksForAgent(agentId, 'tmux-probe=absent');
+            await this.publishFailedTasks(agentId, 'tmux-probe=absent', reconciled.failed);
         }
         await this.recordError({
             agentId,
@@ -8088,6 +8270,21 @@ export class AgentManager {
         });
         return true;
     }
+    // 链内重探与探测器同一口径:没有同名会话、或同名会话的 claim 不是本 agent 才算 absent;探不到(含超时)不能按 absent 落 hold,那会把刚重建好的 REPL 上的任务标成失败
+    async sessionStillAbsent(agentId) {
+        const cfg = this.getAgentConfig(agentId);
+        if (!cfg)
+            return true;
+        try {
+            const snapshot = await new TmuxManager(this.createRunnerFor(cfg))
+                .getSessionSnapshot(agentId, { timeout: this.config.server.tmuxProbeTimeoutMs });
+            return snapshot === null || snapshot.claim !== agentId;
+        }
+        catch (err) {
+            console.warn(`[AgentManager] reconcileFailedAgent(${agentId}): session re-probe inconclusive; leaving the binding untouched:`, err);
+            return false;
+        }
+    }
     async cancelTask(taskId) {
         let devToRelease;
         let qaToRelease;
@@ -8536,12 +8733,9 @@ export class AgentManager {
                 }
                 opts.onSideEffect?.();
                 lease = begun.task.reviewDispatch;
-                if (opts.expectedTask) {
-                    dispatchExpectedTask = {
-                        ...opts.expectedTask,
-                        signalToken: begun.task.signalToken,
-                    };
-                }
+                // 调用方那一代已在 beginGitReviewPass 内校验过,此后要挡的是 pass 开出去之后的改动
+                if (opts.expectedTask)
+                    dispatchExpectedTask = taskGenerationGuard(begun.task);
             }
             const dispatched = await this.dispatchGitReviewLease(taskId, {
                 expectedGeneration: lease.generation,
@@ -9149,39 +9343,67 @@ export class AgentManager {
             await new Promise(r => setTimeout(r, this.compactIdlePollMs));
         }
     }
-    async probeReplPrompt(tmux, pane, runtime) {
+    async probeReplPrompt(tmux, pane, runtime, snapshotOpts) {
         const paneId = pane.paneId;
-        const current = await tmux.displayMessage(pane, '#{pane_current_command}');
+        const snapshot = snapshotOpts
+            ? await tmux.readReplSnapshot(pane, runtime, { timeout: snapshotOpts.timeoutMs })
+            : undefined;
+        const current = snapshot?.current ?? await tmux.displayMessage(pane, '#{pane_current_command}');
         if (!hasReplProcTitle(current, runtime)) {
-            throw new Error(`waitForReplPromptReady: pane ${paneId} pane_current_command=${current.trim()} (not runtime, REPL may have exited)`);
+            const detail = `waitForReplPromptReady: pane ${paneId} pane_current_command=${current.trim()} (not runtime, REPL may have exited)`;
+            if (snapshot)
+                throw new ReplNotReadyError(paneId, runtime, snapshot.cap, detail);
+            throw new Error(detail);
         }
-        const cap = await tmux.capturePaneById(pane, { ansi: false, scrollback: 0, runtime });
+        const cap = snapshot?.cap ?? await tmux.capturePaneById(pane, { ansi: false, scrollback: 0, runtime });
         let detection = classifyScreen(runtime, cap);
         // 标题规则优先级最高:屏幕判 idle 不作数,必须带标题复核
         if (detection.state === 'idle')
-            detection = classifyScreen(runtime, cap, await tmux.readPaneTitle(pane));
+            detection = classifyScreen(runtime, cap, snapshot?.title ?? await tmux.readPaneTitle(pane));
         const ready = hasRuntimeReadyView(cap, runtime, detection);
         if (detection.state === 'pending' || detection.skipStateUpdate) {
-            throw new Error(`waitForReplPromptReady: pane ${paneId} shows menu/dialog, not a ready REPL prompt`);
+            const detail = `waitForReplPromptReady: pane ${paneId} shows menu/dialog, not a ready REPL prompt`;
+            if (snapshot)
+                throw new ReplNotReadyError(paneId, runtime, cap, detail);
+            throw new Error(detail);
         }
         return { cap, ready, working: detection.state === 'working' };
     }
-    async waitForReplPromptStableIdle(tmux, pane, runtime, timeoutMs) {
+    async waitForReplPromptStableIdle(tmux, pane, runtime, timeoutMs, opts = {}) {
         const paneId = pane.paneId;
         const samples = Math.max(1, this.readyStableSamples);
-        const spacing = this.readyStableSpacingMs;
-        const deadline = Date.now() + timeoutMs + (samples - 1) * spacing;
+        const spacing = opts.manual ? Math.min(200, this.readyStableSpacingMs) : this.readyStableSpacingMs;
+        const stabilityWindow = opts.manual ? 0 : (samples - 1) * spacing;
+        const deadline = performance.now() + timeoutMs + stabilityWindow;
         let streak = 0;
+        let cap = '';
+        let lastError;
         while (true) {
-            const { cap, ready } = await this.probeReplPrompt(tmux, pane, runtime);
-            streak = ready ? streak + 1 : 0;
-            if (streak >= samples)
-                return;
-            if (Date.now() >= deadline) {
-                throw new ReplNotReadyError(paneId, runtime, cap, `stable idle not confirmed within ${timeoutMs}ms (+${(samples - 1) * spacing}ms stability window)`);
+            const remaining = Math.ceil(deadline - performance.now());
+            if (remaining <= 0)
+                break;
+            try {
+                const probe = await this.probeReplPrompt(tmux, pane, runtime, opts.manual ? { timeoutMs: remaining } : undefined);
+                cap = probe.cap;
+                lastError = undefined;
+                streak = probe.ready ? streak + 1 : 0;
+                if (streak >= samples)
+                    return;
             }
-            await new Promise(r => setTimeout(r, spacing));
+            catch (err) {
+                if (!opts.manual || !(err instanceof Error)
+                    || err instanceof ExecNotStartedError || err instanceof PaneGoneError
+                    || !(err instanceof ReplNotReadyError || isTransientNetworkFailure(err.message)))
+                    throw err;
+                lastError = err;
+                if (err instanceof ReplNotReadyError)
+                    cap = err.lastScreen;
+                streak = 0;
+            }
+            await new Promise(r => setTimeout(r, Math.max(0, Math.min(spacing, deadline - performance.now()))));
         }
+        throw new ReplNotReadyError(paneId, runtime, cap, `stable idle not confirmed within ${timeoutMs}ms (+${stabilityWindow}ms stability window)`
+            + (lastError ? `; last observation: ${lastError.message}` : ''));
     }
     stopPhaseSignalWatcher(taskId) {
         this.phaseSignalWatcher?.stop(taskId);
@@ -10060,8 +10282,8 @@ export class AgentManager {
                 || (taskId !== undefined && afterResolve.lockToken !== lockToken)) {
                 throw new Error(`injectTextToAgent: agent ${agentId} binding changed before paste`);
             }
-            await tmux.injectPrompt(pane, text, agentId);
-            await tmux.sendEnter(pane);
+            await tmux.injectPrompt(pane, text, agentId, cfg.runtime);
+            await tmux.sendEnter(pane, cfg.runtime);
         }
         finally {
             this.compactInFlight.delete(agentId);