@songsid/agend 2.3.3-beta.1 → 2.3.3-beta.10

package/dist/daemon.js

@@ -25,13 +25,12 @@ import { createTranscriptSource } from "./transcript-sources.js";
 import { TranscriptTurnLedger } from "./transcript-turns.js";
 import { credentialProfileStoreHome, resolveCredentialProfile } from "./backend/credential-profile.js";
 import { resolveToolSet, toolsFor } from "./tool-permissions.js";
-import { TOOLS, toolsWithCanvasWorker } from "./channel/mcp-tools.js";
+import { TOOLS } from "./channel/mcp-tools.js";
 import { dashboardAccessProblem, dashboardFeaturesOff, withoutFeatures } from "./dashboard-permissions.js";
 import { getAgendHome } from "./paths.js";
-import { readCanvasWorkerEnabled, scopedFleetConfigEnvironment } from "./web-experimental.js";
-import { readAgentEffect, sendEffectInParts } from "./web-effect-upload.js";
+import { scopedFleetConfigEnvironment } from "./web-experimental.js";
 import { readAgentFile } from "./agent-file-read.js";
-import { ASSET_UPLOAD_MAX_BYTES, MOD_FILE, MOD_MAX_PARTS, MOD_UPLOAD_MAX_BYTES, receiveFiles, receivePreview, sendAssetInParts, writeModFile, writePreview } from "./web-asset-parts.js";
+import { ASSET_UPLOAD_MAX_BYTES, receivePreview, sendAssetInParts, writePreview } from "./web-asset-parts.js";
 import { LOGIN_FLOWS } from "./login-flows.js";
 import { ProgressAccumulator, summarizeProgress } from "./tool-progress.js";
 import { assembleSystemPrompt, resolveWorkflowText } from "./prompt-file-ref.js";
