baxian 1.2.22 → 1.2.24

package/dist/agent/manager.js

@@ -13,7 +13,7 @@ import { WorktreeManager } from './worktree.js';
 import { RepoStore, createRepoStoreCache } from './repo-store.js';
 import { PhaseSignalWatcher } from './phase-signal-watcher.js';
 import { ReviewTransport } from './review-transport.js';
-import { buildPromptInline, buildGreetingPrompt, buildPostMergeCleanupPrompt, PromptSizeError, RequiredSkillsMissingError, MAX_PROMPT_BYTES_ROUTE_LIMIT, } from './prompt.js';
+import { buildPromptInline, buildGreetingPrompt, PromptSizeError, RequiredSkillsMissingError, MAX_PROMPT_BYTES_ROUTE_LIMIT, } from './prompt.js';
 import { ApiError } from '../errors.js';
 import { prepareConfig } from '../config/loader.js';
 export class EnsureSessionError extends Error {
@@ -53,7 +53,7 @@ export function buildLaunchCommand(agent) {
     const segments = [];
     switch (agent.runtime) {
         case 'claude-code':
-            segments.push('env CLAUDE_CODE_NO_FLICKER=1 claude --permission-mode bypassPermissions');
+            segments.push('env CLAUDE_CODE_NO_FLICKER=1 CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1 claude --permission-mode bypassPermissions');
             break;
         case 'codex':
             segments.push('codex --dangerously-bypass-approvals-and-sandbox');
@@ -137,16 +137,6 @@ export function shouldReleaseHeldBinding(state, boundTask) {
     const turnCompleted = state.awaitingPhase != null && TURN_COMPLETED_AWAITING_PHASES.has(state.awaitingPhase);
     return !boundTask || taskIsTerminal || turnCompleted;
 }
-// null 表示 context 已无效（换 task / 换 pane），调用方应回退到完整注入。
-// 返回数组（含空数组）则代表当前 REPL session 已有的 skill 名集合，可作 excludeSkills 入参。
-function reuseSkillsIfContextValid(state, taskId, paneId) {
-    const rec = state?.injectedSkills;
-    if (!rec)
-        return null;
-    if (rec.taskId !== taskId || rec.paneId !== paneId)
-        return null;
-    return rec.skills;
-}
 export class AgentManager {
     config;
     agentStore;
@@ -1297,7 +1287,7 @@ export class AgentManager {
                     await tmux.killSession(agentId).catch(() => { });
                     return this.buildFreshSession(tmux, agent, agentId, workdir);
                 }
-                // 复用既有 REPL，上下文未中断——dedup 仍可沿用。
+                // 复用既有 REPL，上下文未中断——freshRuntime=false，post-approve 可走增量 nudge。
                 return { ok: true, createdSession: false, freshRuntime: false, paneId, workdir };
             }
             case 'startup-dialog':
@@ -1598,16 +1588,17 @@ export class AgentManager {
         const result = await this.withTaskLock(async () => {
             const state = await this.agentStore.get(agentId);
             if (!state)
-                return { resumed: false, releasedBinding: false };
+                return { resumed: false, releasedBinding: false, reason: 'Agent state not found.' };
             if (state.status !== 'awaiting_human') {
-                return { resumed: false, releasedBinding: false };
+                return { resumed: false, releasedBinding: false, reason: 'Agent is not awaiting human; nothing to resume.' };
             }
             // creationToken 仍 set = bootstrap dialog 仍未解决。Resume 不能让它"继续"——
             // dialog 在 pane 里需要 operator 通过 web terminal 处理，slowPoll 解决后自动清状态。
             // 如果 operator 想放弃这个 agent，应该走 DELETE 路径。
             if (state.creationToken) {
-                console.warn(`[AgentManager] resumeAgent: agent ${agentId} still has creationToken (bootstrap dialog unresolved); refusing Resume — operator should resolve dialog via web terminal or DELETE the agent.`);
-                return { resumed: false, releasedBinding: false };
+                const reason = 'Bootstrap dialog still unresolved; resolve it via the web terminal or DELETE the agent.';
+                console.warn(`[AgentManager] resumeAgent: agent ${agentId} still has creationToken — ${reason}`);
+                return { resumed: false, releasedBinding: false, reason };
             }
             const boundTask = state.taskId ? await this.taskStore.get(state.taskId) : null;
             // "prompt 可能仍在 pane 中跑"类 phase + bound task 仍 active 时 refuse：Resume 让
@@ -1623,8 +1614,9 @@ export class AgentManager {
             if (state.awaitingPhase != null
                 && PROMPT_MAYBE_RUNNING_PHASES.has(state.awaitingPhase)
                 && boundTask && ACTIVE_TASK_STATUSES.has(boundTask.status)) {
-                console.warn(`[AgentManager] resumeAgent: agent ${agentId} ${state.awaitingPhase} with active task ${state.taskId} — prompt may still be running; refusing Resume until outcome arrives or operator cancels the task / deletes the agent.`);
-                return { resumed: false, releasedBinding: false };
+                const reason = `Prompt may still be running (${state.awaitingPhase}); Resume is blocked until the task outcome arrives. Cancel task ${state.taskId} or DELETE the agent to recover.`;
+                console.warn(`[AgentManager] resumeAgent: agent ${agentId} — ${reason}`);
+                return { resumed: false, releasedBinding: false, reason };
             }
             // agent_dialog_pending: pane 仍卡 startup dialog，REPL 未 ready。Resume 让
             // shouldReleaseHeldBinding 看 task terminal/missing 放行后会清 binding/lock，下一次
@@ -1633,8 +1625,9 @@ export class AgentManager {
             // agent_dialog_resolved_runtime（Resume 放行）或 bootstrap path 直接清 Held → status='ok'，
             // 或 DELETE agent。
             if (state.awaitingPhase === 'agent_dialog_pending') {
-                console.warn(`[AgentManager] resumeAgent: agent ${agentId} dialog still pending; refusing Resume — operator should dismiss dialog via web terminal (slowPoll will mark agent_dialog_resolved_runtime, then Resume) or DELETE the agent.`);
-                return { resumed: false, releasedBinding: false };
+                const reason = 'Startup dialog still pending; Resume cannot dismiss it. Dismiss the dialog via the web terminal (baxian will auto-resume) or DELETE the agent.';
+                console.warn(`[AgentManager] resumeAgent: agent ${agentId} — ${reason}`);
+                return { resumed: false, releasedBinding: false, reason };
             }
             // agent_dialog_resolved_runtime + active task：正常路径下 handleDialogPendingFromRuntime
             // 已 fail task → boundTask 应 terminal。bound task 仍 active 表示 crash window
@@ -1643,8 +1636,9 @@ export class AgentManager {
             // refuse Resume，提示 operator 显式 cancel task 或 DELETE agent。
             if (state.awaitingPhase === 'agent_dialog_resolved_runtime'
                 && boundTask && ACTIVE_TASK_STATUSES.has(boundTask.status)) {
-                console.warn(`[AgentManager] resumeAgent: agent ${agentId} dialog resolved but bound task ${state.taskId} still active (crash window) — prompt was never injected; refusing Resume. Operator should cancel the task or DELETE the agent.`);
-                return { resumed: false, releasedBinding: false };
+                const reason = `Dialog resolved but task ${state.taskId} is still active and its prompt was never injected; Resume would strand it. Cancel the task or DELETE the agent.`;
+                console.warn(`[AgentManager] resumeAgent: agent ${agentId} — ${reason}`);
+                return { resumed: false, releasedBinding: false, reason };
             }
             // code-dispatch-failed: the code-phase prompt never reached the pane (spec
             // approval already transitioned the task). Resume = clear the hold AND
@@ -1674,23 +1668,25 @@ export class AgentManager {
             // Refuse while the task is active; operator must cancel the task or DELETE the agent to retry.
             if (state.awaitingPhase?.startsWith('signal-arm-failed')
                 && boundTask && ACTIVE_TASK_STATUSES.has(boundTask.status)) {
-                console.warn(`[AgentManager] resumeAgent: agent ${agentId} ${state.awaitingPhase} with active task ${state.taskId} — the dispatched prompt's pane signal has no consumer and Resume cannot rebuild the watcher; refusing Resume. Operator should cancel the task or DELETE the agent.`);
-                return { resumed: false, releasedBinding: false };
+                const reason = `The dispatched prompt's pane signal has no consumer and Resume cannot rebuild the watcher; cancel task ${state.taskId} or DELETE the agent to retry.`;
+                console.warn(`[AgentManager] resumeAgent: agent ${agentId} ${state.awaitingPhase} — ${reason}`);
+                return { resumed: false, releasedBinding: false, reason };
             }
             // Un-cleared pane (cancel mid-clear or /clear unconfirmed): Resume would free + reuse it (terminal
             // task → shouldReleaseHeldBinding) and leak the cancelled task's context. Refuse; only DELETE (which
             // destroys the pane) is a safe recovery.
             if (state.awaitingPhase != null && UNCLEARED_PANE_PHASES.has(state.awaitingPhase)) {
-                console.warn(`[AgentManager] resumeAgent: agent ${agentId} ${state.awaitingPhase} — pane holds un-cleared context; refusing Resume. DELETE the agent to discard it.`);
-                return { resumed: false, releasedBinding: false };
+                const reason = 'The pane holds un-cleared context from a cancelled task; Resume would leak it into the next task. DELETE the agent to discard it.';
+                console.warn(`[AgentManager] resumeAgent: agent ${agentId} ${state.awaitingPhase} — ${reason}`);
+                return { resumed: false, releasedBinding: false, reason };
             }
             // A greeting capability failure must be RE-PROVEN, not Resumed away: the default path below
             // flips status→'ok' regardless of shouldReleaseHeldBinding, which would put an unverified
             // agent back in the dispatch pool. The recovery path is restart-repl / retry (re-greets).
             if (state.awaitingPhase != null && REGREET_REQUIRED_HOLD_PHASES.has(state.awaitingPhase)) {
-                console.warn(`[AgentManager] resumeAgent: agent ${agentId} ${state.awaitingPhase} — capability must be re-proven; ` +
-                    `refusing Resume. Use restart-repl / retry to re-run the greeting check.`);
-                return { resumed: false, releasedBinding: false };
+                const reason = 'Greeting capability check failed; the runtime must re-prove it. Resume cannot clear this hold — use Restart REPL to re-run the greeting check.';
+                console.warn(`[AgentManager] resumeAgent: agent ${agentId} ${state.awaitingPhase} — ${reason}`);
+                return { resumed: false, releasedBinding: false, reason };
             }
             const now = new Date().toISOString();
             const shouldReleaseBinding = shouldReleaseHeldBinding(state, boundTask);
@@ -1761,7 +1757,11 @@ export class AgentManager {
                 await this.markAwaitingHuman(agentId, 'code-dispatch-failed', 'Code-phase redispatch on Resume failed; Resume again to retry or cancel the task.', { expectedTaskId: result.redispatchCodeTaskId }).catch(() => undefined);
             }
         }
-        return { resumed: result.resumed, releasedBinding: result.releasedBinding };
+        return {
+            resumed: result.resumed,
+            releasedBinding: result.releasedBinding,
+            ...(result.reason ? { reason: result.reason } : {}),
+        };
     }
     async resolvePaneId(state, cfg) {
         if (state.paneId)
@@ -3108,13 +3108,6 @@ export class AgentManager {
             await assertSessionUnchanged();
             await tmux.sendKeysLiteral(paneId, command);
             await tmux.sendEnter(paneId);
-            if (command === '/clear') {
-                await this.agentStore.update(agentId, (s) => {
-                    if (!s)
-                        return AGENT_STORE_NOOP;
-                    return { ...s, injectedSkills: undefined };
-                });
-            }
             guardHandedOff = true;
             void this.waitForReplPromptReady(tmux, paneId, cfg.runtime, this.compactIdleWaitMs)
                 .catch(err => {
@@ -3396,14 +3389,6 @@ export class AgentManager {
         // Caller-transmitted token/round take precedence — task fields are stale during dispatch.
         const promptSignalToken = opts.signalToken ?? task.signalToken;
         const promptSpecRound = opts.currentSpecRound ?? task.specReviewRound;
-        const beforeInjectAgent = await this.agentStore.get(agentId);
-        // freshRuntime=true 覆盖两种场景：(a) buildFreshSession 全新 tmux session；
-        // (b) adoptOrRestartSession 的 shell 重启 / trust-dialog 答完——pane 仍在但 REPL
-        // 是新进程。两种情况下旧上下文都没了，必须重置 dedup baseline，决不能因为
-        // paneId 字符串恰好相同就沿用旧 skill 集。
-        const reuseInjectedSkills = ensure.freshRuntime
-            ? null
-            : reuseSkillsIfContextValid(beforeInjectAgent, taskId, paneId);
         // develop prompt 按 QA 有无裁剪 spec 路线（qaAgentId 快照优先，与 review 派发同一解析）。
         const hasQaPartner = !!(task.qaAgentId ?? this.findQaPartner(agentId)?.id);
         let prompt;
@@ -3418,7 +3403,6 @@ export class AgentManager {
                 hasQaPartner,
                 ...(promptSignalToken ? { signalToken: promptSignalToken } : {}),
                 ...(promptSpecRound !== undefined ? { currentSpecRound: promptSpecRound } : {}),
-                ...(reuseInjectedSkills ? { excludeSkills: reuseInjectedSkills } : {}),
                 ...(imagePaths.length ? { imagePaths } : {}),
                 ...(opts.serverContent !== undefined ? { serverContent: opts.serverContent } : {}),
                 ...(opts.serverDiffstat !== undefined ? { serverDiffstat: opts.serverDiffstat } : {}),
@@ -3491,6 +3475,15 @@ export class AgentManager {
             catch { }
             return false;
         }
+        // Pane exists now but the prompt is not out — arm here so a request it triggers is a live chunk,
+        // not snapshot-suppressed scrollback. Abort cleanly (no binding written yet) if it cannot arm.
+        if (opts.armBeforeInject && !(await opts.armBeforeInject())) {
+            try {
+                await worktree.removeWithBranch(workdir, worktreePath, customBranch);
+            }
+            catch { }
+            return false;
+        }
         const now = new Date().toISOString();
         let agentMarkedRunning = false;
         try {
@@ -3514,9 +3507,6 @@ export class AgentManager {
                     bootstrappingTaskId: taskId,
                     updatedAt: now,
                     ...(existing?.creationToken !== undefined ? { creationToken: existing.creationToken } : {}),
-                    ...(reuseInjectedSkills
-                        ? { injectedSkills: { taskId, paneId, skills: reuseInjectedSkills } }
-                        : {}),
                 };
             });
             if (cancelHoldWon) {
@@ -3529,7 +3519,7 @@ export class AgentManager {
                 return false;
             }
             agentMarkedRunning = true;
-            const ack = await this.injectAndAwaitAck(tmux, paneId, prompt, agentId, agent.runtime);
+            await this.injectAndAwaitAck(tmux, paneId, prompt, agentId, agent.runtime);
             // Prompt delivered → clear the mid-bootstrap marker IMMEDIATELY, before the slower persist/emit/watch
             // steps: a crash between ack and the clear would otherwise leave recover() seeing a stale marker on
             // an already-running prompt and re-dispatching it. The clear is best-effort and NON-destructive — its
@@ -3545,14 +3535,6 @@ export class AgentManager {
                     console.warn(`[AgentManager] startSession: hold after marker-clear failure for task=${taskId} failed:`, holdErr);
                 });
             }
-            // dedup baseline 记录的是「已 paste 进 idle composer 的 skill 文本」：paste 落入 composer 即进
-            // REPL 上下文，与 submit-ack 无关。ack 超时（首个 Enter 被吞）下 skill 仍在 composer，跳过落盘会让
-            // 下一轮整组重注入——即 SKILLS 重复注入。但 composerDelivered=false（paste 时 pane
-            // 已 busy，文本进了运行中输入流而非 composer）则不能落盘，否则恢复提示会缺必需 skill。freshRuntime
-            // 负责 REPL 真正重启时作废 baseline。
-            if (ack.composerDelivered) {
-                await this.persistInjectedSkills(agentId, taskId, paneId, agent.role, phase, reuseInjectedSkills);
-            }
             await this.eventBus.emit({
                 id: '',
                 type: 'session.started',
@@ -3728,29 +3710,6 @@ export class AgentManager {
             return false;
         }
     }
-    // Snapshot which skills are now resident in the REPL's context, union of
-    // the pre-dispatch baseline (when context was still valid) and the phase's
-    // declared skills. Guarded by (taskId, paneId) so a concurrent rebind never
-    // overwrites a freshly-bound agent.
-    async persistInjectedSkills(agentId, taskId, paneId, role, phase, reuseInjectedSkills) {
-        const phaseSkills = this.skillRegistry.skillsForPhase(role, phase);
-        const baseList = reuseInjectedSkills ?? [];
-        // 已有有效 context 记录，且本 phase 没有引入新 skill → 写盘无信息增益，short-circuit。
-        // reuseInjectedSkills === null 时缺基线记录，仍需建一份初始档。
-        if (reuseInjectedSkills !== null && phaseSkills.every(s => baseList.includes(s)))
-            return;
-        const merged = Array.from(new Set([...baseList, ...phaseSkills]));
-        const now = new Date().toISOString();
-        await this.agentStore.update(agentId, (latest) => {
-            if (!latest || latest.taskId !== taskId || latest.paneId !== paneId)
-                return AGENT_STORE_NOOP;
-            return {
-                ...latest,
-                injectedSkills: { taskId, paneId, skills: merged },
-                updatedAt: now,
-            };
-        });
-    }
     // Ready gate prevents mid-paste webhook from flipping to 'waiting' on a busy REPL.
     async markAgentWaiting(agentId, expectedTaskId, opts = {}) {
         return this.releaseAgentForTask(agentId, expectedTaskId, 'waiting', opts);
@@ -3810,17 +3769,10 @@ export class AgentManager {
         const runner = this.createRunnerFor(agent);
         const tmux = new TmuxManager(runner);
         const promptSpecRound = opts.currentSpecRound ?? task.specReviewRound;
-        // 与 startSession 同步：任何 REPL 启动 / 重启路径（freshRuntime=true）都视为新上下文，
-        // 强制重新注入完整 skill 集——既覆盖 fresh tmux session，也覆盖同 pane 里的 shell 重启
-        // 与 trust-dialog 完成两种 adopt 场景。
-        const reuseInjectedSkills = ensure.freshRuntime
-            ? null
-            : reuseSkillsIfContextValid(agentState, taskId, paneId);
         let prompt;
         try {
-            // freshRuntime=true 表示 tmux/REPL 刚新建或重启，旧 post-approve prompt 上下文已丢失
-            // (同步：reuseInjectedSkills 在 freshRuntime 时也强制 null 重发 skill 集)。此时即使
-            // redispatchCount>0 也必须发完整长段，否则 dev 拿不到 T_self / idempotency / final
+            // freshRuntime=true 表示 tmux/REPL 刚新建或重启，旧 post-approve prompt 上下文已丢失。
+            // 此时即使 redispatchCount>0 也必须发完整长段，否则 dev 拿不到 T_self / idempotency / final
             // re-fetch / 禁止 merge 等首轮规则。
             const useIncrementalNudge = typeof opts.postApproveRedispatchCount === 'number'
                 && opts.postApproveRedispatchCount > 0
@@ -3839,7 +3791,6 @@ export class AgentManager {
                     ? { postApproveRedispatchCount: opts.postApproveRedispatchCount }
                     : {}),
                 ...(promptSpecRound !== undefined ? { currentSpecRound: promptSpecRound } : {}),
-                ...(reuseInjectedSkills ? { excludeSkills: reuseInjectedSkills } : {}),
                 ...(imagePaths.length ? { imagePaths } : {}),
                 ...(opts.serverContent !== undefined ? { serverContent: opts.serverContent } : {}),
                 ...(opts.serverDiffstat !== undefined ? { serverDiffstat: opts.serverDiffstat } : {}),
@@ -3891,6 +3842,10 @@ export class AgentManager {
                 return false;
             }
         }
+        // Arm before paste (same reasoning as startSession): pane exists, prompt not out yet.
+        if (opts.armBeforeInject && !(await opts.armBeforeInject())) {
+            return false;
+        }
         const now = new Date().toISOString();
         await this.agentStore.update(agentId, (latest) => {
             if (!latest)
@@ -3900,16 +3855,9 @@ export class AgentManager {
                 paneId,
                 worktreePath,
                 updatedAt: now,
-                ...(reuseInjectedSkills
-                    ? { injectedSkills: { taskId, paneId, skills: reuseInjectedSkills } }
-                    : { injectedSkills: undefined }),
             };
         });
-        const ack = await this.injectAndAwaitAck(tmux, paneId, prompt, agentId, agent.runtime);
-        // 仅 composer 投递成功才落 dedup baseline（理由见 startSession）；freshRuntime 负责 REPL 重启时作废。
-        if (ack.composerDelivered) {
-            await this.persistInjectedSkills(agentId, taskId, paneId, agent.role, phase, reuseInjectedSkills);
-        }
+        await this.injectAndAwaitAck(tmux, paneId, prompt, agentId, agent.runtime);
         return true;
     }
     // A bootstrappingTaskId marker means a dispatch began (binding written) but its prompt was never
@@ -4053,7 +4001,6 @@ export class AgentManager {
                             continue;
                         }
                         await this.dispatchPostMergeCleanup(state.id, {
-                            prNumber: boundTask.prNumber,
                             taskId: boundTask.id,
                             branch: boundTask.branch,
                         });
@@ -5214,10 +5161,9 @@ export class AgentManager {
         this.phaseSignalWatcher?.stop(taskId);
         // Keep the agent BOUND (non-dispatchable) until branch cleanup + context reset finish, then
         // release. dispatchPostMergeCleanup owns the whole lifecycle: worktree removal → branch
-        // delete → /clear (or /compact if cleanup failed) → release.
+        // delete → /clear → release (no agent notification).
         if (task.prNumber && task.branch) {
             const ctx = {
-                prNumber: task.prNumber,
                 taskId: task.id,
                 branch: task.branch,
             };
@@ -5265,14 +5211,22 @@ export class AgentManager {
         }
         await this.removeMergedWorktree(agent, agentId, ctx.taskId);
         const runner = this.createRunnerFor(agent);
-        const cleanupResult = state.repoPath
-            ? await this.deleteLocalBranchInRepo(runner, state.repoPath, ctx.branch, agentId)
-            : { outcome: 'skipped', detail: 'agent has no repoPath in binding' };
+        if (state.repoPath) {
+            await this.deleteLocalBranchInRepo(runner, state.repoPath, ctx.branch, agentId);
+        }
+        else {
+            // No repoPath on the binding → can't run `git branch -D`. Keep the "can't clean → warn
+            // server-side" contract: surface the skip (the merged branch may linger locally) rather than
+            // dropping it silently now that there is no agent notification carrying `branch-cleanup: skipped`.
+            console.warn(`[AgentManager] dispatchPostMergeCleanup(${agentId}): no repoPath on binding; skipping local ` +
+                `branch delete for ${ctx.branch} (it may linger locally)`);
+        }
+        // No agent dialogue: the merged task is already done and the agent is idle, so baxian just resets
+        // its context with /clear and releases it. Worktree + local branch were cleaned above; a failed
+        // branch delete is logged server-side (deleteLocalBranchInRepo), not surfaced into the pane.
         const tmux = new TmuxManager(runner);
-        const prompt = buildPostMergeCleanupPrompt(ctx, cleanupResult);
         const runtime = agentRuntimeKindFor(agent);
-        const cleanSlate = cleanupResult.outcome === 'deleted' || cleanupResult.outcome === 'absent';
-        void this.runPostMergeCompaction(tmux, state.paneId, agentId, ctx.taskId, runtime, prompt, cleanSlate).catch(err => console.warn(`[AgentManager] runPostMergeCompaction(${agentId}) failed:`, err));
+        void this.runPostMergeCompaction(tmux, state.paneId, agentId, ctx.taskId, runtime).catch(err => console.warn(`[AgentManager] runPostMergeCompaction(${agentId}) failed:`, err));
     }
     // Release the post-merge binding (clears taskId + frees the lock we held → agent dispatchable
     // again). Shared success tail. Skips when the binding has already moved to another task, so it
@@ -5316,11 +5270,9 @@ export class AgentManager {
             });
         });
     }
-    // shellQuote prevents injection. Three outcomes the caller must distinguish so the
-    // notification prompt to the agent doesn't lie about a deletion that actually failed:
-    //   - deleted: branch ref was removed (or no longer exists at the end of the call).
-    //   - absent:  branch wasn't there at all (auto-delete-head-branches, never landed locally).
-    //   - failed:  worktree still occupies the ref, permissions, etc. — agent must NOT be told "cleaned".
+    // Best-effort local cleanup after merge: prune the remote-tracking ref + worktree admin entry, then
+    // delete the local branch. shellQuote prevents injection. Failures are logged server-side only — the
+    // wrap-up resets the pane with /clear regardless, and there is no agent notification to keep honest.
     async deleteLocalBranchInRepo(runner, repoPath, branch, agentId) {
         // --expire=now: bare `git worktree prune` honors gc.worktreePruneExpire (default 3 months),
         // so a worktree that the release just removed could still be tracked as occupying the ref.
@@ -5338,28 +5290,22 @@ export class AgentManager {
         const delCmd = `cd ${shellQuote(repoPath)} && git branch -D ${shellQuote(branch)}`;
         try {
             const delResult = await runner.exec(delCmd, { timeout: this.postMergeBranchTimeoutMs });
-            if (delResult.exitCode === 0) {
-                return { outcome: 'deleted', detail: delResult.stdout.trim() };
+            // exit 0 → deleted; "not found"/"no such branch" → already absent (auto-delete-head-branches). Both fine.
+            if (delResult.exitCode !== 0 && !/not found|not a valid|no such branch/i.test(delResult.stderr)) {
+                console.warn(`[AgentManager] deleteLocalBranchInRepo(${agentId}, ${branch}): branch -D exit=${delResult.exitCode} ` +
+                    `stderr=${delResult.stderr.trim()}`);
             }
-            if (/not found|not a valid|no such branch/i.test(delResult.stderr)) {
-                return { outcome: 'absent', detail: delResult.stderr.trim() };
-            }
-            console.warn(`[AgentManager] deleteLocalBranchInRepo(${agentId}, ${branch}): branch -D exit=${delResult.exitCode} ` +
-                `stderr=${delResult.stderr.trim()}`);
-            return { outcome: 'failed', detail: delResult.stderr.trim() || `exit ${delResult.exitCode}` };
         }
         catch (err) {
-            const detail = err instanceof Error ? err.message : String(err);
             console.warn(`[AgentManager] deleteLocalBranchInRepo(${agentId}, ${branch}) branch -D threw:`, err);
-            return { outcome: 'failed', detail };
         }
     }
-    async runPostMergeCompaction(tmux, paneId, agentId, originalTaskId, runtime, prompt, cleanSlate) {
-        // 等待获取（而非无条件 add）：手动 compact 持锁时直接进入会并发注入，
+    async runPostMergeCompaction(tmux, paneId, agentId, originalTaskId, runtime) {
+        // 等待获取（而非无条件 add）：手动 compact 持锁时直接进入会并发，
         // 且 finally 会误删对方的 guard 放穿后续请求。
         await this.acquireCompactGuard(agentId);
         try {
-            await this.runPostMergeCompactionSteps(tmux, paneId, agentId, originalTaskId, runtime, prompt, cleanSlate);
+            await this.runPostMergeCompactionSteps(tmux, paneId, agentId, originalTaskId, runtime);
         }
         finally {
             this.compactInFlight.delete(agentId);
@@ -5385,64 +5331,36 @@ export class AgentManager {
         this.compactInFlight.add(agentId);
         return true;
     }
-    async runPostMergeCompactionSteps(tmux, paneId, agentId, originalTaskId, runtime, prompt, cleanSlate) {
+    async runPostMergeCompactionSteps(tmux, paneId, agentId, originalTaskId, runtime) {
         const bindingStillOurs = async () => {
             const s = await this.agentStore.get(agentId);
             return !!s && s.taskId === originalTaskId && s.paneId === paneId;
         };
-        let attempts = 0;
+        if (!await bindingStillOurs())
+            return;
+        // No notification, no dialogue: the merged task is done and the agent is idle, so just reset its
+        // context. sendPostMergeSlashCommand interrupts any lingering turn (Esc), waits for idle, sends
+        // /clear, verifies it wasn't rejected, and retries. Returns false if the binding moved mid-way.
         let cleared = false;
-        while (attempts < 2) {
-            attempts++;
-            try {
-                if (attempts > 1) {
-                    if (!await bindingStillOurs())
-                        return;
-                    await tmux.sendKeysToPane(paneId, 'C-c');
-                    await new Promise(r => setTimeout(r, 1000));
-                }
-                await this.waitForReplPromptReady(tmux, paneId, runtime, this.compactIdleWaitMs);
-                if (!await bindingStillOurs())
-                    return;
-                await tmux.injectPrompt(paneId, prompt, agentId);
-                // Resend a swallowed first Enter (bracketed-paste TUI quirk); settle so baseline holds the paste.
-                const baseline = await tmux.captureSettledSnapshot(paneId, { timeoutMs: this.dispatchSettleTimeoutMs });
-                await tmux.sendEnter(paneId);
-                try {
-                    await tmux.waitSubmitAck(paneId, baseline, runtime, {
-                        timeoutMs: this.dispatchAckTimeoutMs,
-                        resend: () => tmux.sendEnter(paneId),
-                        resendIntervalMs: this.dispatchAckResendIntervalMs,
-                    });
-                }
-                catch (ackErr) {
-                    // Only a genuine ack timeout is best-effort; other (infra) errors must reach the outer retry.
-                    if (!(ackErr instanceof Error && /runtime ack timeout/.test(ackErr.message)))
-                        throw ackErr;
-                    console.warn(`[AgentManager] post-merge notification ack timeout (${agentId}, pane ${paneId}):`, ackErr);
-                }
-                await this.waitForReplPromptReady(tmux, paneId, runtime, this.compactIdleWaitMs);
-                if (!await bindingStillOurs())
-                    return;
-                const command = cleanSlate ? '/clear' : '/compact';
-                if (!await this.sendPostMergeSlashCommand(tmux, paneId, agentId, runtime, command, bindingStillOurs)) {
-                    return;
-                }
+        try {
+            cleared = await this.sendPostMergeSlashCommand(tmux, paneId, agentId, runtime, bindingStillOurs);
+        }
+        catch (err) {
+            console.warn(`[AgentManager] runPostMergeCompaction(${agentId}) /clear failed:`, err);
+        }
+        if (!cleared) {
+            // A runtime that exited to a shell can't take /clear; restarting it yields the same clean slate.
+            if (await this.recoverPostMergeExitedRuntime(tmux, paneId, agentId, originalTaskId, runtime)) {
                 cleared = true;
-                break;
             }
-            catch (err) {
-                const label = attempts < 2 ? 'retrying' : 'giving up';
-                console.warn(`[AgentManager] runPostMergeCompaction(${agentId}) attempt ${attempts} failed (${label}):`, err);
+            else if (!await bindingStillOurs()) {
+                return; // binding moved to another flow mid-cleanup → leave its pane alone (no C-c, no release)
             }
+            else if (!await this.clearComposerForReuse(tmux, paneId, agentId)) {
+                return; // can't even reach a clean composer → hold (don't release) for a human
+            }
+            // else: composer cleaned → a stuck pane must not strand the agent bound to a merged task; release.
         }
-        if (!cleared && await this.recoverPostMergeExitedRuntime(tmux, paneId, agentId, originalTaskId, runtime)) {
-            await this.releasePostMergeAgent(agentId, originalTaskId);
-            return;
-        }
-        // Give-up: clear the injected-but-unsubmitted notification; hold (don't release) if it can't be cleared.
-        if (!cleared && !await this.clearComposerForReuse(tmux, paneId, agentId))
-            return;
         await this.releasePostMergeAgent(agentId, originalTaskId);
     }
     async recoverPostMergeExitedRuntime(tmux, paneId, agentId, taskId, runtime) {
@@ -5470,16 +5388,13 @@ export class AgentManager {
             await this.agentStore.update(agentId, (existing) => {
                 if (!existing || existing.taskId !== taskId)
                     return AGENT_STORE_NOOP;
-                if (existing.paneId === ensure.paneId
-                    && existing.repoPath === ensure.workdir
-                    && existing.injectedSkills === undefined) {
+                if (existing.paneId === ensure.paneId && existing.repoPath === ensure.workdir) {
                     return AGENT_STORE_NOOP;
                 }
                 return {
                     ...existing,
                     paneId: ensure.paneId,
                     repoPath: ensure.workdir,
-                    injectedSkills: undefined,
                     updatedAt: new Date().toISOString(),
                 };
             });
@@ -5491,33 +5406,33 @@ export class AgentManager {
             return false;
         }
     }
-    async sendPostMergeSlashCommand(tmux, paneId, agentId, runtime, command, bindingStillOurs) {
+    async sendPostMergeSlashCommand(tmux, paneId, agentId, runtime, bindingStillOurs) {
         let rejection;
         for (let attempt = 1; attempt <= 2; attempt++) {
-            // The runtime rejects /clear|/compact while a turn is in progress, and the post-merge
-            // notification turn can still be running when our idle scrape passes. Esc interrupts it (the
-            // same stop the cancel flow runs before /clear); a genuinely idle pane absorbs it harmlessly.
+            // The runtime rejects /clear while a turn is in progress, and the agent's last task turn can
+            // still be settling when our idle scrape passes. Esc interrupts it (the same stop the cancel
+            // flow runs before /clear); a genuinely idle pane absorbs it harmlessly.
             await tmux.sendKeysToPane(paneId, 'Escape');
             await this.waitForReplPromptReady(tmux, paneId, runtime, this.compactIdleWaitMs);
             if (!await bindingStillOurs())
                 return false;
-            await tmux.sendKeysLiteral(paneId, command);
+            await tmux.sendKeysLiteral(paneId, '/clear');
             await tmux.sendEnter(paneId);
             await new Promise(r => setTimeout(r, this.compactIdlePollMs));
             await this.waitForReplPromptReady(tmux, paneId, runtime, this.compactIdleWaitMs);
             if (!await bindingStillOurs())
                 return false;
-            if (!await this.hasRuntimeSlashCommandRejection(tmux, paneId, command))
+            if (!await this.hasRuntimeSlashCommandRejection(tmux, paneId, '/clear'))
                 return true;
-            rejection = new Error(`runtime rejected ${command} because a task is still in progress`);
+            rejection = new Error('runtime rejected /clear because a task is still in progress');
             if (attempt < 2) {
-                console.warn(`[AgentManager] runPostMergeCompaction(${agentId}) ${command} rejected; retrying`);
+                console.warn(`[AgentManager] runPostMergeCompaction(${agentId}) /clear rejected; retrying`);
                 await new Promise(r => setTimeout(r, this.compactIdlePollMs));
                 if (!await bindingStillOurs())
                     return false;
             }
         }
-        throw rejection ?? new Error(`runtime rejected ${command}`);
+        throw rejection ?? new Error('runtime rejected /clear');
     }
     async hasRuntimeSlashCommandRejection(tmux, paneId, command) {
         const cap = await tmux.capturePaneById(paneId, { ansi: false, scrollback: 0 });
@@ -5903,6 +5818,9 @@ export class AgentManager {
             ...(opts.priorFindingsJson ? { serverPriorFindings: opts.priorFindingsJson } : {}),
             ...(opts.priorResponseJson ? { serverPriorResponse: opts.priorResponseJson } : {}),
             ...(opts.phase === 'spec' ? { currentSpecRound: newRound } : {}),
+            // Arm the verdict + read-file watcher in the pane-exists / pre-paste window so a QA
+            // [bx:read-file:...] emitted during the dispatch is a live chunk, not snapshot-suppressed.
+            armBeforeInject: () => this.setupPhaseSignalWatcher(taskId, qaId, expectedKind, newToken, false, (req) => { void this.handleReadFileRequest(taskId, qaId, req); }),
         };
         // A continuation consumed the QA's reviewed signal (not the dev's entry
         // signal): rollback restores the prior slice's review/token, so re-arm the
@@ -5923,6 +5841,9 @@ export class AgentManager {
                 : await this.startSession(taskId, qaId, dispatchPhase, sessionOpts);
         }
         catch (err) {
+            // armBeforeInject may have armed the watcher before the failing paste — drop it so a stale
+            // entry can't fire on a rolled-back / failed task (no-op if it never armed).
+            this.stopPhaseSignalWatcher(taskId);
             if (err instanceof DispatchTerminalError) {
                 await this.failTaskForDispatchError(taskId, dispatchPhase, qaId, err);
             }
@@ -5939,6 +5860,9 @@ export class AgentManager {
             throw err;
         }
         if (!started) {
+            // Covers armBeforeInject returning false (watcher couldn't arm) as well as any other
+            // pre-paste abort; stop is a no-op when nothing armed.
+            this.stopPhaseSignalWatcher(taskId);
             await rollback();
             if (!opts.continuation) {
                 await this.releaseAgentForTask(qaId, taskId, 'idle').catch(() => undefined);
@@ -5955,8 +5879,6 @@ export class AgentManager {
             });
             return null;
         }
-        this.stopPhaseSignalWatcher(taskId);
-        await this.armPostDispatchSignalOrHold(taskId, qaId, expectedKind, newToken, false, (req) => { void this.handleReadFileRequest(taskId, qaId, req); });
         return await this.taskStore.get(taskId);
     }
     async dispatchServerFixToDev(taskId, findingsJson) {