@songsid/agend 2.1.12-beta.6 → 2.1.12-beta.8

package/dist/daemon.js

@@ -30,7 +30,7 @@ import { writeSecretFile } from "./secret-file.js";
 import { PaneWriteLock } from "./pane-write-lock.js";
 import { buildFleetInstructions } from "./instructions.js";
 import { formatCrossInstanceInboundMessage, renderCrossInstanceHandoffMetadata, } from "./cross-instance-envelope.js";
-import { bottomRowIsReady, inputAreaText, inputShowsPastedText, pastedTextSignature, pasteLeftInInput, strandedAgendMessageInInput } from "./pane-input-residue.js";
+import { agendMessageInInput, bottomRowIsReady, inputAreaText, inputShowsPastedText, pastedTextSignature, pasteLeftInInput, strandedAgendMessageInInput } from "./pane-input-residue.js";
 import { TurnReplyGuard } from "./turn-reply-guard.js";
 import { t } from "./locale.js";
 import { MuseUsageRelay, clearMuseUsageSnapshot } from "./muse-usage-relay.js";
@@ -6143,7 +6143,7 @@ export class Daemon extends EventEmitter {
             const canHandOff = (supportsQueuedInput || opts?.steer)
                 && readiness === "busy"
                 && (await this.probeBlockingDialog()).state === "clear"
-                && await this.hasPositiveDeliveryInput();
+                && await this.hasPositiveDeliveryInput(true);
             if (canHandOff) {
                 // Native queue (codex), or an explicit /steer: hand the complete
                 // paste+Enter transaction to the busy CLI now. For steer this is the
@@ -6240,7 +6240,7 @@ export class Daemon extends EventEmitter {
                     if (probe.state !== "clear")
                         return "dialog";
                 }
-                if (!(await this.hasPositiveDeliveryInput()))
+                if (!(await this.hasPositiveDeliveryInput(handingOffToNativeQueue)))
                     return "dialog";
                 // #829: a CLI that restores a cancelled prompt into its input box would
                 // have this message pasted onto it and both submitted as one. Clear it
@@ -6262,6 +6262,9 @@ export class Daemon extends EventEmitter {
                 if (residue !== "clear")
                     return this.failDelivery(verdict, status, "input-residue", residue);
                 const written = await this.writeMessageToPane(formatted, windowId, handingOffToNativeQueue, status, opts?.submissionId, verdict, opts?.durableAttempt, opts?.steer === true, writeCurrent);
+                // 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";
                 // Fenced before its first write: not attempted — redo after a spawn, else drop without a ❌.
                 return written === false && verdict.fenced ? stale() : written;
             });
@@ -6809,8 +6812,26 @@ export class Daemon extends EventEmitter {
         }
         return true;
     }
