aicodeman 1.41.0 → 1.42.0

package/dist/session.js

@@ -42,7 +42,7 @@ import { TaskTracker } from './task-tracker.js';
 import { RalphTracker } from './ralph-tracker.js';
 import { BashToolParser } from './bash-tool-parser.js';
 import { isTrustDialogScreen, trustDialogNextKey, TRUST_KEY_CONFIRM, TRUST_DIALOG_WINDOW_MS, TRUST_DIALOG_RETRY_MS, TRUST_DIALOG_MAX_ATTEMPTS, TRUST_DIALOG_SCAN_BYTES, } from './session-trust-dialog.js';
-import { trackActivityStreak, isSustainedActivity, isPaneQuiet, watchingLabel, isAwaitingWorkers, WATCHING_TAIL_LINES, IDLE_RECHECK_MS, PANE_PROBE_MIN_INTERVAL_MS, PANE_PROBE_RECHECK_MS, } from './session-activity.js';
+import { trackActivityStreak, isSustainedActivity, isPaneQuiet, watchingLabel, isAwaitingWorkers, isBlockedScreen, WATCHING_TAIL_LINES, BLOCKED_TAIL_LINES, BLOCKED_RECHECK_MS, BLOCKED_QUIET_RECHECK_MS, BLOCKED_CLEAR_READS, IDLE_RECHECK_MS, PANE_PROBE_MIN_INTERVAL_MS, PANE_PROBE_RECHECK_MS, } from './session-activity.js';
 import { BufferAccumulator, ANSI_ESCAPE_PATTERN_FULL, TOKEN_PATTERN, SPINNER_PATTERN, CLAUDE_WORKING_LINE_PATTERN, MAX_SESSION_TOKENS, execPattern, getClaudeCliVersion, getClaudeBinaryPath, spawnPtyWithHelperRepair, resolveLocalShell, waitForProcessesExit, } from './utils/index.js';
 import { MAX_TERMINAL_BUFFER_SIZE, TRIM_TERMINAL_TO as TERMINAL_BUFFER_TRIM_SIZE, MAX_TEXT_OUTPUT_SIZE, TRIM_TEXT_TO as TEXT_OUTPUT_TRIM_SIZE, MAX_MESSAGES, MAX_LINE_BUFFER_SIZE, } from './config/buffer-limits.js';
 import { DEFAULT_TMUX_HISTORY_LIMIT } from './config/terminal-history.js';
