@songsid/agend 2.3.4-beta.3 → 2.3.4-beta.4

package/dist/daemon.js

@@ -1,3 +1,4 @@
+import { dialogScreenText } from "./dialog-screen-text.js";
 import { readActiveKiroModel } from "./backend/kiro.js";
 import { dashboardAccessOf } from "./dashboard-permissions.js";
 import { sendPackSources } from "./web-office-pack-read.js";
@@ -531,6 +532,9 @@ function countOccurrences(haystack, needle) {
 }
 /** Bottom-ready re-poll cadence for Enter-dropping TUIs once the pane is quiet. */
 const BOTTOM_READY_POLL_MS = 250;
+/** M-2267: how often a pane left in a tmux mode is looked at again, and how long the delivery Enter waits for it to end. */
+const PANE_MODE_POLL_MS = 500;
+const PANE_MODE_ENTER_WAIT_MS = 10 * 60_000;
 /** Consecutive unreadable pane probes tolerated by the delivery gate before the delivery is failed (≈10s at the poll cadence). */
 const DIALOG_PROBE_UNKNOWN_MAX = 40;
 /** Startup dialog scan: poll cadence and wall-clock budget (keys and waits included). */
@@ -3706,7 +3710,9 @@ export class Daemon extends EventEmitter {
                 const interactivePrompt = this.interactivePromptDetector.observe(pane, Date.now(), this.instanceStateLastOutputAt);
                 if (interactivePrompt) {
                     this.logger.warn(interactivePrompt, "Interactive terminal prompt is waiting for human input");
-                    this.emit("interactive_prompt", { name: this.name, ...interactivePrompt });
+                    // M-2269: the prompt as it was on screen, from this capture, for the Log.
+                    const screen = dialogScreenText(pane);
+                    this.emit("interactive_prompt", { name: this.name, ...interactivePrompt, ...(screen ? { screen } : {}) });
                     // A prompt is not an error and must not enter the PTY recovery gate.
                     // Continue scanning real errors in this same snapshot.
                 }
@@ -3901,7 +3907,7 @@ export class Daemon extends EventEmitter {
                     else if (dialog.verifyAfterKeys && !resolved) {
                         this.logger.warn({ dialog: dialog.description }, "Safety dialog choice was sent but follow-up verification or notice submission failed");
                     }
-                    this.trackDialogParked(blockingSeen);
+                    this.trackDialogParked(blockingSeen, pane);
                     return; // Dialog handled (or deliberately deferred): skip error checks this cycle
                 }
                 // Reached only when no dialog was answered this poll (none on screen, a fenced one, or one waiting out its
@@ -3911,7 +3917,7 @@ export class Daemon extends EventEmitter {
                     this.dialogAnswers = null;
                     this.retireParkedNotice("answer");
                 }
-                this.trackDialogParked(blockingSeen);
+                this.trackDialogParked(blockingSeen, pane);
                 this.trackRemoteCard(blockingSeen, pane, captureMono);
                 if (blockingSeen)
                     return; // held dialog: skip error checks this cycle
@@ -7768,6 +7774,9 @@ export class Daemon extends EventEmitter {
                 // The hand-off's last capture had no box: nothing was begun or written — wait for readiness, then try again.
                 if (written === "handoff-box-unread")
                     return "dialog";
+                // M-2267: the pane is in a tmux mode: nothing written — wait for readiness (it holds while the mode lasts), retry.
+                if (written === "pane-in-mode")
+                    return "dialog";
                 // Fenced before its first write: not attempted — redo after a spawn, else drop without a ❌.
                 return written === false && verdict.fenced ? stale() : written;
             });
@@ -8241,7 +8250,7 @@ export class Daemon extends EventEmitter {
                 && this.hasAutoDialogClaim(dialog)
                 && dialogs.some(other => other !== dialog && Daemon.dialogMatches(other, pane)))
                 continue;
-            this.trackDialogParked(dialog);
+            this.trackDialogParked(dialog, pane);
             this.trackRemoteCard(dialog, pane, probeMono);
             return { state: "dialog", dialog };
         }
