baxian 2.0.27 → 2.0.29

package/dist/agent/manager.js

@@ -15,7 +15,7 @@ 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, 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';
@@ -262,6 +262,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 +280,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);
@@ -299,12 +302,23 @@ export class AgentManager {
                     eventBus: deps.eventBus,
                     resolveAgent: (id) => this.getAgentConfig(id),
                     commitNeedInputWatermark: (intent) => this.commitNeedInputWatermark(intent),
+                    spawnTask: (intent) => this.spawnTaskFromSignal(intent),
                 })
                 : undefined);
         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);
@@ -896,7 +910,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;
             }
         }
@@ -2089,6 +2103,105 @@ export class AgentManager {
             }
         }
     }
+    spawnRetry = new Map();
+    spawnRetryInFlight = new Set();
+    spawnRetryTimer = null;
+    async spawnTaskFromSignal(intent) {
+        const key = `${intent.taskId}\0${intent.title}`;
+        let outcome;
+        try {
+            outcome = await this.withTaskLock(() => this.trySpawnTask(intent));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const previous = this.spawnRetry.get(key);
+            const entry = { ...intent, lastError: message, notified: previous?.notified ?? false };
+            this.spawnRetry.set(key, entry);
+            this.ensureSpawnRetryTimer();
+            if (!previous) {
+                console.error(`[AgentManager] task-create from ${intent.taskId} failed, queued for retry: ${message}`);
+            }
+            else if (previous.lastError !== message) {
+                console.warn(`[AgentManager] task-create from ${intent.taskId} still failing: ${message}`);
+            }
+            if (!entry.notified) {
+                entry.notified = await this.emitIntervention(intent.projectId, intent.agentId, intent.taskId, {
+                    phase: 'task-create-failed', title: intent.title, token: intent.token, error: message,
+                });
+            }
+            return;
+        }
+        this.spawnRetry.delete(key);
+        this.ensureSpawnRetryTimer();
+        if (outcome === 'source-missing') {
+            console.warn(`[AgentManager] task-create dropped: source ${intent.taskId} no longer exists`);
+        }
+        else if (outcome === 'project-missing') {
+            console.error(`[AgentManager] task-create from ${intent.taskId} abandoned: project ${intent.projectId} no longer configured`);
+            const persisted = await this.emitFinalSpawnFailure(intent);
+            if (!persisted && !this.spawnRetry.has(key)) {
+                this.spawnRetry.set(key, { ...intent, lastError: 'project-missing', notified: false, final: 'project-missing' });
+                this.ensureSpawnRetryTimer();
+            }
+        }
+    }
+    // A final verdict only retries its notification; the intent itself is closed and must never create.
+    emitFinalSpawnFailure(intent) {
+        return this.emitIntervention(intent.projectId, intent.agentId, intent.taskId, {
+            phase: 'task-create-failed', reason: 'project-missing', title: intent.title, token: intent.token,
+        });
+    }
+    async trySpawnTask(intent) {
+        const source = await this.taskStore.get(intent.taskId);
+        if (!source)
+            return 'source-missing';
+        if (!this.getProjectConfig(source.projectId))
+            return 'project-missing';
+        const child = await this.createTask(source.projectId, {
+            title: intent.title,
+            description: '',
+            preferredAgentId: '',
+            origin: { taskId: source.id, title: intent.title },
+        });
+        console.info(`[AgentManager] task-create from ${source.id} via ${intent.agentId} -> ${child.id}`);
+        return 'done';
+    }
+    ensureSpawnRetryTimer() {
+        if (this.spawnRetry.size === 0) {
+            if (this.spawnRetryTimer) {
+                clearInterval(this.spawnRetryTimer);
+                this.spawnRetryTimer = null;
+            }
+            return;
+        }
+        if (this.spawnRetryTimer)
+            return;
+        this.spawnRetryTimer = setInterval(() => {
+            void this.outsideTaskMutationScope(() => this.spawnRetryPass());
+        }, this.needInputRetryIntervalMs);
+        this.spawnRetryTimer.unref?.();
+    }
+    async spawnRetryPass() {
+        for (const [key, entry] of [...this.spawnRetry.entries()]) {
+            if (this.spawnRetryInFlight.has(key))
+                continue;
+            this.spawnRetryInFlight.add(key);
+            try {
+                if (entry.final) {
+                    const persisted = await this.emitFinalSpawnFailure(entry);
+                    if (persisted && this.spawnRetry.get(key) === entry)
+                        this.spawnRetry.delete(key);
+                }
+                else {
+                    await this.spawnTaskFromSignal(entry);
+                }
+            }
+            finally {
+                this.spawnRetryInFlight.delete(key);
+            }
+        }
+        this.ensureSpawnRetryTimer();
+    }
     needInputRetry = new Map();
     needInputRetryInFlight = new Set();
     gitReviewRecoveryAlerted = new Set();
