@songsid/agend 2.3.1 → 2.3.2-beta.10

package/dist/daemon.js

@@ -1,3 +1,4 @@
+import { dashboardAccessOf } from "./dashboard-permissions.js";
 import { agentWhatsNew, agendVersion, planWhatsNew, readWhatsNewRecord, recordWhatsNew, whatsNewNotice } from "./agent-whats-new.js";
 import { join, dirname, resolve } from "node:path";
 import { checkoutTarget, readCheckouts, releaseCandidate, reposRoot, verifyWorktree, writeCheckouts } from "./repo-worktree-guard.js";
@@ -42,11 +43,12 @@ import { parseReplyButtons, replyButtonsFallbackText } from "./reply-buttons.js"
 import { HangDetector } from "./hang-detector.js";
 import { writeSecretFile } from "./secret-file.js";
 import { PaneWriteLock } from "./pane-write-lock.js";
+import { answerRemoteCard } from "./remote-card-answer.js";
 import { buildFleetInstructions } from "./instructions.js";
 import { formatHumanInboundMessage, prepareDeliveryWire, steerInboundEnvelope, BTW_INBOUND_PREFIX, humanBodyHash, humanOwnerObjectId } from "./human-delivery-receipts.js";
 import { formatCrossInstanceInboundMessage, renderCrossInstanceHandoffMetadata, } from "./cross-instance-envelope.js";
 import { agendMessageInInput, bottomRowIsReady, inputAreaText, inputShowsPastedText, pastedTextSignature, pasteLeftInInput, strandedAgendMessageInInput } from "./pane-input-residue.js";
-import { TurnReplyGuard } from "./turn-reply-guard.js";
+import { TurnReplyGuard, formatReplyDropDetection, turnExpectsPersonReply } from "./turn-reply-guard.js";
 import { t } from "./locale.js";
 import { MuseUsageRelay, clearMuseUsageSnapshot } from "./muse-usage-relay.js";
 import { deliveryContentDigest } from "./delivery-outbox.js";
@@ -86,6 +88,8 @@ const WEB_THEME_IPC = Object.freeze({
     apply_web_effect: "fleet_apply_web_effect",
     remove_web_effect: "fleet_remove_web_effect",
     delete_web_effect: "fleet_delete_web_effect",
+    // #2578: its own character in the Office view — the args as they are (the fleet checks them).
+    office_view: "fleet_office_view", office_set: "fleet_office_set",
 });
 /** The largest picture any slot may take (a card slot's ceiling; the fleet checks the limit in force): read no more. */
 const WEB_THEME_ASSET_MAX_BYTES = ASSET_UPLOAD_MAX_BYTES;
@@ -570,6 +574,8 @@ export const OWN_SWITCH_WAIT_MS = 6_000;
 const OWN_SWITCH_SETTLE_MS = 3_000;
 /** A blocking dialog still on screen this long after first being seen is reported for a human. */
 const DIALOG_PARKED_NOTIFY_MS = 60_000;
+/** #2675: a card a person can answer from the chat is posted once it has been on screen, unchanged, this long. */
+const REMOTE_CARD_STABLE_MS = 1_500;
 /** #1691: a prompt no table knows must sit unchanged this long (monotonic) before it holds deliveries and is reported. */
 export const UNRECOGNISED_PROMPT_STABLE_MS = 60_000;
 /** #1691: the rows under a prompt a backend without a composer reader shows its ready chrome in (status bar, hint). */