@@ -408,6 +408,7 @@ export class Session extends EventEmitter {
     _activityStreak = null; // Unbroken run of PTY repaints (working detection)
     _lastPaneProbeAt = 0; // Throttle for the tmux screen probe
     _lastPaneProbeWorking = null; // Its last verdict (null = could not read)
+    _lastPaneProbeTrustDialog = false; // Same capture showed the workspace-trust dialog (see _confirmIdle)
     /**
      * Background work the pane's own footer reports, e.g. `1 monitor`; null for none.
      *
@@ -431,6 +432,8 @@ export class Session extends EventEmitter {
      * running. A session that comes back with no label has no chip on its screen.
      */
     _watching = null;
+    /** Last `prompt_cache` report from the statusline exporter; null until Claude sends one. */
+    _promptCache = null;
     /** Lazily compiled `capabilities.workDetect.workingLine`. See _workingLinePattern(). */
     _workingLineRe = undefined;
     /** Lazily compiled `capabilities.workDetect.watchingLine`. See _watchingLinePattern(). */
@@ -439,6 +442,23 @@ export class Session extends EventEmitter {
     _watchingWindow = WATCHING_TAIL_LINES;
     /** Lazily compiled `capabilities.workDetect.awaitingLine`. See _awaitingLinePattern(). */
     _awaitingLineRe = undefined;
+    /** Lazily compiled `capabilities.workDetect.blockedLine`. See _blockedLinePattern(). */
+    _blockedLineRe = undefined;
+    /** Resolved with the pattern above: how many rows at the foot of the screen it sees. */
+    _blockedWindow = BLOCKED_TAIL_LINES;
+    /**
+     * The pane is showing a dialog the CLI blocks on, read off the screen with
+     * `capabilities.workDetect.blockedLine` (codex: an approval, a question, the trust
+     * prompt). Live state, not persisted: a restarted server re-reads it from the attach
+     * repaint the same way the watching label comes back. See `_noteBlockedReading()`.
+     */
+    _screenBlocked = false;
+    /** Consecutive readable captures without the dialog (cleared at BLOCKED_CLEAR_READS). */
+    _blockedGoneReads = 0;
+    /** When the last reading that SAW the dialog was taken. See `_armBlockedRecheck()`. */
+    _blockedSeenAt = 0;
+    /** Re-reads the screen while a dialog is up, so the alert clears with it. */
+    _blockedRecheckTimer = null;
     /**
      * The newest model the running CLI reported for itself (its statusline, or its own
      * footer read off the probe's capture), or null when none has. Feeds `displayModel`
@@ -753,6 +773,11 @@ export class Session extends EventEmitter {
         // browser panel arms and disarms — see `startPaneExitWatcher`.
         this.setPaneExit(config.paneExit);
         this._reportedModel = restoredReportedModel(config.displayModel) ?? null;
+        // Last prompt-cache report, restored so the Session Options readout is not blank until
+        // the pane's next statusline render. The readout is time-aware, so a value whose expiry
+        // has passed renders as cold rather than stale-warm. Set directly, not via
+        // setPromptCache, so recovery does not re-stamp a compaction it did not just observe.
+        this._promptCache = config.promptCache ?? null;
         // Never self-parent: a session pointing at itself would draw a zero-length
         // lineage arc under its own tab. Only reachable via the recovery path, where
         // both the id and the saved parent come from disk.
@@ -934,6 +959,11 @@ export class Session extends EventEmitter {
         if (newId === this._claudeSessionId)
             return;
         this._claudeSessionId = newId;
+        // The conversation itself changed (a post-/clear switch), so the old prefix's cache
+        // report and its compaction baseline belong to a conversation that is gone. Drop them
+        // rather than show the previous conversation's "warm until" against the new one; the
+        // next statusline render repopulates. A same-id reattach returned above, untouched.
+        this._promptCache = null;
     }
     /**
      * Append to the conversation chain, oldest first. A repeat of the current tail
@@ -1092,6 +1122,54 @@ export class Session extends EventEmitter {
     get watching() {
         return this._watching;
     }
+    /**
+     * True while the pane shows a dialog its CLI is blocked on, as read off the screen
+     * (`capabilities.workDetect.blockedLine`). Always false for a CLI that declares none,
+     * Claude included: its dialogs arrive as hook events instead. The `blocked` wait reads
+     * it so a caller that asks after the dialog appeared is answered at once.
+     */
+    get screenBlocked() {
+        return this._screenBlocked;
+    }
+    /**
+     * Prompt-cache state of the main conversation as Claude Code last reported it on the
+     * statusline (v2.1.251+), fed by `POST /api/status-telemetry`. Null until the first
+     * report. It rides `toState()` for the Session Options readout and is restored on a
+     * Codeman restart (constructor `promptCache`) so the row is not blank until the pane's
+     * next render; the readout is time-aware, so a value whose `expiresAt` has passed renders
+     * as cold rather than as a stale warm.
+     */
+    get promptCache() {
+        return this._promptCache;
+    }
+    /**
+     * Replace the prompt-cache report; true when it differs from the previous one. Stamps
+     * `compactedAt` when this report ENTERS the window in which Claude Code reads
+     * `recacheTokensIfCold` as null: a compaction (`/compact` or its own idle compaction) or
+     * a clearing of old tool results opened it, and the previous report still had a known
+     * value. Claude Code closes the window on the next request (that request is the one that
+     * counts as an expected rebuild), so `expectedRebuilds` never rises inside it and is not
+     * read here. The stamp is carried while the window holds and dropped once it closes; a
+     * first report already inside the window gets none. It is never an alert.
+     */
+    setPromptCache(status) {
+        const prev = this._promptCache;
+        const inWindow = status.warm && status.recacheTokensIfCold == null;
+        let compactedAt;
+        if (inWindow && prev?.recacheTokensIfCold != null) {
+            compactedAt = Date.now();
+        }
+        else if (inWindow && prev?.compactedAt != null) {
+            compactedAt = prev.compactedAt;
+        }
+        // A NEW object when a stamp applies, never a mutation of the caller's parsed report: the
+        // route broadcasts the STORED object, so the stamp lives here and never leaks back into the
+        // parser's output (which would make the route's "broadcast the stored object" choice vacuous).
+        const next = compactedAt != null ? { ...status, compactedAt } : status;
+        const changed = JSON.stringify(next) !== JSON.stringify(prev);
+        this._promptCache = next;
+        return changed;
+    }
     /**
      * Check if the session's process tree has active child processes beyond Claude itself.
      * Detects running bash tools, test suites, builds, servers, etc. that Claude spawned.
@@ -1506,6 +1584,8 @@ export class Session extends EventEmitter {
             autoCompactPrompt: this._autoOps.autoCompactPrompt,
             autoResumeEnabled: this._autoOps.autoResumeEnabled,
             autoResumeAt: this._autoOps.autoResumeAt ?? undefined,
+            promptCache: this._promptCache ?? undefined,
+            statusLineExporter: this._muxSession?.statusLine,
             imageWatcherEnabled: this._imageWatcherEnabled,
             pinned: this._pinned || undefined,
             pinnedAt: this._pinned ? (this._pinnedAt ?? undefined) : undefined,
@@ -2245,6 +2325,7 @@ export class Session extends EventEmitter {
         this._interactiveStartedAt = Date.now();
         this._trustDialogAttempts = 0;
         this._lastTrustDialogScanAt = 0;
+        this._lastPaneProbeTrustDialog = false; // the last pane's verdict, not this one's
         if (this._trustDialogTimer) {
             clearTimeout(this._trustDialogTimer);
             this._trustDialogTimer = null;
@@ -2591,6 +2672,10 @@ export class Session extends EventEmitter {
                 this._expensiveProcessTimer = null;
             }
             this._pendingCleanData = '';
+            // Nothing reads this pane any more, so a dialog on it can no longer be seen to
+            // close: drop the state (and its timer) while the listeners are still attached.
+            // A re-attach re-reads the screen and raises it again if the dialog is still up.
+            this._clearScreenBlocked();
             // If using mux, mark the session as detached but don't kill it
             if (this._muxSession && this._mux) {
                 this._mux.setAttached(this.id, false);
@@ -2648,15 +2733,26 @@ export class Session extends EventEmitter {
      * a two-marker match (isTrustDialogScreen), and an attempt cap.
      */
     _maybeAcceptTrustDialog() {
-        if (this._trustDialogAccepted)
+        // Stopped: the kill itself produces PTY output, and the buffer tail still holds the
+        // dialog, so without this a deleted session kept "answering" it for several seconds.
+        if (this._trustDialogAccepted || this._isStopped)
             return;
         const now = Date.now();
         if (now - this._interactiveStartedAt > TRUST_DIALOG_WINDOW_MS) {
             this._trustDialogAccepted = true; // window closed; anything matching now is not the dialog
             return;
         }
-        if (now - this._lastTrustDialogScanAt < TRUST_DIALOG_RETRY_MS)
+        const sinceScan = now - this._lastTrustDialogScanAt;
+        if (sinceScan < TRUST_DIALOG_RETRY_MS) {
+            // ⚠️ Defer a throttled read, never drop it. The dialog's own paint is usually the
+            // last output a launching pane produces, and it tends to land inside the throttle
+            // of the read the blank screen before it triggered: dropped, nothing re-read the
+            // screen and the session sat on the dialog for good (2 of 12 fresh launches on
+            // Claude Code 2.1.294). A read already scheduled covers this one.
+            if (!this._trustDialogTimer)
+                this._rescanTrustDialogIn(TRUST_DIALOG_RETRY_MS - sinceScan + 100);
             return;
+        }
         this._lastTrustDialogScanAt = now;
         // Prefer the pane; fall back to the buffer tail on a direct-PTY session,
         // where there is no screen to read.
@@ -2686,15 +2782,17 @@ export class Session extends EventEmitter {
         // on a live 2.1.252 spawn: cursor moved at 6 s, then nothing). The timer is
         // one-shot and self-rearming through this same path, and every exit route
         // goes through _clearAllTimers().
-        // The +100ms puts the re-entry OUTSIDE the scan throttle above; firing at
-        // exactly the throttle boundary would let the scan return early and break
-        // the chain with the dialog still on screen.
+        // The +100ms puts the re-entry OUTSIDE the scan throttle above.
+        this._rescanTrustDialogIn(TRUST_DIALOG_RETRY_MS + 100);
+    }
+    /** Re-run the trust-dialog scan after `delayMs`, replacing any read already scheduled. */
+    _rescanTrustDialogIn(delayMs) {
         if (this._trustDialogTimer)
             clearTimeout(this._trustDialogTimer);
         this._trustDialogTimer = setTimeout(() => {
             this._trustDialogTimer = null;
             this._maybeAcceptTrustDialog();
-        }, TRUST_DIALOG_RETRY_MS + 100);
+        }, delayMs);
     }
     /**
      * Per-chunk working/idle detection for an interactive pane. Split out of the
@@ -2768,10 +2866,29 @@ export class Session extends EventEmitter {
             return this._lastPaneProbeWorking;
         this._lastPaneProbeAt = now;
         const text = this._mux.capturePaneText?.(this._muxSession.muxName) ?? null;
+        // A dialog the CLI is blocked on is not work, whatever else is on screen: codex's
+        // question dialog carries `esc to interrupt` in its own key hints, which is codex's
+        // working line, so without this a session waiting on the user's answer read as busy.
+        // Decided from THIS capture, never from `_screenBlocked`, which lags a vanished dialog
+        // by design (see `_noteBlockedReading`) and would otherwise call a resumed turn idle.
+        const blockedOnScreen = text === null ? null : this._paneShowsBlocked(text);
+        this._noteBlockedReading(blockedOnScreen, text);
         // A turn that ended by handing off to workers the CLI waits for is work too: the
         // composer is up and the pane is quiet, but the next turn starts without the user.
         this._lastPaneProbeWorking =
-            text === null ? null : this._workingLinePattern().test(text) || this._paneAwaitsWorkers(text);
+            text === null
+                ? null
+                : !blockedOnScreen && (this._workingLinePattern().test(text) || this._paneAwaitsWorkers(text));
+        // A capture that failed proves nothing either way, so it keeps the last answer.
+        if (text !== null) {
+            const trustDialog = isTrustDialogScreen(text);
+            if (trustDialog &&
+                !this._lastPaneProbeTrustDialog &&
+                now - this._interactiveStartedAt <= TRUST_DIALOG_WINDOW_MS) {
+                console.log(`[Session] Holding idle while the workspace trust dialog is on screen: ${this.id}`);
+            }
+            this._lastPaneProbeTrustDialog = trustDialog;
+        }
         this._readWatching(text);
         this._readScreenModel(text);
         return this._lastPaneProbeWorking;
@@ -2963,6 +3080,109 @@ export class Session extends EventEmitter {
         const glyph = getCli(this.mode)?.capabilities.workDetect?.promptGlyph ?? '❯';
         return isAwaitingWorkers(paneText, this._awaitingLineRe, glyph);
     }
+    /**
+     * The regex matching the dialog this CLI blocks on, or null for a CLI whose registry
+     * entry declares none (every CLI but codex today, Claude included: its dialogs arrive
+     * as hook events). Compiled once per session through `compileVersionRegex()`, the same
+     * guard the schema applies, so a pattern it refuses yields null rather than a throw.
+     */
+    _blockedLinePattern() {
+        if (this._blockedLineRe === undefined) {
+            const detect = getCli(this.mode)?.capabilities.workDetect;
+            this._blockedLineRe = detect?.blockedLine ? compileVersionRegex(detect.blockedLine) : null;
+            this._blockedWindow = detect?.blockedLines ?? BLOCKED_TAIL_LINES;
+        }
+        return this._blockedLineRe;
+    }
+    /** Whether this capture shows a dialog the CLI is blocked on. See `isBlockedScreen()`. */
+    _paneShowsBlocked(paneText) {
+        const pattern = this._blockedLinePattern();
+        return pattern ? isBlockedScreen(paneText, pattern, this._blockedWindow) : false;
+    }
+    /**
+     * Fold one screen reading into the blocked state, announcing each transition with
+     * `blockedChanged` (the web server turns it into the alert and the `blocked` signal).
+     *
+     * The two directions are deliberately unequal:
+     * - RAISE on one reading. A match needs the dialog's own footer at the foot of the
+     *   screen, which is only there when the dialog is fully drawn.
+     * - CLEAR on BLOCKED_CLEAR_READS readings in a row. A single capture can land inside a
+     *   full-frame repaint, and clearing on it would re-raise a moment later and send the
+     *   alert, push and webhook twice for one dialog.
+     * A capture that could not be read (`null`) is no evidence either way and changes
+     * nothing, so a tmux hiccup can neither raise nor drop an alert. That is the opposite
+     * of `_readWatching`, and for the same reason: each degrades toward the alert.
+     *
+     * While blocked, `_blockedRecheckTimer` keeps reading, since answering resumes the turn
+     * and a busy pane never reaches the settle path that raised it.
+     *
+     * @param frame the capture the reading came from; rides the raise as the alert's context
+     */
+    _noteBlockedReading(onScreen, frame) {
+        if (onScreen === null || !this._blockedLinePattern())
+            return;
+        if (onScreen) {
+            this._blockedGoneReads = 0;
+            // Stamped after the capture returned: output processed later is newer than it.
+            this._blockedSeenAt = Date.now();
+            if (!this._screenBlocked) {
+                this._screenBlocked = true;
+                this.emit('blockedChanged', true, frame);
+            }
+            this._armBlockedRecheck();
+            return;
+        }
+        if (!this._screenBlocked)
+            return;
+        if (++this._blockedGoneReads < BLOCKED_CLEAR_READS) {
+            this._armBlockedRecheck();
+            return;
+        }
+        this._clearScreenBlocked();
+    }
+    /** (Re)arm the while-blocked screen read. One-shot and self-rearming, like the trust scan. */
+    _armBlockedRecheck() {
+        if (this._blockedRecheckTimer)
+            clearTimeout(this._blockedRecheckTimer);
+        this._blockedRecheckTimer = setTimeout(() => {
+            this._blockedRecheckTimer = null;
+            // No pane left to read (detached): nothing can change until a re-attach, whose
+            // `_resetBuffers()` clears the state and whose repaint reads the screen afresh.
+            if (this._isStopped || !this._screenBlocked || !this._mux?.capturePaneText || !this._muxSession)
+                return;
+            // A dialog leaves the screen only through a repaint, and tmux sends every repaint
+            // to this client as PTY output (`_markActivity`). So while the last reading saw
+            // the dialog and nothing has been drawn since, it is still up: skip the capture
+            // (synchronous, see BLOCKED_QUIET_RECHECK_MS) and look again next interval. Never
+            // once a reading has missed it: the confirming read must happen on a quiet pane
+            // too, or the clear would wait for output that may never come.
+            if (this._blockedGoneReads === 0 &&
+                this._lastActivityAt < this._blockedSeenAt &&
+                Date.now() - this._blockedSeenAt < BLOCKED_QUIET_RECHECK_MS) {
+                this._armBlockedRecheck();
+                return;
+            }
+            const text = this._mux.capturePaneText(this._muxSession.muxName) ?? null;
+            // Unreadable this time: keep the state, keep looking (_noteBlockedReading ignores a null).
+            if (text === null) {
+                this._armBlockedRecheck();
+                return;
+            }
+            this._noteBlockedReading(this._paneShowsBlocked(text), text);
+        }, BLOCKED_RECHECK_MS);
+    }
+    /** Drop the blocked state (and its timer), announcing it when it was set. */
+    _clearScreenBlocked() {
+        this._blockedGoneReads = 0;
+        if (this._blockedRecheckTimer) {
+            clearTimeout(this._blockedRecheckTimer);
+            this._blockedRecheckTimer = null;
+        }
+        if (!this._screenBlocked)
+            return;
+        this._screenBlocked = false;
+        this.emit('blockedChanged', false, null);
+    }
     /**
      * The regex matching this CLI's "a turn is running" status line.
      *
@@ -3023,6 +3243,16 @@ export class Session extends EventEmitter {
             this.activityTimeout = setTimeout(() => this._confirmIdle(), PANE_PROBE_RECHECK_MS);
             return;
         }
+        // ⚠️ The workspace-trust dialog is not a composer, although its `❯` (on "No, exit")
+        // arms this check and the dialog sits quiet. Calling it idle let an agent that waited
+        // for idle send its prompt into the dialog, and the prompt's Enter answered *exit*.
+        // Not working either, so the status stays where it is until the dialog is gone.
+        // Bounded by the auto-accept's own startup window: later on, a screen that merely
+        // quotes the dialog (an agent reading session-trust-dialog.ts) must not hold idle off.
+        if (this._lastPaneProbeTrustDialog && Date.now() - this._interactiveStartedAt <= TRUST_DIALOG_WINDOW_MS) {
+            this.activityTimeout = setTimeout(() => this._confirmIdle(), PANE_PROBE_RECHECK_MS);
+            return;
+        }
         this._awaitingIdleConfirmation = false;
         this.activityTimeout = null;
         // Emit idle if either:
@@ -3462,6 +3692,9 @@ export class Session extends EventEmitter {
         // into a program that never enabled tracking.
         this._cliMouseModes.clear();
         this._syncCliMouseTracking();
+        // Nor does it start inside a dialog. Announced, so a pending alert for the old
+        // pane's dialog is resolved rather than left behind it.
+        this._clearScreenBlocked();
         this._markActivity(true);
     }
     _clearAllTimers() {
@@ -3473,6 +3706,11 @@ export class Session extends EventEmitter {
             clearTimeout(this._trustDialogTimer);
             this._trustDialogTimer = null;
         }
+        // Clear the while-blocked screen read (the state itself is left to its owner)
+        if (this._blockedRecheckTimer) {
+            clearTimeout(this._blockedRecheckTimer);
+            this._blockedRecheckTimer = null;
+        }
         // Clear activity timeout to prevent memory leak
         if (this.activityTimeout) {
             clearTimeout(this.activityTimeout);
@@ -3928,7 +4166,7 @@ export class Session extends EventEmitter {
      *
      * More reliable than direct PTY write for programmatic input, especially
      * with Claude CLI which uses Ink (React for terminals).
-     * Uses tmux `send-keys -l` to inject text + Enter.
+     * Uses tmux to inject the text (one bracketed paste) + Enter.
      *
      * @param data - Input data with optional `\r` for Enter
      * @returns true if input was sent, false if no mux session or PTY