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

package/dist/daemon.d.ts

@@ -12,7 +12,6 @@ import type { StormWindow } from "./storm-window.js";
 import type { BackendOutageView } from "./backend-outage.js";
 import { type DaemonDeliveryPort } from "./delivery-outbox.js";
 import type { InteractionSnapshot } from "./backend/types.js";
-/** Point a resumed CLI at its one backend-native instruction source. */
 export declare function buildInstructionReloadNotice(binaryName: string, instanceName: string, instanceDir: string): string;
 /**
  * Whether this backend has to be told in its pane that its instructions moved.
@@ -1209,6 +1208,8 @@ export declare class Daemon extends EventEmitter {
     pause(reason?: PauseReason): Promise<void>;
     /** Respawn the CLI in the preserved window and block until its prompt is ready. */
     wake(timeoutMs?: number): Promise<void>;
+    /** A reset baseline must settle before a launch admits new work. */
+    private resetTranscriptBeforeAdmission;
     /**
      * One line per edge, until the instance is flapping. The edges themselves are
      * still published to every observer; only the log is limited, so the next
@@ -1757,6 +1758,20 @@ export declare class Daemon extends EventEmitter {
      */
     private confirmAfterEnter;
     private confirmSubmitted;
+    /**
+     * The CLI's transcript, from this attempt's checkpoint, holds this delivery's exact marker: a user entry (read) or
+     * one it queued (taken into its queue). Either is the CLI having taken the
+     * message, so it outranks the pane — including a box that still shows the paste a moment after Enter (Claude paints
+     * the submit late, captured live on 2.1.293), which on its own reads as a strand. Positive only; never a downgrade.
+     */
+    private transcriptLook;
+    /**
+     * A write's transcript proof: bounded looks from its checkpoint, fenced to the write — its spawn and launch, a stop,
+     * and the caller's own fence — so a look that lands after any of them is never used (#1380 review).
+     */
+    private transcriptProofFor;
+    /** The CLI this daemon drives, for log lines shared by every backend ("claude-code", "codex", …). */
+    private cliLabel;
     /**
      * 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

package/dist/daemon.js

@@ -37,6 +37,7 @@ import { MuseUsageRelay, clearMuseUsageSnapshot } from "./muse-usage-relay.js";
 import { deliveryContentDigest } from "./delivery-outbox.js";
 import { queueResumePolicyForAttempt } from "./delivery-queue-evidence.js";
 import { scanTranscriptForDeliveryMarker } from "./delivery-reconciliation.js";
+import { TranscriptDeltaReader } from "./transcript-delta-reader.js";
 import { buildResumeContinuation, clearInFlightTurnMarker, consumeInFlightTurnMarker, decideTurnResume, normalizeResumeBackend, readResumeFingerprint, RESUME_BLOCKING_DELIVERY_STATES, writeInFlightTurnMarker, } from "./turn-resume.js";
 import { codexLiveRowMatches } from "./backend/codex.js";
 import { InteractionObservation, INTERACTION_CONFIRM_MS, sameInteractionOwner } from "./interaction-observation.js";
@@ -68,6 +69,10 @@ const REPLY_DROP_WARNING_COOLDOWN_MS = 5 * 60_000;
 const REPLY_GUARD_IDLE_CONFIRM_MS = 60_000;
 const REPLY_RECOVERY_PROMPT = "[system:reply-required] The previous human-facing turn ended without a successfully delivered reply. Do not redo the work. React with an emoji or use the reply tool exactly once now to send the user a concise conclusion. If no substantive answer is needed, a brief react is sufficient. If you already replied to this message, do nothing. Do not reply to this system instruction except through the react or reply tool.";
 /** Point a resumed CLI at its one backend-native instruction source. */