@@ -8620,7 +8629,8 @@ export class Daemon extends EventEmitter {
         this.parkedNoticeOut = null;
         this.emit("dialog_unparked", { name: this.name });
     }
-    trackDialogParked(dialog) {
+    /** `pane`: the capture the caller already holds — M-2269 keeps the dialog's text from it for the Log (no new capture). */
+    trackDialogParked(dialog, pane = "") {
         if (!dialog) {
             if (this.dialogParkedSince !== 0)
                 this.logger.info({ dialog: this.dialogParkedKey }, "Blocking dialog is gone from the pane");
@@ -8658,7 +8668,9 @@ export class Daemon extends EventEmitter {
             this.dialogParkedReported = true;
             this.parkedNoticeOut = "parked";
             this.logger.warn({ dialog: dialog.description, parkedForMs: Date.now() - this.dialogParkedSince }, "CLI dialog is still on screen — not auto-answering, reporting for a human");
+            const screen = dialogScreenText(pane);
             this.emit("dialog_parked", { name: this.name, description: dialog.description, holdOnly: dialog.holdOnly === true,
+                ...(screen ? { screen } : {}),
                 ...(dialog.parkedAdvice ? { advice: dialog.parkedAdvice } : {}),
                 ...(episode !== null && interaction.kind ? { kind: interaction.kind, episode, backend: this.config.backend ?? "claude-code" } : {}),
                 ...(unrecognised ? { unrecognised: true, question: this.unrecognisedPrompt?.shape.question ?? null } : {}) });
@@ -9018,6 +9030,14 @@ export class Daemon extends EventEmitter {
                 : await this.waitForPaneIdleForDelivery(windowId, remaining);
             if (idle !== true)
                 return idle;
+            // M-2267: a person left the pane in a tmux mode (copy-mode): its keys would go to the mode. Hold — never take the
+            // pane out of it — and look again; the delivery goes once the mode ends (or this wait's own deadline).
+            if (await this.paneInTmuxMode("readiness")) {
+                if (stop && await stop())
+                    return "stopped";
+                await new Promise(r => setTimeout(r, BOTTOM_READY_POLL_MS));
+                continue;
+            }
             // The idle wait just resolved, so re-reading the silence gate would only
             // add a stale-cache race; ask the pane the remaining questions directly.
             const transient = await this.probeInputTransient();
@@ -9568,6 +9588,38 @@ export class Daemon extends EventEmitter {
             return false;
         return this.sendDeliveryEnterAfterAvailability(phase, stillCurrent, durableAttempt, onInputHeld);
     }
+    /**
+     * M-2267 (hmsg-b8a170c0): is the pane in a tmux mode (a person left it in copy-mode)? Logged once per stretch. Unknown
+     * (unreadable) is not a mode: the delivery's own reads decide then, as before.
+     */
+    paneModeSince = 0;
+    async paneInTmuxMode(phase) {
+        const inMode = await this.tmux?.paneInMode?.();
+        if (inMode !== true) {
+            this.paneModeSince = 0;
+            return false;
+        }
+        if (!this.paneModeSince) {
+            this.paneModeSince = performance.now();
+            this.logger.warn({ phase }, "The pane is in a tmux mode (copy-mode) — delivery waits for it to end; no key is sent to it");
+        }
+        return true;
+    }
+    /** M-2267: wait while the pane is in a tmux mode, until `deadline` (PANE_MODE_ENTER_WAIT_MS) — "clear", "stale" (fenced), "held". */
+    async waitWhilePaneInMode(phase, current, deadline = performance.now() + PANE_MODE_ENTER_WAIT_MS) {
+        for (;;) {
+            const inMode = await this.paneInTmuxMode(phase);
+            if (!current())
+                return "stale";
+            if (!inMode)
+                return "clear";
+            if (performance.now() >= deadline)
+                return "held";
+            await new Promise(r => setTimeout(r, PANE_MODE_POLL_MS));
+            if (!current())
+                return "stale";
+        }
+    }
     /** Write half only: callers must finish the availability wait before any final recovery ownership proof. */
     async sendDeliveryEnterAfterAvailability(phase, stillCurrent, durableAttempt, onInputHeld) {
         // A recovery Enter may have waited for a transient while cancel or spawn
@@ -9589,47 +9641,75 @@ export class Daemon extends EventEmitter {
             this.logger.warn({ phase }, "Delivery input is not a verified composer; Enter withheld");
             return false;
         };
-        let pane;
-        try {
-            pane = await tmux.capturePane();
-        }
-        catch {
-            return current() ? hold() : false;
-        }
-        if (!current())
-            return false;
-        let composer = false;
-        try {
-            if (this.runtimeDialogs().some(dialog => Daemon.dialogMatches(dialog, pane)))
+        // M-2267 (#2971 review, Prism P2): a pane in a tmux mode would take this Enter. Wait for the mode to end FIRST, then
+        // prove the composer (and that no dialog took its place) on a capture taken after it — and again whenever the pane
+        // went back into a mode meanwhile: the Enter only ever goes on a proof newer than the last mode. Never ended for the
+        // person, never answering a dialog that appeared during the wait (hold() then, as for any).
+        const modeDeadline = performance.now() + PANE_MODE_ENTER_WAIT_MS;
+        for (;;) {
+            const mode = await this.waitWhilePaneInMode(phase, current, modeDeadline);
+            if (mode === "stale")
+                return false;
+            if (mode === "held")
                 return hold();
-            if (backend?.readInputRow)
-                composer = backend.readInputRow(pane) != null;
-            else if (backend?.inputDraft)
-                composer = backend.inputDraft(pane) != null;
-            else if (backend?.isDeliveryInputReadyPane)
-                composer = this.deliveryInputReadyPane(pane);
-            else if (backend?.readSteerComposer?.(pane) != null)
-                composer = true;
-            else if (backend) {
-                // Legacy backends still need their own current ready chrome, never a menu's cursor or old transcript row.
-                const shape = unrecognisedPromptShape(pane);
-                const ownComposer = backend.isDeliveryComposerPane?.(pane) === true;
-                if ((!selectionCard(pane, "CLI") || ownComposer) && (!shape || ownComposer || this.cliComposerShowing(pane, shape))) {
-                    const bottom = backend.getBottomReadyPattern?.();
-                    const ready = backend.getReadyPattern();
-                    ready.lastIndex = 0;
-                    composer = ownComposer || (bottom ? bottomRowIsReady(pane, bottom)
-                        : ready.test(pane.trimEnd().split("\n").slice(-COMPOSER_TAIL_ROWS).join("\n")));
+            let pane;
+            try {
+                pane = await tmux.capturePane();
+            }
+            catch {
+                return current() ? hold() : false;
+            }
+            if (!current())
+                return false;
+            let composer = false;
+            try {
+                if (this.runtimeDialogs().some(dialog => Daemon.dialogMatches(dialog, pane)))
+                    return hold();
+                if (backend?.readInputRow)
+                    composer = backend.readInputRow(pane) != null;
+                else if (backend?.inputDraft)
+                    composer = backend.inputDraft(pane) != null;
+                else if (backend?.isDeliveryInputReadyPane)
+                    composer = this.deliveryInputReadyPane(pane);
+                else if (backend?.readSteerComposer?.(pane) != null)
+                    composer = true;
+                else if (backend) {
+                    // Legacy backends still need their own current ready chrome, never a menu's cursor or old transcript row.
+                    const shape = unrecognisedPromptShape(pane);
+                    const ownComposer = backend.isDeliveryComposerPane?.(pane) === true;
+                    if ((!selectionCard(pane, "CLI") || ownComposer) && (!shape || ownComposer || this.cliComposerShowing(pane, shape))) {
+                        const bottom = backend.getBottomReadyPattern?.();
+                        const ready = backend.getReadyPattern();
+                        ready.lastIndex = 0;
+                        composer = ownComposer || (bottom ? bottomRowIsReady(pane, bottom)
+                            : ready.test(pane.trimEnd().split("\n").slice(-COMPOSER_TAIL_ROWS).join("\n")));
+                    }
                 }
             }
+            catch {
+                return hold();
+            }
+            if (!composer)
+                return hold();
+            if (!current())
+                return false;
+            // The proof stands only if the pane did not go into a mode while it was made: else wait, and prove again — within
+            // the same deadline (#2971 re-review, Prism P2: a pane flickering in and out of a mode must not hold the write lock
+            // past it), and never spinning: one poll interval before the next look.
+            if (await this.paneInTmuxMode(phase)) {
+                if (!current())
+                    return false;
+                if (performance.now() >= modeDeadline)
+                    return hold();
+                await new Promise(r => setTimeout(r, PANE_MODE_POLL_MS));
+                if (!current())
+                    return false;
+                continue;
+            }
+            if (!current())
+                return false;
+            break;
         }
-        catch {
-            return hold();
-        }
-        if (!composer)
-            return hold();
-        if (!current())
-            return false;
         // W1: persist the "Enter may have happened" boundary before tmux receives
         // the key. A crash after this commit is never auto-replayed without a
         // positive transcript marker, even if the stale pane still shows composer.
@@ -9697,6 +9777,10 @@ export class Daemon extends EventEmitter {
                 verdict.fenced = !verdict.durableBeginCommitted;
                 return false;
             }
+            // M-2267: the pane went into a tmux mode after the readiness wait. Nothing begun or written: the caller waits for
+            // readiness (which holds while it lasts) and tries again — as for a dialog that appeared before the write.
+            if (!verdict.durableBeginCommitted && await this.paneInTmuxMode("paste"))
+                return "pane-in-mode";
             // A hand-off pastes and presses Enter into a busy pane: the box must still be readable on this, the last capture
             // before the write (#1169 review) — a modal that appeared after the under-lock check would take that Enter. Before
             // the durable begin the caller waits for readiness outside the lock and tries again; after it (a paste retry),
@@ -9793,6 +9877,22 @@ export class Daemon extends EventEmitter {
             // failed/throwing write as uncertain rather than retrying bytes into the
             // same pane; the write-ahead Enter marker later separates safe pre-Enter
             // recovery from a possibly executed command.
+            // M-2267 (#2971 review, Prism P2): EVERY paste attempt — a retry after a failed paste, a first paste whose durable
+            // begin already went — asks too. Before the begin: nothing begun, the caller waits for readiness and tries again.
+            // After it: this attempt waits here, keeping its durable attempt; a mode outlasting the wait fails it unwritten.
+            if (!verdict.durableBeginCommitted) {
+                if (await this.paneInTmuxMode("paste"))
+                    return "pane-in-mode";
+            }
+            else {
+                const mode = await this.waitWhilePaneInMode("paste", () => (!stillCurrent || stillCurrent()) && !this.deliveryWritesStopping);
+                if (mode === "stale") {
+                    verdict.fenced = false;
+                    return false;
+                }
+                if (mode === "held")
+                    return this.failDelivery(verdict, status, "paste", "pane-in-tmux-mode");
+            }
             const pasteGeneration = this.spawnGeneration;
             beforePaste?.();
             const pasted = await this.tmux.pasteBuffer(formatted);
@@ -12960,7 +13060,7 @@ export class Daemon extends EventEmitter {
                         // ones included: if the auto-dismiss keeps failing here, the human
                         // report should count from first sight, not from the runtime scan.
                         if (!dialog.fatal && this.deliveryBlockingDialogs().some(d => Daemon.dialogKey(d) === Daemon.dialogKey(dialog))) {
-                            this.trackDialogParked(dialog);
+                            this.trackDialogParked(dialog, pane);
                         }
                         // A fatal startup screen cannot be dismissed by keypresses (e.g. a
                         // corrupt claude.json modal offering only "exit" / "reset config").
@@ -12990,7 +13090,7 @@ export class Daemon extends EventEmitter {
                                     this.heldReasonLoggedKey = Daemon.dialogKey(dialog);
                                 this.logger.warn({ description: dialog.description, ...reason }, "Startup dialog held — not auto-answering, deliveries stay blocked");
                             }
-                            this.trackDialogParked(dialog);
+                            this.trackDialogParked(dialog, pane);
                             matched = true;
                             break;
                         }