@songsid/agend 2.3.4-beta.2 → 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();
@@ -9563,17 +9583,133 @@ export class Daemon extends EventEmitter {
      * precisely so the lock's scope is visible at the call site rather than being
      * an invariant maintained by comments.
      */
-    async sendDeliveryEnter(phase, stillCurrent, durableAttempt) {
+    async sendDeliveryEnter(phase, stillCurrent, durableAttempt, onInputHeld) {
         if (!(await this.waitForInputTransientToClear(phase)))
             return false;
-        return this.sendDeliveryEnterAfterAvailability(phase, stillCurrent, durableAttempt);
+        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) {
+    async sendDeliveryEnterAfterAvailability(phase, stillCurrent, durableAttempt, onInputHeld) {
         // A recovery Enter may have waited for a transient while cancel or spawn
         // replaced the delivery. Check at the last point before the tmux write.
-        if (this.deliveryWritesStopping || (stillCurrent && !stillCurrent()))
+        const tmux = this.tmux;
+        const backend = this.backend;
+        const generation = this.spawnGeneration;
+        const fence = this.launchFenceEpoch;
+        const windowId = tmux?.getWindowId();
+        const current = () => !!tmux && !!windowId && this.tmux === tmux && this.backend === backend
+            && this.spawnGeneration === generation && this.launchFenceEpoch === fence && tmux.getWindowId() === windowId
+            && !this.deliveryWritesStopping && (!stillCurrent || stillCurrent());
+        if (!current())
+            return false;
+        // A paste-settle wait or retry can outlive the composer it saw. Passive startup-transient checks do not prove
+        // that a permission card has not replaced it. Read this exact pane again, without resolving any dialog.
+        const hold = () => {
+            onInputHeld?.();
+            this.logger.warn({ phase }, "Delivery input is not a verified composer; Enter withheld");
             return false;
+        };
+        // 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();
+            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;
+        }
         // 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.
@@ -9581,7 +9717,7 @@ export class Daemon extends EventEmitter {
             this.logger.error({ phase, deliveryId: durableAttempt.deliveryId }, "Could not commit durable Enter write-ahead fence");
             return false;
         }
-        const sent = await this.tmux.sendSpecialKey("Enter");
+        const sent = await tmux.sendSpecialKey("Enter");
         if (!sent) {
             this.logger.error({
                 phase,
@@ -9641,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),
@@ -9737,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);
@@ -9825,15 +9981,22 @@ export class Daemon extends EventEmitter {
             let enterAt = Date.now();
             const enterMono = performance.now();
             const steerEnterCurrent = () => steerCurrent() && performance.now() <= steerEnterDeadline;
-            if (!(await this.sendDeliveryEnter("initial-submit", steerComposerProof ? steerEnterCurrent : undefined, durableAttempt))) {
-                if (steerComposerProof && !steerCurrent()) {
+            let inputHeld = false;
+            if (!(await this.sendDeliveryEnter("initial-submit", steerEnterCurrent, durableAttempt, () => { inputHeld = true; }))) {
+                if (inputHeld) {
+                    // The paste may still be in the CLI. Keep the existing uncertain path; no false failure or blind replay.
+                    verdict.phase = "submit-enter";
+                    verdict.proof = "input-not-verified";
+                    return false;
+                }
+                if (!steerCurrent()) {
                     verdict.phase = "submit-enter";
                     verdict.proof = "fenced-before-enter";
                     return false;
                 }
                 if (steerComposerProof && performance.now() > steerEnterDeadline)
                     return this.failDelivery(verdict, status, "submit-enter", "pre-enter-deadline");
-                return this.failDelivery(verdict, status, "submit-enter", "tmux-send-keys-failed");
+                return this.failDelivery(verdict, status, "submit-enter", "enter-not-sent");
             }
             // The proof's whole budget, from the Enter: every capture and dialog probe inside it, a late answer dropped.
             const steerProofDeadline = performance.now() + NATIVE_QUEUE_PASTE_VERIFY_MS + POST_ENTER_PROOF_WINDOW_MS;
@@ -9855,7 +10018,7 @@ export class Daemon extends EventEmitter {
             if (!rawPaste && !steerComposerProof && this.backend?.requiresDeliveryEnterRetry?.() === true) {
                 await new Promise(r => setTimeout(r, 1_000));
                 const retryAt = Date.now();
-                if (await this.sendDeliveryEnter("queue-less-defensive-retry")) {
+                if (await this.sendDeliveryEnter("queue-less-defensive-retry", steerCurrent)) {
                     enterAt = retryAt;
                     enterRetry = true;
                     this.logger.debug("Sent defensive Enter retry (queue-less TUI can swallow the first)");
@@ -9986,7 +10149,7 @@ export class Daemon extends EventEmitter {
                     // again. The prompt is back now, so an Enter can land.
                     this.logger.warn("Message still in the input row after idle — submitting the existing text instead of pasting it again");
                     const strandedAt = Date.now();
-                    if (!(await this.sendDeliveryEnter("native-queue-stranded-submit"))) {
+                    if (!(await this.sendDeliveryEnter("native-queue-stranded-submit", steerCurrent))) {
                         return this.failDelivery(verdict, status, "native-queue-submit", "tmux-send-keys-failed");
                     }
                     // The recovery Enter can be accepted before Codex paints its new
@@ -10039,7 +10202,7 @@ export class Daemon extends EventEmitter {
                 }
                 await new Promise(r => setTimeout(r, NORMAL_ENTER_SETTLE_MS));
                 const retryAt = Date.now();
-                if (!(await this.sendDeliveryEnter("native-queue-idle-redelivery"))) {
+                if (!(await this.sendDeliveryEnter("native-queue-idle-redelivery", steerCurrent))) {
                     return this.failDelivery(verdict, status, "native-queue-redelivery", "tmux-send-keys-failed");
                 }
                 if (windowId && this.controlClient) {
@@ -10091,7 +10254,7 @@ export class Daemon extends EventEmitter {
                     this.logger.warn("Message not submitted after Enter — waiting for the prompt, then re-sending Enter once");
                     const promptBack = await this.waitForPaneReadyForDelivery(windowId, STRANDED_RETRY_READY_WAIT_MS);
                     const retryAt = Date.now();
-                    if (promptBack && !(await this.sendDeliveryEnter("stranded-text-retry"))) {
+                    if (promptBack && !(await this.sendDeliveryEnter("stranded-text-retry", steerCurrent))) {
                         return this.failDelivery(verdict, status, "stranded-text-retry", "tmux-send-keys-failed");
                     }
                     submitted = promptBack && await this.confirmSubmittedAfterEnter(windowId, retryAt, formatted);
@@ -10179,7 +10342,7 @@ export class Daemon extends EventEmitter {
                 }
                 // No control client to observe output: fall back to the legacy double-Enter.
                 await new Promise(r => setTimeout(r, 1000));
-                await this.sendDeliveryEnter("unobserved-defensive-retry");
+                await this.sendDeliveryEnter("unobserved-defensive-retry", steerCurrent);
                 if (status)
                     this.emit("message_confirmed", status); // ✅ (best-effort)
             }
@@ -10647,20 +10810,27 @@ export class Daemon extends EventEmitter {
      * `guard` is for a paste that must not outlive the reason it was made (the continue nudge): `accept` judges the ONE
      * capture taken here — the same picture is the baseline, the expected-screen check and the idle check — and `current`
      * is asked again after every await that precedes a write, so a cancelled paste adds no further paste and no key
-     * (the retries included). Without a guard it is exactly the old unconditional path.
+     * (the retries included). Every system paste also keeps the pane owner from before its first await.
      */
     async submitSystemPaste(text, label, guard, admission) {
-        const current = guard || admission ? () => { admission?.(); return guard?.current() ?? true; } : undefined;
-        if (current && !current())
+        const tmux = this.tmux, generation = this.spawnGeneration, fence = this.launchFenceEpoch;
+        const windowId = tmux?.getWindowId();
+        const current = () => {
+            admission?.();
+            return !!tmux && !!windowId && this.tmux === tmux && tmux.getWindowId() === windowId
+                && this.spawnGeneration === generation && this.launchFenceEpoch === fence
+                && !this.deliveryWritesStopping && (guard?.current() ?? true);
+        };
+        if (!current())
             return false;
-        if (!this.tmux)
+        if (!tmux)
             return false;
         const signature = this.submissionSignature(text);
         let baseline;
         if (guard) {
             let pane;
             try {
-                pane = await this.tmux.capturePane();
+                pane = await tmux.capturePane();
             }
             catch {
                 return false;
@@ -10675,7 +10845,7 @@ export class Daemon extends EventEmitter {
         if (current && !current())
             return false;
         const pasteGeneration = this.spawnGeneration;
-        const pasted = current ? await this.tmux.pasteBuffer(text, { guard: current }) : await this.tmux.pasteBuffer(text);
+        const pasted = current ? await tmux.pasteBuffer(text, { guard: current }) : await tmux.pasteBuffer(text);
         if (!pasted) {
             this.logger.warn({ label }, "System paste failed to reach the pane");
             return false;
@@ -12890,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").
@@ -12920,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;
                         }