@@ -1245,6 +1251,8 @@ export class Daemon extends EventEmitter {
      * skipResume — the #1209 gate reads this, never the resettable flag.
      */
     bootSkippedResume = false;
+    recoveryCrashLoopFresh = false;
+    recoveryFreshChoice = false;
     startupAborted = false;
     /** First time the current on-screen blocking dialog was seen (0 = none); drives the parked report. */
     dialogParkedSince = 0;
@@ -1252,6 +1260,12 @@ export class Daemon extends EventEmitter {
     dialogParkedKey = null;
     dialogParkedInteractionEpisode = null;
     dialogParkedReported = false;
+    /** #2675: the card on screen that a person can answer from the chat — what it asks, since when, and whether it was posted. */
+    remoteCardShown = null;
+    /** #2675: when (performance.now, taken before its capture) the newest read the card tracker used was started. */
+    remoteCardReadAt = -Infinity;
+    /** #2675: an answer from the chat is being keyed in (one at a time). */
+    remoteCardAnswering = false;
     /**
      * #1691: the prompt at the bottom of the pane that no backend table knows — its block, since when (performance.now)
      * it has been unchanged, and whether that has lasted UNRECOGNISED_PROMPT_STABLE_MS. Updated by the runtime scan.
@@ -1747,6 +1761,11 @@ export class Daemon extends EventEmitter {
         return `${ep.type}:${ep.pattern.source}`;
     }
     /** Read the occurrence baseline so a lifecycle-owned restart can carry it forward. */
+    /** #2648: kiro only — what a model error on the current launch should do (see kiro-retired-model.ts). */
+    kiroModelError() {
+        const backend = this.backend;
+        return typeof backend?.onModelError === "function" ? backend.onModelError() : null;
+    }
     getErrorPatternOccurrenceCount(type, pattern) {
         return this.lastErrorCount.get(`${type}:${pattern.source}`) ?? 0;
     }
@@ -1823,6 +1842,9 @@ export class Daemon extends EventEmitter {
         this.spawnGate = spawnGate;
         this.stormWindow = stormWindow;
         this.backendOutage = backendOutage;
+        // The live process owns its adopted configuration. Fleet defaults may be re-resolved in place after a save;
+        // sharing that object would activate cold changes before the normal restart/apply boundary.
+        this.config = structuredClone(config);
         if (!rootLogger)
             throw new Error("Daemon requires a shared root logger");
         this.runtimeIdentity ??= {
@@ -2203,6 +2225,7 @@ export class Daemon extends EventEmitter {
     }
     async startAdmitted() {
         this.assertSessionOomAdmission();
+        this.recoveryBootWorkPending = true;
         ensureInstanceDir(this.instanceDir);
         writeFileSync(join(this.instanceDir, "daemon.pid"), String(process.pid));
         this.logger.info(`Starting ${this.name}`);
@@ -2211,6 +2234,8 @@ export class Daemon extends EventEmitter {
         // even when the JSON is corrupt so it cannot remain forever.
         const crashStatePath = join(this.instanceDir, "crash-state.json");
         this.bootSkippedResume = false;
+        this.recoveryCrashLoopFresh = false;
+        this.recoveryFreshChoice = false;
         try {
             if (existsSync(crashStatePath)) {
                 const content = readFileSync(crashStatePath, "utf-8");
@@ -2219,6 +2244,10 @@ export class Daemon extends EventEmitter {
                     if (state?.resumeDisabled === true) {
                         this.skipResume = true;
                         this.bootSkippedResume = true;
+                        this.recoveryCrashLoopFresh = (state.reason === undefined || state.reason === "crash_loop")
+                            && Number.isInteger(state.crashesInWindow) && state.crashesInWindow >= 3
+                            && Number.isFinite(state.lastCrashAt) && state.lastCrashAt > 0;
+                        this.recoveryFreshChoice = !this.recoveryCrashLoopFresh;
                         this.logger.warn("Previous crash loop detected — starting without resume");
                     }
                 }
@@ -2367,12 +2396,19 @@ export class Daemon extends EventEmitter {
         // #1209: conditional continuation for the turn interrupted by the last
         // restart, if the gates allow. Detached like the warmup notice; the gate
         // consumes its one-shot marker first and never throws into boot.
-        void this.maybeResumeInterruptedTurn().catch(() => { });
+        const legacyResume = this.maybeResumeInterruptedTurn().catch(() => "unknown");
         // Warmup: wait for CLI idle, then trigger steering reload — but only when
         // the instructions actually changed since the agent last saw them.
         // Skipping the no-op reload saves 10-30s of agent time on every restart
         // where instructions are unchanged.
-        void this.runWarmupInstructionNotice();
+        const warmup = this.runWarmupInstructionNotice();
+        const recoveryOwner = JSON.stringify(this.interactionOwner());
+        void Promise.allSettled([legacyResume, warmup]).then(() => {
+            if (JSON.stringify(this.interactionOwner()) === recoveryOwner) {
+                this.recoveryBootWorkPending = false;
+                this.recoveryBootSettled = true;
+            }
+        });
         if (!this.config.lightweight) {
             // 3. Pipe-pane for prompt detection. Rotate first so a ballooned log from a
             // previous stuck splash (hundreds of MB of ANSI frames) is truncated before
@@ -2384,7 +2420,7 @@ export class Daemon extends EventEmitter {
             // (statusline transcript); codex/kiro/opencode read their CLI's own
             // conversation store via a pluggable source. Backends with no known
             // source stay inert exactly as before.
-            this.transcriptMonitor = this.buildTranscriptMonitor(createTranscriptSource(this.config.backend ?? "claude-code", this.config.working_directory, this.credentialProfileStore()));
+            this.transcriptMonitor = this.buildTranscriptMonitor(createTranscriptSource(this.config.backend ?? "claude-code", this.config.working_directory, this.credentialProfileStore(), () => this.backend?.transcriptLaunch?.() ?? null));
             const transcriptMonitor = this.transcriptMonitor;
             const transcriptFence = this.launchFenceEpoch;
             // Baseline in the isolate before this daemon accepts new work. A
@@ -3716,6 +3752,7 @@ export class Daemon extends EventEmitter {
                 if (!answersBackedOff)
                     this.dialogAnswers = null;
                 this.trackDialogParked(blockingSeen);
+                this.trackRemoteCard(blockingSeen, pane, captureMono);
                 if (blockingSeen)
                     return; // held dialog: skip error checks this cycle
                 this.evaluateErrorPatterns(pane, patterns, readyPattern, Date.now(), busyPattern);
@@ -3974,6 +4011,7 @@ export class Daemon extends EventEmitter {
     clearPendingDeliveries(fleetEpoch) {
         // FleetManager calls this synchronously before sendEscape. Cancel only the
         // current human turn; leave already-forwarded tool requests to settle.
+        this.recoveryCancelled = true;
         this.turnReplyGuard.cancelByUser();
         // #1241: a cancelled turn never confirms — its next edge completes it as
         // intentional. Drop a pending confirmation so it cannot promote afterwards.
@@ -3985,6 +4023,7 @@ export class Daemon extends EventEmitter {
         this.deliveryEpoch = fleetEpoch === undefined
             ? this.deliveryEpoch + 1
             : Math.max(this.deliveryEpoch, fleetEpoch);
+        this.cancelCapacityNudge("the user cancelled");
         this.publishWorkingState("cancelled");
         this.logger.info({ deliveryEpoch: this.deliveryEpoch }, "Pending delivery queue cleared by user cancel");
     }
@@ -4703,6 +4742,88 @@ export class Daemon extends EventEmitter {
     getInteractionSnapshot() {
         return this.interactionObservation.snapshot(this.interactionOwner());
     }
+    ownedWorkingSession = null;
+    recoveryBootSettled = false;
+    recoveryBootWorkPending = false;
+    recoveryLegacyCovered = false;
+    recoveryNativeWork = false;
+    recoveryContinuationId = null;
+    recoveryCancelled = false;
+    workingRecoveryInputOwner = null;
+    noteLegacyRestartReminder() { this.recoveryLegacyCovered = true; }
+    getWorkingRecoveryState() {
+        const observation = this.getWorkingStateObservation();
+        const owner = JSON.stringify(observation.owner), ownsInput = this.workingRecoveryInputOwner === owner;
+        return { owner, configuration: observation.configuration,
+            sessionId: this.ownedWorkingSession, idle: (ownsInput || this.instanceState === "idle") && this.pasteQueueDepth === 0,
+            paused: this.isPaused, stopped: this.isSessionOomStopped(), legacyPending: !this.recoveryBootSettled,
+            legacyCovered: this.recoveryLegacyCovered, nativeWork: !ownsInput && this.recoveryNativeWork,
+            freshChoice: this.recoveryFreshChoice || this.isNewSession && !this.bootSkippedResume, crashLoopFresh: this.recoveryCrashLoopFresh,
+            cancelled: this.recoveryCancelled, background: this.workingBackgroundObservation };
+    }
+    /** Local system work: no user turn, channel reply target, wake or replay of an original request. */
+    async deliverWorkingRecovery(content, delivery, admitted) {
+        const tmux = this.tmux, owner = JSON.stringify(this.interactionOwner()), epoch = this.deliveryEpoch;
+        const current = () => this.tmux === tmux && owner === JSON.stringify(this.interactionOwner())
+            && this.deliveryEpoch === epoch && !this.deliveryWritesStopping && !this.runtimeMonitorsFrozen
+            && !this.spawning && !this.startupAborted && !this.isPaused && !this.healthCheckPaused
+            && this.processStatus === "running" && this.pasteQueueDepth === 0
+            && (this.workingRecoveryInputOwner === owner || this.instanceState === "idle" && !this.recoveryNativeWork)
+            && this.recoveryBootSettled && !this.recoveryCancelled && !this.isSessionOomStopped() && admitted();
+        let begun = false;
+        try {
+            await this.paneWriteLock.run(async () => {
+                if (!tmux || !current())
+                    return;
+                const pane = await tmux.capturePane();
+                const input = this.backend?.readInputRow?.(pane);
+                if (!current() || !input || input.text !== "" || input.collapsedPastes !== 0 || input.queued
+                    || !this.paneAuthoritativelyIdle(pane) || this.inputTransientInPane(pane)
+                    || this.backend?.backgroundWorkRunning?.(pane) === true)
+                    return;
+                if (await tmux.getPaneInputMode?.() !== "raw" || !current())
+                    return;
+                const evidence = await this.durableAttemptEvidence(tmux.getWindowId(), false, false);
+                if (!current())
+                    return;
+                const signature = this.submissionSignature(content), baseline = this.paneEvidence(pane, signature);
+                const attempt = { ...delivery, contentSha256: deliveryContentDigest(content) };
+                if (!this.beginDurableDelivery(attempt, evidence))
+                    return;
+                begun = true;
+                // Own PTY input immediately produces a working observation. It must not
+                // cancel this same fenced write; external queue/cancel/owner guards stay.
+                this.workingRecoveryInputOwner = owner;
+                // Conservatively commit possible input BEFORE paste, not merely before Enter.
+                // A process death at any later boundary must never replay this continuation.
+                if (!this.deliveryOutbox?.markEnterStarted(delivery.deliveryId, this.bootId, delivery.attemptNo))
+                    return;
+                if (!current() || !await tmux.pasteBuffer(content, { guard: current }) || !current())
+                    return;
+                await new Promise(resolve => setTimeout(resolve, NORMAL_ENTER_SETTLE_MS));
+                if (!current() || !await this.sendDeliveryEnterAfterAvailability("working-recovery", current, attempt))
+                    return;
+                const proof = await this.confirmSubmitted(signature, baseline);
+                const committed = this.deliveryOutbox.complete(delivery.deliveryId, this.bootId, delivery.attemptNo, proof === "submitted" ? "delivered" : "uncertain", "local continuation Enter attempted once; no replay");
+                if (committed && proof === "submitted" && current()) {
+                    this.recoveryContinuationId = delivery.deliveryId;
+                    this.publishWorkingState("execution");
+                }
+            });
+        }
+        catch { /* The durable fence below owns ambiguity; never retry a begun write. */ }
+        finally {
+            if (this.workingRecoveryInputOwner === owner) {
+                this.workingRecoveryInputOwner = null;
+                if (this.tmux === tmux && owner === JSON.stringify(this.interactionOwner()))
+                    this.recoveryNativeWork = true;
+            }
+            if (begun)
+                this.deliveryOutbox?.complete(delivery.deliveryId, this.bootId, delivery.attemptNo, "uncertain", "local continuation may have reached input; not replayed");
+            else
+                this.deliveryOutbox?.retryBeforeBegin(delivery.deliveryId, this.bootId, delivery.attemptNo, "working recovery prerequisite changed before input", 5_000);
+        }
+    }
     workingTurnDelivery = null;
     workingBackgroundObservation = null;
     /** Pure metadata read: never discovers sessions, captures a pane or reads backend files. */
@@ -4714,7 +4835,8 @@ export class Daemon extends EventEmitter {
             owner: this.interactionOwner(), backend,
             configuration: createHash("sha256").update(JSON.stringify([backend, this.config.working_directory, profile])).digest("hex"),
             executionState: this.processStatus === "running" ? this.isPaused ? "paused" : this.instanceState : null,
-            processStatus: this.getProcessStatus(), sessionId: null, backendTurnId: null,
+            processStatus: this.getProcessStatus(), sessionId: this.ownedWorkingSession, backendTurnId: null,
+            ...(this.recoveryContinuationId ? { recoveryDeliveryId: this.recoveryContinuationId } : {}),
             backgroundWork: this.workingBackgroundObservation,
             turn: turn ? { generation: turn.generation,
                 deliveryId: this.workingTurnDelivery?.generation === turn.generation ? this.workingTurnDelivery.deliveryId : null,
@@ -5174,6 +5296,9 @@ export class Daemon extends EventEmitter {
             if (unblockedTurn && unblockedTurn.phase === "awaiting")
                 this.maybeProxyReplyOnTurnEnd(pane);
         }
+        if (snapshot.state === "working" && this.recoveryBootSettled
+            && this.workingRecoveryInputOwner !== JSON.stringify(this.interactionOwner()))
+            this.recoveryNativeWork = true;
         this.instanceState = snapshot.state;
         this.acceptedInstanceSnapshot = { ...snapshot };
         // Reuse an already-captured pane and the backend's pure parser, never capture for the journal.
@@ -5290,14 +5415,21 @@ export class Daemon extends EventEmitter {
         // Its late success must not re-arm the turn that the user just cancelled.
         if (!this.isDeliveryEpochCurrent(deliveryEpoch))
             return;
-        // Channel turns only. A cross-instance inbound (from_instance, empty
-        // chat_id) does not update lastChatId, so its proxy reply would land in
-        // whatever USER topic spoke to this instance last — the wrong audience for
-        // a task result, and a stale one (sol's review of #515).
-        // A web message on a fleet with no chat platform has no chat_id (its reply goes to the web chat through the fleet's
-        // web-only sink), but it is a person waiting for an answer all the same: the guard arms for it (alpha.2).
-        if (meta.from_instance || (!meta.chat_id && meta.source !== "web"))
+        // Channel turns started by a person. Cross-instance, schedules (silent or
+        // not), and AgEnD system notices must not expect a reply to a person (#2544):
+        // a proxy or recovery notice would land in the last USER topic, or flag a
+        // heartbeat that was told not to report. A web message on a fleet with no
+        // chat platform has no chat_id (its reply goes to the web chat through the
+        // fleet's web-only sink), but it is a person waiting for an answer all the
+        // same: the guard arms for it (alpha.2).
+        if (!turnExpectsPersonReply(meta)) {
+            this.logger.debug({
+                source: meta.source || null,
+                user: meta.user || null,
+                from_instance: meta.from_instance || null,
+            }, "Reply guard skipped — turn was not started by a person");
             return;
+        }
         // The last non-empty line of what we pasted: everything on screen after it
         // is the agent's own output.
         const inboundMarker = deliveredText.split(/\r?\n/).map(l => l.trim()).filter(Boolean).pop();
@@ -5314,7 +5446,8 @@ export class Daemon extends EventEmitter {
             deliveredText,
             deliveredAt,
         }, this.pendingWork.lastInboundTimestamp());
-        this.workingTurnDelivery = { generation: this.turnReplyGuard.snapshot().generation, deliveryId: meta.delivery_id || null };
+        const armed = this.turnReplyGuard.snapshot();
+        this.workingTurnDelivery = { generation: armed.generation, deliveryId: meta.delivery_id || null };
         this.publishWorkingState("turn_started");
         // #1209: persist the in-flight turn with a seam checkpoint. A marker
         // that survives a restart is an interrupted turn by construction —
@@ -5323,7 +5456,9 @@ export class Daemon extends EventEmitter {
         // the interruption. Reads are windowed/bounded (see turn-resume.ts).
         // A resumed continuation never re-arms (P3a): episode-once means a crash
         // during the continuation boots clean instead of chaining resumes.
-        if (!meta.resumedContinuationOf) {
+        // #2544: a reply that settled before this arm already answered the person —
+        // writing a marker would re-inject a continuation for a finished turn.
+        if (!meta.resumedContinuationOf && !armed.completionDelivered) {
             const resumeBackend = this.config.backend ?? this.backend?.binaryName ?? this.runtimeIdentity?.backend;
             const resumeCwd = this.config.working_directory ?? "";
             writeInFlightTurnMarker(this.instanceDir, {
@@ -5371,6 +5506,7 @@ export class Daemon extends EventEmitter {
         const marker = consumeInFlightTurnMarker(this.instanceDir);
         if (!marker)
             return "none";
+        this.recoveryLegacyCovered = true;
         // P1 fence: capture before any await. A cancel (deliveryEpoch),
         // respawn (spawnGeneration) or stop/pause (launchFenceEpoch) during the
         // grace hold must stale this gate — the push below rechecks, and the
@@ -5736,8 +5872,8 @@ export class Daemon extends EventEmitter {
             generation: turn.generation,
             reason,
             recoveryStarted: true,
+            message: formatReplyDropDetection(turn, reason),
         });
-        void this.deliverDaemonReply(t("inst.reply_drop_retrying"), "replydrop", "Reply-drop status", turn.target, true);
         this.queueReplyRecoveryPrompt(turn);
     }
     reportReplyDropWithoutRetry(turn, reason) {
@@ -5747,8 +5883,8 @@ export class Daemon extends EventEmitter {
             generation: turn.generation,
             reason,
             recoveryStarted: false,
+            message: formatReplyDropDetection(turn, reason),
         });
-        void this.deliverDaemonReply(t("inst.reply_drop_unknown"), "replydrop", "Unconfirmed reply status", turn.target, true);
     }
     queueReplyRecoveryPrompt(turn) {
         const deliveryEpoch = this.deliveryEpoch;
@@ -5840,13 +5976,22 @@ export class Daemon extends EventEmitter {
             correlationId: turn.target.correlationId,
             generation: turn.generation,
             reason,
+            message: formatReplyDropDetection(turn, reason),
         });
-        const now = Date.now();
-        if (this.lastReplyDropWarningAt !== 0
-            && now - this.lastReplyDropWarningAt < REPLY_DROP_WARNING_COOLDOWN_MS)
-            return;
-        this.lastReplyDropWarningAt = now;
-        void this.deliverDaemonReply(t("inst.reply_drop_unrecovered"), "replydropwarn", "Reply-drop recovery warning", turn.target, true);
+        this.deliverReplyDropNotice("inst.reply_drop_unrecovered", "replydropwarn", "Reply-drop recovery warning", turn, reason, true);
+    }
+    /** Channel notice for a reply-drop. `rateLimit` shares the per-instance cooldown (#2544). */
+    deliverReplyDropNotice(key, kind, title, turn, reason, rateLimit) {
+        if (rateLimit) {
+            const now = Date.now();
+            if (this.lastReplyDropWarningAt !== 0
+                && now - this.lastReplyDropWarningAt < REPLY_DROP_WARNING_COOLDOWN_MS) {
+                this.logger.debug({ reason, kind }, "Reply-drop channel notice rate-limited");
+                return;
+            }
+            this.lastReplyDropWarningAt = now;
+        }
+        void this.deliverDaemonReply(t(key), kind, title, turn.target, true);
     }
     /** Relay the pane's final text to the channel, marked as a daemon proxy reply. */
     async sendProxyReply(pane, target) {
@@ -6444,6 +6589,7 @@ export class Daemon extends EventEmitter {
     }
     /** Stop every runtime poller/watcher while preserving IPC and daemon state. */
     freezeRuntimeMonitors() {
+        this.cancelCapacityNudge("the instance was stopped, paused or respawned");
         this.runtimeMonitorsFrozen = true;
         this.launchFenceEpoch++;
         this.interactionObservation.reset(this.interactionOwner());
@@ -6542,6 +6688,10 @@ export class Daemon extends EventEmitter {
         if (update.tool_progress === null || ["off", "standard", "verbose"].includes(String(update.tool_progress))) {
             this.updateToolProgress(update.tool_progress === null ? undefined : update.tool_progress);
         }
+        if (typeof update.reply_triggers === "boolean")
+            this.config.reply_triggers = update.reply_triggers;
+        else if (update.reply_triggers === null)
+            delete this.config.reply_triggers;
         if (typeof update.reply_completion_guard === "boolean") {
             this.config.reply_completion_guard = update.reply_completion_guard;
         }
@@ -6556,6 +6706,10 @@ export class Daemon extends EventEmitter {
             this.config.warm_cap = update.warm_cap;
         else if (update.warm_cap === null)
             delete this.config.warm_cap;
+        if (typeof update.resume_interrupted_work === "boolean")
+            this.config.resume_interrupted_work = update.resume_interrupted_work;
+        else if (update.resume_interrupted_work === null)
+            delete this.config.resume_interrupted_work;
         const nextAutoPause = typeof update.auto_pause_after === "number"
             && Number.isFinite(update.auto_pause_after)
             && update.auto_pause_after >= 0
@@ -6591,6 +6745,10 @@ export class Daemon extends EventEmitter {
         else if (update.board_cards_at_once === null)
             delete this.config.board_cards_at_once;
         // The fleet reads it at each tool call; kept current here for the next spawn's tool menu.
+        if (typeof update.office_access === "boolean")
+            this.config.office_access = update.office_access;
+        else if (update.office_access === null)
+            delete this.config.office_access;
         if (update.dashboard && typeof update.dashboard === "object" && !dashboardAccessProblem(update.dashboard))
             this.config.dashboard = update.dashboard;
         else if (update.dashboard === null)
@@ -7820,15 +7978,18 @@ export class Daemon extends EventEmitter {
                 && dialogs.some(other => other !== dialog && Daemon.dialogMatches(other, pane)))
                 continue;
             this.trackDialogParked(dialog);
+            this.trackRemoteCard(dialog, pane, probeMono);
             return { state: "dialog", dialog };
         }
         this.trackDialogParked(null);
+        this.trackRemoteCard(null, pane, probeMono);
         return { state: "clear" };
     }
     /**
      * Arm the "keep going" nudge for the error occurrence just reported (`pattern` must be the one the lifecycle was
      * handed). The nudge is sent once, `delayMs` from now on the MONOTONIC clock (a wall-clock step changes nothing),
-     * and only if nothing has changed by then — see {@link tickCapacityNudge}. Returns false when there is nothing to arm.
+     * and only if the failed turn still owns an empty idle composer — see {@link tickCapacityNudge}.
+     * Cosmetic footer redraws are not new work. Returns false when there is nothing to arm.
      */
     armCapacityNudge(pattern, delayMs) {
         const episode = this.lastErrorEpisode;
@@ -7847,9 +8008,12 @@ export class Daemon extends EventEmitter {
         // lookahead on the counting pattern: whole-pane dedup would max at 1 and miss later hits. See #1215.)
         if (!codexLiveRowMatches(episode.pane, pattern))
             return false;
+        this.cancelCapacityNudge("the instance has work of its own");
         this.capacityNudge = {
             pane: episode.pane, pattern, spawn: episode.spawn, fence: episode.fence,
             epoch: this.deliveryEpoch, dueAt: performance.now() + delayMs,
+            episode,
+            promiseTarget: null,
         };
         this.logger.info({ delayMs }, "Model-capacity nudge armed");
         return true;
@@ -7864,7 +8028,7 @@ export class Daemon extends EventEmitter {
         const nudge = this.capacityNudge, episode = this.lastErrorEpisode;
         const tmux = this.tmux, attempt = this.launchAttempt, boot = this.bootId;
         this.cancelCapacityNudge("retries exhausted");
-        if (!nudge || !episode || !tmux)
+        if (!nudge || !episode || nudge.episode !== episode || !tmux)
             return null;
         const window = tmux.getWindowId?.();
         const current = () => this.tmux === tmux && tmux.getWindowId?.() === window
@@ -7872,9 +8036,7 @@ export class Daemon extends EventEmitter {
             && episode === this.lastErrorEpisode && this.isDeliveryEpochCurrent(nudge.epoch)
             && !this.startupAborted && !this.spawning && !this.isPaused
             && this.getProcessStatus() === "running" && this.instanceState === "idle" && this.pasteQueueDepth === 0;
-        const accepts = (pane) => pane === nudge.pane && this.paneAuthoritativelyIdle(pane)
-            && this.backend?.isPeriodicRedrawIdlePane?.(pane) === true
-            && codexLiveRowMatches(pane, nudge.pattern) && !this.backend?.backgroundWorkRunning?.(pane);
+        const accepts = (pane) => this.capacityNudgePaneCurrent(nudge, pane);
         const revalidate = () => this.paneWriteLock.run(async () => {
             if (!current())
                 return false;
@@ -7896,10 +8058,35 @@ export class Daemon extends EventEmitter {
     }
     /** Drop an armed nudge (the user stopped / paused the instance, or the lifecycle gave up on it). */
     cancelCapacityNudge(reason) {
-        if (!this.capacityNudge)
+        const nudge = this.capacityNudge;
+        if (!nudge)
             return;
         this.capacityNudge = null;
         this.logger.info({ reason }, "Model-capacity nudge cancelled");
+        this.reportCapacityNudgeCancelled(nudge, reason);
+    }
+    /** Only a dispatched channel promise needs a later cancellation notice. */
+    markCapacityNudgePromised(target) {
+        if (this.capacityNudge)
+            this.capacityNudge.promiseTarget = target;
+    }
+    reportCapacityNudgeCancelled(nudge, reason) {
+        const target = nudge.promiseTarget;
+        if (!target)
+            return;
+        nudge.promiseTarget = null;
+        this.emit("capacity_nudge_cancelled", { name: this.name, reason, target });
+    }
+    /**
+     * A failed turn must still be the last live transcript item, with no new
+     * error occurrence, draft, queue, busy status or background work. Codex's
+     * own periodic-redraw idle classifier recognises its empty composer/footer;
+     * never infer inactivity from byte equality or a cached idle state alone.
+     */
+    capacityNudgePaneCurrent(nudge, pane) {
+        return this.paneAuthoritativelyIdle(pane) && this.backend?.isPeriodicRedrawIdlePane?.(pane) === true
+            && !this.backend?.backgroundWorkRunning?.(pane) && codexLiveRowMatches(pane, nudge.pattern)
+            && Daemon.countOccurrences(nudge.pattern, pane) === Daemon.countOccurrences(nudge.pattern, nudge.pane);
     }
     /** The first live composer of a spawn fixes what is history (see {@link nudgeBaselines}). */
     takeNudgeBaselines(pane, patterns) {
@@ -7922,8 +8109,8 @@ export class Daemon extends EventEmitter {
     }
     /**
      * One monitor poll's look at an armed nudge. It is CANCELLED — never postponed — when anything about the instance
-     * moved: a stop / pause / respawn (spawn generation or monitor epoch), a user cancel (delivery epoch), the pane no
-     * longer being exactly the one the error was seen on (it moved on by itself, a person typed, another dialog), the
+     * moved: a stop / pause / respawn (spawn generation or monitor epoch), a user cancel (delivery epoch), the pane
+     * no longer belonging to the failed turn (new output, a draft, another dialog), the
      * agent working, or a message waiting for delivery. Only when it is due and still untouched is it fired — once — and
      * the injection re-verifies everything under the pane-write lock.
      */
@@ -7933,10 +8120,11 @@ export class Daemon extends EventEmitter {
             return;
         const gone = nudge.spawn !== this.spawnGeneration || nudge.fence !== this.launchFenceEpoch ? "the instance was stopped, paused or respawned"
             : !this.isDeliveryEpochCurrent(nudge.epoch) ? "the user cancelled"
-                : this.isPaused || this.healthCheckPaused || this.getProcessStatus() === "stopped" ? "the instance is not running"
-                    : pane !== nudge.pane ? "the screen changed"
+                : nudge.episode !== this.lastErrorEpisode ? "the instance has work of its own"
+                    : this.isPaused || this.healthCheckPaused || this.getProcessStatus() === "stopped" ? "the instance is not running"
                         : this.instanceState === "working" || this.pasteQueueDepth > 0 ? "the instance has work of its own"
-                            : null;
+                            : !this.capacityNudgePaneCurrent(nudge, pane) ? "the failed turn is no longer idle with an empty input"
+                                : null;
         if (gone) {
             this.cancelCapacityNudge(gone);
             return;
@@ -7944,29 +8132,38 @@ export class Daemon extends EventEmitter {
         if (performance.now() < nudge.dueAt)
             return;
         this.capacityNudge = null; // fired: once per episode
-        void this.sendCapacityNudge(nudge).catch(err => this.logger.warn({ err: err.message }, "Model-capacity nudge failed"));
+        void this.sendCapacityNudge(nudge).catch(err => {
+            this.logger.warn({ err: err.message }, "Model-capacity nudge failed");
+            this.reportCapacityNudgeCancelled(nudge, "the retry could not be submitted");
+        });
     }
     async sendCapacityNudge(nudge) {
         // Everything the nudge was armed under, asked again after EVERY await that precedes a write — inside the paste
         // primitive too (its capture, its paste, its pause, its Enter, its retry): once any of it is false nothing more is
         // written. A message queued behind the lock, or the agent starting a turn, is "work of its own" like at the poll.
         const current = () => nudge.spawn === this.spawnGeneration && nudge.fence === this.launchFenceEpoch
+            && nudge.episode === this.lastErrorEpisode
             && this.isDeliveryEpochCurrent(nudge.epoch) && !this.isPaused && !this.healthCheckPaused
             && !this.startupAborted && this.getProcessStatus() !== "stopped"
             && this.pasteQueueDepth === 0 && this.instanceState !== "working";
         // Exclusive with every delivery: nothing can paste a turn between the verdict below and the nudge.
-        await this.paneWriteLock.run(async () => {
-            if (!this.tmux)
-                return;
-            // ONE capture decides: it must be exactly the screen the error was seen on AND an idle composer. (A second picture
-            // vouching for the first — "same screen" here, "idle" there — would let a half-typed draft through.)
-            const sent = await this.submitSystemPaste(t("inst.codex_capacity_nudge_text"), "capacity-continue", {
-                current,
-                accept: pane => pane === nudge.pane && this.paneAuthoritativelyIdle(pane)
-                    && codexLiveRowMatches(pane, nudge.pattern),
+        let sent = false;
+        try {
+            await this.paneWriteLock.run(async () => {
+                if (!this.tmux)
+                    return;
+                // ONE capture decides failed-turn ownership and empty/idle input.
+                sent = await this.submitSystemPaste(t("inst.codex_capacity_nudge_text"), "capacity-continue", {
+                    current,
+                    accept: pane => this.capacityNudgePaneCurrent(nudge, pane),
+                });
+                this.logger.info({ sent }, "Model-capacity nudge attempted");
             });
-            this.logger.info({ sent }, "Model-capacity nudge attempted");
-        });
+        }
+        finally {
+            if (!sent)
+                this.reportCapacityNudgeCancelled(nudge, "the retry could not be submitted");
+        }
     }
     /** What identifies the request on screen: the backend's own identity when it has one, else the whole screen verbatim. */
     static screenOf(dialog, pane) {
@@ -8026,6 +8223,73 @@ export class Daemon extends EventEmitter {
         this.logger.warn({ dialog: dialog.description, attempts: episode.ignored, holdsDeliveries }, "Runtime dialog is ignoring AgEnD's answer — reporting for a human");
         this.emit("dialog_answer_ignored", { name: this.name, description: dialog.description, attempts: episode.ignored, holdsDeliveries });
     }
+    /**
+     * #2675: a held card a person can answer from the chat (the dialog's remoteCard reader) is posted once it has stayed
+     * the same card for REMOTE_CARD_STABLE_MS — `remote_card` with what it asks; the fleet posts it with its buttons. When
+     * it closes or another card replaces it, `remote_card_gone` retires that post. Moving through the card (ours or the
+     * person's in the pane) is the same card: its identity has no cursor. `readAt` is when the pane's capture was started
+     * (performance.now): a read that started before the newest one used here finishes late and says nothing about now —
+     * it may neither retire a newer card nor bring an older one back (#2677 review).
+     */
+    trackRemoteCard(dialog, pane, readAt) {
+        if (readAt < this.remoteCardReadAt)
+            return;
+        this.remoteCardReadAt = readAt;
+        const card = dialog?.remoteCard?.(pane) ?? null;
+        const shown = this.remoteCardShown;
+        if (shown && shown.identity !== card?.identity) {
+            this.remoteCardShown = null;
+            if (shown.posted)
+                this.emit("remote_card_gone", { name: this.name, identity: shown.identity });
+        }
+        if (!card)
+            return;
+        if (!this.remoteCardShown) {
+            this.remoteCardShown = { identity: card.identity, since: performance.now(), posted: false };
+            return;
+        }
+        if (this.remoteCardShown.posted || performance.now() - this.remoteCardShown.since < REMOTE_CARD_STABLE_MS)
+            return;
+        this.remoteCardShown.posted = true;
+        this.logger.info({ kind: card.kind }, "A card a person can answer from the chat is on screen — posting it");
+        this.emit("remote_card", { name: this.name, card });
+    }
+    /**
+     * #2675: answer the card on screen from the chat, as the person chose: only while it is the card they saw
+     * (`identity`), on a verified cursor, under the pane write lock (remote-card-answer.ts). Never logs the answer.
+     */
+    async answerRemoteCard(identity, action) {
+        const tmux = this.tmux;
+        const readers = this.runtimeDialogs().filter(dialog => dialog.remoteCard);
+        if (!tmux || readers.length === 0)
+            return { outcome: "stale" };
+        if (this.remoteCardAnswering)
+            return { outcome: "refused", reason: "another answer to this card is being keyed in" };
+        this.remoteCardAnswering = true;
+        try {
+            const outcome = await answerRemoteCard({
+                locked: fn => this.paneWriteLock.run(fn),
+                // An unreadable screen (a failed capture, another spawn's pane) is unknown — never "the card closed".
+                read: () => this.tmux === tmux ? tmux.capturePane().catch(() => null) : Promise.resolve(null),
+                key: key => this.tmux !== tmux ? Promise.resolve(false) : key === "Space" ? tmux.sendKeys(" ") : tmux.sendSpecialKey(key),
+                paste: text => this.tmux !== tmux ? Promise.resolve(false) : tmux.pasteBuffer(text),
+                sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
+                now: () => performance.now(),
+            }, pane => {
+                for (const dialog of readers) {
+                    const card = dialog.remoteCard(pane);
+                    if (card)
+                        return card;
+                }
+                return null;
+            }, identity, action);
+            this.logger.info({ action: action.kind, ...outcome }, "Answered a card from the chat");
+            return outcome;
+        }
+        finally {
+            this.remoteCardAnswering = false;
+        }
+    }
     /**
      * Remember how long a blocking dialog has been on screen. Once it has
      * outlived DIALOG_PARKED_NOTIFY_MS — the auto-dismiss did not take, or the
@@ -10233,7 +10497,9 @@ export class Daemon extends EventEmitter {
                 // false and must not clear the window either.
                 if (replyAttempt?.completionAction) {
                     const snap = this.turnReplyGuard.snapshot();
-                    if (snap?.generation === replyAttempt.generation && snap.phase === "awaiting"
+                    // generation 0 is a pre-arm token applied to the live generation (#2544).
+                    if (snap && (snap.generation === replyAttempt.generation || replyAttempt.generation === 0)
+                        && snap.phase === "awaiting"
                         && snap.completionDelivered && !snap.cancelledByUser) {
                         this.clearReplyGuardConfirm();
                     }
@@ -10654,7 +10920,7 @@ export class Daemon extends EventEmitter {
             fleetCwd: process.cwd(),
             onWarning: (warning) => {
                 if (warning.problem === "fleet_dir_fallback") {
-                    this.logger.warn({ field: warning.field, path: warning.path, legacyPath: warning.legacyPath }, `${warning.field} file: ref is not under the instance's working directory (${warning.path}); read ${warning.legacyPath} from the fleet directory instead — make the path absolute or move the file. The fallback is removed in 2.2.`);
+                    this.logger.warn({ field: warning.field, path: warning.path, legacyPath: warning.legacyPath }, `${warning.field} file: ref is not under the instance's working directory (${warning.path}); read ${warning.legacyPath} from the fleet directory instead — make the path absolute or move the file. A later release will remove this fallback.`);
                     const key = `${warning.field}:${warning.path}`;
                     if (!this.promptFileFallbackNoticed.has(key)) {
                         this.promptFileFallbackNoticed.add(key);
@@ -10742,7 +11008,7 @@ export class Daemon extends EventEmitter {
         mcpEnv.AGEND_TOOL_SET = toolSet;
         // The dashboard features the person switched off: out of the tool menu from this start (the fleet refuses them
         // at once, whatever the menu still shows).
-        const dashboardOff = dashboardFeaturesOff(this.config.dashboard);
+        const dashboardOff = dashboardFeaturesOff(dashboardAccessOf(this.config));
         if (dashboardOff.length)
             mcpEnv.AGEND_DASHBOARD_OFF = dashboardOff.join(",");
         if (this.config.display_name)
@@ -10883,9 +11149,14 @@ export class Daemon extends EventEmitter {
     beginSpawn() {
         this.unclearOomStopped = false;
         this.publishWorkingState("before_spawn");
+        this.recoveryContinuationId = null;
         this.workingBackgroundObservation = null;
+        this.ownedWorkingSession = null;
+        this.recoveryBootSettled = false;
+        this.recoveryNativeWork = false;
+        this.recoveryCancelled = false;
         this.dialogAnswers = null;
-        this.capacityNudge = null;
+        this.cancelCapacityNudge("the instance was stopped, paused or respawned");
         this.lastErrorEpisode = null;
         this.nudgeBaselines = null;
         // A relaunch settles any outstanding quit watch: the CLI came back.
@@ -10916,6 +11187,8 @@ export class Daemon extends EventEmitter {
         this.spawnDepth = Math.max(0, this.spawnDepth - 1);
         if (this.spawnDepth > 0)
             return; // an enclosing spawn is still running
+        if (!this.recoveryBootWorkPending)
+            this.recoveryBootSettled = true;
         this.spawning = false;
         const resolve = this.resolveSpawnSettled;
         this.spawnSettled = null;
@@ -11174,7 +11447,7 @@ export class Daemon extends EventEmitter {
                         // out loud — this start does NOT continue the previous conversation.
                         this.logger.error({ attempts: failures }, "Giving up on resuming after repeated startup failures — starting fresh. "
                             + "The previous conversation is NOT continued; its context is lost to this session.");
-                        this.emit("context_lost", this.name, "resume_repeatedly_failed");
+                        this.emit("context_lost", this.name, "resume_repeatedly_failed", failures);
                     }
                     this.setSessionAside(proven ? "cli_reported_no_conversation" : "resume_failed_repeatedly");
                     this.skipResume = true;
@@ -12369,6 +12642,13 @@ export class Daemon extends EventEmitter {
             const sid = this.backend?.getSessionId();
             if (!sid)
                 return;
+            if ((this.config.backend ?? "claude-code") === "claude-code" && Buffer.byteLength(sid) <= 256
+                && !/[\u0000-\u001f\u007f]/.test(sid) && this.ownedWorkingSession !== sid) {
+                this.ownedWorkingSession = sid;
+                // Reuse this existing owned checkpoint. An idle instance may have no
+                // later state edge before an OOM; its journal must not stay unknown.
+                this.publishWorkingState("process");
+            }
             const path = join(this.instanceDir, "session-id");
             // Idle observations happen after turns. Avoid needless writes (and mtime
             // churn) while still updating the marker when /new changes the session.