baxian 2.0.18 → 2.0.19

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';
@@ -1295,7 +1296,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, {
@@ -2981,36 +2982,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;
@@ -6987,12 +7001,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 +7018,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 +7034,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 +7058,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 +7076,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 +7094,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 +7152,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) {
@@ -8861,17 +8890,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 +8903,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 +8927,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) {