@songsid/agend 2.1.6-beta.7 → 2.1.6-beta.9

package/dist/daemon.js

@@ -896,6 +896,11 @@ export class Daemon extends EventEmitter {
     /** Identity of that dialog: its pattern, not its description (two tables may describe one screen differently). */
     dialogParkedKey = null;
     dialogParkedReported = false;
+    /** Current stdin-owning runtime dialog, independent from execution state. */
+    inputBlockedDialogKey = null;
+    /** Generation/signature fence for safety dialogs while their screen is still visible. */
+    autoResolvedDialogKey = null;
+    autoResolvedDialogGeneration = 0;
     backgroundSessionRecoveryAttempted = false;
     /** Whether the last spawn started a fresh session (not resumed). */
     isNewSession = false;
@@ -2186,6 +2191,7 @@ export class Daemon extends EventEmitter {
                 if (!alive)
                     return;
                 const pane = await this.tmux.capturePane();
+                const inputBlockedDialog = this.updateInputBlockedState(pane, dialogs);
                 const interactivePrompt = this.interactivePromptDetector.observe(pane, Date.now(), this.instanceStateLastOutputAt);
                 if (interactivePrompt) {
                     this.logger.warn(interactivePrompt, "Interactive terminal prompt is waiting for human input");
@@ -2202,7 +2208,7 @@ export class Daemon extends EventEmitter {
                 const hasPendingWork = this.pendingWork.hasPendingWork();
                 if (!hasPendingWork)
                     this.blockingProcessDetector.reset();
-                const blockingProcess = hasPendingWork
+                const blockingProcess = hasPendingWork && !inputBlockedDialog
                     ? this.blockingProcessDetector.observe(pane, paneActivity, Date.now())
                     : null;
                 if (blockingProcess) {
@@ -2224,27 +2230,80 @@ export class Daemon extends EventEmitter {
                         blockingSeen = dialog;
                     if (dialog.holdOnly)
                         break; // recognised, deliberately not answered; trackDialogParked reports it
+                    const autoKey = dialog.autoResolutionKey;
+                    if (dialog.verifyAfterKeys && autoKey
+                        && this.autoResolvedDialogGeneration === this.spawnGeneration
+                        && this.autoResolvedDialogKey === autoKey) {
+                        // A previous poll sent the safety choice but the CLI has not
+                        // repainted yet. Never send another Enter into the same screen.
+                        continue;
+                    }
                     // These keys go straight into the pane. Sent while a message delivery is
                     // mid-transaction, an `Escape` wipes the pasted text and an `Enter`
                     // submits it half-composed — the user sees a message that vanished. Skip
                     // (not queue) when the pane is busy: this poller runs every 5s, and the
                     // dialog will still be on screen next tick.
+                    let resolved = false;
                     const dismissed = await this.paneWriteLock.tryRun(async () => {
+                        // Re-read under the lock: the first capture may have gone stale
+                        // while a delivery was finishing. A stale danger menu must never
+                        // receive a blind key sequence.
+                        const currentPane = await this.tmux.capturePane();
+                        if (!Daemon.dialogMatches(dialog, currentPane)) {
+                            this.updateInputBlockedState(currentPane, dialogs);
+                            return;
+                        }
+                        if (dialog.verifyAfterKeys && autoKey
+                            && this.autoResolvedDialogGeneration === this.spawnGeneration
+                            && this.autoResolvedDialogKey === autoKey)
+                            return;
+                        if (dialog.verifyAfterKeys && autoKey) {
+                            this.autoResolvedDialogGeneration = this.spawnGeneration;
+                            this.autoResolvedDialogKey = autoKey;
+                        }
                         this.logger.info(`Auto-dismissing runtime dialog: ${dialog.description}`);
                         const SPECIAL_KEYS = new Set(["Up", "Down", "Enter", "Escape", "Right", "Left"]);
                         for (const key of dialog.keys) {
+                            let sent = false;
                             if (SPECIAL_KEYS.has(key)) {
-                                await this.tmux.sendSpecialKey(key);
+                                sent = await this.tmux.sendSpecialKey(key);
                             }
                             else {
-                                await this.tmux.pasteText(key, this.systemPasteOptions());
+                                sent = await this.tmux.pasteText(key, this.systemPasteOptions());
+                            }
+                            if (!sent) {
+                                if (dialog.verifyAfterKeys && autoKey) {
+                                    this.autoResolvedDialogGeneration = 0;
+                                    this.autoResolvedDialogKey = null;
+                                }
+                                return;
                             }
                             await new Promise(r => setTimeout(r, 200));
                         }
+                        if (dialog.verifyAfterKeys) {
+                            const afterKeysPane = await this.tmux.capturePane();
+                            const dialogStillActive = dialog.inputBlocked
+                                ? dialogs.some(candidate => candidate.inputBlocked && Daemon.dialogMatches(candidate, afterKeysPane))
+                                : Daemon.dialogMatches(dialog, afterKeysPane);
+                            if (dialogStillActive) {
+                                this.logger.warn({ dialog: dialog.description }, "Runtime dialog remained after its safety choice");
+                                return;
+                            }
+                            this.updateInputBlockedState(afterKeysPane, dialogs);
+                            if (dialog.postDismissNotice) {
+                                resolved = await this.submitSystemPaste(dialog.postDismissNotice.text, dialog.postDismissNotice.label);
+                            }
+                            else {
+                                resolved = true;
+                            }
+                        }
                     });
                     if (!dismissed) {
                         this.logger.info({ dialog: dialog.description }, "Dialog dismissal deferred — pane write in flight");
                     }
+                    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);
                     return; // Dialog handled (or deliberately deferred): skip error checks this cycle
                 }
@@ -2842,6 +2901,15 @@ export class Daemon extends EventEmitter {
     }
     applyInstanceStateSnapshot(snapshot, pane) {
         const previous = this.instanceState;
+        // A live safety menu owns stdin.  It may still contain Claude's persistent
+        // `❯` ready marker, but that is not an idle turn and must not clear pending
+        // work, retire Cancel, arm auto-pause, or enter the generic stuck path.
+        // Keep the public execution state unchanged until the menu disappears; the
+        // dedicated input_blocked event carries the reason to observers.
+        if (this.inputBlockedDialogKey !== null) {
+            this.logger.debug({ dialog: this.inputBlockedDialogKey }, "Suppressing execution-state edge while CLI input is blocked by a dialog");
+            return;
+        }
         this.instanceState = snapshot.state;
         // OpenCode creates its session lazily on the first submitted message.
         // Waiting until stop/pause to persist that id loses resume state when the
@@ -3315,6 +3383,7 @@ export class Daemon extends EventEmitter {
         const captureStartedAt = Date.now();
         try {
             const pane = await this.tmux.capturePane();
+            this.updateInputBlockedState(pane);
             // Output received while capture-pane was in flight makes this snapshot
             // stale. Its output handler has already armed a new debounce.
             const outputMovedDuringCapture = (expectedOutputAt > 0 && this.instanceStateLastOutputAt > expectedOutputAt)
@@ -3551,6 +3620,10 @@ export class Daemon extends EventEmitter {
         this.instanceStateSafetyListener = null;
     }
     handleStuckTransition(pane, snapshot, readyPattern) {
+        if (this.inputBlockedDialogKey !== null) {
+            this.logger.debug({ dialog: this.inputBlockedDialogKey }, "Suppressing stuck notification while CLI input is blocked by a dialog");
+            return;
+        }
         const deterministicReadyPattern = new RegExp(readyPattern.source, readyPattern.flags.replace(/[gy]/g, ""));
         const diagnostic = {
             backend: this.backend?.binaryName ?? this.config.backend ?? "unknown",
@@ -4388,8 +4461,33 @@ export class Daemon extends EventEmitter {
     }
     /** A dialog counts only when it is the CURRENT interactive region, if the backend can tell; else by pattern. */
     static dialogMatches(dialog, pane) {
+        dialog.pattern.lastIndex = 0;
         return dialog.isActive ? dialog.isActive(pane) : dialog.pattern.test(pane);
     }
+    /** Refresh the separate stdin-blocked observation from one pane capture. */
+    updateInputBlockedState(pane, dialogs = this.backend?.getRuntimeDialogs?.() ?? []) {
+        const active = dialogs.find(dialog => dialog.inputBlocked && Daemon.dialogMatches(dialog, pane)) ?? null;
+        const nextKey = active ? Daemon.dialogKey(active) : null;
+        if (nextKey !== this.inputBlockedDialogKey) {
+            this.inputBlockedDialogKey = nextKey;
+            this.emit("input_blocked", {
+                name: this.name,
+                blocked: active !== null,
+                description: active?.description,
+            });
+        }
+        if (!active && this.autoResolvedDialogGeneration === this.spawnGeneration) {
+            // The old screen is gone.  A later dangerous command in the same spawn
+            // must get its own one-shot answer.
+            this.autoResolvedDialogKey = null;
+            this.autoResolvedDialogGeneration = 0;
+        }
+        return active;
+    }
+    /** Whether a runtime prompt currently owns the pane's stdin. */
+    isInputBlocked() {
+        return this.inputBlockedDialogKey !== null;
+    }
     /**
      * Tri-state liveness. tmux's own isWindowAlive folds every query failure
      * into `false`, so a transient tmux hiccup would read as "the CLI died" —