@songsid/agend 2.2.0-alpha.1 → 2.2.0-alpha.2

package/dist/daemon.d.ts

@@ -536,6 +536,8 @@ export declare class Daemon extends EventEmitter {
     /** Generation/signature fence for safety dialogs while their screen is still visible. */
     private autoResolvedDialogKey;
     private autoResolvedDialogGeneration;
+    /** Per-launch safety phases survive startup handoff, redraws and failed/uncertain key ACKs. */
+    private launchDialogClaims;
     /**
      * (#1103) Proof that THIS spawn's Codex went onto Luna Reserve: AgEnD saw (and
      * answered) the usage-limit menu that codex shows when it switches itself to
@@ -1493,6 +1495,8 @@ export declare class Daemon extends EventEmitter {
     private static dialogMatches;
     /** Refresh the separate stdin-blocked observation from one pane capture. */
     private updateInputBlockedState;
+    private hasAutoDialogClaim;
+    private claimAutoDialog;
     /** Whether a runtime prompt currently owns the pane's stdin. */
     isInputBlocked(): boolean;
     /**
@@ -1767,6 +1771,8 @@ export declare class Daemon extends EventEmitter {
      * an invariant maintained by comments.
      */
     private sendDeliveryEnter;
+    /** Write half only: callers must finish the availability wait before any final recovery ownership proof. */
+    private sendDeliveryEnterAfterAvailability;
     private writeMessageToPane;
     /**
      * The single place a pasted message is judged submitted, shared by the

package/dist/daemon.js

@@ -1168,6 +1168,8 @@ export class Daemon extends EventEmitter {
     /** Generation/signature fence for safety dialogs while their screen is still visible. */
     autoResolvedDialogKey = null;
     autoResolvedDialogGeneration = 0;
+    /** Per-launch safety phases survive startup handoff, redraws and failed/uncertain key ACKs. */
+    launchDialogClaims = null;
     /**
      * (#1103) Proof that THIS spawn's Codex went onto Luna Reserve: AgEnD saw (and
      * answered) the usage-limit menu that codex shows when it switches itself to
@@ -3166,8 +3168,9 @@ export class Daemon extends EventEmitter {
         const readyPattern = this.backend.getReadyPattern();
         const busyPattern = this.backend.getBusyPattern?.() ?? null;
         this.errorMonitorTimer = setInterval(async () => {
-            if (!this.tmux || this.spawning)
+            if (!this.tmux || this.spawning || this.deliveryWritesStopping)
                 return;
+            const pollTmux = this.tmux;
             // This poll belongs to the spawn and the monitors it started under. Every await below can outlive them (a stop,
             // a pause, a respawn); a stale poll must not touch state a newer one owns, so it checks before committing.
             const pollSpawn = this.spawnGeneration;
@@ -3176,18 +3179,19 @@ export class Daemon extends EventEmitter {
             const captureOrder = ++this.interactionCaptureSerial;
             const captureMono = performance.now();
             const stale = () => pollSpawn !== this.spawnGeneration || pollFence !== this.launchFenceEpoch
-                || !sameInteractionOwner(pollOwner, this.interactionOwner()) || this.runtimeMonitorsFrozen || this.spawning;
+                || !sameInteractionOwner(pollOwner, this.interactionOwner()) || this.runtimeMonitorsFrozen || this.spawning
+                || this.deliveryWritesStopping || this.tmux !== pollTmux;
             let scanStartedAt = null;
             const endScan = () => { if (scanStartedAt !== null)
                 noteSyncWork("daemon.errorMonitorScan", scanStartedAt); scanStartedAt = null; };
             try {
-                const alive = await this.tmux.isWindowAlive();
+                const alive = await pollTmux.isWindowAlive();
                 if (stale())
                     return;
                 if (!alive)
                     return;
                 const captureAt = Date.now();
-                const pane = await this.tmux.capturePane();
+                const pane = await pollTmux.capturePane();
                 // The scan of this pane is synchronous until it answers a dialog (an await) or ends: attributed (#1235).
                 scanStartedAt = performance.now();
                 if (stale())
@@ -3264,9 +3268,7 @@ export class Daemon extends EventEmitter {
                         continue;
                     }
                     const autoKey = dialog.autoResolutionKey;
-                    if (dialog.verifyAfterKeys && autoKey
-                        && this.autoResolvedDialogGeneration === this.spawnGeneration
-                        && this.autoResolvedDialogKey === autoKey) {
+                    if (dialog.verifyAfterKeys && autoKey && this.hasAutoDialogClaim(dialog)) {
                         // A previous poll sent the safety choice but the CLI has not
                         // repainted yet. Never send another Enter into the same screen.
                         continue;
@@ -3285,7 +3287,7 @@ export class Daemon extends EventEmitter {
                         const currentAt = Date.now();
                         const currentMono = performance.now();
                         const currentOrder = ++this.interactionCaptureSerial;
-                        const currentPane = await this.tmux.capturePane();
+                        const currentPane = await pollTmux.capturePane();
                         // Every await below can outlive the spawn / monitors this poll started under: after each one, before
                         // any state is touched or any further key is sent, `stale()` (fixed at the poll's start) is asked again.
                         if (stale())
@@ -3309,28 +3311,26 @@ export class Daemon extends EventEmitter {
                         // not evidence that the old request was answered, and the one-minute fallback must keep running.
                         if (this.dialogAnswers?.key === Daemon.answerKey(dialog) && this.dialogAnswers.screen !== before)
                             this.endDialogEpisode(dialog.requestIdentity !== undefined);
-                        if (dialog.verifyAfterKeys && autoKey
-                            && this.autoResolvedDialogGeneration === this.spawnGeneration
-                            && this.autoResolvedDialogKey === autoKey)
+                        if (dialog.verifyAfterKeys && autoKey && this.hasAutoDialogClaim(dialog))
                             return;
-                        if (dialog.verifyAfterKeys && autoKey) {
-                            this.autoResolvedDialogGeneration = this.spawnGeneration;
-                            this.autoResolvedDialogKey = autoKey;
-                        }
+                        if (dialog.verifyAfterKeys && autoKey)
+                            this.claimAutoDialog(dialog);
                         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) {
+                            if (stale())
+                                return;
                             let sent = false;
                             if (SPECIAL_KEYS.has(key)) {
-                                sent = await this.tmux.sendSpecialKey(key);
+                                sent = await pollTmux.sendSpecialKey(key);
                             }
                             else {
-                                sent = await this.tmux.pasteText(key, this.systemPasteOptions());
+                                sent = await pollTmux.pasteText(key, this.systemPasteOptions());
                             }
                             if (stale())
                                 return;
                             if (!sent) {
-                                if (dialog.verifyAfterKeys && autoKey) {
+                                if (dialog.verifyAfterKeys && autoKey && !dialog.oncePerLaunch) {
                                     this.autoResolvedDialogGeneration = 0;
                                     this.autoResolvedDialogKey = null;
                                 }
@@ -3345,7 +3345,7 @@ export class Daemon extends EventEmitter {
                             const afterKeysAt = Date.now();
                             const afterKeysMono = performance.now();
                             const afterKeysOrder = ++this.interactionCaptureSerial;
-                            const afterKeysPane = await this.tmux.capturePane();
+                            const afterKeysPane = await pollTmux.capturePane();
                             if (stale())
                                 return;
                             const dialogStillActive = dialog.inputBlocked
@@ -3375,7 +3375,7 @@ export class Daemon extends EventEmitter {
                             // backend-named identity any difference on the screen (a ticking timer) proves nothing either way: nothing
                             // is reported and the parked clock is left alone. Two requests that look exactly alike cannot be told apart.
                             await new Promise(r => setTimeout(r, DIALOG_ANSWER_SETTLE_MS));
-                            const afterPane = await this.tmux.capturePane();
+                            const afterPane = await pollTmux.capturePane();
                             if (stale())
                                 return; // (nothing was touched since the last check: only a read)
                             const stillThere = Daemon.dialogMatches(dialog, afterPane);
@@ -6727,6 +6727,32 @@ export class Daemon extends EventEmitter {
         }
         return active;
     }
+    hasAutoDialogClaim(dialog) {
+        const key = dialog.autoResolutionKey;
+        if (!key)
+            return false;
+        if (dialog.oncePerLaunch) {
+            const claims = this.launchDialogClaims;
+            return claims !== null && claims.spawn === this.spawnGeneration && claims.attempt === this.launchAttempt
+                && claims.keys.has(key);
+        }
+        return this.autoResolvedDialogGeneration === this.spawnGeneration && this.autoResolvedDialogKey === key;
+    }
+    claimAutoDialog(dialog) {
+        const key = dialog.autoResolutionKey;
+        if (!key)
+            return;
+        if (dialog.oncePerLaunch) {
+            if (!this.launchDialogClaims || this.launchDialogClaims.spawn !== this.spawnGeneration
+                || this.launchDialogClaims.attempt !== this.launchAttempt) {
+                this.launchDialogClaims = { spawn: this.spawnGeneration, attempt: this.launchAttempt, keys: new Set() };
+            }
+            this.launchDialogClaims.keys.add(key);
+            return;
+        }
+        this.autoResolvedDialogGeneration = this.spawnGeneration;
+        this.autoResolvedDialogKey = key;
+    }
     /** Whether a runtime prompt currently owns the pane's stdin. */
     isInputBlocked() {
         return this.inputBlockedDialogKey !== null;
@@ -6788,8 +6814,7 @@ export class Daemon extends EventEmitter {
             // this spawn is not what the screen is waiting on any more — the entry
             // after it (typically a hold) describes it.
             if (dialog.verifyAfterKeys && dialog.autoResolutionKey
-                && this.autoResolvedDialogGeneration === this.spawnGeneration
-                && this.autoResolvedDialogKey === dialog.autoResolutionKey
+                && this.hasAutoDialogClaim(dialog)
                 && dialogs.some(other => other !== dialog && Daemon.dialogMatches(other, pane)))
                 continue;
             this.trackDialogParked(dialog);
@@ -7766,6 +7791,10 @@ export class Daemon extends EventEmitter {
     async sendDeliveryEnter(phase, stillCurrent, durableAttempt) {
         if (!(await this.waitForInputTransientToClear(phase)))
             return false;
+        return this.sendDeliveryEnterAfterAvailability(phase, stillCurrent, durableAttempt);
+    }
+    /** Write half only: callers must finish the availability wait before any final recovery ownership proof. */
+    async sendDeliveryEnterAfterAvailability(phase, stillCurrent, durableAttempt) {
         // 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 (this.deliveryWritesStopping || (stillCurrent && !stillCurrent()))
@@ -8547,12 +8576,12 @@ export class Daemon extends EventEmitter {
         //    read as ours, we would press Enter to "recover" it, and the turn IT
         //    starts would confirm a message that never reached the pane.
         //
-        //    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.
+        //    Structured evidence (Claude's box and Codex's current input/footer pair) requires both snapshots to be READ.
+        //    An unreadable baseline says nothing about what the box held; treating it as empty would claim an older draft
+        //    as ours and press Enter on it (#1353/#1359). Codex's native warning viewer can ignore the paste and first Enter,
+        //    then reveal an older draft when the user dismisses it. Row-only backends retain their existing attribution.
         const attributable = baseline != null
-            && (!this.backend?.readInputRow || (baseline.inputReadable && after.inputReadable));
+            && (!this.structuredInputEvidence() || (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
@@ -8802,12 +8831,36 @@ export class Daemon extends EventEmitter {
             return true; // best effort, exactly as before — nothing here is verified
         }
         if (proof !== "submitted") {
-            // A bare Enter is a no-op at an empty prompt, so this is safe even if the
-            // first one did land; when the text is still in the input row it is the
-            // submit it never got. Re-pasting would append the text to itself.
             await new Promise(r => setTimeout(r, NORMAL_ENTER_SETTLE_MS));
-            if (!(await this.sendDeliveryEnter(`${label}-retry`, current)))
+            if (current && !current())
                 return false;
+            const retryPhase = `${label}-retry`;
+            if (this.structuredInputEvidence()) {
+                // Both the retry delay and the Enter availability wait may outlive the
+                // paste. Complete those waits BEFORE the last ownership/positive proof.
+                if (!(await this.waitForInputTransientToClear(retryPhase)))
+                    return false;
+                if (this.deliveryWritesStopping || (current && !current()))
+                    return false;
+                proof = await this.confirmSubmitted(signature, baseline);
+                if (this.deliveryWritesStopping || (current && !current()))
+                    return false;
+                if (proof === "submitted")
+                    return true;
+                if (proof !== "stranded") {
+                    this.logger.warn({ label, proof }, "System paste recovery input could not be attributed");
+                    return false;
+                }
+                // No further availability wait may invalidate this proof. The write
+                // half retains the same stopping/admission fence immediately before IPC.
+                if (!(await this.sendDeliveryEnterAfterAvailability(retryPhase, current)))
+                    return false;
+            }
+            else {
+                // Row-only backends retain their ordinary availability wait and retry.
+                if (!(await this.sendDeliveryEnter(retryPhase, current)))
+                    return false;
+            }
             proof = await this.confirmSubmitted(signature, baseline);
             if (current && !current())
                 return false;
@@ -9353,7 +9406,8 @@ export class Daemon extends EventEmitter {
             instanceName: this.name,
             mcpServers: isCliMode ? {} : {
                 "agend": {
-                    command: "node",
+                    // The Node this daemon runs on (#1450 C5): the CLIs start the MCP server with it, not a `node` from PATH.
+                    command: process.execPath,
                     args: [serverJs],
                     env: mcpEnv,
                 },
@@ -10499,7 +10553,8 @@ export class Daemon extends EventEmitter {
         const ownerTmux = this.tmux;
         const ownerSpawn = this.spawnGeneration;
         const ownerFence = this.launchFenceEpoch;
-        const owned = () => this.tmux === ownerTmux && this.spawnGeneration === ownerSpawn && this.launchFenceEpoch === ownerFence;
+        const owned = () => !this.deliveryWritesStopping && this.tmux === ownerTmux
+            && this.spawnGeneration === ownerSpawn && this.launchFenceEpoch === ownerFence;
         do {
             this.startupAdmission?.();
             attempts++;
@@ -10545,8 +10600,7 @@ export class Daemon extends EventEmitter {
                     if (Daemon.dialogMatches(dialog, pane)) {
                         if (dialog.autoResolutionKey
                             && (attemptedSafetyChoices.has(dialog.autoResolutionKey)
-                                || (this.autoResolvedDialogGeneration === this.spawnGeneration
-                                    && this.autoResolvedDialogKey === dialog.autoResolutionKey)))
+                                || this.hasAutoDialogClaim(dialog)))
                             continue;
                         lastDialog = dialog;
                         this.noteCodexReserveDialog(dialog, pane);
@@ -10610,8 +10664,7 @@ export class Daemon extends EventEmitter {
                             }
                             if (dialog.autoResolutionKey) {
                                 attemptedSafetyChoices.add(dialog.autoResolutionKey);
-                                this.autoResolvedDialogGeneration = ownerSpawn;
-                                this.autoResolvedDialogKey = dialog.autoResolutionKey;
+                                this.claimAutoDialog(dialog);
                             }
                             for (const key of dialog.keys) {
                                 this.startupAdmission?.();