+/** The outbox evidence for a delivery the CLI's transcript shows taken (#758). */
+function transcriptMarkerEvidence(kind) {
+    return kind === "user" ? "transcript-marker" : "transcript-marker-queued";
+}
 export function buildInstructionReloadNotice(binaryName, instanceName, instanceDir) {
     const source = binaryName === "codex" || binaryName === "grok" || binaryName === "muse"
         ? "AGENTS.md"
@@ -1765,7 +1770,8 @@ export class Daemon extends EventEmitter {
             this.finishDurableDelivery(delivery, "delivered", OUTPUT_EDGE_ONLY_EVIDENCE);
             return;
         }
-        this.finishDurableDelivery(delivery, "delivered", "positive submission proof");
+        this.finishDurableDelivery(delivery, "delivered", verdict.transcriptProof
+            ? `positive submission proof; ${transcriptMarkerEvidence(verdict.transcriptProof)}` : "positive submission proof");
     }
     /**
      * Finish a delivery that only the output edge vouched for, by the delivery's own marker in the CLI's transcript (#758).
@@ -1794,7 +1800,7 @@ export class Daemon extends EventEmitter {
                 const found = await scanTranscriptForDeliveryMarker(checkpoint.path, checkpoint.offset, checkpoint.backend, delivery.deliveryId);
                 if (found === "user" || found === "queued") {
                     outcome = "delivered";
-                    evidence = found === "user" ? "transcript-marker" : "transcript-marker-queued";
+                    evidence = transcriptMarkerEvidence(found);
                     break;
                 }
                 last = found;
@@ -2073,6 +2079,15 @@ export class Daemon extends EventEmitter {
             // conversation store via a pluggable source. Backends with no known
             // source stay inert exactly as before.
             this.transcriptMonitor = new TranscriptMonitor(this.instanceDir, this.logger, createTranscriptSource(this.config.backend ?? "claude-code", this.config.working_directory, this.credentialProfileStore()));
+            const transcriptMonitor = this.transcriptMonitor;
+            const transcriptFence = this.launchFenceEpoch;
+            // Baseline in the isolate before this daemon accepts new work. A
+            // stopped/replaced launch may never re-arm polling after this await.
+            await transcriptMonitor.initialize();
+            if (this.startupAborted || this.launchFenceEpoch !== transcriptFence || this.transcriptMonitor !== transcriptMonitor) {
+                transcriptMonitor.stop();
+                return;
+            }
             // 5. Wire transcript events
             const ackIfPending = () => {
                 if (!this.pendingAckMessage || !this.adapter)
@@ -2843,7 +2858,13 @@ export class Daemon extends EventEmitter {
                         // was just stopped or paused (#1160 review).
                         if (this.runtimeMonitorsFrozen || this.healthCheckPaused)
                             return;
-                        this.transcriptMonitor?.resetOffset();
+                        // Reset is synchronous for file sources, but Kiro's baseline is
+                        // read off-thread. Finish it before starting the replacement CLI,
+                        // otherwise its first work could become part of that baseline.
+                        if (!await this.resetTranscriptBeforeAdmission())
+                            return;
+                        if (this.runtimeMonitorsFrozen || this.healthCheckPaused)
+                            return;
                         // Kill orphan MCP server from the crashed CLI session.
                         // MCP server writes its PID to channel.mcp.pid on startup.
                         try {
@@ -4252,50 +4273,77 @@ export class Daemon extends EventEmitter {
         // concurrency coordination, first output + idle is `budgetMs`, the dialog
         // scan is STARTUP_DIALOG_BUDGET_MS — so the outcome is always trySpawn's
         // own verdict. A soft timer only makes a slow wake visible in the log.
-        const transition = this.autoPauseController.wakeOnDeliver(async () => {
-            const slow = setTimeout(() => {
-                this.logger.warn({ budgetMs }, "Wake is exceeding its budget — still waiting for the spawn (it cannot be cancelled)");
-            }, budgetMs + STARTUP_DIALOG_BUDGET_MS);
-            slow.unref?.();
+        const wakeFence = this.launchFenceEpoch;
+        const wakeGeneration = this.spawnGeneration;
+        const isCurrent = () => !this.startupAborted && this.launchFenceEpoch === wakeFence
+            && this.spawnGeneration === wakeGeneration && this.pauseWakeState === "waking";
+        // The shared transition covers baseline initialization as well as spawn.
+        // Every wake().then(deliver) caller must wait for the same admission edge.
+        const transition = (async () => {
             try {
-                const ready = await this.trySpawn(true, budgetMs);
-                if (!ready)
-                    throw new Error(`Wake failed: the CLI did not become ready (budget ${budgetMs}ms)`);
+                await this.autoPauseController.wakeOnDeliver(async () => {
+                    const slow = setTimeout(() => {
+                        this.logger.warn({ budgetMs }, "Wake is exceeding its budget — still waiting for the spawn (it cannot be cancelled)");
+                    }, budgetMs + STARTUP_DIALOG_BUDGET_MS);
+                    slow.unref?.();
+                    try {
+                        const ready = await this.trySpawn(true, budgetMs);
+                        if (!ready)
+                            throw new Error(`Wake failed: the CLI did not become ready (budget ${budgetMs}ms)`);
+                    }
+                    finally {
+                        clearTimeout(slow);
+                    }
+                });
+                if (!isCurrent())
+                    throw new Error("Wake cancelled: the launch was superseded");
+                if (!await this.resetTranscriptBeforeAdmission() || !isCurrent()) {
+                    throw new Error("Wake cancelled: transcript initialization was superseded");
+                }
+                this.pauseWakeState = "active";
+                this.healthCheckPaused = false;
+                this.pauseRequested = false;
+                // trySpawn resolved only after the new CLI reached its ready prompt.
+                // Discard any recovery gate retained while monitors were frozen.
+                this.clearErrorRecoveryGate();
+                clearPausedMarker(this.instanceDir);
+                this.resumeRuntimeMonitors();
+                this.logger.info("Instance auto-woke");
+                this.ipcServer?.broadcast({
+                    type: "instance_state", instanceName: this.name, state: this.instanceState, pausedAt: null,
+                });
+                this.emit("auto_woke", { name: this.name });
+            }
+            catch (err) {
+                if (isCurrent()) {
+                    this.pauseWakeState = "paused";
+                    this.healthCheckPaused = true;
+                }
+                this.logger.error({ err: err.message }, "Instance wake failed");
+                throw err;
             }
             finally {
-                clearTimeout(slow);
+                this.endSpawn();
             }
-        });
+        })();
         this.pauseWakeTransition = transition;
         try {
             await transition;
-            this.pauseWakeState = "active";
-            this.healthCheckPaused = false;
-            this.pauseRequested = false;
-            // trySpawn resolved only after the new CLI reached its ready prompt.
-            // Discard any recovery gate retained while monitors were frozen.
-            this.clearErrorRecoveryGate();
-            clearPausedMarker(this.instanceDir);
-            this.transcriptMonitor?.resetOffset();
-            this.resumeRuntimeMonitors();
-            this.logger.info("Instance auto-woke");
-            this.ipcServer?.broadcast({
-                type: "instance_state", instanceName: this.name, state: this.instanceState, pausedAt: null,
-            });
-            this.emit("auto_woke", { name: this.name });
-        }
-        catch (err) {
-            this.pauseWakeState = "paused";
-            this.healthCheckPaused = true;
-            this.logger.error({ err: err.message }, "Instance wake failed");
-            throw err;
         }
         finally {
-            this.endSpawn();
             if (this.pauseWakeTransition === transition)
                 this.pauseWakeTransition = null;
         }
     }
+    /** A reset baseline must settle before a launch admits new work. */
+    async resetTranscriptBeforeAdmission() {
+        const monitor = this.transcriptMonitor;
+        const fence = this.launchFenceEpoch, generation = this.spawnGeneration;
+        monitor?.resetOffset();
+        await monitor?.initialize();
+        return !this.startupAborted && this.launchFenceEpoch === fence
+            && this.spawnGeneration === generation && this.transcriptMonitor === monitor;
+    }
     /**
      * One line per edge, until the instance is flapping. The edges themselves are
      * still published to every observer; only the log is limited, so the next
@@ -7553,6 +7601,11 @@ export class Daemon extends EventEmitter {
                         path: attemptEvidence.transcriptPath,
                         offset: attemptEvidence.transcriptOffset,
                     };
+                    // From here every proof of this write may also ask the CLI's transcript (the pane can lose the echo to the
+                    // reply, or still be painting the paste) — this delivery's exact marker only.
+                    if (["claude-code", "codex"].includes(attemptEvidence.backend)) {
+                        signature.transcript = this.transcriptProofFor(verdict.transcriptCheckpoint, durableAttempt.deliveryId, spawnAtWrite, stillCurrent, kind => { verdict.transcriptProof = kind; });
+                    }
                 }
             }
             if (rawPaste)
@@ -7745,7 +7798,7 @@ export class Daemon extends EventEmitter {
                     // message nobody submitted. Output is corroboration; text sitting in
                     // the input row is disqualifying, and disqualifying evidence wins.
                     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");
+                        this.logger.warn({ phase: "native-queue-submit", proof: afterEnter, strandedAt }, `${this.cliLabel()} recovery Enter outcome uncertain — no hard failure or duplicate paste`);
                         verdict.phase = "native-queue-submit";
                         verdict.proof = afterEnter;
                         return false;
@@ -7761,7 +7814,7 @@ export class Daemon extends EventEmitter {
                     // 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.
-                    this.logger.warn({ phase: "native-queue-proof", proof: settled }, "Codex native-queue outcome uncertain — not re-pasting");
+                    this.logger.warn({ phase: "native-queue-proof", proof: settled }, `${this.cliLabel()} native-queue outcome uncertain — not re-pasting`);
                     verdict.phase = "native-queue-proof";
                     verdict.proof = settled;
                     return false;
@@ -7871,7 +7924,7 @@ export class Daemon extends EventEmitter {
                         // although its echo had not appeared within the proof window. A
                         // missing viewport signature cannot establish non-delivery; keep
                         // 👀 and never emit the sender's hard ❌ or re-paste blindly.
-                        this.logger.warn({ phase: "post-submit-proof", proof }, "Codex delivery outcome uncertain — no hard failure or duplicate paste");
+                        this.logger.warn({ phase: "post-submit-proof", proof }, `${this.cliLabel()} delivery outcome uncertain — no hard failure or duplicate paste`);
                         verdict.phase = "post-submit-proof";
                         verdict.proof = proof;
                         return false;
@@ -7988,11 +8041,15 @@ export class Daemon extends EventEmitter {
             // here: the CLI may already be processing the unique message_id.
             let proof = "unproven";
             const firstDeadline = Date.now() + POST_ENTER_PROOF_WINDOW_MS;
+            // A structural box reader (claude-code) sees its box still holding the paste for a moment after an Enter it did
+            // take — Claude paints the submit late (captured live on 2.1.293: ~40 captures in a row). So for it a strand
+            // proves a swallowed Enter only once it outlasts the window; an early one is polled through. Codex keeps its rule.
+            const strandMustPersist = !!this.backend?.readInputRow;
             for (;;) {
                 proof = await this.confirmSubmitted(signature, baseline);
                 if (proof === "submitted")
                     return true;
-                if (proof === "stranded" || Date.now() >= firstDeadline)
+                if ((proof === "stranded" && !strandMustPersist) || Date.now() >= firstDeadline)
                     break;
                 await new Promise(r => setTimeout(r, POST_ENTER_PROOF_POLL_MS));
             }
@@ -8042,14 +8099,58 @@ export class Daemon extends EventEmitter {
     async confirmSubmitted(signature, baseline) {
         if (!this.tmux)
             return "unproven";
-        let pane;
+        let pane = null;
         try {
             pane = await this.tmux.capturePane();
         }
-        catch {
-            return "unproven";
-        }
-        return this.judgeSubmission(pane, signature, baseline);
+        catch { /* the transcript may still say */ }
+        const onPane = pane === null ? "unproven" : this.judgeSubmission(pane, signature, baseline);
+        if (onPane === "submitted")
+            return onPane;
+        const t = signature.transcript;
+        const found = await this.transcriptLook(signature);
+        // One synchronous stretch from here: the fence is asked after the last await, and only then is the hit kept and the
+        // spawn's guard retired — a stop or respawn that lands between the look and this line leaves both untouched.
+        if (!found || !t?.current())
+            return onPane;
+        if (!t.provenBy) {
+            t.provenBy = found;
+            t.onProof?.(found);
+        }
+        return this.submittedProof();
+    }
+    /**
+     * The CLI's transcript, from this attempt's checkpoint, holds this delivery's exact marker: a user entry (read) or
+     * one it queued (taken into its queue). Either is the CLI having taken the
+     * message, so it outranks the pane — including a box that still shows the paste a moment after Enter (Claude paints
+     * the submit late, captured live on 2.1.293), which on its own reads as a strand. Positive only; never a downgrade.
+     */
+    async transcriptLook(signature) {
+        const t = signature.transcript;
+        if (!t || !t.current())
+            return null;
+        if (t.provenBy)
+            return t.provenBy;
+        const found = await t.reader.look();
+        // No side effect here: the caller keeps the hit and retires the guard only after its own fence check.
+        return found === "user" || found === "queued" ? found : null;
+    }
+    /**
+     * A write's transcript proof: bounded looks from its checkpoint, fenced to the write — its spawn and launch, a stop,
+     * and the caller's own fence — so a look that lands after any of them is never used (#1380 review).
+     */
+    transcriptProofFor(checkpoint, deliveryId, spawnAtWrite, stillCurrent, onProof) {
+        const launchAtWrite = this.launchFenceEpoch;
+        return {
+            reader: new TranscriptDeltaReader(checkpoint.path, checkpoint.offset, checkpoint.backend, deliveryId),
+            current: () => !this.deliveryWritesStopping && this.spawnGeneration === spawnAtWrite
+                && this.launchFenceEpoch === launchAtWrite && (stillCurrent?.() ?? true),
+            onProof,
+        };
+    }
+    /** The CLI this daemon drives, for log lines shared by every backend ("claude-code", "codex", …). */
+    cliLabel() {
+        return this.config.backend ?? this.backend?.binaryName ?? "CLI";
     }
     /**
      * The verdict one snapshot supports — the live viewport, or (for a unique signature) the scrollback a late proof