@@ -53,7 +52,9 @@ import { formatHumanInboundMessage, prepareDeliveryWire, steerInboundEnvelope, B
 import { formatCrossInstanceInboundMessage, renderCrossInstanceHandoffMetadata, } from "./cross-instance-envelope.js";
 import { agendMessageInInput, bottomRowIsReady, inputAreaText, inputShowsPastedText, pastedTextSignature, pasteLeftInInput, strandedAgendMessageInInput } from "./pane-input-residue.js";
 import { TurnReplyGuard, formatReplyDropDetection, turnExpectsPersonReply } from "./turn-reply-guard.js";
+import { CLAUDE_CREDIT_BALANCE_LOW, CLAUDE_MODEL_USAGE_LIMIT, CLAUDE_USAGE_LIMIT_PAUSE } from "./backend/claude-transcript-errors.js";
 import { t } from "./locale.js";
+import { claudeResetTime, quotaPausedLine } from "./quota-notice.js";
 import { MuseUsageRelay, clearMuseUsageSnapshot } from "./muse-usage-relay.js";
 import { deliveryContentDigest } from "./delivery-outbox.js";
 import { consumedWatches } from "./delivery-consumed-watch.js";
@@ -81,15 +82,6 @@ const WEB_THEME_IPC = Object.freeze({
     set_web_widget: "fleet_set_web_widget", remove_web_widget: "fleet_remove_web_widget",
     // #2117: its own declarative ambient.
     set_web_ambient: "fleet_set_web_ambient", clear_web_ambient: "fleet_clear_web_ambient",
-    // r4-5b: mods — an export's file is written here, a proposal's file read here (on the agent's side).
-    export_web_mod: "fleet_export_web_mod", propose_web_mod: "fleet_propose_web_mod",
-    upload_web_effect: "fleet_upload_web_effect",
-    list_web_effects: "fleet_list_web_effects",
-    preview_web_effect: "fleet_preview_web_effect",
-    profile_web_effect: "fleet_profile_web_effect",
-    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",
     // #2692: the skin packs — check and upload read the pack here (web-office-pack-read.ts) and send its bytes in parts.
@@ -567,6 +559,8 @@ const DIALOG_ANSWER_IGNORED_MAX = 3;
  * normal pace (and a fresh count).
  */
 const DIALOG_ANSWER_BACKOFF_MS = 30_000;
+/** #2844: how long a dialog AgEnD answers itself (`answeredByAgend`) stays nobody's interaction while it is on screen. */
+const AGEND_ANSWER_GRACE_MS = 20_000;
 /** How many "dialog painted just before the write → wait → retry" rounds a delivery tolerates. */
 const LATE_DIALOG_WRITE_ROUNDS = 3;
 /** How many times a delivery redoes itself when a spawn starts between its settle wait and its pane write. */
@@ -1263,13 +1257,26 @@ export class Daemon extends EventEmitter {
     bootSkippedResume = false;
     recoveryCrashLoopFresh = false;
     recoveryFreshChoice = false;
+    /** The current boot found a crash-loop marker and is attempting resume rather than going fresh immediately. */
+    bootCrashLoopResume = false;
     startupAborted = false;
     /** First time the current on-screen blocking dialog was seen (0 = none); drives the parked report. */
     dialogParkedSince = 0;
     /** Identity of that dialog: its pattern, not its description (two tables may describe one screen differently). */
     dialogParkedKey = null;
+    /**
+     * #2893: the held dialog whose heldReason was last logged. Its own state, not the parked clock's: the delivery probe
+     * starts that clock too, and must not use up the one log line. Cleared with the hold, so a later hold logs again.
+     */
+    heldReasonLoggedKey = null;
     dialogParkedInteractionEpisode = null;
     dialogParkedReported = false;
+    /**
+     * #2897: a "needs a human" notice is out for a dialog, and what it lives with: "parked" — the parked clock (retired when
+     * that dialog leaves the pane or another replaces it); "answer" — an answer episode of a dialog the parked clock does
+     * not track (a non-blocking one, whose scans pass no blocking dialog): retired when that episode ends.
+     */
+    parkedNoticeOut = null;
     /** #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. */
@@ -1320,7 +1327,7 @@ export class Daemon extends EventEmitter {
      * cancels it when anything changed, and it fires at most once. The due time is on the monotonic clock.
      */
     /**
-     * How many occurrences of each `nudge_continue` pattern were already on screen when this spawn first showed a live
+     * How many occurrences of each `nudge_continue` (or `historyUntilLiveComposer`) pattern were already on screen when this spawn first showed a live
      * composer (null until then): resumed scrollback, i.e. HISTORY. An occurrence is a new episode only beyond that — a
      * resumed session whose scrollback holds an old capacity line must not be told to "keep going" for it (#949).
      */
@@ -1334,6 +1341,8 @@ export class Daemon extends EventEmitter {
     interactionObservedOutputRevision = 0;
     interactionCaptureSerial = 0;
     interactionDialogKey = null;
+    /** Since when (monotonic) the `answeredByAgend` dialog now on screen has been withheld from the interaction state. */
+    agendAnswerGrace = null;
     acceptedInstanceSnapshot = null;
     /** Generation/signature fence for safety dialogs while their screen is still visible. */
     autoResolvedDialogKey = null;
@@ -1765,6 +1774,77 @@ export class Daemon extends EventEmitter {
     // old transcript, so pre-ready scans must not lower this seeded baseline.
     seededErrorCountBaselines = new Map();
     lastDetectedErrorType = null;
+    /**
+     * #2822: Claude's per-model usage limit (`You've reached your <model> limit.`), known only from Claude's own record of
+     * the failed call in its transcript (`isApiErrorMessage`, a 429) — never from pane text, which an agent can print. It
+     * names no reset time. While it holds it is told once, and the reply guard stays quiet while the transcript's newest
+     * event is that error; any later assistant output (of any turn, from a person or not) ends it. The order is Claude's
+     * own: a 429 is recorded within a second, often before AgEnD has armed the turn, so no AgEnD-side clock is used.
+     */
+    usageLimitHold = null;
+    /** Transcript events in Claude's order (prompts, output, every API error): the newest, and the latest limit error. */
+    transcriptEventSeq = 0;
+    usageLimitErrorSeq = 0;
+    static MODEL_USAGE_LIMIT = CLAUDE_MODEL_USAGE_LIMIT;
+    /** #2822: the usage-limit hold, while it lasts — Needs you lists it. */
+    usageHold() {
+        return this.usageLimitHold ? { ...this.usageLimitHold } : null;
+    }
+    /** #2834: Claude's account is out of API credits — its own record; the same pause as the pane pattern it replaces. */
+    static CREDIT_BALANCE_LOW = CLAUDE_CREDIT_BALANCE_LOW;
+    /** #2834 (#816): Claude's usage-limit auto-continue note, as it records it (`system` / `informational`). */
+    static USAGE_LIMIT_PAUSE = CLAUDE_USAGE_LIMIT_PAUSE;
+    /** #2834 (#816): Claude paused itself until its usage window opens — the same notice the screen pattern gave. */
+    noteClaudeInformational(text) {
+        const match = Daemon.USAGE_LIMIT_PAUSE.exec(text.trim());
+        if (!match)
+            return;
+        const when = match[1].trim();
+        this.emit("pty_error", { name: this.name, type: "quota", action: "notify", verifyQuota: true, skipCooldown: true, skipRecoveryWait: true,
+            message: `Claude Code usage limit reached — paused; continuing automatically ${when}`,
+            notice: quotaPausedLine("Claude", "usage", claudeResetTime(when)) });
+    }
+    /** #2822: Claude recorded a failed API call. */
+    noteClaudeApiError(text, status, errorKind = null) {
+        const seq = ++this.transcriptEventSeq;
+        if (errorKind === "billing_error" || (status === 400 && Daemon.CREDIT_BALANCE_LOW.test(text))) {
+            this.emit("pty_error", { name: this.name, type: "quota", action: "pause", message: "Insufficient API credits", notice: quotaPausedLine("Claude", "api_credits") });
+            return;
+        }
+        const match = status === 429 ? Daemon.MODEL_USAGE_LIMIT.exec(text.trim()) : null;
+        if (!match)
+            return;
+        this.usageLimitErrorSeq = seq;
+        if (this.usageLimitHold)
+            return; // told already: one notice per hold
+        const model = match[1].trim();
+        this.usageLimitHold = { model, since: Date.now() };
+        const message = t("inst.model_usage_limit", model);
+        this.logger.warn({ model }, "Usage-limit hold started (reset time unknown)");
+        this.emit("usage_hold", { name: this.name, held: true });
+        this.emit("pty_error", { name: this.name, type: "quota", action: "notify", message, notice: t("inst.quota_model_hold", model), skipCooldown: true, skipRecoveryWait: true });
+    }
+    /** #2822: Claude produced output (text or a tool call): the model answers again, so a hold ends. */
+    noteClaudeOutput() {
+        ++this.transcriptEventSeq;
+        if (!this.usageLimitHold)
+            return;
+        this.logger.info({ model: this.usageLimitHold.model }, "Usage-limit hold cleared — Claude answered again");
+        this.usageLimitHold = null;
+        this.emit("usage_hold", { name: this.name, held: false });
+    }
+    /** #2822: a prompt reached Claude (recorded in its transcript). */
+    noteClaudePrompt() {
+        ++this.transcriptEventSeq;
+    }
+    /**
+     * #2822: the turn ended on the limit error — the transcript's newest event of any kind. A prompt after it (a new
+     * message the error is older than), output after it (the model answered) or another API error after it (a 500, a
+     * different 429) means the limit error is not this turn's end.
+     */
+    personTurnEndedOnUsageLimit() {
+        return this.usageLimitErrorSeq > 0 && this.usageLimitErrorSeq === this.transcriptEventSeq;
+    }
     static errorPatternKey(ep) {
         return `${ep.type}:${ep.pattern.source}`;
     }
@@ -2265,19 +2345,40 @@ export class Daemon extends EventEmitter {
         this.bootSkippedResume = false;
         this.recoveryCrashLoopFresh = false;
         this.recoveryFreshChoice = false;
+        this.bootCrashLoopResume = false;
         try {
             if (existsSync(crashStatePath)) {
                 const content = readFileSync(crashStatePath, "utf-8");
                 try {
                     const state = JSON.parse(content);
-                    if (state?.resumeDisabled === true) {
+                    if (state?.resumeFailed === true) {
+                        // The previous start tried resume after a crash loop but the resumed
+                        // session died before reaching ready. Go fresh this time.
                         this.skipResume = true;
                         this.bootSkippedResume = true;
-                        this.recoveryCrashLoopFresh = (state.reason === undefined || state.reason === "crash_loop")
+                        this.recoveryCrashLoopFresh = true;
+                        this.recoveryFreshChoice = false;
+                        this.logger.warn("Previously resumed session died quickly after a crash loop — starting fresh");
+                    }
+                    else if (state?.resumeDisabled === true) {
+                        // Crash loop detected, but the session is not proven broken.
+                        // Try resume first; if it dies before reaching ready, the next
+                        // boot will see resumeFailed and go fresh (PR #2809).
+                        const isCrashLoop = (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");
+                        if (isCrashLoop) {
+                            this.bootCrashLoopResume = true;
+                            this.logger.warn("Previous crash loop detected — attempting resume (will fall back to fresh if session is broken)");
+                        }
+                        else {
+                            // Explicit fresh-start request (not a crash loop); honour it.
+                            this.skipResume = true;
+                            this.bootSkippedResume = true;
+                            this.recoveryCrashLoopFresh = false;
+                            this.recoveryFreshChoice = true;
+                            this.logger.warn("Previous crash loop detected — starting without resume");
+                        }
                     }
                 }
                 finally {
@@ -2465,6 +2566,7 @@ export class Daemon extends EventEmitter {
                     .catch(e => this.logger.debug({ err: e.message }, "Ack react failed"));
             };
             this.transcriptMonitor.on("tool_use", (name, input) => {
+                this.noteClaudeOutput();
                 this.logger.debug({ tool: name }, "Tool use");
                 ackIfPending();
                 this.recordRecentEvent({ type: "tool_use", name, preview: this.summarizeTool(name, input) });
@@ -2478,7 +2580,11 @@ export class Daemon extends EventEmitter {
                 // show only elapsed time than to leave a stale "Bash: npm test" on screen.
                 this.publishActivity(null);
             });
+            this.transcriptMonitor.on("api_error", (text, status, _at, errorKind) => this.noteClaudeApiError(text, status, errorKind));
+            this.transcriptMonitor.on("system_informational", (text) => this.noteClaudeInformational(text));
+            this.transcriptMonitor.on("user_prompt", () => this.noteClaudePrompt());
             this.transcriptMonitor.on("assistant_text", (text) => {
+                this.noteClaudeOutput();
                 this.logger.debug({ text: text.slice(0, 200) }, "Claude response");
                 ackIfPending();
                 this.recordRecentEvent({ type: "assistant_text", preview: text.slice(0, 100) });
@@ -3626,10 +3732,21 @@ export class Daemon extends EventEmitter {
                     if (!Daemon.dialogMatches(dialog, pane))
                         continue;
                     this.noteCodexReserveDialog(dialog, pane);
+                    this.noteLiveIncidentDialog(dialog, pane);
                     if (dialog.blocksDelivery || dialog.holdOnly)
                         blockingSeen = dialog;
-                    if (dialog.holdOnly)
-                        break; // recognised, deliberately not answered; trackDialogParked reports it
+                    if (dialog.holdOnly) {
+                        // Recognised, deliberately not answered; trackDialogParked reports it. Why an automatic answer passed it by
+                        // is logged once, when this hold begins (#2893).
+                        if (this.heldReasonLoggedKey !== Daemon.dialogKey(dialog)) {
+                            const reason = Daemon.heldReasonOf(dialog, pane);
+                            if (Object.keys(reason).length) {
+                                this.heldReasonLoggedKey = Daemon.dialogKey(dialog);
+                                this.logger.warn({ description: dialog.description, ...reason }, "Runtime dialog held — not auto-answering");
+                            }
+                        }
+                        break;
+                    }
                     // Reported as ignoring the daemon: the SAME request (the identity the count was made on — verbatim, the
                     // backend's own when it names one) is answered only once per DIALOG_ANSWER_BACKOFF_MS. Anything else — another
                     // request, an unexplained difference, the dialog gone — is not held back here; the answer path below ends or
@@ -3692,7 +3809,7 @@ export class Daemon extends EventEmitter {
                             return;
                         if (dialog.verifyAfterKeys && autoKey)
                             this.claimAutoDialog(dialog);
-                        this.logger.info(`Auto-dismissing runtime dialog: ${dialog.description}`);
+                        this.logger.info(Daemon.answerDetailOf(dialog, currentPane), `Auto-dismissing runtime dialog: ${dialog.description}`);
                         const SPECIAL_KEYS = new Set(["Up", "Down", "Enter", "Escape", "Right", "Left"]);
                         for (const key of dialog.keys) {
                             if (stale())
@@ -3701,6 +3818,9 @@ export class Daemon extends EventEmitter {
                             if (SPECIAL_KEYS.has(key)) {
                                 sent = await pollTmux.sendSpecialKey(key);
                             }
+                            else if (dialog.literalKeys) {
+                                sent = await pollTmux.sendKeys(key); // typed, no Enter (#2872)
+                            }
                             else {
                                 sent = await pollTmux.pasteText(key, this.systemPasteOptions());
                             }
@@ -3745,6 +3865,8 @@ export class Daemon extends EventEmitter {
                             else {
                                 resolved = true;
                             }
+                            if (dialog.dismissIncident)
+                                this.emitDismissIncident(dialog);
                         }
                         else if (dialog.keys.length > 0) {
                             // Did the keys take? Read the pane again. The same request still there is an answer that did nothing. A request
@@ -3778,8 +3900,10 @@ export class Daemon extends EventEmitter {
                 // Reached only when no dialog was answered this poll (none on screen, a fenced one, or one waiting out its
                 // backoff): unless it is the one backing off, the screen that was being answered is gone, and the next dialog is
                 // a new one.
-                if (!answersBackedOff)
+                if (!answersBackedOff && this.dialogAnswers) {
                     this.dialogAnswers = null;
+                    this.retireParkedNotice("answer");
+                }
                 this.trackDialogParked(blockingSeen);
                 this.trackRemoteCard(blockingSeen, pane, captureMono);
                 if (blockingSeen)
@@ -3897,9 +4021,10 @@ export class Daemon extends EventEmitter {
             const count = countMatches(ep.pattern);
             const seen = this.lastErrorCount.get(key) ?? 0;
             // #2282: a resumed exhausted429 row is history, not even a new
-            // notification/failover incident. Wait for the first live composer to
-            // establish its baseline; later appended occurrences remain eligible.
-            if (ep.type === "rate_limit" && ep.action === "nudge_continue") {
+            // notification/failover incident; so is a resumed codex workspace-limit row
+            // (#2844: a wake must not pause again on it). Wait for the first live
+            // composer to establish its baseline; later appended occurrences remain eligible.
+            if ((ep.type === "rate_limit" && ep.action === "nudge_continue") || ep.historyUntilLiveComposer) {
                 const baseline = this.nudgeBaselines?.get(key);
                 if (baseline === undefined || count <= baseline) {
                     if (baseline !== undefined)
@@ -3976,6 +4101,17 @@ export class Daemon extends EventEmitter {
             break; // Only handle first unsuppressed new error per scan
         }
     }
+    /**
+     * #2872: the incident a dialog stood for, once AgEnD's own keys closed it (RuntimeDialog.dismissIncident). It skips
+     * the usage check (the modal was the proof) and arms no pane gate: nothing on screen is its evidence, so nothing
+     * stale can raise it again.
+     */
+    emitDismissIncident(dialog) {
+        const inc = dialog.dismissIncident;
+        this.logger.warn({ errorType: inc.type, action: inc.action, dialog: dialog.description }, `Dialog incident: ${inc.message}`);
+        this.emit("pty_error", { name: this.name, type: inc.type, action: inc.action, message: inc.message, skipUsageVerify: true,
+            ...(inc.notice ? { notice: inc.notice } : {}) });
+    }
     /** Arm the recovery gates and emit one detected error pattern. */
     emitErrorPattern(ep, key, pane, now) {
         // #2795: auth text on the pane proves nothing about the credentials (22 of 22 such matches on the main host were
@@ -3994,7 +4130,9 @@ export class Daemon extends EventEmitter {
         const message = this.resolveErrorMessage(pane, ep);
         this.logger.warn({ errorType: ep.type, action: ep.action }, `PTY error detected: ${message}`);
         this.lastErrorEpisode = { key, pattern: ep.pattern, pane, spawn: this.spawnGeneration, fence: this.launchFenceEpoch };
-        this.emit("pty_error", { name: this.name, ...ep, message });
+        const { notice: noticeOf, ...rest } = ep;
+        const notice = noticeOf ? this.resolveErrorNotice(pane, ep, noticeOf) : undefined;
+        this.emit("pty_error", { name: this.name, ...rest, message, ...(notice ? { notice } : {}) });
     }
     /**
      * Notification text for a detected pattern. `formatMessage` patterns build it
@@ -4004,6 +4142,18 @@ export class Daemon extends EventEmitter {
      * Uses the LAST match in the pane: an older warning may still be scrolled up
      * (10% earlier, 5% now), and the newest one is the one worth reporting.
      */
+    /** The pattern's short notice from its last match on the pane (no match: from none); undefined if it throws. */
+    resolveErrorNotice(pane, ep, noticeOf) {
+        try {
+            const flags = ep.pattern.flags.includes("g") ? ep.pattern.flags : ep.pattern.flags + "g";
+            const matches = [...pane.matchAll(new RegExp(ep.pattern.source, flags))];
+            return noticeOf(matches[matches.length - 1] ?? null);
+        }
+        catch (err) {
+            this.logger.debug({ err, errorType: ep.type }, "notice failed — posting the standard notification");
+            return undefined;
+        }
+    }
     resolveErrorMessage(pane, ep) {
         if (!ep.formatMessage)
             return ep.message;
@@ -4934,6 +5084,22 @@ export class Daemon extends EventEmitter {
                 && Daemon.dialogMatches(d, pane)
                 // #1690: AgEnD's own switch dialog, being answered right now, is nobody's to answer.
                 && !(this.ownSwitch && claudeSwitchDialog(pane) !== null));
+            // #2844: a dialog AgEnD is answering itself is nobody's to answer — for AGEND_ANSWER_GRACE_MS of being on screen,
+            // and only until its answers are reported as ignored. No evidence at all meanwhile: the catch-alls further down
+            // the table match the same screen. A dialog still there after the grace (an Escape that did not take, keys that
+            // could not be sent) is a person's again.
+            if (dialog?.answeredByAgend) {
+                const key = Daemon.answerKey(dialog);
+                const now = performance.now();
+                if (this.agendAnswerGrace?.key !== key)
+                    this.agendAnswerGrace = { key, since: now };
+                if (now - this.agendAnswerGrace.since < AGEND_ANSWER_GRACE_MS
+                    && !(this.dialogAnswers?.reported && this.dialogAnswers.key === key))
+                    return null;
+            }
+            else {
+                this.agendAnswerGrace = null;
+            }
             if (dialog) {
                 const identity = dialog.requestIdentity?.(pane) ?? pane.replace(/\r/g, "")
                     .split("\n").map(row => row.replace(/^([ \t]*)[❯›]([ \t]+)(?=\d\.|Yes\b|No\b|Resume\b)/, "$1$2").trimEnd())
@@ -5662,6 +5828,15 @@ export class Daemon extends EventEmitter {
             this.turnReplyGuard.complete(turn.generation);
             return;
         }
+        // #2822: a turn whose newest transcript event is Claude's usage-limit error could not have replied — no recovery
+        // turn, no drop report: the limit is told once (the notice and Needs you). Only that record counts: pane text and
+        // an error from before this turn began do not.
+        if (this.personTurnEndedOnUsageLimit()) {
+            this.logger.info({ correlationId: turn.target.correlationId }, "Turn ended on Claude's usage-limit error — no reply recovery");
+            this.clearReplyGuardConfirm();
+            this.turnReplyGuard.complete(turn.generation);
+            return;
+        }
         // A second idle edge ends the one permitted recovery turn. Never create a
         // third turn or guess at terminal text; make the failure visible instead.
         if (turn.phase === "recovering") {
@@ -8170,13 +8345,36 @@ export class Daemon extends EventEmitter {
             && !this.backend?.backgroundWorkRunning?.(pane) && codexLiveRowMatches(pane, nudge.pattern)
             && Daemon.countOccurrences(nudge.pattern, pane) === Daemon.countOccurrences(nudge.pattern, nudge.pane);
     }
+    /**
+     * #2844: a dialog that only paints for a live incident proves the newest such error row on screen is current: its
+     * baseline is held below it, so neither a first poll that sees the dialog before any live composer nor the composer
+     * after it can take that row for resumed history. Older rows, of any kind, stay history.
+     */
+    noteLiveIncidentDialog(dialog, pane) {
+        if (!dialog.marksLiveIncident)
+            return;
+        const baselines = this.nudgeBaselines ?? new Map();
+        // Only the row nearest the dialog is the incident; every other kind on screen (an older credits row above a new
+        // spend cap) stays history, so the first matching pattern cannot claim the live incident under its own name.
+        const rows = (this.backend?.getErrorPatterns?.() ?? []).filter(ep => ep.historyUntilLiveComposer).map(ep => {
+            const flags = ep.pattern.flags.includes("g") ? ep.pattern.flags : ep.pattern.flags + "g";
+            const matches = [...pane.matchAll(new RegExp(ep.pattern.source, flags))];
+            return { key: Daemon.errorPatternKey(ep), count: matches.length, last: matches.at(-1)?.index ?? -1 };
+        }).filter(row => row.count > 0);
+        const newest = rows.reduce((best, row) => !best || row.last > best.last ? row : best, null);
+        for (const row of rows) {
+            const floor = row === newest ? row.count - 1 : row.count;
+            baselines.set(row.key, Math.min(baselines.get(row.key) ?? floor, floor));
+        }
+        this.nudgeBaselines = baselines;
+    }
     /** The first live composer of a spawn fixes what is history (see {@link nudgeBaselines}). */
     takeNudgeBaselines(pane, patterns) {
         if (!this.isCodexLivePaneSnapshot(pane))
             return;
         const baselines = this.nudgeBaselines ?? new Map();
         for (const ep of patterns) {
-            if (ep.action !== "nudge_continue")
+            if (ep.action !== "nudge_continue" && !ep.historyUntilLiveComposer)
                 continue;
             const key = Daemon.errorPatternKey(ep);
             const count = Daemon.countOccurrences(ep.pattern, pane);
@@ -8260,6 +8458,7 @@ export class Daemon extends EventEmitter {
      */
     endDialogEpisode(clearParked = true) {
         this.dialogAnswers = null;
+        this.retireParkedNotice("answer");
         if (clearParked)
             this.trackDialogParked(null);
     }
@@ -8286,8 +8485,11 @@ export class Daemon extends EventEmitter {
      */
     noteDialogAnswer(dialog, outcome, screen) {
         const key = Daemon.answerKey(dialog);
-        if (!this.dialogAnswers || this.dialogAnswers.key !== key)
-            this.dialogAnswers = { key, ignored: 0, reported: false, screen, lastAnswerAt: 0 }; // the exact screen being counted: every answer in the episode saw this same one
+        if (!this.dialogAnswers || this.dialogAnswers.key !== key) {
+            if (this.dialogAnswers)
+                this.retireParkedNotice("answer"); // #2897: a different screen: the reported one is over
+            this.dialogAnswers = { key, ignored: 0, reported: false, screen, lastAnswerAt: 0 };
+        } // the exact screen being counted: every answer in the episode saw this same one
         const episode = this.dialogAnswers;
         if (outcome !== "ignored") {
             this.endDialogEpisode(outcome === "took");
@@ -8303,6 +8505,8 @@ export class Daemon extends EventEmitter {
             this.dialogParkedReported = true;
         const holdsDeliveries = dialog.blocksDelivery === true || dialog.holdOnly === true;
         this.logger.warn({ dialog: dialog.description, attempts: episode.ignored, holdsDeliveries }, "Runtime dialog is ignoring AgEnD's answer — reporting for a human");
+        // #2897: a dialog the parked clock tracks keeps its notice until it leaves the pane; any other, until this episode ends.
+        this.parkedNoticeOut = this.dialogParkedSince !== 0 && this.dialogParkedKey === Daemon.dialogKey(dialog) ? "parked" : "answer";
         this.emit("dialog_answer_ignored", { name: this.name, description: dialog.description, attempts: episode.ignored, holdsDeliveries });
     }
     /**
@@ -8376,6 +8580,24 @@ export class Daemon extends EventEmitter {
             this.remoteCardAnswering = false;
         }
     }
+    /** #2893: a held dialog's own account of why no automatic answer took it (RuntimeDialog.heldReason); {} when none. */
+    static heldReasonOf(dialog, pane) {
+        try {
+            return dialog.heldReason?.(pane) ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
+    /** What an answered dialog says about the answer (RuntimeDialog.answerDetail); {} when it gives none. */
+    static answerDetailOf(dialog, pane) {
+        try {
+            return dialog.answerDetail?.(pane) ?? {};
+        }
+        catch {
+            return {};
+        }
+    }
     /**
      * 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
@@ -8384,14 +8606,24 @@ export class Daemon extends EventEmitter {
      * is safe. Identity is the pattern, so the delivery gate and the runtime
      * scanner (same canonical list) never reset each other's clock.
      */
+    /** #2897: the notice out for a dialog is out of date (its `owner` ended): the fleet takes it back. */
+    retireParkedNotice(owner) {
+        if (this.parkedNoticeOut !== owner)
+            return;
+        this.parkedNoticeOut = null;
+        this.emit("dialog_unparked", { name: this.name });
+    }
     trackDialogParked(dialog) {
         if (!dialog) {
             if (this.dialogParkedSince !== 0)
                 this.logger.info({ dialog: this.dialogParkedKey }, "Blocking dialog is gone from the pane");
             this.dialogParkedSince = 0;
             this.dialogParkedKey = null;
+            this.heldReasonLoggedKey = null;
             this.dialogParkedInteractionEpisode = null;
             this.dialogParkedReported = false;
+            // #2897: whatever it posted is out of date — the fleet takes its notices back.
+            this.retireParkedNotice("parked");
             return;
         }
         const key = Daemon.dialogKey(dialog);
@@ -8403,6 +8635,9 @@ export class Daemon extends EventEmitter {
         if (episode !== null)
             this.dialogParkedInteractionEpisode = episode;
         if (this.dialogParkedSince === 0 || this.dialogParkedKey !== key) {
+            // #2897: a different dialog replaced the one being tracked — that one's notices are out of date.
+            if (this.dialogParkedSince !== 0)
+                this.retireParkedNotice("parked");
             this.dialogParkedSince = Date.now();
             this.dialogParkedKey = key;
             this.dialogParkedReported = false;
@@ -8414,8 +8649,10 @@ export class Daemon extends EventEmitter {
             this.dialogParkedReported = true;
         if (!this.dialogParkedReported && Date.now() - this.dialogParkedSince >= (unrecognised ? 0 : DIALOG_PARKED_NOTIFY_MS)) {
             this.dialogParkedReported = true;
+            this.parkedNoticeOut = "parked";
             this.logger.warn({ dialog: dialog.description, parkedForMs: Date.now() - this.dialogParkedSince }, "CLI dialog is still on screen — not auto-answering, reporting for a human");
             this.emit("dialog_parked", { name: this.name, description: dialog.description, holdOnly: dialog.holdOnly === true,
+                ...(dialog.parkedAdvice ? { advice: dialog.parkedAdvice } : {}),
                 ...(episode !== null && interaction.kind ? { kind: interaction.kind, episode, backend: this.config.backend ?? "claude-code" } : {}),
                 ...(unrecognised ? { unrecognised: true, question: this.unrecognisedPrompt?.shape.question ?? null } : {}) });
         }
@@ -10785,96 +11022,12 @@ export class Daemon extends EventEmitter {
                     reply(written, undefined);
                     return;
                 }
-                if (tool === "export_web_mod") {
-                    // The fleet builds the file (whole, or in parts); it is written here, in the working directory.
-                    const first = await ask(args);
-                    if (first.error) {
-                        reply(null, first.error);
-                        return;
-                    }
-                    let failed;
-                    const firstResult = (first.result && typeof first.result === "object" ? first.result : {});
-                    const got = await receiveFiles(firstResult, async (payload) => {
-                        const r = await ask(payload);
-                        if (r.error) {
-                            failed = r.error;
-                            return { error: r.error };
-                        }
-                        return (r.result && typeof r.result === "object" ? r.result : {});
-                    }, { name: MOD_FILE, idKey: "transfer", what: "export", maxParts: MOD_MAX_PARTS });
-                    if (failed) {
-                        reply(null, failed);
-                        return;
-                    }
-                    if ("error" in got) {
-                        reply(got, undefined);
-                        return;
-                    }
-                    const written = await writeModFile(got.files, { workspace: this.config.working_directory, configuredWorkspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name });
-                    if ("error" in written) {
-                        reply(null, `export_web_mod: ${written.error}`);
-                        return;
-                    }
-                    reply({ ...written, ...(firstResult.effects_omitted ? { effects_omitted: firstResult.effects_omitted } : {}) }, undefined);
-                    return;
-                }
-                if (tool === "propose_web_mod") {
-                    const read = await readAgentFile(args.file, { workspace: this.config.working_directory, configuredWorkspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name, maxBytes: MOD_UPLOAD_MAX_BYTES });
-                    const named = typeof args.file === "string" ? args.file.slice(0, 200) : "the file argument";
-                    if (!read.ok) {
-                        reply(null, `propose_web_mod: ${named} — ${read.reason}`);
-                        return;
-                    }
-                    let failed;
-                    const answer = await sendAssetInParts("mod", read.bytes, async (payload) => {
-                        const r = await ask(payload);
-                        if (r.error) {
-                            failed = r.error;
-                            return { error: r.error };
-                        }
-                        return (r.result && typeof r.result === "object" ? r.result : {});
-                    });
-                    reply(failed ? null : answer, failed);
-                    return;
-                }
                 if (tool === "office_pack_check" || tool === "office_pack_upload") {
                     // #2692: the folder (or the manifest's files) is read here, on the agent's side; the fleet gets bytes in parts.
                     const answer = await sendPackSources(args, { workspace: this.config.working_directory, configuredWorkspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name }, async (payload) => { const r = await ask(payload); return r.error ? { error: "fleet", message: r.error } : (r.result && typeof r.result === "object" ? r.result : {}); });
                     reply(answer, undefined);
                     return;
                 }
-                if (tool === "upload_web_effect") {
-                    const owner = { fence: this.launchFenceEpoch, spawn: this.spawnGeneration, boot: this.bootId, ipc: this.ipcServer };
-                    const current = () => !!owner.ipc && owner.ipc === this.ipcServer && owner.fence === this.launchFenceEpoch && owner.spawn === this.spawnGeneration && owner.boot === this.bootId && !this.deliveryWritesStopping && !this.startupAborted;
-                    if (!current()) {
-                        reply(null, "upload_web_effect: launch no longer current");
-                        return;
-                    }
-                    const read = await readAgentEffect(args.dir, { workspace: this.config.working_directory, configuredWorkspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name });
-                    if (!current()) {
-                        reply(null, "upload_web_effect: launch no longer current");
-                        return;
-                    }
-                    if (!read.ok) {
-                        reply(null, `upload_web_effect: ${read.reason}`);
-                        return;
-                    }
-                    let failed;
-                    const answer = await sendEffectInParts(read.files, async (payload) => {
-                        if (!current()) {
-                            failed = "upload_web_effect: launch no longer current";
-                            return { error: failed };
-                        }
-                        const r = await ask(payload);
-                        if (r.error) {
-                            failed = r.error;
-                            return { error: r.error };
-                        }
-                        return (r.result && typeof r.result === "object" ? r.result : {});
-                    });
-                    reply(failed ? null : answer, failed);
-                    return;
-                }
                 if (tool !== "set_web_theme_asset") {
                     const r = await ask(args);
                     reply(r.result, r.error);
@@ -11335,6 +11488,13 @@ export class Daemon extends EventEmitter {
         this.recoveryNativeWork = false;
         this.recoveryCancelled = false;
         this.dialogAnswers = null;
+        // #2897: a relaunched CLI shows none of the old dialogs — whatever notice was out for one is out of date.
+        // A dialog still tracked when the new CLI shows it again is reported afresh (its old notice is gone).
+        if (this.parkedNoticeOut) {
+            this.parkedNoticeOut = null;
+            this.dialogParkedReported = false;
+            this.emit("dialog_unparked", { name: this.name });
+        }
         this.cancelCapacityNudge("the instance was stopped, paused or respawned");
         this.lastErrorEpisode = null;
         this.nudgeBaselines = null;
@@ -11563,6 +11723,8 @@ export class Daemon extends EventEmitter {
             // as this backend's and resumed by the next start.
             this.startupAdmission?.();
             this.setAsideForeignSession();
+            // A crash-loop-resume boot should attempt resume even though skipResume is false:
+            // bootCrashLoopResume set at boot means we had a crash loop but try resume first.
             const attemptedResume = !this.skipResume;
             // A resume launch may get a longer budget than a fresh one (kiro: the
             // conversation must come back from the backend before anything paints).
@@ -11647,6 +11809,20 @@ export class Daemon extends EventEmitter {
                     }
                     this.setSessionAside(proven ? "cli_reported_no_conversation" : "resume_failed_repeatedly");
                     this.skipResume = true;
+                    // If this was a crash-loop-resume attempt, the session is now proven
+                    // broken. Persist resumeFailed so the next restart goes fresh without
+                    // attempting resume again.
+                    if (this.bootCrashLoopResume) {
+                        try {
+                            writeFileSync(join(this.instanceDir, "crash-state.json"), JSON.stringify({
+                                resumeFailed: true,
+                                failedAt: Date.now(),
+                            }));
+                        }
+                        catch { /* best effort */ }
+                        this.logger.warn("Crash-loop-resume: session abandoned — next boot will go fresh");
+                        this.bootCrashLoopResume = false;
+                    }
                 }
                 // A fresh start that also failed retries once, as before. It never clears
                 // a session: nothing about a failed fresh launch says the stored
@@ -11664,9 +11840,37 @@ export class Daemon extends EventEmitter {
                     this.startupAdmission?.();
                     throw new Error("CLI failed to start after retry");
                 }
+                // Fresh fallback succeeded. Clear any resumeFailed marker written during this
+                // boot's setSessionAside path, so the next normal restart is not forced fresh.
+                // NOTE: bootCrashLoopResume is already false here (cleared by setSessionAside path),
+                // so check the marker directly rather than relying on the flag.
+                try {
+                    const p = join(this.instanceDir, "crash-state.json");
+                    if (existsSync(p)) {
+                        const s = JSON.parse(readFileSync(p, "utf-8"));
+                        if (s?.resumeFailed === true)
+                            unlinkSync(p);
+                    }
+                }
+                catch { /* best effort */ }
             }
             else if (attemptedResume) {
                 resumedSuccessfully = true;
+                if (this.bootCrashLoopResume) {
+                    // Resume succeeded after a crash loop — clear any stale resumeFailed marker
+                    // that might have been written by a concurrent write or a previous attempt,
+                    // so the next restart is not forced fresh.
+                    this.bootCrashLoopResume = false;
+                    try {
+                        const p = join(this.instanceDir, "crash-state.json");
+                        if (existsSync(p)) {
+                            const s = JSON.parse(readFileSync(p, "utf-8"));
+                            if (s?.resumeFailed === true)
+                                unlinkSync(p);
+                        }
+                    }
+                    catch { /* best effort */ }
+                }
                 this.clearUnprovenResumeFailures();
                 // A resume needs the backend: its success is positive proof the backend
                 // is reachable again (a fresh prompt is local and proves nothing).
@@ -12306,7 +12510,7 @@ export class Daemon extends EventEmitter {
      */
     currentWhatsNew(pending) {
         const plan = planWhatsNew({ record: readWhatsNewRecord(this.instanceDir), fresh: false, version: pending.version,
-            roles: this.whatsNewRoles(), tools: this.whatsNewTools(), canvasWorker: readCanvasWorkerEnabled(join(this.instanceDir, "..", "..")) });
+            roles: this.whatsNewRoles(), tools: this.whatsNewTools() });
         if (!plan || "silent" in plan) {
             this.pendingWhatsNew = null;
             if (plan)
@@ -12327,13 +12531,13 @@ export class Daemon extends EventEmitter {
         }
     }
     /**
-     * #2800: the tools this instance's agend MCP server lists now — the same filters (tool set, dashboard switches, the
-     * Canvas Worker switch) — so a notice names only changes to tools it has.
+     * #2800: the tools this instance's agend MCP server lists now — the same filters (tool set, dashboard switches) — so a
+     * notice names only changes to tools it has.
      */
     whatsNewTools() {
         const allowed = toolsFor(resolveToolSet(this.config, this.name));
         const listed = withoutFeatures(TOOLS.filter(t => allowed.has(t.name)), dashboardFeaturesOff(dashboardAccessOf(this.config)));
-        return new Set(toolsWithCanvasWorker(readCanvasWorkerEnabled(join(this.instanceDir, "..", "..")), listed).map(t => t.name));
+        return new Set(listed.map(t => t.name));
     }
     /**
      * #2163: who this instance is to the what's-new notices — a ClassicBot room's agent, General, or a fleet worker (with
@@ -12351,7 +12555,7 @@ export class Daemon extends EventEmitter {
     prepareWhatsNew(fresh, version = agendVersion()) {
         try {
             const plan = planWhatsNew({ record: readWhatsNewRecord(this.instanceDir), fresh, version, roles: this.whatsNewRoles(),
-                tools: this.whatsNewTools(), canvasWorker: readCanvasWorkerEnabled(join(this.instanceDir, "..", "..")) });
+                tools: this.whatsNewTools() });
             if (!plan) {
                 this.pendingWhatsNew = null;
                 return;
@@ -12671,7 +12875,10 @@ export class Daemon extends EventEmitter {
                             continue;
                         lastDialog = dialog;
                         this.noteCodexReserveDialog(dialog, pane);
+                        this.noteLiveIncidentDialog(dialog, pane);
                         cleanReadyPolls = 0;
+                        // Before the parked clock below claims it: a hold seen for the first time is said once, with its reason (#2893).
+                        const firstSight = this.dialogParkedKey !== Daemon.dialogKey(dialog);
                         // Start the parked clock for every delivery-blocking dialog, exact
                         // ones included: if the auto-dismiss keeps failing here, the human
                         // report should count from first sight, not from the runtime scan.
@@ -12700,14 +12907,16 @@ export class Daemon extends EventEmitter {
                         }
                         if (dialog.holdOnly) {
                             // Recognised but deliberately not answered (see RuntimeDialog.holdOnly).
-                            if (this.dialogParkedKey !== Daemon.dialogKey(dialog)) {
-                                this.logger.warn({ description: dialog.description }, "Startup dialog held — not auto-answering, deliveries stay blocked");
+                            if (firstSight) {
+                                const reason = this.heldReasonLoggedKey !== Daemon.dialogKey(dialog) ? Daemon.heldReasonOf(dialog, pane) : {};
+                                if (Object.keys(reason).length)
+                                    this.heldReasonLoggedKey = Daemon.dialogKey(dialog);
+                                this.logger.warn({ description: dialog.description, ...reason }, "Startup dialog held — not auto-answering, deliveries stay blocked");
                             }
                             this.trackDialogParked(dialog);
                             matched = true;
                             break;
                         }
-                        this.logger.info(`Dismissing startup dialog: ${dialog.description}`);
                         // Restart is exactly when inbound messages pile up, and nothing gates
                         // delivery on `spawning`. Take the pane lock for the key sequence so a
                         // queued message cannot be pasted into a half-dismissed trust dialog.
@@ -12720,6 +12929,7 @@ export class Daemon extends EventEmitter {
                             // a pane that is no longer this launch's is not read or keyed.
                             if (!owned())
                                 return false;
+                            let answeredPane = pane;
                             if (dialog.inputBlocked) {
                                 const currentPane = await this.tmux.capturePane();
                                 this.startupAdmission?.();
@@ -12728,7 +12938,10 @@ export class Daemon extends EventEmitter {
                                     return false;
                                 if (!Daemon.dialogMatches(dialog, currentPane))
                                     return false;
+                                answeredPane = currentPane;
                             }
+                            // Said of the screen actually answered — the one re-read under the lock (#2896 review).
+                            this.logger.info(Daemon.answerDetailOf(dialog, answeredPane), `Dismissing startup dialog: ${dialog.description}`);
                             if (dialog.autoResolutionKey) {
                                 attemptedSafetyChoices.add(dialog.autoResolutionKey);
                                 this.claimAutoDialog(dialog);