@@ -3044,7 +3157,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);
@@ -3114,10 +3227,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) {
@@ -3223,23 +3336,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: '',
@@ -3278,22 +3396,96 @@ 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
+        if (!await this.reachedRuntime(() => tmux.submitToRuntime(pane, runtime, REPL_EXIT_COMMAND[cfg.runtime])))
+            return;
+        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}`);
@@ -3310,23 +3502,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)) {
@@ -3337,10 +3528,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,
             });
@@ -5924,6 +6130,13 @@ export class AgentManager {
     }
     async createTask(projectId, input) {
         return this.withTaskLock(async () => {
+            const origin = input.origin;
+            if (origin) {
+                const existing = (await this.taskStore.listStrict({ projectId }))
+                    .find(task => task.origin?.taskId === origin.taskId && task.origin.title === origin.title);
+                if (existing)
+                    return existing;
+            }
             const taskId = await this.taskStore.nextId();
             const now = new Date().toISOString();
             if (input.branch) {
@@ -5958,6 +6171,7 @@ export class AgentManager {
                 createdAt: now,
                 updatedAt: now,
                 ...(imageFilenames ? { images: imageFilenames } : {}),
+                ...(input.origin ? { origin: input.origin } : {}),
             };
             if (input.preferredAgentId === '') {
                 const unassigned = {
@@ -6231,7 +6445,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 {
@@ -6264,25 +6478,35 @@ export class AgentManager {
             };
             const tmux = new TmuxManager(this.createRunnerFor(cfg));
             const pane = await this.resolveClaimedPane(tmux, agentId, paneId);
-            const waitReady = async () => {
+            const waitReady = async (stage) => {
                 try {
                     await this.waitForReplPromptReady(tmux, pane, cfg.runtime, this.manualCompactWaitMs);
                 }
                 catch (err) {
+                    console.warn(`[AgentManager] sendSlashCommand(${agentId}, ${command}) ${stage}: 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 waitReady('before composer clear');
             await assertSessionUnchanged();
-            await tmux.clearComposerDraft(pane);
-            await waitReady();
+            try {
+                await 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 waitReady('after composer clear');
             await assertSessionUnchanged();
             if (command === '/clear') {
                 await this.setSessionOptions(tmux, agentId, pane.session, [[TASK_CONTEXT_SESSION_OPTION, '']]);
             }
-            await tmux.sendKeysLiteral(pane, command);
-            await tmux.sendEnter(pane);
+            await tmux.sendKeysLiteral(pane, command, cfg.runtime);
+            await tmux.sendEnter(pane, cfg.runtime);
             guardHandedOff = true;
             void this.outsideTaskMutationScope(() => this.waitForReplPromptReady(tmux, pane, cfg.runtime, this.compactIdleWaitMs))
                 .catch(err => {
@@ -7116,8 +7340,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;
                 });
             }
@@ -7136,7 +7360,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);
@@ -7156,9 +7380,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 = '';
@@ -7169,7 +7393,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) {
@@ -7177,7 +7401,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);
@@ -7187,7 +7411,7 @@ export class AgentManager {
                 }
             }
             else {
-                await tmux.sendEnter(pane);
+                await tmux.sendEnter(pane, runtime);
             }
         }
         catch (preAckErr) {
@@ -7196,7 +7420,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}`);
         }
@@ -7213,13 +7437,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 };
@@ -7231,7 +7455,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);
@@ -7252,10 +7476,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) {
@@ -7906,58 +8130,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,
@@ -7980,6 +8211,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;
@@ -8428,12 +8674,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,
@@ -9197,11 +9440,20 @@ export class AgentManager {
                 });
             }
         }
-        const released = await this.releaseAgentForTask(qaAgentId, taskId, 'idle', {
-            expectedTask: parkedGeneration,
-        })
-            .catch(() => false);
-        if (!released) {
+        let released = false;
+        let qaBusy = false;
+        try {
+            // the reconciler may have released the QA while the dev was parking; an unbound QA is a success, not a failure
+            released = await this.releaseAgentIfBound(qaAgentId, taskId, {
+                expectedTask: parkedGeneration,
+                deferWhenBusy: true,
+            });
+        }
+        catch (err) {
+            // a QA still printing after its APPROVE stays bound without a hold; the reconciler releases it once idle
+            qaBusy = err instanceof ReplNotReadyError;
+        }
+        if (!released && !qaBusy) {
             await this.emitIntervention(parked.projectId, qaAgentId, taskId, {
                 phase: 'spec-ready-qa-release-failed',
                 qaAgentId,
@@ -9943,8 +10195,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);