@songsid/agend 2.1.5-beta.17 → 2.1.5-beta.19

package/dist/daemon.js

@@ -391,6 +391,9 @@ export class PendingWorkTracker {
     }
 }
 const NORMAL_ENTER_SETTLE_MS = 500;
+/** How long to keep looking for proof after a retry Enter before failing it. */
+const POST_ENTER_PROOF_WINDOW_MS = 3_000;
+const POST_ENTER_PROOF_POLL_MS = 250;
 /** Attempts to read the pre-paste pane before a delivery gives up on a baseline. */
 const BASELINE_CAPTURE_ATTEMPTS = 3;
 const BASELINE_CAPTURE_RETRY_MS = 150;
@@ -428,6 +431,9 @@ export class BackendUnreachableStartupError extends Error {
 }
 /** Bounded wait (under the pane lock) for the prompt to return before retrying a dropped Enter. */
 const STRANDED_RETRY_READY_WAIT_MS = 30_000;
+/** A passive startup phase must clear within this bound before an Enter is sent. */
+const INPUT_TRANSIENT_WAIT_MS = 30_000;
+const INPUT_TRANSIENT_POLL_MS = 250;
 /** Max "stranded text → submit → wait for prompt → re-check" rounds per delivery; each may send one recovery Enter. */
 const STRANDED_INPUT_MAX_ROUNDS = 3;
 const FIRST_ENTER_SETTLE_MS = 1_750;
