@hyperdrive.bot/paseo-server 0.3.11 → 0.3.12

package/dist/server/server/agent/providers/claude/transport/pty-query.d.ts

@@ -28,6 +28,15 @@ export declare class PtyQuery implements AsyncGenerator<SDKMessage, void> {
     private done;
     private readonly readyPromise;
     private offReadyData;
+    /**
+     * Cancels the readiness gate and its timers.
+     *
+     * Teardown MUST call this. A query closed before the gate settles used to leave its
+     * deadline interval running, so a session that attached and detached in the same
+     * millisecond still logged "readiness gate hit its timeout" a full minute later, warning
+     * about a terminal nobody was waiting on and leaking a timer per closed session.
+     */
+    private cancelReadiness;
     private turnEndTimer;
     private lastStopReason;
     private lastUsage;
@@ -36,6 +45,20 @@ export declare class PtyQuery implements AsyncGenerator<SDKMessage, void> {
     private readonly stallTimeoutMs;
     private stallTimer;
     private turnInFlight;
+    private terminalTail;
+    private offTerminalTap;
+    private readonly startedAt;
+    private recordingPath;
+    private recordingBytes;
+    private ptyBytesTotal;
+    private ptyBytesAtLastBeat;
+    private lastMeaningfulLine;
+    private lastTranscriptAt;
+    private heartbeatTimer;
+    private readySettledBy;
+    /** Last time the TUI footer said a turn was running. 0 = never seen. */
+    private lastBusyAt;
+    private interruptPromptAt;
     constructor(opts: PtyQueryOptions);
     private emit;
     next(): Promise<IteratorResult<SDKMessage, void>>;
@@ -44,13 +67,44 @@ export declare class PtyQuery implements AsyncGenerator<SDKMessage, void> {
     [Symbol.asyncIterator](): AsyncGenerator<SDKMessage, void>;
     private finish;
     private runInputLoop;
+    /**
+     * The message the user sees when the terminal would not take their prompt.
+     *
+     * Only reachable while the query is still live (teardown breaks out before this), so it
+     * always describes a message that genuinely did not land and that only the user can
+     * resend. Shaped as a normal result so it renders in the timeline rather than being
+     * buried in the daemon log.
+     */
+    private buildSubmitFailedResult;
     /**
      * Press Enter to submit the composed prompt, and CONFIRM the turn actually started by
-     * watching the transcript grow — claude appends the user message to <sid>.jsonl the
-     * instant it accepts a turn. During boot the TUI intermittently swallows the first Enter
-     * (a "what's new" notice / MCP-auth warning steals focus), so retry until it takes.
+     * watching for the USER LINE claude appends to <sid>.jsonl the instant it accepts a turn.
+     * During boot the TUI intermittently swallows the first Enter (a "what's new" notice /
+     * MCP-auth warning steals focus), so retry until it takes.
+     *
+     * The confirmation used to be `transcriptSize() > before`, which is any growth at all.
+     * That is not specific to the turn starting: claude writes `attachment`, `last-prompt`
+     * and other bookkeeping lines on its own schedule, so a swallowed Enter that happened to
+     * coincide with unrelated writes read as success. Observed in production 2026-08-01: a
+     * session logged 157 consecutive `attachment` lines and NOT ONE `user` line, yet
+     * submitTurn returned on the first attempt. The prompt stayed unsent in the TUI composer,
+     * paseo set turnInFlight and waited on a turn that had never begun, and the agent showed
+     * a spinner until the liveness backstop fired ten minutes later. The retry loop below was
+     * always right; the thing it was checking was not.
      */
+    /**
+     * Dismiss the post-interrupt modal if the terminal is showing one. ESC is only sent on a
+     * recent sighting: on an idle prompt it is harmless, but on a live turn it would interrupt
+     * real work, so a stale marker must never trigger it.
+     */
+    private clearInterruptPrompt;
     private submitTurn;
+    /**
+     * True once a real `user` line has been appended past `offset`. Reads only the bytes
+     * added since then, so it stays cheap on a transcript that can reach tens of MB.
+     * `isMeta` user lines are claude's own bookkeeping and do not mean a turn started.
+     */
+    private sawUserLineSince;
     private transcriptSize;
     private onTranscriptMessage;
     private scheduleTurnEndCheck;
@@ -68,16 +122,44 @@ export declare class PtyQuery implements AsyncGenerator<SDKMessage, void> {
      * the reader as a fresh turn.
      */
     private onTurnStalled;
-    private buildResult;
     /**
-     * A non-success `result` for a stalled turn. agent.ts's `appendResultEvents()` turns any
-     * `subtype !== "success"` into a `turn_failed` carrying `errors.join("\n")`, which is what
-     * puts a real message in front of the user.
+     * Append terminal output to the rolling tail.
+     *
+     * Scrubbed and filtered on the way IN, not on the way out, because the TUI's spinner
+     * redraws at a few hundred bytes/second: a raw buffer holds only a second or two of
+     * history and would evict the one line worth reading. Keeping only lines that carry
+     * letters or digits means a message like "Compacting conversation…" survives minutes of
+     * animation. Verified against a real stall: the raw tail was 163 chars of pure spinner.
+     */
+    /**
+     * True when the rolling tail's last frame looks like an input box waiting for typing.
      *
-     * Wording matters: `isAbortError()` suppresses results whose errors match /\baborted\b/i,
-     * and `buildTurnFailedEvent()` scrapes /\bcode\s+(\d+)\b/i for an exit code. Avoid both so
-     * this neither gets swallowed nor reports a phantom exit code.
+     * Deliberately requires the busy marker to be ABSENT rather than trusting the prompt
+     * markers alone: the working footer renders as `… · esc to interrupt · ← for agents`, so
+     * "for agents" on its own is present in both states and would read a mid-turn terminal
+     * as idle.
      */
+    private looksIdle;
+    private appendTerminalTail;
+    /** Open `$PASEO_HOME/pty-recordings/<sessionId>.log`. Best-effort: never fail a session. */
+    private openRecording;
+    private recordLine;
+    private safeSize;
+    /**
+     * While a turn is outstanding, emit one line every {@link LIVENESS_HEARTBEAT_MS} with
+     * enough state to tell the failure modes apart without waiting for the stall budget:
+     * terminal bytes since the last beat (0 means the TUI is frozen, not thinking), seconds
+     * since the transcript last grew, and the last meaningful line on screen.
+     */
+    private startHeartbeat;
+    private stopHeartbeat;
+    private beat;
+    /**
+     * The tail as readable text: ANSI/OSC sequences dropped and runs of whitespace collapsed,
+     * because a raw TUI capture is mostly cursor movement and redraw padding.
+     */
+    private readTerminalTail;
+    private buildResult;
     private buildStalledResult;
     interrupt(): Promise<void>;
     setPermissionMode(): Promise<void>;