@songsid/agend 2.3.4-beta.5 → 2.3.4-beta.7

package/dist/daemon.js

@@ -9624,13 +9624,19 @@ export class Daemon extends EventEmitter {
     async sendDeliveryEnterAfterAvailability(phase, stillCurrent, durableAttempt, onInputHeld) {
         // A recovery Enter may have waited for a transient while cancel or spawn replaced the delivery: check here, and
         // again after every wait below, at the last point before the tmux write.
+        // M-2290 (#2985 review, Fable): the mode wait can last up to 10 minutes, and a respawn or relaunch reuses the same
+        // tmux object and window — so the spawn generation and launch fence are part of the fence too: an Enter meant for
+        // the CLI this paste went to is never sent to its successor.
         const tmux = this.tmux;
-        const current = () => this.tmux === tmux && !this.deliveryWritesStopping && (!stillCurrent || stillCurrent());
+        const generation = this.spawnGeneration;
+        const fence = this.launchFenceEpoch;
+        const current = () => this.tmux === tmux && this.spawnGeneration === generation && this.launchFenceEpoch === fence
+            && !this.deliveryWritesStopping && (!stillCurrent || stillCurrent());
         if (!current())
             return false;
         // The pasted text may still be in the box: the caller keeps it uncertain (no false failure, no second paste).
         const hold = () => {
-            onInputHeld?.();
+            onInputHeld?.("pane-in-mode");
             this.logger.warn({ phase }, "The pane stayed in a tmux mode; Enter withheld");
             return false;
         };
@@ -9659,6 +9665,37 @@ export class Daemon extends EventEmitter {
                 return false;
             break;
         }
+        // M-2290 (the simple half of the #2957 redesign, leader xmsg-1793712561468): a dialog the backend RECOGNISES
+        // (runtimeDialogs: a permission card, the dangerous-command card, …) that painted between the paste and this Enter
+        // would take the key as its answer. Read the pane once more: such a dialog withholds the Enter, the caller keeps the
+        // delivery uncertain (Needs-you), and the dialog scanner parks the dialog for a person. Nothing else is judged here
+        // — an unknown or unreadable screen sends, exactly as before: #2958's composer proof (decision f57474aa) is NOT back.
+        // Only a caller that can hold (onInputHeld: the delivery's initial submit, settled uncertain → Needs-you) asks: one
+        // that cannot would read `false` as a failure and paste again. Only the backend's OWN dialogs count — not AgEnD's
+        // unrecognised-prompt guess — so an unknown screen still sends.
+        if (onInputHeld) {
+            let finalPane = null;
+            try {
+                finalPane = await tmux.capturePane();
+            }
+            catch {
+                finalPane = null;
+            }
+            if (!current())
+                return false;
+            let dialog;
+            try {
+                dialog = finalPane === null ? undefined : (this.backend?.getRuntimeDialogs?.() ?? []).find(d => Daemon.dialogMatches(d, finalPane))?.description;
+            }
+            catch {
+                dialog = undefined;
+            }
+            if (dialog !== undefined) {
+                onInputHeld?.("dialog");
+                this.logger.warn({ phase, dialog }, "A dialog is on the pane; the delivery's Enter is withheld (it would answer it)");
+                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.
@@ -9930,12 +9967,13 @@ export class Daemon extends EventEmitter {
             let enterAt = Date.now();
             const enterMono = performance.now();
             const steerEnterCurrent = () => steerCurrent() && performance.now() <= steerEnterDeadline;
-            let inputHeld = false;
-            if (!(await this.sendDeliveryEnter("initial-submit", steerComposerProof ? steerEnterCurrent : undefined, durableAttempt, () => { inputHeld = true; }))) {
+            let inputHeld = null;
+            if (!(await this.sendDeliveryEnter("initial-submit", steerComposerProof ? steerEnterCurrent : undefined, durableAttempt, (why) => { inputHeld = why; }))) {
                 if (inputHeld) {
-                    // #2971: held in a tmux mode past the bound. The paste may still be in the CLI: keep it uncertain, never re-paste.
+                    // #2971: held in a tmux mode past the bound; M-2290: a recognised dialog on the pane. The paste may still be in
+                    // the CLI: keep it uncertain (Needs-you), never re-paste, never answer the dialog.
                     verdict.phase = "submit-enter";
-                    verdict.proof = "pane-in-mode-held";
+                    verdict.proof = inputHeld === "dialog" ? "dialog-on-pane" : "pane-in-mode-held";
                     return false;
                 }
                 if (steerComposerProof && !steerCurrent()) {
@@ -10077,8 +10115,10 @@ export class Daemon extends EventEmitter {
                 // confirmation ladder. "stranded" is the case that used to be a silent
                 // ✅ — the text was visible, so the old check called it delivered.
                 this.logger.warn({ proof }, "Native-queue paste not confirmed as submitted — retrying via idle-gated delivery");
-                if (windowId && this.controlClient) {
-                    await this.controlClient.waitUntilIdle(windowId);
+                if (windowId && this.controlClient && !(await this.controlClient.waitUntilIdle(windowId))) {
+                    verdict.phase = "native-queue-idle-wait";
+                    verdict.proof = "idle-wait-failed";
+                    return false;
                 }
                 // Re-read before doing anything: the CLI had a whole turn to flush its
                 // queue while we waited, and the right recovery differs per outcome.