baxian 2.0.18 → 2.0.20

package/dist/agent/manager.js

@@ -17,8 +17,9 @@ import { platformBindingMismatch, taskNeedsPlatformBindingAudit, } from '../plat
 import { AGENT_STORE_NOOP } from '../state/agent-store.js';
 import { createRunner, LocalRunner, shellQuote, resolveAgentHost, workdirHostGroupKey, } from './runner.js';
 import { isTransientNetworkFailure } from './net-exec.js';
+import { classifyScreen, isMenuRule } from './detect/classify.js';
 import { imageFilename, agentHostPath, writeImageToHost } from './image-input.js';
-import { TmuxManager, ReplNotReadyError, detectStartupDialog, detectRuntimeMenu, runtimeBusyCheck, hasRuntimeReadyView, hasReplProcTitle, isShellProcTitle, hasOscTitleWorking, hasOscTitleIdle, screenAllowsTitleIdle, PaneGoneError, } from './tmux.js';
+import { TmuxManager, ReplNotReadyError, detectStartupDialog, 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';
@@ -180,12 +181,17 @@ export function canDispatchWithBinding(binding) {
 const RECOVERABLE_QA_DISPATCH_HOLD_PHASES = new Set([
     'checkout-preparation-failed',
     'dirty-workdir',
+    'branch-cleanup-pending',
 ]);
 export function isRecoverableQaDispatchHold(binding) {
     return binding?.status === 'awaiting_human'
         && binding.awaitingPhase != null
         && RECOVERABLE_QA_DISPATCH_HOLD_PHASES.has(binding.awaitingPhase);
 }
+const GIT_REVIEW_DISPATCH_HOLD_PHASES = new Set([
+    ...RECOVERABLE_QA_DISPATCH_HOLD_PHASES,
+    'dispatch-failed:ack_unknown',
+]);
 const CANCEL_CLEANUP_HOLD_PHASES = new Set(['cancel-clearing', 'cancel-interrupt-failed']);
 function isCancelCleanupHold(binding) {
     return binding?.awaitingPhase != null && CANCEL_CLEANUP_HOLD_PHASES.has(binding.awaitingPhase);
@@ -1295,7 +1301,7 @@ export class AgentManager {
                 fresh.paneId !== state.paneId) {
                 continue;
             }
-            const onMenu = detectRuntimeMenu(stripped);
+            const onMenu = isMenuRule(cfg.runtime, classifyScreen(cfg.runtime, stripped).matchedRuleId);
             if (onMenu && !pendingMenu) {
                 pendingMenu = true;
                 await this.emitIntervention(fresh.projectId, agentId, fresh.taskId, {
@@ -1517,6 +1523,8 @@ export class AgentManager {
             : null;
         const sameTaskLocked = existingToken !== null;
         const reentryPhases = new Set(['fix', 'post-approve', 'code']);
+        // fix / post-approve 由 continueSession 投递,没有配对的 clearBootstrapMarker
+        const unfinalizedPhases = new Set(['fix', 'post-approve']);
         const sameTaskReentry = state?.taskId === taskId &&
             !state.creationToken &&
             state.status !== 'awaiting_human' &&
@@ -1553,7 +1561,7 @@ export class AgentManager {
                     projectId: cfg.projectId,
                     taskId,
                     lockToken: token,
-                    ...(phase === 'code' && !sameTaskReentry ? { bootstrappingTaskId: taskId } : {}),
+                    ...(!unfinalizedPhases.has(phase) ? { bootstrappingTaskId: taskId } : {}),
                     updatedAt: now,
                 };
             });
@@ -2981,36 +2989,49 @@ export class AgentManager {
     }
     async paneHasLiveTurn(tmux, pane, runtime) {
         const paneId = pane.paneId;
-        let first;
-        let firstTitle;
-        try {
-            first = await tmux.capturePaneById(pane, { ansi: false, scrollback: 0 });
-            firstTitle = await tmux.readPaneTitle(pane);
-        }
-        catch (err) {
-            console.warn(`[AgentManager] interruptPaneAndWaitReady: liveness capture failed for pane ${paneId}:`, err);
-            return true;
-        }
-        for (let i = 1; i < RUNTIME_LIVENESS_SAMPLES; i++) {
-            await new Promise(r => setTimeout(r, this.runtimeLivenessProbeMs));
-            let frame;
-            let title;
+        const sample = async (phase) => {
             try {
-                frame = await tmux.capturePaneById(pane, { ansi: false, scrollback: 0 });
-                title = await tmux.readPaneTitle(pane);
+                return {
+                    frame: await tmux.capturePaneById(pane, { ansi: false, scrollback: 0 }),
+                    title: await tmux.readPaneTitle(pane),
+                };
             }
             catch (err) {
-                console.warn(`[AgentManager] interruptPaneAndWaitReady: liveness re-capture failed for pane ${paneId}:`, err);
-                return true;
+                console.warn(`[AgentManager] interruptPaneAndWaitReady: liveness ${phase} failed for pane ${paneId}:`, err);
+                return null;
             }
-            if (title !== firstTitle && hasOscTitleWorking(title))
+        };
+        const first = await sample('capture');
+        if (!first)
+            return true;
+        // 空屏幕 = 只让标题规则说话:标题相对首帧变了且判 working,说明 turn 还活着
+        const titleTurnedWorking = (title) => title !== first.title && classifyScreen(runtime, '', title).state === 'working';
+        let prev = first.frame;
+        let settledSinceChange = true;
+        for (let i = 1; i < RUNTIME_LIVENESS_SAMPLES; i++) {
+            await new Promise(r => setTimeout(r, this.runtimeLivenessProbeMs));
+            const next = await sample('re-capture');
+            if (!next)
                 return true;
-            if (hasRuntimeReadyView(frame, runtime))
-                return false;
-            if (frame !== first)
+            if (titleTurnedWorking(next.title))
                 return true;
+            if (next.frame === prev) {
+                settledSinceChange = true;
+                continue;
+            }
+            if (!hasRuntimeReadyView(next.frame, runtime))
+                return true;
+            // working→idle 的最新帧已 ready:不能仅凭帧差判 live,需再观察一拍确认它稳定
+            prev = next.frame;
+            settledSinceChange = false;
         }
-        return false;
+        if (settledSinceChange)
+            return false;
+        await new Promise(r => setTimeout(r, this.runtimeLivenessProbeMs));
+        const confirm = await sample('confirm capture');
+        if (!confirm)
+            return true;
+        return titleTurnedWorking(confirm.title) || confirm.frame !== prev;
     }
     async paneRunsRuntime(tmux, pane, runtime) {
         const paneId = pane.paneId;
@@ -4612,13 +4633,37 @@ export class AgentManager {
             }
             next.reviewDispatchedAt = now;
             delete next.reviewDispatch;
-            if (next.attention?.reason === 'git-review-dispatch-recovery-uncertain') {
+            if (next.attention?.reason === 'git-review-dispatch-recovery-uncertain'
+                || await this.dispatchHoldAttentionIsStale(next)) {
                 delete next.attention;
             }
             await this.taskStore.set(next);
             return true;
         });
     }
+    // a hold and its task attention are written as a pair, so no live hold means this one was consumed
+    async dispatchHoldAttentionIsStale(task) {
+        const reason = task.attention?.reason;
+        if (reason === undefined || !GIT_REVIEW_DISPATCH_HOLD_PHASES.has(reason))
+            return false;
+        for (const participantId of [task.agentId, task.qaAgentId]) {
+            if (!participantId)
+                continue;
+            let participant;
+            try {
+                participant = await this.agentStore.get(participantId);
+            }
+            catch (err) {
+                console.error(`[AgentManager] hold liveness probe for ${participantId} failed:`, err);
+                return false;
+            }
+            if (participant?.taskId === task.id
+                && participant.status === 'awaiting_human'
+                && participant.awaitingPhase === reason)
+                return false;
+        }
+        return true;
+    }
     async recoverPendingGitReviewDispatchHold(taskId, expectedGeneration) {
         return this.withTaskLock(async () => {
             const task = await this.taskStore.get(taskId);
@@ -6987,12 +7032,12 @@ export class AgentManager {
         const paneId = pane.paneId;
         const preTitle = await tmux.readPaneTitle(pane);
         const preFrame = await tmux.capturePaneById(pane, { ansi: false, scrollback: 0 });
-        const staticBusy = hasOscTitleWorking(preTitle)
-            ? (runtimeBusyCheck(preFrame, runtime) || !hasRuntimeReadyView(preFrame, runtime))
-            : runtimeBusyCheck(preFrame, runtime);
-        if (staticBusy && await this.paneHasLiveTurn(tmux, pane, runtime)) {
-            throw new ReplNotReadyError(paneId, runtime, preFrame, `pre-inject busy check: pane ${paneId} is still running a turn; dispatch aborted`);
+        const preDetection = classifyScreen(runtime, preFrame, preTitle);
+        if (preDetection.state === 'pending') {
+            throw new ReplNotReadyError(paneId, runtime, preFrame, `pre-inject check: pane ${paneId} shows a blocker; dispatch aborted`);
         }
+        // working pane 上清稿的 C-c 会打断进行中的 turn
+        const paneWorking = preDetection.state === 'working';
         await revalidate?.();
         if (guardBeforePaste) {
             if (!(await guardBeforePaste())) {
@@ -7004,7 +7049,8 @@ export class AgentManager {
                 pasted = await this.withTaskLock(async () => {
                     if (!(await guardBeforePaste()))
                         return false;
-                    await tmux.clearComposerDraft(pane);
+                    if (!paneWorking)
+                        await tmux.clearComposerDraft(pane);
                     await tmux.pasteStagedBuffer(paneId, staged.buf);
                     return true;
                 });
@@ -7019,6 +7065,10 @@ export class AgentManager {
                     console.warn(`[AgentManager] staged buffer ${staged.buf} not confirmed dropped after failed paste (missing or unprobeable); failing closed to a composer scrub:`, dropErr);
                 }
                 if (bufferConsumed) {
+                    const message = pasteErr instanceof Error ? pasteErr.message : String(pasteErr);
+                    if (paneWorking) {
+                        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);
                     }
@@ -7039,7 +7089,8 @@ export class AgentManager {
             }
         }
         else {
-            await tmux.clearComposerDraft(pane);
+            if (!paneWorking)
+                await tmux.clearComposerDraft(pane);
             await revalidate?.();
             await tmux.injectPrompt(pane, prompt, agentId);
         }
@@ -7056,6 +7107,9 @@ export class AgentManager {
                     return true;
                 });
                 if (!submitted) {
+                    if (paneWorking) {
+                        throw new Error(`fence-rejected prompt stays in the composer of working pane ${paneId}`);
+                    }
                     try {
                         await tmux.clearComposerDraft(pane);
                     }
@@ -7071,11 +7125,18 @@ export class AgentManager {
             }
         }
         catch (preAckErr) {
+            const message = preAckErr instanceof Error ? preAckErr.message : String(preAckErr);
+            // working pane 上 scrub 的 C-c 会打断进行中的 turn:交人工核验,不动 composer
+            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))
                 throw preAckErr;
-            const message = preAckErr instanceof Error ? preAckErr.message : String(preAckErr);
             throw new DispatchTerminalError('ack_unknown', `pre-ack failure left an unconfirmed composer on live pane ${paneId}: ${message}`);
         }
+        // 判据必须取自粘贴之前:粘贴后的基线含提示词正文,会自匹配 working 规则
+        if (paneWorking)
+            return { acked: true, composerDelivered: true };
         let staleDuringResend = false;
         try {
             await tmux.waitSubmitAck(pane, baseline, runtime, {
@@ -7122,8 +7183,7 @@ export class AgentManager {
                     'baxian intentionally did NOT send C-c — the input may still be queued. ' +
                     'Attach via web terminal to verify and resolve.',
             });
-            const composerDelivered = !/pane already busy at baseline/.test(message);
-            return { acked: false, composerDelivered };
+            return { acked: false, composerDelivered: true };
         }
     }
     async clearComposerForReuse(tmux, pane, agentId) {
@@ -7487,10 +7547,12 @@ export class AgentManager {
             return false;
         }
     }
-    async clearBootstrapMarker(agentId, taskId) {
+    async clearBootstrapMarker(agentId, taskId, expectedLockToken) {
         await this.agentStore.update(agentId, (latest) => {
             if (!latest || latest.taskId !== taskId || latest.bootstrappingTaskId === undefined)
                 return AGENT_STORE_NOOP;
+            if (expectedLockToken !== undefined && latest.lockToken !== expectedLockToken)
+                return AGENT_STORE_NOOP;
             const { bootstrappingTaskId: _delivered, ...rest } = latest;
             return { ...rest, updatedAt: new Date().toISOString() };
         });
@@ -8043,6 +8105,13 @@ export class AgentManager {
                 await this.resetGitReviewDispatchClaim(taskId, lease);
                 throw new ApiError(409, `QA agent ${qaId} could not be released for git review dispatch`);
             }
+            if (previousQa.status === 'awaiting_human' && previousQa.awaitingPhase !== undefined) {
+                await this.emitIntervention(task.projectId, qaId, taskId, {
+                    phase: 'git-review-dispatch-hold-cleared',
+                    previousPhase: previousQa.awaitingPhase,
+                    generation: lease.generation,
+                });
+            }
             opts.onSideEffect?.();
         }
         let acquiredLockToken;
@@ -8861,17 +8930,8 @@ export class AgentManager {
         });
         await new Promise(r => setTimeout(r, this.compactIdlePollMs));
         while (true) {
-            const 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 cap = await tmux.capturePaneById(pane, { ansi: false, scrollback: 0 });
-            const ready = hasRuntimeReadyView(cap, runtime)
-                || (screenAllowsTitleIdle(cap, runtime) && hasOscTitleIdle(await tmux.readPaneTitle(pane), runtime));
-            if (detectRuntimeMenu(cap) || (!ready && detectStartupDialog(cap, runtime))) {
-                throw new Error(`waitForReplPromptReady: pane ${paneId} shows menu/dialog, not a ready REPL prompt`);
-            }
-            if (!runtimeBusyCheck(cap, runtime)) {
+            const { cap, ready, working } = await this.probeReplPrompt(tmux, pane, runtime);
+            if (!working) {
                 if (!ready) {
                     throw new Error(`waitForReplPromptReady: pane ${paneId} observed idle but no ready anchor (stale frame?)`);
                 }
@@ -8883,6 +8943,23 @@ export class AgentManager {
             await new Promise(r => setTimeout(r, this.compactIdlePollMs));
         }
     }
+    async probeReplPrompt(tmux, pane, runtime) {
+        const paneId = pane.paneId;
+        const 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 cap = await tmux.capturePaneById(pane, { ansi: false, scrollback: 0 });
+        let detection = classifyScreen(runtime, cap);
+        // 标题规则优先级最高:屏幕判 idle 不作数,必须带标题复核
+        if (detection.state === 'idle')
+            detection = classifyScreen(runtime, cap, await tmux.readPaneTitle(pane));
+        const ready = hasRuntimeReadyView(cap, runtime, detection);
+        if (detection.state === 'pending' || detection.skipStateUpdate || detectStartupDialog(cap, runtime)) {
+            throw new Error(`waitForReplPromptReady: pane ${paneId} shows menu/dialog, not a ready REPL prompt`);
+        }
+        return { cap, ready, working: detection.state === 'working' };
+    }
     async waitForReplPromptStableIdle(tmux, pane, runtime, timeoutMs) {
         const paneId = pane.paneId;
         const samples = Math.max(1, this.readyStableSamples);
@@ -8890,17 +8967,8 @@ export class AgentManager {
         const deadline = Date.now() + timeoutMs + (samples - 1) * spacing;
         let streak = 0;
         while (true) {
-            const 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 cap = await tmux.capturePaneById(pane, { ansi: false, scrollback: 0 });
-            const ready = hasRuntimeReadyView(cap, runtime)
-                || (screenAllowsTitleIdle(cap, runtime) && hasOscTitleIdle(await tmux.readPaneTitle(pane), runtime));
-            if (detectRuntimeMenu(cap) || (!ready && detectStartupDialog(cap, runtime))) {
-                throw new Error(`waitForReplPromptReady: pane ${paneId} shows menu/dialog, not a ready REPL prompt`);
-            }
-            streak = ready && !runtimeBusyCheck(cap, runtime) ? streak + 1 : 0;
+            const { cap, ready } = await this.probeReplPrompt(tmux, pane, runtime);
+            streak = ready ? streak + 1 : 0;
             if (streak >= samples)
                 return;
             if (Date.now() >= deadline) {
@@ -9659,6 +9727,15 @@ export class AgentManager {
                     console.warn(`[AgentManager] transitionToCodePhase(${taskId}): stale-generation acquire rollback failed:`, err);
                 }
             }
+            else {
+                try {
+                    await this.clearBootstrapMarker(devAgentId, taskId, acquiredLockToken);
+                }
+                catch (clearErr) {
+                    console.warn(`[AgentManager] transitionToCodePhase(${taskId}): clearing the reentry bootstrap marker failed:`, clearErr);
+                    throw clearErr;
+                }
+            }
             return null;
         }
         this.stopPhaseSignalWatcher(taskId);
@@ -9692,6 +9769,16 @@ export class AgentManager {
                         });
                     }
                 }
+                else {
+                    try {
+                        await this.clearBootstrapMarker(devAgentId, taskId, acquiredLockToken);
+                    }
+                    catch (clearErr) {
+                        // 原始派发错误在这里落日志,抛出去的是更需要处理的回滚失败
+                        console.error(`[AgentManager] transitionToCodePhase dispatch(dev=${devAgentId}) failed:`, err);
+                        throw clearErr;
+                    }
+                }
             }
             else if (!(err instanceof EnsureSessionError && err.partial.handled)) {
                 await this.markAwaitingHuman(devAgentId, 'code-dispatch-failed', 'Code-phase prompt was not delivered after spec approval; the task looks in_progress but the dev never received it. Resume/restart the agent or cancel the task.', { expectedTaskId: taskId }).catch(() => undefined);