-    /** Codex can paint a prompt before the TTY enters raw mode. Both are required. */
-    async hasPositiveDeliveryInput() {
+    /**
+     * Codex can paint a prompt before the TTY enters raw mode. Both are required.
+     *
+     * A hand-off into a busy pane (native queue or steer) pastes and presses Enter at once, so a backend with a structural
+     * box reader must see its box on a fresh capture first: a pane whose box cannot be read — a modal the dialog table
+     * does not know, a frame the reader refuses, a failed capture — is not one to type into (#1169 review). Asked
+     * before the hand-off is chosen and again under the pane lock, right before the write; false waits for readiness.
+     */
+    async hasPositiveDeliveryInput(handOff = false) {
+        if (handOff && this.backend?.readInputRow) {
+            if (!this.tmux)
+                return false;
+            try {
+                if (this.backend.readInputRow(await this.tmux.capturePane()) === null)
+                    return false;
+            }
+            catch {
+                return false;
+            }
+        }
         if (!this.needsStartupInputProof())
             return true;
         const check = this.backend?.isDeliveryInputReadyPane;
@@ -7494,6 +7515,15 @@ export class Daemon extends EventEmitter {
                 verdict.fenced = !verdict.durableBeginCommitted;
                 return false;
             }
+            // 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),
+            // nothing was written and the attempt ends like a paste that failed.
+            if (handingOffToNativeQueue && this.backend?.readInputRow && !pasteBaseline?.inputReadable) {
+                if (!verdict.durableBeginCommitted)
+                    return "handoff-box-unread";
+                return this.failDelivery(verdict, status, "paste", "handoff-input-unreadable");
+            }
             // Readiness, idle-gate, dialog, spawn and pane-lock waits have all ended.
             // Commit the submission fence at the last possible point before the
             // first side effect; a crash during those waits remains safely replayable.
@@ -7700,7 +7730,7 @@ export class Daemon extends EventEmitter {
                     // The recovery Enter can be accepted before Codex paints its new
                     // transcript. One immediate capture is not a failure verdict: give
                     // that echo/queue a bounded chance to appear, without re-pasting.
-                    const afterEnter = this.backend?.isDeliveryInputReadyPane
+                    const afterEnter = this.structuredInputEvidence()
                         ? await this.lateCodexSubmissionProof(signature, pasteBaseline, true)
                         : await this.confirmSubmitted(signature, pasteBaseline);
                     if (afterEnter === "submitted") {
@@ -7714,7 +7744,7 @@ export class Daemon extends EventEmitter {
                     // another turn's output — and treating that as proof re-confirms a
                     // message nobody submitted. Output is corroboration; text sitting in
                     // the input row is disqualifying, and disqualifying evidence wins.
-                    if (this.backend?.isDeliveryInputReadyPane && afterEnter !== "stranded") {
+                    if (this.structuredInputEvidence() && afterEnter !== "stranded") {
                         this.logger.warn({ phase: "native-queue-submit", proof: afterEnter, strandedAt }, "Codex recovery Enter outcome uncertain — no hard failure or duplicate paste");
                         verdict.phase = "native-queue-submit";
                         verdict.proof = afterEnter;
@@ -7723,7 +7753,11 @@ export class Daemon extends EventEmitter {
                     this.logger.error({ afterEnter, strandedAt }, "Stranded message could not be submitted by Enter");
                     return this.failDelivery(verdict, status, "native-queue-submit", afterEnter);
                 }
-                if (this.backend?.isDeliveryInputReadyPane) {
+                // A structural box reader (claude-code, #1200) is in the same position as Codex once the turn has run: the
+                // message may have been taken and its echo scrolled out, the queue drained, the box empty — or the capture
+                // failed. None of that proves the paste was lost, so nothing short of positive evidence is a reason to paste
+                // again (#1353 review); "unverifiable" used to, and could submit the message twice.
+                if (this.backend?.isDeliveryInputReadyPane || this.backend?.readInputRow) {
                     // In Codex a missing viewport echo is inconclusive, not a proof of
                     // loss. Another paste could run the same request twice. Leave the
                     // already-pasted delivery at 👀 and let the next observation decide.
@@ -7824,7 +7858,7 @@ export class Daemon extends EventEmitter {
                         verdict.proof = "output-edge";
                 }
                 else {
-                    const proof = this.backend?.isDeliveryInputReadyPane
+                    const proof = this.structuredInputEvidence()
                         ? await this.lateCodexSubmissionProof(signature, pasteBaseline)
                         : await this.confirmSubmitted(signature, pasteBaseline);
                     if (proof === "submitted") {
@@ -7832,7 +7866,7 @@ export class Daemon extends EventEmitter {
                             this.emit("message_confirmed", status);
                         return true;
                     }
-                    if (this.backend?.isDeliveryInputReadyPane && proof !== "stranded") {
+                    if (this.structuredInputEvidence() && proof !== "stranded") {
                         // This is the observed #910 race: the CLI processed the message
                         // although its echo had not appeared within the proof window. A
                         // missing viewport signature cannot establish non-delivery; keep
@@ -7910,7 +7944,7 @@ export class Daemon extends EventEmitter {
         return dialogClear && this.spawnGeneration === spawnGeneration && this.getWindowId() === windowId;
     }
     canProveSubmission() {
-        return !!this.backend?.getBottomReadyPattern?.();
+        return this.readsInput();
     }
     /** Positive submission retires the startup transient guard for this spawn. */
     submittedProof() {
@@ -7947,7 +7981,7 @@ export class Daemon extends EventEmitter {
             }
             return busy;
         }
-        if (this.backend?.isDeliveryInputReadyPane) {
+        if (this.structuredInputEvidence()) {
             // Codex's first post-wake redraw may hide the echo for a few seconds.
             // Absence from a viewport is NOT proof the paste was lost, so only a
             // positively identified strand authorizes another Enter. Never re-paste
@@ -8015,6 +8049,14 @@ export class Daemon extends EventEmitter {
         catch {
             return "unproven";
         }
+        return this.judgeSubmission(pane, signature, baseline);
+    }
+    /**
+     * The verdict one snapshot supports — the live viewport, or (for a unique signature) the scrollback a late proof
+     * reads. One judge for both, so a history read cannot vouch for what the live one refuses: an unreadable box, or our
+     * text still in it (#1353 review).
+     */
+    judgeSubmission(pane, signature, baseline) {
         // Without a way to tell the input row from the transcript, "the text is on
         // screen" cannot distinguish submitted from stranded — that ambiguity IS
         // the bug. Such a backend gets an explicit verdict rather than a guess:
@@ -8024,8 +8066,7 @@ export class Daemon extends EventEmitter {
         // for the first and recovers on the second, which is what it did before —
         // the fix here is for backends that CAN be read, not a new guess for those
         // that cannot.
-        const prompt = this.backend?.getBottomReadyPattern?.();
-        if (!prompt) {
+        if (!this.readsInput()) {
             const seen = this.paneEvidence(pane, signature);
             if (signature.unique && seen.payload > 0)
                 return "unverifiable";
@@ -8042,6 +8083,11 @@ export class Daemon extends EventEmitter {
             && !this.backend.getBusyPattern?.()?.test(pane)) {
             return after.payload > 0 ? "unverifiable" : "unproven";
         }
+        // A structural reader (claude-code) that finds no input box on this screen — a dialog in front of it, a layout it
+        // does not know — cannot place our text on either side of the box: the same verdicts as a readerless backend.
+        if (this.backend?.readInputRow && !after.inputReadable) {
+            return after.payload > 0 ? "unverifiable" : "unproven";
+        }
         // 1. Disqualifying evidence, checked FIRST and never overridden by the
         //    corroborating evidence below: our text is sitting in the input row, so
         //    it was not submitted — whatever else is on screen.
@@ -8052,8 +8098,22 @@ export class Daemon extends EventEmitter {
         //    Otherwise an older stranded message with the same opening would be
         //    read as ours, we would press Enter to "recover" it, and the turn IT
         //    starts would confirm a message that never reached the pane.
-        if (after.strandedInput && (signature.unique || baseline?.strandedInput === false))
+        //
+        //    For a structural box reader (claude-code), "did not already show it" needs a baseline whose box was READ: an
+        //    unreadable one (a dialog, a redraw the reader refused) says nothing about what the box held, and counting it as
+        //    empty would claim an older message as ours and press Enter on it (#1353 review). The prompt-row backends (codex,
+        //    kiro) keep their existing attribution.
+        const attributable = baseline != null
+            && (!this.backend?.readInputRow || (baseline.inputReadable && after.inputReadable));
+        if (after.strandedInput && (signature.unique || (attributable && baseline.strandedInput === false)))
+            return "stranded";
+        //    A paste the CLI shows collapsed carries no signature at all. One the box did not hold before we pasted is
+        //    ours, and it is still in the box — whatever echo or output is on screen (#1200).
+        if (attributable && after.collapsedPastes > baseline.collapsedPastes)
             return "stranded";
+        //    Something sits in the box that cannot be attributed either way. Only a unique signature seen outside the box
+        //    (below) can still prove this delivery; nothing else on screen may.
+        const unattributedResidue = !attributable && (after.strandedInput || after.collapsedPastes > 0);
         // 2. Positive evidence. A unique signature needs no baseline: no earlier
         //    message can carry this delivery's message_id, so finding it outside
         //    the input row is proof in itself — which also means a momentary
@@ -8061,12 +8121,16 @@ export class Daemon extends EventEmitter {
         //    message into a re-paste.
         if (signature.unique && after.payload > 0)
             return this.submittedProof();
+        if (unattributedResidue)
+            return "unverifiable";
         // 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)
+            // A queue is new only against a box that was read before the paste (a reader backend): an unreadable baseline
+            // says nothing about whether the queue was already there.
+            if (after.queued > baseline.queued && (!this.backend?.readInputRow || baseline.inputReadable))
                 return this.submittedProof();
             if (after.payload > baseline.payload)
                 return this.submittedProof();
@@ -8094,12 +8158,10 @@ export class Daemon extends EventEmitter {
                 return proof;
             if (signature.unique && this.tmux?.capturePaneWithHistory) {
                 try {
+                    // Scrollback can hold the echo the viewport lost — but it is judged exactly like the viewport: a box that
+                    // cannot be read, or that still holds our text, is never upgraded by an echo further up.
                     const history = await this.tmux.capturePaneWithHistory(300);
-                    const seen = this.paneEvidence(history, signature);
-                    const known = !this.backend?.isDeliveryInputReadyPane
-                        || this.backend.isDeliveryInputReadyPane(history)
-                        || this.backend.getBusyPattern?.()?.test(history);
-                    if (known && seen.payload > 0 && !seen.strandedInput)
+                    if (this.judgeSubmission(history, signature, baseline) === "submitted")
                         return this.submittedProof();
                 }
                 catch { /* a failed history read proves neither delivery nor loss */ }
@@ -8123,9 +8185,8 @@ export class Daemon extends EventEmitter {
             try {
                 const pane = await this.tmux.capturePane();
                 const evidence = this.paneEvidence(pane, signature);
-                const prompt = this.backend?.getBottomReadyPattern?.();
-                if (prompt && (!this.backend?.isDeliveryInputReadyPane || this.backend.isDeliveryInputReadyPane(pane))
-                    && strandedAgendMessageInInput(pane, prompt)) {
+                const input = this.inputRegion(pane);
+                if (input && agendMessageInInput(input.text)) {
                     // Whatever we paste now lands after it, and one Enter submits both as
                     // a single message. Nothing here can undo that; saying so beats
                     // letting two messages silently merge.
@@ -8144,16 +8205,45 @@ export class Daemon extends EventEmitter {
         return null;
     }
     paneEvidence(pane, signature) {
-        const marker = this.backend?.getQueuedInputMarker?.();
-        const prompt = this.backend?.getBottomReadyPattern?.();
-        const input = prompt && (!this.backend?.isDeliveryInputReadyPane || this.backend.isDeliveryInputReadyPane(pane))
-            ? inputAreaText(pane, prompt) : null;
+        const input = this.inputRegion(pane);
+        // A structural box reader vouches for the queue itself (InputBox.queued): a marker's words elsewhere on the pane —
+        // a reply quoting it, an old block — are not a queue (#1169 review). Other backends count their marker rows.
+        const marker = this.backend?.readInputRow ? null : this.backend?.getQueuedInputMarker?.();
         return {
-            queued: marker ? pane.split(/\r?\n/).filter(row => marker.test(row)).length : 0,
+            queued: this.backend?.readInputRow
+                ? (input?.queued ? 1 : 0)
+                : marker ? pane.split(/\r?\n/).filter(row => marker.test(row)).length : 0,
             payload: countOccurrences(pane.replace(/\s+/g, ""), signature.value),
-            strandedInput: input != null && inputShowsPastedText(input, signature.value),
+            strandedInput: input != null && inputShowsPastedText(input.text, signature.value),
+            collapsedPastes: input?.collapsedPastes ?? 0,
+            inputReadable: input != null,
         };
     }
+    /**
+     * The input box as it stands on this screen: the backend's structural reader when it has one (claude-code, #1200),
+     * else the prompt-row heuristic (codex — only on a screen it vouches for — and kiro). null: no box to read here.
+     */
+    inputRegion(pane) {
+        if (this.backend?.readInputRow)
+            return this.backend.readInputRow(pane);
+        const prompt = this.backend?.getBottomReadyPattern?.();
+        if (!prompt || (this.backend?.isDeliveryInputReadyPane && !this.backend.isDeliveryInputReadyPane(pane)))
+            return null;
+        const text = inputAreaText(pane, prompt);
+        return text == null ? null : { text, collapsedPastes: 0 };
+    }
+    /** Whether this backend's input box can be read at all (a given screen may still have none). */
+    readsInput() {
+        return !!this.backend?.readInputRow || !!this.backend?.getBottomReadyPattern?.();
+    }
+    /**
+     * Backends whose pane evidence is structured (codex's input/footer pair, a structural box reader): there, our text
+     * missing from the viewport is inconclusive — an echo can arrive late or scroll away — and never a loss to re-paste
+     * over. Only text positively seen in the box (a strand) authorizes another Enter.
+     */
+    structuredInputEvidence() {
+        return !!this.backend?.isDeliveryInputReadyPane || !!this.backend?.readInputRow;
+    }
     /**
      * What identifies THIS message on screen. The routing envelope carries a
      * message_id that no earlier transcript entry can share, so prefer it: the
@@ -8220,6 +8310,17 @@ export class Daemon extends EventEmitter {
         if (!(await this.sendDeliveryEnter(label, guard?.current)))
             return false;
         let proof = await this.confirmSubmitted(signature, baseline);
+        // A structural box reader sees the paste in the box until the CLI digests the Enter (claude-code repaints a moment
+        // later): give that a bounded window before calling it stranded or lost, as the delivery ladder does.
+        if (this.backend?.readInputRow) {
+            const deadline = Date.now() + POST_ENTER_PROOF_WINDOW_MS;
+            while (proof !== "submitted" && Date.now() < deadline) {
+                await new Promise(r => setTimeout(r, POST_ENTER_PROOF_POLL_MS));
+                if (guard && !guard.current())
+                    return false;
+                proof = await this.confirmSubmitted(signature, baseline);
+            }
+        }
         if (proof === "unverifiable") {
             if (this.backend?.isDeliveryInputReadyPane) {
                 // A Codex screen without a structurally current input/footer pair is