@songsid/agend 2.1.7 → 2.1.8-beta.2

package/dist/daemon.js

@@ -979,6 +979,25 @@ export class Daemon extends EventEmitter {
      * after the startup scan can still swallow that message's Enter.
      */
     inputTransientGuardGeneration = null;
+    /**
+     * The spawn whose passive transients are over, independently of the
+     * startup-proof tail above. A transient screen can be quoted verbatim by the
+     * transcript (a cropped quote of the resume screen is byte-identical to the
+     * real one), so the pane alone must not be able to hold input. AgEnD's own
+     * launch state retires the check, per launch attempt: a launch that cannot show one, the real
+     * transient seen and then gone, or a "transient" that never changed for
+     * INPUT_TRANSIENT_STALL_MS. (The first submitted message retires the whole
+     * guard, as before.)
+     */
+    inputTransientRetiredAttempt = null;
+    /** The launch attempt in which a passive transient was actually observed on screen. */
+    inputTransientSeenAttempt = null;
+    /**
+     * One per command actually launched. A spawn can launch more than once
+     * (spawnClaudeWindow retries a failed resume without a new beginSpawn), and
+     * each launch paints its own transient, so retirement is per attempt.
+     */
+    launchAttempt = 0;
     skipResume = false;
     startupAborted = false;
     /** First time the current on-screen blocking dialog was seen (0 = none); drives the parked report. */
@@ -4945,19 +4964,39 @@ export class Daemon extends EventEmitter {
         if (this.inputTransientGuardGeneration === null
             || this.inputTransientGuardGeneration !== this.spawnGeneration)
             return [];
+        if (this.inputTransientRetiredAttempt === this.launchAttempt)
+            return [];
         return this.backend?.getInputUnavailableTransients?.() ?? [];
     }
+    /** Stop honouring passive transients for the current spawn. */
+    retireInputTransients(reason) {
+        if (this.inputTransientRetiredAttempt === this.launchAttempt)
+            return;
+        this.inputTransientRetiredAttempt = this.launchAttempt;
+        this.logger.debug({ reason, generation: this.spawnGeneration, attempt: this.launchAttempt }, "Startup input transient retired for this launch");
+    }
     /** Match a passive transient against the current interactive screen. */
     inputTransientInPane(pane) {
-        for (const transient of this.guardedInputTransients()) {
+        const transients = this.guardedInputTransients();
+        if (transients.length === 0)
+            return null;
+        for (const transient of transients) {
             // `pattern` is only a cheap pre-filter. `isActive` is deliberately the
             // authority because users and agents routinely quote diagnostic text.
             transient.pattern.lastIndex = 0;
             if (!transient.pattern.test(pane))
                 continue;
-            if (transient.isActive(pane))
+            if (transient.isActive(pane)) {
+                this.inputTransientSeenAttempt = this.launchAttempt;
                 return transient;
+            }
         }
+        // The phase is over once it has been seen to end; from then on the same
+        // screen is a quote. A settled-looking pane before that proves nothing:
+        // codex 0.154 painted the prompt and footer first and "Resuming session…"
+        // a moment later — the reason this guard outlives the startup scan.
+        if (this.inputTransientSeenAttempt === this.launchAttempt)
+            this.retireInputTransients("transient ended");
         return null;
     }
     /** Capture failure is unknown, never evidence that input is available. */
@@ -4993,7 +5032,12 @@ export class Daemon extends EventEmitter {
         return budget;
     }
     async probeInputTransient() {
-        if (this.guardedInputTransients().length === 0 || !this.tmux)
+        // A retired transient still leaves the startup guard armed: an unreadable
+        // pane keeps answering "unknown", so it stalls out on the same budget
+        // instead of letting a delivery poll a dark pane for ever.
+        const armed = this.inputTransientGuardGeneration !== null && this.inputTransientGuardGeneration === this.spawnGeneration
+            && (this.backend?.getInputUnavailableTransients?.().length ?? 0) > 0;
+        if (!armed || !this.tmux)
             return { state: "clear" };
         try {
             const pane = await this.tmux.capturePane();
@@ -5001,10 +5045,13 @@ export class Daemon extends EventEmitter {
             // The pane text comes back with the verdict: a transient that is still
             // repainting is still working, and that is the only thing separating a
             // slow resume from a wedged one.
+            if (transient)
+                this.resetFooterFallback();
             return transient ? { state: "active", transient, pane } : { state: "clear" };
         }
         catch (err) {
             this.logger.debug({ err }, "capture-pane failed during the input-transient probe — pane state unknown");
+            this.resetFooterFallback();
             return { state: "unknown" };
         }
     }
@@ -5059,6 +5106,11 @@ export class Daemon extends EventEmitter {
                     stalledForMs: budget.stalled ? INPUT_TRANSIENT_STALL_MS : undefined,
                     ceilingMs: timeoutMs,
                 }, "CLI input stayed unavailable — refusing to send Enter");
+                // A screen that did not change for the whole stall window is not a
+                // load in progress. This delivery still fails, but the same screen
+                // (possibly a quote) must not fail every later one too.
+                if (budget.stalled && observedDescription !== null)
+                    this.retireInputTransients("transient stalled");
                 return false;
             }
             await new Promise(r => setTimeout(r, INPUT_TRANSIENT_POLL_MS));
@@ -5210,14 +5262,78 @@ export class Daemon extends EventEmitter {
             return !check;
         try {
             const mode = await this.tmux.getPaneInputMode?.();
-            if (mode !== "raw")
+            if (mode !== "raw") {
+                this.resetFooterFallback();
                 return false;
-            return check.call(this.backend, await this.tmux.capturePane());
+            }
+            return this.deliveryInputReadyPane(await this.tmux.capturePane());
         }
         catch {
+            this.resetFooterFallback();
             return false;
         }
     }
+    /** Pane text of the current footer-fallback candidate, and since when it has been unchanged. */
+    footerFallbackPaneKey = null;
+    footerFallbackStableSince = 0;
+    /** The launch the candidate was seen in: a new spawn or launch attempt starts over. */
+    footerFallbackEpoch = null;
+    /**
+     * Forget the footer-fallback candidate. Called whenever the pane is seen
+     * outside the candidate state (busy, a dialog, a transient, unreadable) and
+     * on every spawn: "stable for UNKNOWN_LAYOUT_STABLE_MS" must mean this screen,
+     * continuously, not time accumulated across an interruption.
+     */
+    resetFooterFallback() {
+        this.footerFallbackPaneKey = null;
+        this.footerFallbackEpoch = null;
+    }
+    footerFallbackWarnedGeneration = null;
+    /**
+     * The input-row proof used before a paste (#931/#947), with one fallback
+     * (#1031). Codex sometimes paints an idle composer without its Context
+     * status item even though tui.status_line asks for it: after four fleet
+     * restarts, sol's resumed session showed only `⚠ 2 warnings · f2 to view`.
+     * The proof needs a recognised footer, so the first delivery after each
+     * restart waited 30 minutes, failed, and waited again, for seven hours.
+     *
+     * When the footer is the only thing missing, the #978 structural evidence
+     * stands in for it, all of it required: the backend's own stable-unknown
+     * idle check (an empty live composer; no busy row, esc-to-interrupt row,
+     * queued ↳ input or known picker), no input transient such as the resume
+     * load, and the same screen for UNKNOWN_LAYOUT_STABLE_MS. The raw-tty
+     * requirement stays with the caller.
+     */
+    deliveryInputReadyPane(pane) {
+        const check = this.backend?.isDeliveryInputReadyPane;
+        if (!check)
+            return true;
+        if (check.call(this.backend, pane)) {
+            this.footerFallbackPaneKey = null;
+            return true;
+        }
+        const stableUnknown = this.backend?.isStableUnknownLayoutIdlePane;
+        if (!stableUnknown?.call(this.backend, pane) || this.inputTransientInPane(pane)) {
+            this.footerFallbackPaneKey = null;
+            return false;
+        }
+        const key = pane.replace(/⋆/gu, "").replace(/[ \t]+$/gmu, "");
+        const epoch = `${this.spawnGeneration}:${this.launchAttempt}`;
+        const now = Date.now();
+        if (key !== this.footerFallbackPaneKey || epoch !== this.footerFallbackEpoch) {
+            this.footerFallbackPaneKey = key;
+            this.footerFallbackEpoch = epoch;
+            this.footerFallbackStableSince = now;
+            return false;
+        }
+        if (now - this.footerFallbackStableSince < UNKNOWN_LAYOUT_STABLE_MS)
+            return false;
+        if (this.footerFallbackWarnedGeneration !== this.spawnGeneration) {
+            this.footerFallbackWarnedGeneration = this.spawnGeneration;
+            this.logger.warn({ backend: this.backend?.binaryName, stableForMs: now - this.footerFallbackStableSince }, "Idle footer not recognised — delivering on the #978 fallback (stable empty composer, no busy/queued/dialog, raw tty, no transient)");
+        }
+        return true;
+    }
     /**
      * Why a pane is not deliverable matters. "busy" may be handed to a native
      * input queue or steered (after its own dialog probe); "dialog", "transient"
@@ -5226,16 +5342,26 @@ export class Daemon extends EventEmitter {
      * pane proves nothing. The silence gate comes first and costs no capture.
      */
     async paneReadinessForDelivery(windowId) {
-        if (!this.isPaneIdleForDelivery(windowId))
+        // Each early return below is the pane seen outside the footer-fallback
+        // candidate state, and never reaches deliveryInputReadyPane: reset here.
+        if (!this.isPaneIdleForDelivery(windowId)) {
+            this.resetFooterFallback();
             return "busy";
+        }
         const probe = await this.probeBlockingDialog();
-        if (probe.state !== "clear")
+        if (probe.state !== "clear") {
+            this.resetFooterFallback();
             return probe.state;
+        }
         const transient = await this.probeInputTransient();
-        if (transient.state === "active")
+        if (transient.state === "active") {
+            this.resetFooterFallback();
             return "transient";
-        if (transient.state === "unknown")
+        }
+        if (transient.state === "unknown") {
+            this.resetFooterFallback();
             return "unknown";
+        }
         if (this.needsStartupInputProof()) {
             return await this.hasPositiveDeliveryInput() ? "ready" : "transient";
         }
@@ -5306,6 +5432,11 @@ export class Daemon extends EventEmitter {
                         stalledForMs: transientBudget.stalled ? INPUT_TRANSIENT_STALL_MS : undefined,
                         ceilingMs: INPUT_TRANSIENT_WAIT_MS,
                     }, "CLI input stayed unavailable during the delivery-readiness wait");
+                    // Same rule as the pre-Enter wait: a screen frozen for the whole
+                    // stall window is not a load in progress, so it holds this delivery
+                    // only.
+                    if (transientBudget.stalled)
+                        this.retireInputTransients("transient stalled");
                     return false;
                 }
                 await new Promise(r => setTimeout(r, BOTTOM_READY_POLL_MS));
@@ -5407,7 +5538,7 @@ export class Daemon extends EventEmitter {
             return "busy";
         if (this.backend?.getBusyPattern?.()?.test(pane))
             return "busy";
-        if (this.backend?.isDeliveryInputReadyPane && !this.backend.isDeliveryInputReadyPane(pane))
+        if (!this.deliveryInputReadyPane(pane))
             return "busy";
         if (strandedAgendMessageInInput(pane, prompt))
             return "stranded";
@@ -7570,6 +7701,13 @@ export class Daemon extends EventEmitter {
             }
         }
         const cmd = `${envPrefix} ` + this.backend.buildCommand(launchConfig);
+        // Every launched command re-arms the passive-transient check, including a
+        // retry inside the same spawn: its load is a new one.
+        this.launchAttempt++;
+        // A launch that cannot paint a passive transient (Codex: a fresh start
+        // never shows "Resuming session…") must not honour one quoted on screen.
+        if (this.backend.launchMayShowInputTransient?.() === false)
+            this.retireInputTransients("launch shows none");
         // e.g. Codex could not read its session DB and chose a fallback (#984):
         // the operator should know which conversation this launch continues.
         const launchWarning = this.backend.consumeLaunchWarning?.() ?? null;