@hyperdrive.bot/paseo-server 0.3.15 → 0.3.18

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

@@ -60,6 +60,16 @@ export declare class PtyQuery implements AsyncGenerator<SDKMessage, void> {
     private lastBusyAt;
     /** Last sighting of the large-session resume dialog. 0 = never seen. */
     private resumeDialogAt;
+    /** Set when the CLI rejected the just-submitted command; carries the CLI's own reply. */
+    private rejectedCommandNotice;
+    /**
+     * Raw capture window for echo verification. The rolling tail deliberately drops lines
+     * with fewer than three letters as spinner noise, which also swallows the echo of a
+     * short message: "> go" never reaches the tail, so verifying against the tail held a
+     * two-letter message forever. While this is non-null, appendTerminalTail mirrors every
+     * stripped chunk here unfiltered.
+     */
+    private echoProbe;
     private interruptPromptAt;
     constructor(opts: PtyQueryOptions);
     private emit;
@@ -77,6 +87,8 @@ export declare class PtyQuery implements AsyncGenerator<SDKMessage, void> {
      * resend. Shaped as a normal result so it renders in the timeline rather than being
      * buried in the daemon log.
      */
+    /** The CLI refused the command; relay its own reply so the sender can correct and resend. */
+    private buildCommandRejectedResult;
     private buildSubmitFailedResult;
     /**
      * Press Enter to submit the composed prompt, and CONFIRM the turn actually started by
@@ -110,6 +122,16 @@ export declare class PtyQuery implements AsyncGenerator<SDKMessage, void> {
      * Down+Enter is at best a wasted keystroke and at worst an answer to a different menu.
      */
     private answerResumeDialog;
+    /**
+     * Type the prompt and confirm the terminal actually received it, retrying against a
+     * deaf terminal with backoff.
+     *
+     * Returns true once an echo (or a transcript user line) confirms the keystrokes landed;
+     * false only after the terminal stayed deaf for the whole {@link READY_BUSY_MAX_WAIT_MS}
+     * ceiling. Retyping cannot double-deliver: a deaf terminal demonstrably discards input
+     * (zero echo), and every iteration first checks whether a user line landed anyway.
+     */
+    private typeWithEchoVerify;
     private submitTurn;
     /**
      * True once a real `user` line has been appended past `offset`. Reads only the bytes

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

@@ -73,6 +73,31 @@ const TURN_END_IDLE_MS = 700;
  * run it twice.
  */
 const SLASH_COMMAND_ECHO_WAIT_MS = 3000;
+/**
+ * Echo-verified delivery.
+ *
+ * A claude TUI that is still parsing a large resumed transcript PAINTS its idle footer
+ * before its input loop is live, and in that state it DISCARDS keystrokes: typing produces
+ * no echo at all. Observed 2026-08-03 on a 215MB session: attach at 13:03:00, idle footer
+ * by 13:03:04, prompt typed plus five Enters, zero echo in the recording, no user line,
+ * message lost -- while every successful delivery in the same recordings shows the typed
+ * text echoed back. Echo is therefore the one signal that distinguishes "idle" from
+ * "idle-looking but deaf", and its absence also proves the keystrokes were discarded,
+ * which is exactly what makes retyping safe rather than a duplication risk.
+ */
+const ECHO_VERIFY_WINDOW_MS = 1500;
+/**
+ * How much of the typed text must be found in the terminal output for it to count as an
+ * echo. Byte-counting was not enough: a freshly spawned claude under load keeps painting
+ * boot output (splash, MCP connects) after the readiness gate settles, and those bytes
+ * passed the old any-bytes check while the input loop was still dead -- three scheduled
+ * spawns failed that way in five minutes on a loaded box, 2026-08-03. Boot output never
+ * contains the user's message; a real input-box echo always does.
+ */
+const ECHO_TEXT_FRAGMENT_CHARS = 24;
+/** Backoff between retype attempts against a deaf terminal. */
+const DEAF_RETRY_INITIAL_MS = 5000;
+const DEAF_RETRY_MAX_MS = 60000;
 const TERMINAL_STOP_REASONS = new Set(["end_turn", "stop_sequence", "max_tokens"]);
 /**
  * Liveness backstop: how long an in-flight turn may append NOTHING to the transcript
@@ -218,6 +243,16 @@ export class PtyQuery {
         this.lastBusyAt = 0;
         /** Last sighting of the large-session resume dialog. 0 = never seen. */
         this.resumeDialogAt = 0;
+        /** Set when the CLI rejected the just-submitted command; carries the CLI's own reply. */
+        this.rejectedCommandNotice = null;
+        /**
+         * Raw capture window for echo verification. The rolling tail deliberately drops lines
+         * with fewer than three letters as spinner noise, which also swallows the echo of a
+         * short message: "> go" never reaches the tail, so verifying against the tail held a
+         * two-letter message forever. While this is non-null, appendTerminalTail mirrors every
+         * stripped chunk here unfiltered.
+         */
+        this.echoProbe = null;
         this.interruptPromptAt = 0;
         this.transport = opts.transport;
         this.input = opts.input;
@@ -417,11 +452,32 @@ export class PtyQuery {
                 // consumed by it, so recovering at submit time is already too late.
                 await this.answerResumeDialog();
                 await this.clearInterruptPrompt();
-                await this.transport.write(text);
-                await delay(200);
+                // Deliberately NOT normalized (e.g. lowercasing an auto-capitalized command
+                // token): paseo must never silently rewrite what the user typed. A wrong command is
+                // handled by relaying the CLI's own rejection -- including its "did you mean"
+                // suggestion -- back to the sender, which corrects every rejection cause honestly
+                // instead of hiding one narrow cause invisibly.
+                const typed = await this.typeWithEchoVerify(text);
+                if (this.done)
+                    break;
+                if (!typed) {
+                    // The terminal stayed deaf for the whole ceiling: keystrokes discarded, nothing
+                    // delivered, and only the sender can decide what to do next.
+                    this.recordLine("--- terminal deaf for the whole budget; message not delivered ---");
+                    this.emit(this.buildSubmitFailedResult());
+                    continue;
+                }
                 const started = await this.submitTurn(text);
                 if (!started && this.done)
                     break;
+                if (!started && this.rejectedCommandNotice) {
+                    // Not lost, refused: hand the CLI's own answer (which includes its "did you
+                    // mean" suggestion) to the sender instead of a phantom running turn.
+                    const notice = this.rejectedCommandNotice;
+                    this.rejectedCommandNotice = null;
+                    this.emit(this.buildCommandRejectedResult(notice));
+                    continue;
+                }
                 if (!started && !this.looksIdle()) {
                     // NOT a lost message. The TUI accepts keystrokes into a queue while a turn is
                     // running and only writes the user line when that turn ends, which can be far
@@ -460,6 +516,16 @@ export class PtyQuery {
      * resend. Shaped as a normal result so it renders in the timeline rather than being
      * buried in the daemon log.
      */
+    /** The CLI refused the command; relay its own reply so the sender can correct and resend. */
+    buildCommandRejectedResult(notice) {
+        const base = this.buildResult("submit_failed");
+        return {
+            ...base,
+            subtype: "error_during_execution",
+            is_error: true,
+            errors: [`The agent's CLI rejected the command: ${notice} Nothing was run.`],
+        };
+    }
     buildSubmitFailedResult() {
         const base = this.buildResult("submit_failed");
         const excerpt = this.terminalTail.slice(-TERMINAL_TAIL_EXCERPT_CHARS).trim();
@@ -541,6 +607,55 @@ export class PtyQuery {
         await delay(500);
         this.resumeDialogAt = 0;
     }
+    /**
+     * Type the prompt and confirm the terminal actually received it, retrying against a
+     * deaf terminal with backoff.
+     *
+     * Returns true once an echo (or a transcript user line) confirms the keystrokes landed;
+     * false only after the terminal stayed deaf for the whole {@link READY_BUSY_MAX_WAIT_MS}
+     * ceiling. Retyping cannot double-deliver: a deaf terminal demonstrably discards input
+     * (zero echo), and every iteration first checks whether a user line landed anyway.
+     */
+    async typeWithEchoVerify(text) {
+        const transcriptBefore = this.transcriptSize();
+        const deadline = monotonicNowMs() + READY_BUSY_MAX_WAIT_MS;
+        let backoff = DEAF_RETRY_INITIAL_MS;
+        let attempt = 0;
+        while (!this.done && monotonicNowMs() < deadline) {
+            attempt += 1;
+            // The needle is whitespace-stripped on both sides: the TUI wraps and re-spaces the
+            // echoed text freely (recordings show "Replywithexactly:PROBE_OK"), so only the
+            // character sequence survives rendering, never the spacing. Verified against a RAW
+            // probe buffer, never the rolling tail: the tail's noise filter drops lines with
+            // fewer than three letters, which swallowed the echo of a short message outright.
+            const needle = text.replace(/\s+/g, "").slice(0, ECHO_TEXT_FRAGMENT_CHARS);
+            this.echoProbe = { buf: "" };
+            let echoed = false;
+            try {
+                await this.transport.write(text);
+                const probe = this.echoProbe;
+                echoed = await pollUntil(() => (needle ? probe.buf.includes(needle) : probe.buf.length > 0), ECHO_VERIFY_WINDOW_MS, 100);
+            }
+            finally {
+                this.echoProbe = null;
+            }
+            if (echoed) {
+                if (attempt > 1) {
+                    this.recordLine(`--- terminal came back after ${attempt - 1} deaf attempt(s); prompt delivered ---`);
+                }
+                await delay(200);
+                return true;
+            }
+            // Deaf. The keystrokes were discarded (no echo), so waiting and retyping is safe.
+            if (this.sawUserLineSince(transcriptBefore))
+                return true;
+            this.logger.warn({ sessionId: this.sessionId, attempt, nextRetryMs: backoff }, "PtyQuery: terminal painted but is not accepting input yet; holding the prompt");
+            this.recordLine(`--- terminal deaf (attempt ${attempt}); retrying in ${Math.round(backoff / 1000)}s ---`);
+            await delay(backoff);
+            backoff = Math.min(backoff * 2, DEAF_RETRY_MAX_MS);
+        }
+        return false;
+    }
     async submitTurn(text) {
         const before = this.transcriptSize();
         // A slash command gets EXACTLY ONE Enter. Never retry it.
@@ -567,6 +682,21 @@ export class PtyQuery {
             const bytesBefore = this.ptyBytesTotal;
             await this.transport.writeRaw?.("\r");
             const reacted = await pollUntil(() => this.sawUserLineSince(before) || this.ptyBytesTotal > bytesBefore, SLASH_COMMAND_ECHO_WAIT_MS, 150);
+            // The terminal responding is not the same as the command running. An unknown command
+            // is answered with `Unknown command: /X. Did you mean /y?` and NOTHING starts -- but
+            // that reply previously counted as acceptance, so the app showed a running turn that
+            // did not exist and the sender saw dead silence. Observed live: a phone-keyboard
+            // auto-capitalized "/WhatsApp-read" rejected twice while the UI said "working".
+            // Checked regardless of the byte-poll outcome: the rejection can repaint before the
+            // poll's baseline is captured, in which case `reacted` is false but the refusal is
+            // already sitting in the tail.
+            await delay(400);
+            const m = this.terminalTail.slice(-500).match(/Unknown command:[^\n]{0,160}/i);
+            if (m) {
+                this.rejectedCommandNotice = m[0].trim();
+                this.recordLine(`--- CLI rejected the command: ${this.rejectedCommandNotice} ---`);
+                return false;
+            }
             if (!reacted) {
                 this.logger.warn({ sessionId: this.sessionId, command: text.trim().split(/\s/, 1)[0] }, "PtyQuery: slash command produced no terminal response; not retrying to avoid double execution");
             }
@@ -754,6 +884,9 @@ export class PtyQuery {
         const text = stripTerminalControl(chunk);
         if (!text)
             return;
+        if (this.echoProbe) {
+            this.echoProbe.buf = (this.echoProbe.buf + text.replace(/\s+/g, "")).slice(-2000);
+        }
         // Read the busy marker off the raw stripped text, NOT the filtered tail below:
         // isProgressNoise() drops a line that is only the footer, which is exactly the frame
         // that proves a turn is running.