@songsid/agend 2.1.6-beta.14 → 2.1.6-beta.15

package/dist/daemon.d.ts

@@ -1143,6 +1143,10 @@ export declare class Daemon extends EventEmitter {
      * (dropped) Enter — and an unreadable pane is not a verified absence either.
      */
     private confirmSubmittedAfterEnter;
+    /** Once Kiro returns to its prompt, its unique envelope id in history proves submission. */
+    private kiroSubmissionEvidence;
+    /** Observe the Kiro paste outside paneWriteLock; a long agent turn must not block dialog handling. */
+    private observeKiroSubmission;
     /**
      * While the CLI is parked on a fatal startup screen (see fatalStartupBlocked),
      * no pane write may happen: paste+Enter into the corrupt-config modal would

package/dist/daemon.js

@@ -449,6 +449,10 @@ 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 pasted Kiro message may be processing for longer than the retry window. */
+const KIRO_SUBMISSION_OBSERVE_MS = 10 * 60_000;
+const KIRO_SUBMISSION_POLL_MS = 1_000;
+const KIRO_SUBMISSION_UNREADABLE_POLLS = 40;
 /** A passive startup phase must clear within this bound before an Enter is sent. */
 /**
  * How long a passive startup/resume transient may sit WITHOUT REPAINTING before
@@ -4244,6 +4248,8 @@ export class Daemon extends EventEmitter {
         // A false return means the cap expired with a spawn STILL running — the
         // generation captured below is in-progress evidence, not settled evidence,
         // so the critical section must still back out (see settledClean).
+        if (this.spawnSettled && status)
+            this.emit("message_queued", status);
         const settledClean = await this.waitForSpawnToSettle();
         // Everything captured below (window id, readiness verdicts) belongs to
         // this spawn generation. A spawn that starts afterwards is detected inside
@@ -4385,6 +4391,9 @@ export class Daemon extends EventEmitter {
                 }
                 return this.deliverMessage(formatted, status, { ...opts, spawnRetry: retries });
             }
+            if (typeof outcome === "object") {
+                return this.observeKiroSubmission(formatted, outcome, status, verdict, cancelled);
+            }
             if (outcome !== "dialog")
                 return outcome;
             // Wait OUTSIDE the lock (holding it would starve the runtime dismisser),
@@ -4913,6 +4922,126 @@ export class Daemon extends EventEmitter {
             this.logger.warn("Could not read the pane after Enter — not confirming the submission");
         return sawOutput && residue === "absent";
     }
+    /** Once Kiro returns to its prompt, its unique envelope id in history proves submission. */
+    async kiroSubmissionEvidence(windowId, formatted, signature) {
+        if (!this.tmux)
+            return "unreadable";
+        let pane;
+        try {
+            pane = await this.tmux.capturePane();
+        }
+        catch {
+            return "unreadable";
+        }
+        const prompt = this.backend?.getBottomReadyPattern?.();
+        if (prompt && bottomRowIsReady(pane, prompt)
+            && inputShowsPastedText(inputAreaText(pane, prompt) ?? "", signature.value))
+            return "stranded";
+        if (prompt && pasteLeftInInput(pane, prompt, formatted))
+            return "stranded";
+        // During generation the same text can still be typeahead for an older
+        // turn. A history hit is safe only after this pane returns to its prompt.
+        if (!signature.unique || !this.tmux.capturePaneWithHistory
+            || !(await this.isPaneReadyForDelivery(windowId)))
+            return "unknown";
+        try {
+            const history = await this.tmux.capturePaneWithHistory(300);
+            // History includes the CURRENT input row. The earlier viewport capture
+            // and readiness probe may belong to an older frame: Kiro can finish a
+            // turn and expose our unsent typeahead between those reads. Judge both
+            // readiness and input residue on this same, final snapshot before its
+            // message id can count as a submitted transcript echo.
+            if (!prompt || !bottomRowIsReady(history, prompt))
+                return "unknown";
+            if (inputShowsPastedText(inputAreaText(history, prompt) ?? "", signature.value)
+                || pasteLeftInInput(history, prompt, formatted))
+                return "stranded";
+            if (countOccurrences(history.replace(/\s+/g, ""), signature.value) > 0)
+                return "submitted";
+        }
+        catch { /* missing history cannot establish a verdict */ }
+        return "unknown";
+    }
+    /** Observe the Kiro paste outside paneWriteLock; a long agent turn must not block dialog handling. */
+    async observeKiroSubmission(formatted, pending, status, verdict, cancelled) {
+        const deadline = Date.now() + KIRO_SUBMISSION_OBSERVE_MS;
+        let retriedStrand = false;
+        let unreadable = 0;
+        const current = () => !cancelled()
+            && !this.spawning
+            && this.spawnGeneration === pending.spawnGeneration
+            && this.getWindowId() === pending.windowId
+            && this.tmux?.getWindowId() === pending.windowId;
+        for (;;) {
+            if (!current())
+                return false;
+            const evidence = await this.kiroSubmissionEvidence(pending.windowId, formatted, pending.signature);
+            if (!current())
+                return false;
+            if (evidence === "submitted") {
+                if (status)
+                    this.emit("message_confirmed", status);
+                return true;
+            }
+            unreadable = evidence === "unreadable" ? unreadable + 1 : 0;
+            if (unreadable >= KIRO_SUBMISSION_UNREADABLE_POLLS) {
+                return this.failDelivery(verdict, status, "post-submit-proof", "pane-unreadable");
+            }
+            if (evidence === "stranded" && await this.isPaneReadyForDelivery(pending.windowId)) {
+                if (!current())
+                    return false;
+                if (retriedStrand)
+                    return this.failDelivery(verdict, status, "stranded-text-retry", "stranded");
+                const retry = await this.paneWriteLock.run(async () => {
+                    if (!current())
+                        return "cancelled";
+                    const fresh = await this.kiroSubmissionEvidence(pending.windowId, formatted, pending.signature);
+                    if (!current())
+                        return "cancelled";
+                    if (fresh === "submitted")
+                        return "submitted";
+                    if (fresh !== "stranded" || !(await this.isPaneReadyForDelivery(pending.windowId)))
+                        return "changed";
+                    if (!current())
+                        return "cancelled";
+                    const sent = await this.sendDeliveryEnter("stranded-text-retry", current);
+                    if (!current())
+                        return "cancelled";
+                    return sent ? "sent" : "failed";
+                });
+                if (!current())
+                    return false;
+                if (retry === "cancelled")
+                    return false;
+                if (retry === "submitted") {
+                    if (status)
+                        this.emit("message_confirmed", status);
+                    return true;
+                }
+                if (retry === "failed")
+                    return this.failDelivery(verdict, status, "stranded-text-retry", "tmux-send-keys-failed");
+                if (retry === "sent") {
+                    retriedStrand = true;
+                    await new Promise(r => setTimeout(r, POST_ENTER_PROOF_WINDOW_MS));
+                    continue;
+                }
+            }
+            const alive = await this.tmux?.isWindowAlive().catch(() => false);
+            if (!current())
+                return false;
+            if (!alive)
+                return this.failDelivery(verdict, status, "post-submit-proof", "window-gone");
+            if (Date.now() >= deadline) {
+                // A live, busy pane and no positive strand are still ambiguous. The
+                // hang detector owns hung CLI recovery; elapsed time alone is not ❌.
+                this.logger.warn("Kiro submission remains unproven; keeping the delivery queued without a false failure");
+                verdict.phase = "post-submit-proof";
+                verdict.proof = "unproven";
+                return false;
+            }
+            await new Promise(r => setTimeout(r, KIRO_SUBMISSION_POLL_MS));
+        }
+    }
     /**
      * While the CLI is parked on a fatal startup screen (see fatalStartupBlocked),
      * no pane write may happen: paste+Enter into the corrupt-config modal would
@@ -4992,9 +5121,13 @@ export class Daemon extends EventEmitter {
      * precisely so the lock's scope is visible at the call site rather than being
      * an invariant maintained by comments.
      */
-    async sendDeliveryEnter(phase) {
+    async sendDeliveryEnter(phase, stillCurrent) {
         if (!(await this.waitForInputTransientToClear(phase)))
             return false;
+        // A recovery Enter may have waited for a transient while cancel or spawn
+        // replaced the delivery. Check at the last point before the tmux write.
+        if (stillCurrent && !stillCurrent())
+            return false;
         const sent = await this.tmux.sendSpecialKey("Enter");
         if (!sent) {
             this.logger.error({
@@ -5219,10 +5352,20 @@ export class Daemon extends EventEmitter {
                 // F2: output after Enter is necessary but not sufficient — the paste
                 // must also have LEFT the input row.
                 let submitted = await this.confirmSubmittedAfterEnter(windowId, enterAt, formatted);
+                if (!submitted && signature.unique) {
+                    submitted = await this.kiroSubmissionEvidence(windowId, formatted, signature) === "submitted";
+                    if (!submitted) {
+                        // No output edge is not proof of a lost message. Leave the pane
+                        // lock before waiting through a long Kiro turn, so runtime dialog
+                        // handling can still make progress.
+                        if (status)
+                            this.emit("message_queued", status);
+                        return { kind: "kiro-pending", windowId, spawnGeneration: this.spawnGeneration, signature };
+                    }
+                }
                 if (!submitted) {
-                    // The Enter landed while the TUI was still busy (it kept the text but
-                    // dropped the key). A retry is only useful once the prompt is back —
-                    // bounded, since we hold the pane lock here.
+                    // Legacy system pastes have no unique envelope id. Preserve their
+                    // existing bounded retry until they can be tied to a specific turn.
                     this.logger.warn("Message not submitted after Enter — waiting for the prompt, then re-sending Enter once");
                     const promptBack = await this.waitForPaneReadyForDelivery(windowId, STRANDED_RETRY_READY_WAIT_MS);
                     const retryAt = Date.now();