@songsid/agend 2.2.0-beta.1 → 2.2.0-beta.3

package/dist/daemon.js

@@ -1,3 +1,4 @@
+import { AGENT_WHATS_NEW, agendVersion, planWhatsNew, readWhatsNewRecord, recordWhatsNew, whatsNewNotice } from "./agent-whats-new.js";
 import { join, dirname, basename, resolve } from "node:path";
 import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, unlinkSync, rmSync, appendFileSync, statSync, renameSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -77,10 +78,18 @@ const REPLY_GUARD_IDLE_CONFIRM_MS = 60_000;
  * down like a turn the transcript cannot place — never a recovery.
  */
 const TRANSCRIPT_RUNNING_HOLD_MAX_MS = 30 * 60_000;
+/**
+ * #1641: an open turn in the CLI's transcript holds the instance busy (no paste, whatever the pane shows) only while the
+ * transcript is still moving: a turn whose end was missed must not pin the instance busy forever. A live turn writes
+ * often; a long silent tool run shows its own busy row on the pane.
+ */
+export const TRANSCRIPT_OPEN_TURN_QUIET_MS = 15 * 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; #1201 absorbed). */
-function transcriptMarkerEvidence(kind) {
+/** The outbox evidence for a delivery the CLI's transcript shows taken (#758; #1201 absorbed; #1647 a raw paste's text). */
+function transcriptMarkerEvidence(kind, rawPaste = false) {
+    if (rawPaste)
+        return "transcript-turn-user-entry-raw-paste-text";
     return kind === "user" ? "transcript-marker" : kind === "absorbed" ? "transcript-marker-absorbed" : "transcript-marker-queued";
 }
 export function buildInstructionReloadNotice(binaryName, instanceName, instanceDir, backendSource) {
@@ -472,6 +481,16 @@ const POST_ENTER_PROOF_WINDOW_MS = 3_000;
 /** A final bounded observation before an ambiguous Codex submit can be classified. */
 const CODEX_LATE_PROOF_MS = 5_000;
 const POST_ENTER_PROOF_POLL_MS = 250;
+/** #1647: a raw paste a pane with no transcript showed taken — its text left the input row (or the CLI's own busy marker
+ * replaced it), with output after the Enter. */
+const RAW_PASTE_LEFT_INPUT = "raw-paste-left-input-after-output";
+/**
+ * #1647/#1663 P1-2: backends whose transcript AgEnD holds for this instance alone, so a raw paste's exact text in it is
+ * this paste's turn. claude-code: the path is its own statusline.json's transcript_path (written by this instance's
+ * CLI). Not codex: its rollout is chosen by working directory, which another instance can share, and AgEnD holds no
+ * session id to bind it — so a codex raw paste the pane could not prove stays uncertain.
+ */
+const RAW_TEXT_TRANSCRIPT_BACKENDS = ["claude-code"];
 /**
  * A readerless CLI's delivery is proven by its own transcript, which lags the pane by a flush. Only a delta that was
  * read and carried no marker for this long is held against the delivery — a late flush must not raise a false ⚠️.
@@ -1237,6 +1256,11 @@ export class Daemon extends EventEmitter {
     turnReplyGuard = new TurnReplyGuard();
     /** #1510: turn boundaries from the CLI's transcript, for a backend whose guard reads its turn end there. */
     transcriptTurns = new TranscriptTurnLedger();
+    /** #1641: when this launch's transcript monitor last read anything (a turn boundary, a tool, assistant text); performance.now(). */
+    transcriptActivityAt = 0;
+    /** #1641: the launch and composer a stuck pane's idle evidence is about, and since when (performance.now()); see recoverStuck. */
+    stuckRecoveryKey = null;
+    stuckRecoverySince = 0;
     /** #1510: since when (monotonic) this generation has been held as running in the transcript. */
     transcriptRunningSince = null;
     /** Prevent a visible stale XML fragment from being recovered on later turns. */
@@ -1388,6 +1412,8 @@ export class Daemon extends EventEmitter {
     recentPastes = [];
     pendingInstructionsUpdate;
     pendingInstructionsNotice = false;
+    /** #1633: the one-time "what's new for you" notice, pasted before the next real delivery; recorded once pasted. */
+    pendingWhatsNew = null;
     // Whether the warmup steering-reload notice should be injected after spawn.
     // Set in trySpawn by comparing the freshly-built instructions against the
     // last value the agent was told about (prev-instructions). Skipped when
@@ -1856,8 +1882,14 @@ export class Daemon extends EventEmitter {
             this.finishDurableDelivery(delivery, "delivered", OUTPUT_EDGE_ONLY_EVIDENCE);
             return;
         }
+        // #1647: a raw paste on a pane with no transcript (kiro), taken by the CLI as its own input row shows.
+        if (verdict.proof === RAW_PASTE_LEFT_INPUT) {
+            this.finishDurableDelivery(delivery, "delivered", verdict.proof, verdict);
+            return;
+        }
         this.finishDurableDelivery(delivery, "delivered", verdict.transcriptProof
-            ? `positive submission proof; ${transcriptMarkerEvidence(verdict.transcriptProof)}` : "positive submission proof", verdict);
+            ? `positive submission proof; ${transcriptMarkerEvidence(verdict.transcriptProof, verdict.submissionMode === "raw_paste")}`
+            : "positive submission proof", verdict);
     }
     /**
      * Finish a delivery that only the output edge vouched for, by the delivery's own marker in the CLI's transcript (#758).
@@ -1873,23 +1905,28 @@ export class Daemon extends EventEmitter {
      * TRANSCRIPT_PROOF_WINDOW_MS). It never finishes a row that stop has handed to reconciliation; a pause or respawn
      * only ends the wait, falling back to today's outcome.
      */
-    async proveDeliveryFromTranscript(delivery, checkpoint) {
+    async proveDeliveryFromTranscript(delivery, checkpoint, rawPaste) {
         const spawn = this.spawnGeneration;
         const fence = this.launchFenceEpoch;
         let last = "unavailable";
         let outcome = "delivered";
         let evidence = OUTPUT_EDGE_ONLY_EVIDENCE;
+        // #1647: a raw paste has no marker; its text is the needle, and its pane proof already failed — so without the turn
+        // in the transcript it stays uncertain (with the pane's reason), never the output-edge outcome.
+        const needle = rawPaste ? { rawText: rawPaste.text } : delivery.deliveryId;
+        let found = false;
         try {
             for (let polls = 0; polls <= TRANSCRIPT_PROOF_WINDOW_MS / TRANSCRIPT_PROOF_POLL_MS; polls++) {
                 if (this.deliveryWritesStopping)
                     return; // reconciliation owns the row now
-                const found = await scanTranscriptForDeliveryMarker(checkpoint.path, checkpoint.offset, checkpoint.backend, delivery.deliveryId);
-                if (found === "user" || found === "absorbed" || found === "queued") {
+                const look = await scanTranscriptForDeliveryMarker(checkpoint.path, checkpoint.offset, checkpoint.backend, needle);
+                if (look === "user" || look === "absorbed" || look === "queued") {
+                    found = true;
                     outcome = "delivered";
-                    evidence = transcriptMarkerEvidence(found);
+                    evidence = transcriptMarkerEvidence(look, !!rawPaste);
                     break;
                 }
-                last = found;
+                last = look;
                 if (spawn !== this.spawnGeneration || fence !== this.launchFenceEpoch) {
                     last = "unavailable";
                     break;
@@ -1909,6 +1946,11 @@ export class Daemon extends EventEmitter {
         catch (err) {
             this.logger.debug({ err }, "Transcript proof of a delivery failed — keeping the output-edge outcome");
         }
+        if (rawPaste && !found) {
+            outcome = "uncertain";
+            evidence = `${rawPaste.unproven}; no-transcript-turn (${last})`;
+            this.logger.warn({ deliveryId: delivery.deliveryId, cause: evidence }, "Raw paste outcome uncertain — not re-pasting");
+        }
         // The settlement itself can throw (e.g. the outbox store is unhealthy), and this runs on a detached `void`
         // promise: an uncaught throw is an unhandled rejection, which the fleet restart path turns into a global fault.
         // Settle observably and leave the row for reconciliation — never a false completion, never another paste (#1207 P2).
@@ -3719,7 +3761,18 @@ export class Daemon extends EventEmitter {
                 if (delivered)
                     this.finishDurableSubmission(durableAttempt ?? null, verdict);
                 else if (durableAttempt && verdict.paneWriteStarted) {
-                    this.finishDurableDelivery(durableAttempt, "uncertain", `${verdict.phase ?? "raw-paste"}:${verdict.proof ?? "unverified"}`);
+                    const unproven = `${verdict.phase ?? "raw-paste"}:${verdict.proof ?? "unverified"}`;
+                    const checkpoint = verdict.transcriptCheckpoint;
+                    if (checkpoint && RAW_TEXT_TRANSCRIPT_BACKENDS.includes(checkpoint.backend)) {
+                        // #1647: the pane could not show it, but the CLI's transcript records the turn the paste started — later
+                        // than the pane window sometimes. Wait for it there (bounded), off the paste lock.
+                        this.logger.info({ deliveryId: durableAttempt.deliveryId, unproven }, "Raw paste not proven on the pane — asking the CLI's transcript for the turn it started");
+                        void this.proveDeliveryFromTranscript(durableAttempt, checkpoint, { text: rawText, unproven });
+                    }
+                    else {
+                        this.logger.warn({ deliveryId: durableAttempt.deliveryId, cause: unproven }, "Raw paste outcome uncertain — not re-pasting");
+                        this.finishDurableDelivery(durableAttempt, "uncertain", unproven);
+                    }
                 }
                 else if (durableAttempt && verdict.durableBeginCommitted) {
                     this.abortDurableDelivery(durableAttempt, `${verdict.phase ?? "raw-paste"}:${verdict.proof ?? "no-pane-write"}`);
@@ -5041,9 +5094,68 @@ export class Daemon extends EventEmitter {
     buildTranscriptMonitor(source) {
         const monitor = new TranscriptMonitor(this.instanceDir, this.logger, source);
         this.transcriptTurns.reset();
-        monitor.on("turns", (turns) => this.transcriptTurns.observe(turns));
+        this.transcriptActivityAt = 0;
+        // Monotonic: a wall-clock correction must neither end nor extend the open-turn hold (#1641 R1).
+        const touch = () => { this.transcriptActivityAt = performance.now(); };
+        monitor.on("turns", (turns) => { this.transcriptTurns.observe(turns, performance.now()); touch(); });
+        // #1641 R2: a re-baselined source starts over, and so does what it said (an open turn read before is withdrawn).
+        monitor.on("reset", () => { if (this.transcriptMonitor === monitor) {
+            this.transcriptTurns.reset();
+            this.transcriptActivityAt = 0;
+        } });
+        for (const event of ["tool_use", "tool_result", "assistant_text"])
+            monitor.on(event, touch);
         return monitor;
     }
+    /**
+     * #1641: what the CLI's own transcript (codex's rollout) says about its turn. `open`: a turn started and has not ended,
+     * and the transcript moved within TRANSCRIPT_OPEN_TURN_QUIET_MS. `closed`: every turn read since this launch's monitor
+     * began has ended. `unknown`: not a transcript backend, nothing followed, or an open turn gone quiet (a missed end).
+     */
+    transcriptTurnState(now = performance.now()) {
+        if (this.backend?.turnEndFromTranscript !== true || this.transcriptMonitor?.following() !== true)
+            return "unknown";
+        // #1641 R2: an empty ledger after a baseline that could not see the current turn's start is not "closed".
+        if (this.transcriptMonitor.turnStateKnown?.() !== true)
+            return "unknown";
+        const since = this.transcriptTurns.openSince();
+        if (since === null)
+            return "closed";
+        return now - Math.max(since, this.transcriptActivityAt) < TRANSCRIPT_OPEN_TURN_QUIET_MS ? "open" : "unknown";
+    }
+    /**
+     * #1641: a stuck pane that is in fact an idle CLI (a footer this build cannot read) must not stay stuck for hours with
+     * every delivery parked behind it. It recovers when the backend sees its own live, EMPTY composer with no busy, queued
+     * or dialog marker (isStableUnknownLayoutIdlePane) AND the transcript shows no open turn — or, with no transcript to
+     * ask, that same composer held unchanged for UNKNOWN_LAYOUT_STABLE_MS (#978's rule). An open turn never recovers.
+     */
+    recoverStuck(pane, snapshot, changeAt, turn) {
+        const machine = this.instanceStateMachine;
+        const idleComposer = this.backend?.isStableUnknownLayoutIdlePane?.(pane) === true;
+        // The resume load (#1031: `Resuming session…` over the same composer) is input that is not open yet (#1641 R1).
+        if (!machine || !idleComposer || turn === "open" || this.inputTransientInPane(pane)) {
+            this.stuckRecoveryKey = null;
+            return snapshot;
+        }
+        // The evidence is about this launch and this screen. Once it holds, it keeps holding — a still pane reads stuck
+        // again at the next sweep (its footer is still unreadable) and must not start the window over (#1641 R1).
+        const mono = performance.now();
+        const key = `${this.spawnGeneration}:${this.launchAttempt}\n${pane.replace(/⋆/gu, "").replace(/[ \t]+$/gmu, "")}`;
+        if (key !== this.stuckRecoveryKey) {
+            this.stuckRecoveryKey = key;
+            this.stuckRecoverySince = mono;
+        }
+        if (turn === "unknown" && mono - this.stuckRecoverySince < UNKNOWN_LAYOUT_STABLE_MS)
+            return snapshot;
+        // A footer this build cannot read stays unreadable: the same still pane reads stuck again at every sweep and is
+        // recovered again. Only the edge into idle is news.
+        const fields = { evidence: turn === "closed" ? "transcript_no_open_turn" : "stable_empty_composer", unchangedForMs: snapshot.unchangedForMs };
+        if (this.instanceState !== "idle")
+            this.logger.info(fields, "Stuck instance recovered — the CLI shows its idle composer and is not running a turn (#1641)");
+        else
+            this.logger.debug(fields, "Still idle on its unreadable footer — the stuck reading was recovered again (#1641)");
+        return machine.observe(pane, Date.now(), { settled: true, changeAt, forceReady: true });
+    }
     replyCompletionGuardEnabled() {
         return this.config.reply_completion_guard !== false
             && this.backend?.replyCompletionGuard === true;
@@ -5425,7 +5537,9 @@ export class Daemon extends EventEmitter {
                     // a pair every ~1.6s for as long as the repaint lasted (#1116). Real
                     // work cannot hide behind this: it changes the layout, the next
                     // output arms another probe, and the debounce capture still fires.
-                    if (this.instanceState === "idle" && this.backend?.isPeriodicRedrawIdlePane?.(pane) === true)
+                    // #1641: never while the transcript shows a turn running — that idle-looking screen is mid-turn.
+                    if (this.instanceState === "idle" && this.backend?.isPeriodicRedrawIdlePane?.(pane) === true
+                        && this.transcriptTurnState() !== "open")
                         return;
                     // A second burst overtook the probe. Do not bless its stale capture as
                     // idle: continuous output is the safer working signal, while the next
@@ -5458,6 +5572,10 @@ export class Daemon extends EventEmitter {
             // decisions about *now*. The old double-observe expressed that by calling
             // observe twice, which silently disabled the "content moved" branch.
             const structuredPeriodicIdle = this.backend?.isPeriodicRedrawIdlePane;
+            // #1641: the transcript outranks the pane: while it shows the turn running, no reading of this pane is idle (codex
+            // hides its status row while streaming, leaving the idle composer and footer in view mid-turn).
+            const transcriptTurn = this.transcriptTurnState();
+            const transcriptBusy = transcriptTurn === "open";
             let snapshot;
             if (deliveryFallback !== null) {
                 // A missing footer cannot fall through to a broad ready match. All
@@ -5466,7 +5584,7 @@ export class Daemon extends EventEmitter {
                     settled: true,
                     changeAt: observedChangeAt,
                     forceReady: deliveryFallback,
-                    forceBusy: !deliveryFallback || paneActivity !== null,
+                    forceBusy: !deliveryFallback || paneActivity !== null || transcriptBusy,
                 });
             }
             else if (structuredPeriodicIdle && reason === "output_probe") {
@@ -5488,6 +5606,7 @@ export class Daemon extends EventEmitter {
                         snapshot = this.instanceStateMachine.observe(pane, Date.now(), {
                             settled: true,
                             changeAt: observedChangeAt,
+                            forceBusy: transcriptBusy,
                         });
                     }
                 }
@@ -5521,6 +5640,7 @@ export class Daemon extends EventEmitter {
                             settled: true,
                             changeAt: observedChangeAt,
                             forceReady: true,
+                            forceBusy: transcriptBusy,
                         });
                     }
                     else {
@@ -5569,6 +5689,7 @@ export class Daemon extends EventEmitter {
                     snapshot = this.instanceStateMachine.observe(pane, Date.now(), {
                         settled: true,
                         changeAt: observedChangeAt,
+                        forceBusy: transcriptBusy,
                     });
                 }
                 else {
@@ -5586,9 +5707,11 @@ export class Daemon extends EventEmitter {
                 snapshot = this.instanceStateMachine.observe(pane, Date.now(), {
                     settled,
                     changeAt: observedChangeAt,
-                    forceBusy: paneActivity !== null,
+                    forceBusy: paneActivity !== null || transcriptBusy,
                 });
             }
+            if (snapshot.state === "stuck")
+                snapshot = this.recoverStuck(pane, snapshot, observedChangeAt, transcriptTurn);
             this.applyInstanceStateSnapshot(snapshot, pane);
             // Backends without a transcript feed can still say what they are doing, if
             // their TUI names it. Free-riding on a capture that already happened: no
@@ -6011,12 +6134,14 @@ export class Daemon extends EventEmitter {
      * here — a steered message must read EXACTLY like a queued one to the
      * agent, or the two drift apart in what the agent is told about replying.
      */
+    /** #1650: how this instance talks to the fleet — MCP tools, or agend-agent commands (agent_mode: cli). */
+    agentMode() { return this.config.agent_mode === "cli" ? "cli" : "mcp"; }
     formatInboundMessage(content, meta) {
         const user = meta.user || "unknown";
         const fromInstance = meta.from_instance;
         let formatted;
         if (fromInstance) {
-            formatted = formatCrossInstanceInboundMessage(content, meta);
+            formatted = formatCrossInstanceInboundMessage(content, meta, this.agentMode());
         }
         else {
             const via = meta.source ? ` via ${meta.source}` : "";
@@ -6029,7 +6154,10 @@ export class Daemon extends EventEmitter {
                 formatted = `[Recent reactions: ${meta.pending_reactions}]\n${formatted}`;
             }
             formatted += renderHandoffMetadata(meta);
-            formatted += "\n(Reply using the reply tool — do NOT respond with direct text)";
+            // #1650: a CLI-mode agent has no reply tool — it answers with the agend-agent command.
+            formatted += this.agentMode() === "cli"
+                ? '\n(Reply with agend-agent reply "…" — do NOT respond with direct text)'
+                : "\n(Reply using the reply tool — do NOT respond with direct text)";
         }
         if (meta.reply_to_text) {
             formatted += `\n(reply_to: "${meta.reply_to_text}")`;
@@ -6291,6 +6419,23 @@ export class Daemon extends EventEmitter {
                     if (!this.isDeliveryEpochCurrent(deliveryEpoch))
                         return;
                 }
+                const whatsNew = this.pendingWhatsNew ? this.currentWhatsNew(this.pendingWhatsNew) : null;
+                if (whatsNew) {
+                    // #1633: here, inside the delivery lock and ahead of a real delivery — never into a busy turn, never to an
+                    // instance nobody writes to. Recorded only once pasted: a failed or cancelled paste stays pending.
+                    const pasted = await this.deliverMessage(whatsNew.notice, undefined, { deliveryEpoch });
+                    if (pasted && this.pendingWhatsNew === whatsNew) {
+                        this.pendingWhatsNew = null;
+                        try {
+                            recordWhatsNew(this.instanceDir, whatsNew.ids, whatsNew.version);
+                        }
+                        catch (err) {
+                            this.logger.warn({ err }, "what's-new record not written — the notice may repeat once");
+                        }
+                    }
+                    if (!this.isDeliveryEpochCurrent(deliveryEpoch))
+                        return;
+                }
                 const status = channelStatus(meta);
                 // A fresh delivery begins a fresh turn — its bubble must not inherit
                 // the previous turn's tool list.
@@ -7663,6 +7808,33 @@ export class Daemon extends EventEmitter {
             this.logger.warn("Could not read the pane after Enter — not confirming the submission");
         return sawOutput && residue === "absent";
     }
+    /**
+     * #1647: whether a raw paste on a pane with no transcript (kiro) was taken: its text gone from the input row (or the
+     * CLI's own busy marker shown instead — pasteResidue's rule) with output after the Enter. That is the confirmation's
+     * own rule, looked at more than once: kiro repaints its composer late, so the single look right after Enter misread
+     * pastes it took. A generic `working` reading is not evidence (#1663 P1-3: a repaint looks like work).
+     *
+     * Bounded by the budget that confirmation already has, measured from the Enter (#1663 P2-1): the busy wait plus the
+     * post-Enter proof window. Every reading is asked again after its await — still this write's owner (`current`: the
+     * caller's fence, no stop, the same tmux and spawn, #1663 P2-2) and still inside the budget — before it counts; a late
+     * or fenced answer proves nothing. Null: not shown — the caller settles uncertain, never a second Enter.
+     */
+    async rawPasteTakenOnPane(windowId, enterAt, enterMono, formatted, current) {
+        const deadline = enterMono + CONFIRM_BUSY_POLLS * CONFIRM_BUSY_POLL_MS + POST_ENTER_PROOF_WINDOW_MS;
+        const live = () => current() && performance.now() <= deadline;
+        for (;;) {
+            if (!live())
+                return null;
+            if (this.controlClient?.hasOutputSince?.(windowId, enterAt)) {
+                const residue = await this.pasteResidue(formatted);
+                if (!live())
+                    return null;
+                if (residue === "absent")
+                    return RAW_PASTE_LEFT_INPUT;
+            }
+            await new Promise(r => setTimeout(r, POST_ENTER_PROOF_POLL_MS));
+        }
+    }
     /** Once Kiro returns to its prompt, its unique envelope id in history proves submission. */
     async kiroSubmissionEvidence(windowId, formatted, signature) {
         if (!this.tmux)
@@ -7975,9 +8147,11 @@ export class Daemon extends EventEmitter {
                         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; });
+                    // reply, or still be painting the paste) — this delivery's exact marker only, or a raw paste's exact text (#1647).
+                    // A raw paste's text only where the transcript is this instance's alone (RAW_TEXT_TRANSCRIPT_BACKENDS).
+                    if (["claude-code", "codex"].includes(attemptEvidence.backend)
+                        && (!rawPaste || RAW_TEXT_TRANSCRIPT_BACKENDS.includes(attemptEvidence.backend))) {
+                        signature.transcript = this.transcriptProofFor(verdict.transcriptCheckpoint, rawPaste ? { rawText: formatted } : durableAttempt.deliveryId, spawnAtWrite, stillCurrent, kind => { verdict.transcriptProof = kind; });
                     }
                 }
             }
@@ -8068,6 +8242,7 @@ export class Daemon extends EventEmitter {
                 steerEnterDeadline = deadline;
             }
             let enterAt = Date.now();
+            const enterMono = performance.now();
             const steerEnterCurrent = () => steerCurrent() && performance.now() <= steerEnterDeadline;
             if (!(await this.sendDeliveryEnter("initial-submit", steerComposerProof ? steerEnterCurrent : undefined, durableAttempt))) {
                 if (steerComposerProof && !steerCurrent()) {
@@ -8313,12 +8488,20 @@ export class Daemon extends EventEmitter {
                         return { kind: "kiro-pending", windowId, spawnGeneration: this.spawnGeneration, signature };
                     }
                 }
-                if (!submitted) {
-                    if (rawPaste) {
+                if (!submitted && rawPaste) {
+                    // #1647: kiro paints output at once but its composer late, so one residue look right after Enter misreads a
+                    // paste it took. Keep looking within the confirmation's own budget from the Enter, under this write's fence;
+                    // never a second Enter (a raw command must not run twice).
+                    const taken = await this.rawPasteTakenOnPane(windowId, enterAt, enterMono, formatted, steerCurrent);
+                    if (!taken) {
                         verdict.phase = "raw-paste-submit-proof";
                         verdict.proof = "no-positive-acceptance-proof";
                         return false;
                     }
+                    verdict.proof = taken;
+                    submitted = true;
+                }
+                if (!submitted) {
                     // 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");
@@ -8631,10 +8814,10 @@ export class Daemon extends EventEmitter {
      * 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) {
+    transcriptProofFor(checkpoint, needle, spawnAtWrite, stillCurrent, onProof) {
         const launchAtWrite = this.launchFenceEpoch;
         return {
-            reader: new TranscriptDeltaReader(checkpoint.path, checkpoint.offset, checkpoint.backend, deliveryId),
+            reader: new TranscriptDeltaReader(checkpoint.path, checkpoint.offset, checkpoint.backend, needle),
             current: () => !this.deliveryWritesStopping && this.spawnGeneration === spawnAtWrite
                 && this.launchFenceEpoch === launchAtWrite && (stillCurrent?.() ?? true),
             onProof,
@@ -10426,6 +10609,49 @@ export class Daemon extends EventEmitter {
         }
         catch { /* non-fatal */ }
     }
+    /**
+     * #1633 (#1639 review): the pending notice as the record stands NOW, just before the paste — it was decided at launch,
+     * and the record may have changed while the delivery waited. Unreadable → nothing is sent (and nothing pending);
+     * entries recorded meanwhile are dropped from it; none left → nothing.
+     */
+    currentWhatsNew(pending) {
+        const record = readWhatsNewRecord(this.instanceDir);
+        if (record === "unreadable") {
+            this.pendingWhatsNew = null;
+            return null;
+        }
+        const known = new Set(record?.announced ?? []);
+        const ids = pending.ids.filter(id => !known.has(id));
+        if (!ids.length) {
+            this.pendingWhatsNew = null;
+            return null;
+        }
+        if (ids.length === pending.ids.length)
+            return pending;
+        const narrowed = { notice: whatsNewNotice(pending.version, AGENT_WHATS_NEW.filter(e => ids.includes(e.id))), ids, version: pending.version };
+        this.pendingWhatsNew = narrowed;
+        return narrowed;
+    }
+    /** #1633: what this instance has not been told about its AgEnD version yet (see agent-whats-new.ts). */
+    prepareWhatsNew(fresh, version = agendVersion()) {
+        try {
+            const plan = planWhatsNew({ record: readWhatsNewRecord(this.instanceDir), fresh, version });
+            if (!plan) {
+                this.pendingWhatsNew = null;
+                return;
+            }
+            if ("silent" in plan) {
+                recordWhatsNew(this.instanceDir, plan.silent, plan.version);
+                this.pendingWhatsNew = null;
+                return;
+            }
+            this.pendingWhatsNew = plan;
+            this.logger.info({ entries: plan.ids }, "what's-new notice pending for the next delivery");
+        }
+        catch (err) {
+            this.logger.debug({ err }, "what's-new not prepared");
+        }
+    }
     async trySpawnInsideGate(reuseWindow = false, startupTimeoutMs) {
         this.startupAdmission?.();
         const launchFence = this.launchFenceEpoch;
@@ -10435,6 +10661,8 @@ export class Daemon extends EventEmitter {
         // instructionsReloadedOnResume) so the warmup steering-reload can be
         // skipped when nothing changed.
         this.lastBuiltInstructions = backendConfig.instructions ?? "";
+        // #1633: decided before prev-instructions is first written — its absence is what says "never launched before".
+        this.prepareWhatsNew(!existsSync(join(this.instanceDir, "prev-instructions")));
         {
             const prevFile = join(this.instanceDir, "prev-instructions");
             let prev = "";