@@ -854,6 +860,14 @@ export class Daemon extends EventEmitter {
     spawnSettled = null;
     resolveSpawnSettled = null;
     spawnDepth = 0;
+    /** Monotonic identity for nested beginSpawn/endSpawn lifecycles. */
+    spawnGeneration = 0;
+    /**
+     * Keeps passive startup-transient checks alive through the first positively
+     * submitted post-spawn message.  Without this tail, a transient painted just
+     * after the startup scan can still swallow that message's Enter.
+     */
+    inputTransientGuardGeneration = null;
     skipResume = false;
     startupAborted = false;
     /** First time the current on-screen blocking dialog was seen (0 = none); drives the parked report. */
@@ -2520,6 +2534,9 @@ export class Daemon extends EventEmitter {
     async stop() {
         this.logger.info("Stopping daemon instance");
         this.turnReplyGuard.reset();
+        // Invalidate any bounded pre-Enter wait from the process generation being
+        // stopped. It must fail closed, not press Enter in a replacement pane.
+        this.inputTransientGuardGeneration = null;
         this.freezeRuntimeMonitors();
         this.pendingIpcRequests.clear();
         if (this.adapter)
@@ -4043,16 +4060,24 @@ export class Daemon extends EventEmitter {
                 }
             }
         }
-        // Everything above is *waiting*; everything below *writes*. Only the write is
-        // held under the pane lock — holding it across the idle wait (up to 30 min)
-        // would starve the runtime-dialog dismisser, which is often the very thing
-        // that would let the pane go idle again.
+        // Everything above is *waiting*; everything below owns the write lock.
+        // Long idle/dialog waits stay outside because the runtime dismisser may be
+        // what makes progress. The one under-lock wait below is explicitly passive:
+        // it clears by itself and closes a repaint race immediately before paste.
         for (let round = 0;; round++) {
             const outcome = await this.paneWriteLock.run(async () => {
                 if (cancelled())
                     return false;
                 if (this.refuseFatalStartupDelivery(status))
                     return false;
+                // A passive startup phase may paint after the outer readiness probe.
+                // It clears without input, so waiting under the pane lock cannot starve
+                // a dialog dismisser and closes the final clear→paste TOCTOU window.
+                if (!(await this.waitForInputTransientToClear("pre-write"))) {
+                    if (status)
+                        this.emit("message_failed", status); // ❌
+                    return false;
+                }
                 // TOCTOU: the probes above ran outside this lock, and the CLI repaints
                 // whenever it likes — a resume prompt can be painted between "clear" and
                 // this critical section. Re-probe here, right before the write; a
@@ -4096,6 +4121,75 @@ export class Daemon extends EventEmitter {
     deliveryBlockingDialogs() {
         return (this.backend?.getRuntimeDialogs?.() ?? []).filter(d => d.blocksDelivery || d.holdOnly);
     }
+    /** Passive input-unavailable phases relevant to the current spawn only. */
+    guardedInputTransients() {
+        if (this.inputTransientGuardGeneration === null
+            || this.inputTransientGuardGeneration !== this.spawnGeneration)
+            return [];
+        return this.backend?.getInputUnavailableTransients?.() ?? [];
+    }
+    /** Match a passive transient against the current interactive screen. */
+    inputTransientInPane(pane) {
+        for (const transient of this.guardedInputTransients()) {
+            // `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))
+                return transient;
+        }
+        return null;
+    }
+    /** Capture failure is unknown, never evidence that input is available. */
+    async probeInputTransient() {
+        if (this.guardedInputTransients().length === 0 || !this.tmux)
+            return { state: "clear" };
+        try {
+            const pane = await this.tmux.capturePane();
+            const transient = this.inputTransientInPane(pane);
+            return transient ? { state: "active", transient } : { state: "clear" };
+        }
+        catch (err) {
+            this.logger.debug({ err }, "capture-pane failed during the input-transient probe — pane state unknown");
+            return { state: "unknown" };
+        }
+    }
+    /**
+     * Wait under the pane lock for a passive transient to disappear. Unlike a
+     * dialog, this state clears by itself, so the wait cannot starve a keypress
+     * dismisser. Stop or a replacement spawn invalidates the captured identity.
+     */
+    async waitForInputTransientToClear(phase, timeoutMs = INPUT_TRANSIENT_WAIT_MS) {
+        const generation = this.inputTransientGuardGeneration;
+        if (generation === null || generation !== this.spawnGeneration)
+            return true;
+        const deadline = Date.now() + timeoutMs;
+        let observedDescription = null;
+        for (;;) {
+            if (this.inputTransientGuardGeneration !== generation || this.spawnGeneration !== generation) {
+                this.logger.warn({ phase, generation }, "Spawn changed while waiting for input availability — refusing to send Enter into the replacement pane");
+                return false;
+            }
+            const probe = await this.probeInputTransient();
+            if (this.inputTransientGuardGeneration !== generation || this.spawnGeneration !== generation) {
+                this.logger.warn({ phase, generation }, "Spawn changed during the input-availability probe — refusing to send Enter into the replacement pane");
+                return false;
+            }
+            if (probe.state === "clear")
+                return true;
+            if (probe.state === "active" && observedDescription !== probe.transient.description) {
+                observedDescription = probe.transient.description;
+                this.logger.info({ phase, transient: probe.transient.description, generation }, "CLI is still completing startup — waiting before sending Enter");
+            }
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                this.logger.error({ phase, generation, timeoutMs, transient: observedDescription }, "CLI input stayed unavailable — refusing to send Enter");
+                return false;
+            }
+            await new Promise(r => setTimeout(r, Math.min(INPUT_TRANSIENT_POLL_MS, remaining)));
+        }
+    }
     static dialogKey(dialog) {
         return `${dialog.pattern.source}/${dialog.pattern.flags}`;
     }
@@ -4206,10 +4300,10 @@ export class Daemon extends EventEmitter {
     }
     /**
      * Why a pane is not deliverable matters. "busy" may be handed to a native
-     * input queue or steered (after its own dialog probe); "dialog" and "unknown"
-     * must never be — a paste + Enter into a dialog answers it with its default,
-     * and an unreadable pane proves nothing. The silence gate comes first and
-     * costs no capture, so a CLI that is simply working never pays for the probe.
+     * input queue or steered (after its own dialog probe); "dialog", "transient"
+     * and "unknown" must never be — a paste + Enter into a dialog answers it
+     * with its default, while a startup transient swallows it and an unreadable
+     * pane proves nothing. The silence gate comes first and costs no capture.
      */
     async paneReadinessForDelivery(windowId) {
         if (!this.isPaneIdleForDelivery(windowId))
@@ -4217,6 +4311,11 @@ export class Daemon extends EventEmitter {
         const probe = await this.probeBlockingDialog();
         if (probe.state !== "clear")
             return probe.state;
+        const transient = await this.probeInputTransient();
+        if (transient.state === "active")
+            return "transient";
+        if (transient.state === "unknown")
+            return "unknown";
         if (this.backend?.dropsEnterWhileBusy?.() !== true)
             return "ready";
         const prompt = this.backend.getBottomReadyPattern?.();
@@ -4263,6 +4362,7 @@ export class Daemon extends EventEmitter {
         const deadline = Date.now() + timeoutMs;
         const bottomGated = this.backend?.dropsEnterWhileBusy?.() === true;
         let unknownStreak = 0;
+        let transientDeadline = 0;
         for (;;) {
             const remaining = deadline - Date.now();
             if (remaining <= 0)
@@ -4272,6 +4372,26 @@ export class Daemon extends EventEmitter {
                 return false;
             // 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();
+            if (transient.state === "active") {
+                unknownStreak = 0;
+                transientDeadline ||= Math.min(deadline, Date.now() + INPUT_TRANSIENT_WAIT_MS);
+                if (Date.now() >= transientDeadline) {
+                    this.logger.error({ transient: transient.transient.description, timeoutMs: INPUT_TRANSIENT_WAIT_MS }, "CLI input stayed unavailable during the delivery-readiness wait");
+                    return false;
+                }
+                await new Promise(r => setTimeout(r, BOTTOM_READY_POLL_MS));
+                continue;
+            }
+            transientDeadline = 0;
+            if (transient.state === "unknown") {
+                if (++unknownStreak >= DIALOG_PROBE_UNKNOWN_MAX) {
+                    this.logger.error({ probes: unknownStreak }, "Pane stayed unreadable during the input-transient probe — refusing to deliver blind");
+                    return false;
+                }
+                await new Promise(r => setTimeout(r, BOTTOM_READY_POLL_MS));
+                continue;
+            }
             if (bottomGated) {
                 if (await this.isPaneReadyForDelivery(windowId))
                     return true;
@@ -4307,15 +4427,16 @@ export class Daemon extends EventEmitter {
      * must fail rather than paste on top of the stranded text).
      */
     async submitStrandedInputIfAny(windowId) {
-        if (this.backend?.dropsEnterWhileBusy?.() !== true || !this.tmux)
+        if (!this.tmux || !this.backend)
             return "idle";
         const prompt = this.backend.getBottomReadyPattern?.();
         if (!prompt)
             return "idle";
+        const requireBottomReady = this.backend.dropsEnterWhileBusy?.() === true;
         // Pre-check outside the lock so the common case (verified clear) never
         // contends with the dialog dismisser. Only a POSITIVE "clear" skips the
         // lock; an unreadable pane is re-examined under it, not waved through.
-        const pre = await this.strandedInputState(prompt);
+        const pre = await this.strandedInputState(prompt, requireBottomReady);
         if (pre === "clear")
             return "idle";
         if (pre === "busy")
@@ -4331,7 +4452,7 @@ export class Daemon extends EventEmitter {
             // no-op at an empty prompt, but into a modal it is a confirmation.
             if (this.fatalStartupBlocked)
                 return "busy";
-            const state = await this.strandedInputState(prompt);
+            const state = await this.strandedInputState(prompt, requireBottomReady);
             if (state === "clear")
                 return "idle";
             if (state !== "stranded")
@@ -4341,12 +4462,12 @@ export class Daemon extends EventEmitter {
         });
     }
     /**
-     * "stranded": an AgEnD message sits in the input row; "clear": the prompt is
-     * at the bottom with no stranded text; "busy": generating, or the prompt is
-     * not at the bottom (incl. a blank frame); "unknown": the pane could not be
-     * read. Only "clear" is positive evidence.
+     * "stranded": an AgEnD message sits in the input row; "clear": no strand is
+     * visible under the backend's readiness policy; "busy": generating, or (for
+     * a bottom-gated backend) the prompt is not at the bottom; "unknown": the
+     * pane could not be read. Only "clear" permits the next paste.
      */
-    async strandedInputState(prompt) {
+    async strandedInputState(prompt, requireBottomReady) {
         let pane;
         try {
             pane = await this.tmux.capturePane();
@@ -4354,11 +4475,16 @@ export class Daemon extends EventEmitter {
         catch {
             return "unknown";
         }
+        if (this.inputTransientInPane(pane))
+            return "busy";
         if (this.backend?.getBusyPattern?.()?.test(pane))
             return "busy";
         if (strandedAgendMessageInInput(pane, prompt))
             return "stranded";
-        return bottomRowIsReady(pane, prompt) ? "clear" : "busy";
+        // Kiro needs a bottom-anchored prompt as positive readiness evidence. Codex
+        // does not: this preflight runs only after its ordinary silence gate and is
+        // enabled solely to recover a positively identified old AgEnD strand.
+        return !requireBottomReady || bottomRowIsReady(pane, prompt) ? "clear" : "busy";
     }
     /**
      * F2: for Enter-dropping TUIs, "some output after Enter" proves nothing — the
@@ -4462,6 +4588,8 @@ export class Daemon extends EventEmitter {
      * an invariant maintained by comments.
      */
     async sendDeliveryEnter(phase) {
+        if (!(await this.waitForInputTransientToClear(phase)))
+            return false;
         const sent = await this.tmux.sendSpecialKey("Enter");
         if (!sent) {
             this.logger.error({
@@ -4647,18 +4775,7 @@ export class Daemon extends EventEmitter {
                     return false;
                 }
                 if (windowId && this.controlClient) {
-                    let becameBusy = await this.confirmBusyAfterEnter(windowId, retryAt);
-                    if (!becameBusy) {
-                        this.logger.warn("No idle→busy after idle-gated redelivery — re-sending Enter once");
-                        const retry2At = Date.now();
-                        if (!(await this.sendDeliveryEnter("native-queue-idle-redelivery-retry"))) {
-                            if (status)
-                                this.emit("message_failed", status); // ❌
-                            return false;
-                        }
-                        becameBusy = await this.confirmBusyAfterEnter(windowId, retry2At);
-                    }
-                    if (becameBusy) {
+                    if (await this.confirmAfterEnter(windowId, retryAt, signature, pasteBaseline, "native-queue-idle-redelivery-retry")) {
                         if (status)
                             this.emit("message_confirmed", status); // ✅
                         return true;
@@ -4714,43 +4831,7 @@ export class Daemon extends EventEmitter {
                 // is disqualifying and no amount of output may override it. Where it
                 // cannot (a backend with no prompt pattern), the output signal remains
                 // exactly as before — this must not regress backends we cannot read.
-                let proof = await this.confirmSubmitted(signature, pasteBaseline);
-                if (proof === "stranded") {
-                    this.logger.warn("Enter did not submit — text is still in the input row; waiting for the prompt and re-sending once");
-                    const promptBack = await this.waitForPaneReadyForDelivery(windowId, STRANDED_RETRY_READY_WAIT_MS);
-                    if (promptBack && !(await this.sendDeliveryEnter("idle-stranded-retry"))) {
-                        if (status)
-                            this.emit("message_failed", status); // ❌
-                        return false;
-                    }
-                    proof = promptBack ? await this.confirmSubmitted(signature, pasteBaseline) : proof;
-                    if (proof !== "submitted") {
-                        this.logger.error({ proof }, "Message pasted but never submitted (still in the input row after the retry)");
-                        if (status)
-                            this.emit("message_failed", status); // ❌
-                        return false;
-                    }
-                }
-                let becameBusy = proof === "submitted";
-                if (!becameBusy)
-                    becameBusy = await this.confirmBusyAfterEnter(windowId, enterAt);
-                if (!becameBusy) {
-                    this.logger.warn("No idle→busy transition after Enter — re-sending Enter once");
-                    const retryAt = Date.now();
-                    if (!(await this.sendDeliveryEnter("idle-to-busy-retry"))) {
-                        if (status)
-                            this.emit("message_failed", status); // ❌
-                        return false;
-                    }
-                    // The input row still outranks output on the retry too.
-                    if (await this.confirmSubmitted(signature, pasteBaseline) === "stranded") {
-                        this.logger.error("Message pasted but never submitted (still in the input row after two Enters)");
-                        if (status)
-                            this.emit("message_failed", status); // ❌
-                        return false;
-                    }
-                    becameBusy = await this.confirmBusyAfterEnter(windowId, retryAt);
-                }
+                const becameBusy = await this.confirmAfterEnter(windowId, enterAt, signature, pasteBaseline, "idle-to-busy-retry");
                 if (becameBusy) {
                     if (status)
                         this.emit("message_confirmed", status); // ✅
@@ -4791,6 +4872,71 @@ export class Daemon extends EventEmitter {
      * anywhere. Evidence is weighed in order of what it can prove, and the
      * disqualifying evidence is checked first.
      */
+    /**
+     * Whether this backend exposes an input row we can actually read, i.e. whether
+     * confirmSubmitted can ever return a verdict stronger than a guess.
+     *
+     * This is a property of the BACKEND, not of one delivery's verdict. Keying the
+     * output-signal fallback off the verdict instead let codex — which can be read
+     * — fall back to "the pane printed something" whenever a paste left no trace,
+     * which is the same false confirmation one layer down.
+     */
+    canProveSubmission() {
+        return !!this.backend?.getBottomReadyPattern?.();
+    }
+    /** Positive submission retires the startup transient guard for this spawn. */
+    submittedProof() {
+        if (this.inputTransientGuardGeneration === this.spawnGeneration) {
+            this.inputTransientGuardGeneration = null;
+        }
+        return "submitted";
+    }
+    /**
+     * Decide a submission after an Enter, with one bounded retry.
+     *
+     * Backends we can read must SHOW the text left the input row: neither a
+     * strand nor a vanished paste may be upgraded to success by output, because
+     * the output that would do the upgrading is usually the very redraw the Enter
+     * was lost to. Backends we cannot read keep the legacy output signal — there
+     * is nothing better available for them, and taking it away would fail every
+     * one of their deliveries.
+     *
+     * One ladder, used by every post-Enter confirmation, so an escape hatch
+     * cannot reappear in just one of them (it did: three copies, two of which
+     * still confirmed on output alone).
+     */
+    async confirmAfterEnter(windowId, enterAt, signature, baseline, retryPhase) {
+        if (!this.canProveSubmission()) {
+            let busy = await this.confirmBusyAfterEnter(windowId, enterAt);
+            if (!busy) {
+                this.logger.warn("No idle→busy transition after Enter — re-sending Enter once");
+                const retryAt = Date.now();
+                if (!(await this.sendDeliveryEnter(retryPhase)))
+                    return false;
+                busy = await this.confirmBusyAfterEnter(windowId, retryAt);
+            }
+            return busy;
+        }
+        if (await this.confirmSubmitted(signature, baseline) === "submitted")
+            return true;
+        // Retry once the prompt is back — an Enter sent into a mid-redraw TUI is
+        // how we got here. Then poll briefly rather than judging on one capture:
+        // the key takes a moment to be digested, and a single early look would
+        // report a failure for a message that did go out.
+        this.logger.warn("Enter did not submit — waiting for the prompt, then re-sending once");
+        if (!(await this.waitForPaneReadyForDelivery(windowId, STRANDED_RETRY_READY_WAIT_MS)))
+            return false;
+        if (!(await this.sendDeliveryEnter(retryPhase)))
+            return false;
+        const deadline = Date.now() + POST_ENTER_PROOF_WINDOW_MS;
+        for (;;) {
+            if (await this.confirmSubmitted(signature, baseline) === "submitted")
+                return true;
+            if (Date.now() >= deadline)
+                return false;
+            await new Promise(r => setTimeout(r, POST_ENTER_PROOF_POLL_MS));
+        }
+    }
     async confirmSubmitted(signature, baseline) {
         if (!this.tmux)
             return "unproven";
@@ -4838,16 +4984,16 @@ export class Daemon extends EventEmitter {
         //    failure to read the pane BEFORE pasting cannot turn a delivered
         //    message into a re-paste.
         if (signature.unique && after.payload > 0)
-            return "submitted";
+            return this.submittedProof();
         // 3. Otherwise the evidence must be NEW relative to the pane as it was
         //    before we pasted: a queue marker left by an earlier message, or an
         //    older transcript entry that opens the same way, are on screen either
         //    way and would otherwise confirm a paste that never landed.
         if (baseline) {
             if (after.queued > baseline.queued)
-                return "submitted";
+                return this.submittedProof();
             if (after.payload > baseline.payload)
-                return "submitted";
+                return this.submittedProof();
             // 4. Nothing new of ours anywhere: the paste was swallowed by a redraw.
             return "unproven";
         }
@@ -5496,6 +5642,12 @@ export class Daemon extends EventEmitter {
         // warning is safer than treating the replacement's startup idle as the old
         // turn ending and injecting a stale recovery prompt.
         this.turnReplyGuard.reset();
+        if (this.spawnDepth === 0) {
+            this.spawnGeneration++;
+            this.inputTransientGuardGeneration = (this.backend?.getInputUnavailableTransients?.().length ?? 0) > 0
+                ? this.spawnGeneration
+                : null;
+        }
         this.spawnDepth++;
         this.spawning = true;
         if (!this.spawnSettled) {
@@ -6095,6 +6247,7 @@ export class Daemon extends EventEmitter {
             await new Promise(r => setTimeout(r, Math.min(pollMs, Math.max(remaining(), 0)))); };
         let cleanReadyPolls = 0;
         let lastDialog = null;
+        let lastTransient = null;
         let captureFailures = 0;
         let attempts = 0;
         do {
@@ -6116,6 +6269,18 @@ export class Daemon extends EventEmitter {
                 continue;
             }
             try {
+                // Some TUIs expose a real-looking input row before they accept Enter.
+                // This phase clears by itself: never send a key, and let its structural
+                // current-screen matcher outrank the otherwise-valid ready pattern.
+                const transient = this.inputTransientInPane(pane);
+                if (transient) {
+                    cleanReadyPolls = 0;
+                    lastDialog = null;
+                    lastTransient = transient;
+                    await sleep();
+                    continue;
+                }
+                lastTransient = null;
                 // Try each startup dialog pattern before checking ready state
                 let matched = false;
                 lastDialog = null;
@@ -6243,7 +6408,10 @@ export class Daemon extends EventEmitter {
             await sleep();
         } while (remaining() > 0);
         // Budget exhausted. Never silently: say which way it went.
-        if (lastDialog) {
+        if (lastTransient) {
+            this.logger.warn({ description: lastTransient.description, attempts, budgetMs }, "Startup scan exhausted while CLI input was still unavailable — retaining the delivery guard");
+        }
+        else if (lastDialog) {
             this.logger.warn({ description: lastDialog.description, attempts, budgetMs }, "Startup scan exhausted with a dialog still on screen — reporting the CLI alive; deliveries stay blocked until it is answered");
         }
         else {