@songsid/agend 2.3.0-beta.2 → 2.3.0-beta.20

package/dist/daemon.d.ts

@@ -233,6 +233,12 @@ export declare class PendingWorkTracker {
 }
 /** #1690: after AgEnD's own `/model`, how long the pane is read for claude's "Switch model?" or its result. */
 export declare const OWN_SWITCH_WAIT_MS = 6000;
+/** Admission and revalidation for pausing one exhausted recovery episode. */
+export interface CapacityNudgePauseGuard {
+    current(): boolean;
+    accepts(pane: string): boolean;
+    revalidate(): Promise<boolean>;
+}
 /** #1690: what AgEnD's own runtime switch came to — sent back to the fleet (IPC runtime_switch_result). */
 export type OwnSwitchOutcome = {
     outcome: "switched";
@@ -772,6 +778,8 @@ export declare class Daemon extends EventEmitter {
     private pendingInstructionsNotice;
     /** #1633: the one-time "what's new for you" notice, pasted before the next real delivery; recorded once pasted. */
     private pendingWhatsNew;
+    /** #2140: deliveries tried for the pending what's-new notice that never reached the pane (capped: never before every message). */
+    private whatsNewUnwritten;
     private warmupNeeded;
     private lastBuiltInstructions;
     private pasteQueueDepth;
@@ -836,6 +844,7 @@ export declare class Daemon extends EventEmitter {
     private windowQueryFailureTicks;
     private mcpRestartPending;
     private mcpRestartStaleTimer;
+    private mcpRestartCooldownTimer;
     /** In-flight replacement grace; also the guard against three triggers stacking. */
     private mcpRestartGraceTimer;
     /**
@@ -1062,6 +1071,8 @@ export declare class Daemon extends EventEmitter {
      * force-restarted: see that constant for why staying mute costs more.
      */
     private armMcpRestartWhenIdle;
+    /** Keep a cooldown-suppressed revival alive without bypassing the idle gate. */
+    deferMcpRestart(delayMs: number): void;
     /**
      * Single chokepoint for all three revival triggers (already_idle, idle_edge,
      * stale_timeout) — and therefore the one place worth re-checking reality.
@@ -1322,7 +1333,7 @@ export declare class Daemon extends EventEmitter {
     private static readonly AUTH_RECONFIRM_ROWS;
     /** Why the deferred pause was requested; what its marker records (Phase 2a). */
     private pendingPauseReason;
-    pause(reason?: PauseReason): Promise<void>;
+    pause(reason?: PauseReason, admission?: CapacityNudgePauseGuard): Promise<void>;
     /** Respawn the CLI in the preserved window and block until its prompt is ready. */
     wake(timeoutMs?: number): Promise<void>;
     /** A reset baseline must settle before a launch admits new work. */
@@ -1673,6 +1684,13 @@ export declare class Daemon extends EventEmitter {
      * and only if nothing has changed by then — see {@link tickCapacityNudge}. Returns false when there is nothing to arm.
      */
     armCapacityNudge(pattern: RegExp, delayMs: number): boolean;
+    /**
+     * Consume an exhausted nudge only if its failed turn still owns an empty,
+     * idle pane. Unlike arming, this verifies all input/work gates before pause.
+     * The returned owner survives pause's own monitor freeze (which advances the
+     * launch fence), but never another spawn/launch, cancel, delivery or episode.
+     */
+    prepareCapacityNudgePause(): Promise<CapacityNudgePauseGuard | null>;
     /** Drop an armed nudge (the user stopped / paused the instance, or the lifecycle gave up on it). */
     cancelCapacityNudge(reason: string): void;
     /** The first live composer of a spawn fixes what is history (see {@link nudgeBaselines}). */
@@ -2288,6 +2306,11 @@ export declare class Daemon extends EventEmitter {
      * entries recorded meanwhile are dropped from it; none left → nothing.
      */
     private currentWhatsNew;
+    /**
+     * #2163: who this instance is to the what's-new notices — a ClassicBot room's agent, General, or a fleet worker (with
+     * `coordinator` too when its tool set is coordinator or full, the ones that carry get_/set_web_settings).
+     */
+    private whatsNewRoles;
     /** #1633: what this instance has not been told about its AgEnD version yet (see agent-whats-new.ts). */
     private prepareWhatsNew;
     private trySpawnInsideGate;

package/dist/daemon.js

@@ -56,6 +56,8 @@ import { codexLiveRowMatches } from "./backend/codex.js";
 import { claudeConfigDirFor, claudeProfileConfigDir, claudeSwitchDialog, claudeSwitchTargetMatches } from "./backend/claude-code.js";
 import { InteractionObservation, INTERACTION_CONFIRM_MS, sameInteractionOwner } from "./interaction-observation.js";
 import { unrecognisedPromptShape } from "./unrecognised-prompt.js";
+/** #2140: deliveries that may carry an unwritten what's-new notice before it is recorded anyway. */
+const WHATS_NEW_MAX_UNWRITTEN = 3;
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Tool routing sets — module-level to avoid re-creation on every handleToolCall
@@ -67,6 +69,8 @@ const WEB_THEME_IPC = Object.freeze({
     get_web_appearance: "fleet_get_web_appearance", preview_web_appearance: "fleet_preview_web_appearance",
     // r4-4: its own declarative widgets.
     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",
@@ -1490,6 +1494,8 @@ export class Daemon extends EventEmitter {
     pendingInstructionsNotice = false;
     /** #1633: the one-time "what's new for you" notice, pasted before the next real delivery; recorded once pasted. */
     pendingWhatsNew = null;
+    /** #2140: deliveries tried for the pending what's-new notice that never reached the pane (capped: never before every message). */
+    whatsNewUnwritten = 0;
     // Whether the warmup steering-reload notice should be injected after spawn.
     // Set in trySpawn by comparing the freshly-built instructions against the
     // last value the agent was told about (prev-instructions). Skipped when
@@ -1559,6 +1565,7 @@ export class Daemon extends EventEmitter {
     windowQueryFailureTicks = 0;
     mcpRestartPending = false;
     mcpRestartStaleTimer = null;
+    mcpRestartCooldownTimer = null;
     /** In-flight replacement grace; also the guard against three triggers stacking. */
     mcpRestartGraceTimer = null;
     /**
@@ -2577,6 +2584,24 @@ export class Daemon extends EventEmitter {
             this.fireMcpRestartRequest("already_idle");
         }
     }
+    /** Keep a cooldown-suppressed revival alive without bypassing the idle gate. */
+    deferMcpRestart(delayMs) {
+        this.clearMcpRestartRequest();
+        if (this.config.mcp_auto_restart === false || this.authFailureUnresolved
+            || this.mcpRestartCancelledByRecovery("cooldown"))
+            return;
+        this.mcpRestartPending = true;
+        this.mcpRestartCooldownTimer = setTimeout(() => {
+            this.mcpRestartCooldownTimer = null;
+            if (this.mcpRestartCancelledByRecovery("cooldown_expired"))
+                return;
+            this.clearMcpRestartRequest();
+            if (this.config.mcp_auto_restart === false || this.authFailureUnresolved || this.mcpServerAlive().alive)
+                return;
+            this.armMcpRestartWhenIdle();
+        }, Math.max(0, delayMs));
+        this.mcpRestartCooldownTimer.unref?.();
+    }
     /**
      * Single chokepoint for all three revival triggers (already_idle, idle_edge,
      * stale_timeout) — and therefore the one place worth re-checking reality.
@@ -2594,6 +2619,8 @@ export class Daemon extends EventEmitter {
     fireMcpRestartRequest(trigger) {
         if (this.mcpRestartCancelledByRecovery(trigger))
             return;
+        if (this.mcpRestartCooldownTimer)
+            return;
         // Authoritative re-read — the CLI may have replaced the server since the
         // health tick that armed this.
         if (this.mcpServerAlive().alive) {
@@ -2788,6 +2815,10 @@ export class Daemon extends EventEmitter {
     }
     clearMcpRestartRequest() {
         this.mcpRestartPending = false;
+        if (this.mcpRestartCooldownTimer) {
+            clearTimeout(this.mcpRestartCooldownTimer);
+            this.mcpRestartCooldownTimer = null;
+        }
         if (this.mcpRestartStaleTimer) {
             clearTimeout(this.mcpRestartStaleTimer);
             this.mcpRestartStaleTimer = null;
@@ -3645,6 +3676,17 @@ export class Daemon extends EventEmitter {
             const key = Daemon.errorPatternKey(ep);
             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") {
+                const baseline = this.nudgeBaselines?.get(key);
+                if (baseline === undefined || count <= baseline) {
+                    if (baseline !== undefined)
+                        this.lastErrorCount.set(key, count);
+                    continue;
+                }
+            }
             // The generic Codex usage-limit line remains in scrollback after the
             // user selects Luna Reserve. What proves that is NOT a live composer —
             // codex paints one after a plain hit too, and the old live-composer guard
@@ -4671,7 +4713,9 @@ export class Daemon extends EventEmitter {
     static AUTH_RECONFIRM_ROWS = 15;
     /** Why the deferred pause was requested; what its marker records (Phase 2a). */
     pendingPauseReason = "auth";
-    async pause(reason = "operator") {
+    async pause(reason = "operator", admission) {
+        if (admission && !admission.current())
+            return;
         if (this.pauseWakeState === "paused")
             return;
         if (this.pauseWakeState === "pausing" || this.pauseWakeState === "waking") {
@@ -4679,6 +4723,8 @@ export class Daemon extends EventEmitter {
             if (this.getPauseWakeState() !== "active")
                 return;
         }
+        if (admission && !admission.current())
+            return;
         // `pauseAllowStuck` is consumed here, not merely read: it authorises exactly
         // one pause from a stuck pane (the auth-deferred one) and must never leak
         // into an ordinary idle-timeout pause of a busy instance.
@@ -4698,7 +4744,7 @@ export class Daemon extends EventEmitter {
         // this cycle while the backend reports background work; the next idle
         // tick retries once the task ends. A pane-capture failure proceeds (the
         // quit-menu handler below stays the backstop), never wedges unpaused.
-        if (this.backend?.backgroundWorkRunning && this.tmux) {
+        if ((admission || this.backend?.backgroundWorkRunning) && this.tmux) {
             const tmux = this.tmux;
             const windowId = tmux.getWindowId?.();
             const generation = this.spawnGeneration;
@@ -4710,7 +4756,8 @@ export class Daemon extends EventEmitter {
             // #1730 P2-2: the await yields — the pane read is only valid for the
             // world it was taken from. Revalidate owner, phase, state and queue
             // before acting on it; anything that moved defers this cycle.
-            if (this.tmux !== tmux
+            if ((admission && (!admission.current() || pane === null || !admission.accepts(pane)))
+                || this.tmux !== tmux
                 || this.tmux?.getWindowId?.() !== windowId
                 || this.spawnGeneration !== generation
                 || this.getPauseWakeState() !== "active"
@@ -6347,6 +6394,10 @@ export class Daemon extends EventEmitter {
             this.config.cross_instance_visibility = update.cross_instance_visibility;
         else if (update.cross_instance_visibility === null)
             delete this.config.cross_instance_visibility;
+        if (Number.isInteger(update.board_cards_at_once) && update.board_cards_at_once >= 1)
+            this.config.board_cards_at_once = update.board_cards_at_once;
+        else if (update.board_cards_at_once === null)
+            delete this.config.board_cards_at_once;
         if (["trace", "debug", "info", "warn", "error"].includes(String(update.log_level))) {
             const level = update.log_level;
             if (this.config.log_level !== level) {
@@ -6794,15 +6845,30 @@ export class Daemon extends EventEmitter {
                 const whatsNew = this.pendingWhatsNew ? this.currentWhatsNew(this.pendingWhatsNew) : null;
                 if (whatsNew) {
                     // #1633: here, inside the delivery lock and ahead of a real delivery — never into a busy turn, never to an
-                    // instance nobody writes to. Recorded only once pasted: a failed or cancelled paste stays pending.
-                    const pasted = await this.deliverMessage(whatsNew.notice, undefined, { deliveryEpoch });
-                    if (pasted && this.pendingWhatsNew === whatsNew) {
-                        this.pendingWhatsNew = null;
-                        try {
-                            recordWhatsNew(this.instanceDir, whatsNew.ids, whatsNew.version);
-                        }
-                        catch (err) {
-                            this.logger.warn({ err }, "what's-new record not written — the notice may repeat once");
+                    // instance nobody writes to. #2140: told at most once. Once its paste reached the pane it is recorded, proven
+                    // submitted or not. A system paste has no unique id: its only pane proof is its opening line on the screen, and
+                    // a long notice (every entry since an old session began) scrolls that line above the captured rows once Claude
+                    // paints it — unproven, though the agent read it. One that never reached the pane (cancelled, never idle) is
+                    // tried again, at most WHATS_NEW_MAX_UNWRITTEN times, then recorded with a warning.
+                    const attempt = { reached: false };
+                    const pasted = await this.deliverMessage(whatsNew.notice, undefined, { deliveryEpoch, verdict: attempt });
+                    if (this.pendingWhatsNew === whatsNew) {
+                        const written = pasted || attempt.paneWriteStarted === true;
+                        if (!written)
+                            this.whatsNewUnwritten++;
+                        if (written || this.whatsNewUnwritten >= WHATS_NEW_MAX_UNWRITTEN) {
+                            if (!pasted) {
+                                this.logger.warn({ entries: whatsNew.ids, written, attempts: this.whatsNewUnwritten, phase: attempt.phase, proof: attempt.proof }, written ? "what's-new notice pasted but its submission could not be proven — recorded so it is not sent again"
+                                    : "what's-new notice did not reach the pane after several deliveries — recorded so it is not sent again");
+                            }
+                            this.pendingWhatsNew = null;
+                            this.whatsNewUnwritten = 0;
+                            try {
+                                recordWhatsNew(this.instanceDir, whatsNew.ids, whatsNew.version);
+                            }
+                            catch (err) {
+                                this.logger.warn({ err }, "what's-new record not written — the notice may repeat once");
+                            }
                         }
                     }
                     if (!this.isDeliveryEpochCurrent(deliveryEpoch))
@@ -7591,6 +7657,46 @@ export class Daemon extends EventEmitter {
         this.logger.info({ delayMs }, "Model-capacity nudge armed");
         return true;
     }
+    /**
+     * Consume an exhausted nudge only if its failed turn still owns an empty,
+     * idle pane. Unlike arming, this verifies all input/work gates before pause.
+     * The returned owner survives pause's own monitor freeze (which advances the
+     * launch fence), but never another spawn/launch, cancel, delivery or episode.
+     */
+    async prepareCapacityNudgePause() {
+        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)
+            return null;
+        const window = tmux.getWindowId?.();
+        const current = () => this.tmux === tmux && tmux.getWindowId?.() === window
+            && boot === this.bootId && nudge.spawn === this.spawnGeneration && attempt === this.launchAttempt
+            && 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 revalidate = () => this.paneWriteLock.run(async () => {
+            if (!current())
+                return false;
+            try {
+                const pane = await tmux.capturePane();
+                return current() && accepts(pane);
+            }
+            catch {
+                return false;
+            }
+        });
+        // Initial admission must also respect the captured monitor fence. Later
+        // revalidation deliberately tolerates only pause's own fence advancement.
+        if (nudge.fence !== this.launchFenceEpoch || this.healthCheckPaused || this.runtimeMonitorsFrozen)
+            return null;
+        if (!await revalidate() || nudge.fence !== this.launchFenceEpoch || this.healthCheckPaused || this.runtimeMonitorsFrozen)
+            return null;
+        return { current, accepts, revalidate };
+    }
     /** Drop an armed nudge (the user stopped / paused the instance, or the lifecycle gave up on it). */
     cancelCapacityNudge(reason) {
         if (!this.capacityNudge)
@@ -10014,7 +10120,7 @@ export class Daemon extends EventEmitter {
                         reply(got, undefined);
                         return;
                     }
-                    const written = await writePreview(got.files, { workspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name });
+                    const written = await writePreview(got.files, { workspace: this.config.working_directory, configuredWorkspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name });
                     if ("error" in written) {
                         reply(null, `preview_web_appearance: ${written.error}`);
                         return;
@@ -10047,7 +10153,7 @@ export class Daemon extends EventEmitter {
                         reply(got, undefined);
                         return;
                     }
-                    const written = await writeModFile(got.files, { workspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name });
+                    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;
@@ -10056,7 +10162,7 @@ export class Daemon extends EventEmitter {
                     return;
                 }
                 if (tool === "propose_web_mod") {
-                    const read = await readAgentFile(args.file, { workspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name, maxBytes: MOD_UPLOAD_MAX_BYTES });
+                    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}`);
@@ -10081,7 +10187,7 @@ export class Daemon extends EventEmitter {
                         reply(null, "upload_web_effect: launch no longer current");
                         return;
                     }
-                    const read = await readAgentEffect(args.dir, { workspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name });
+                    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;
@@ -10111,7 +10217,7 @@ export class Daemon extends EventEmitter {
                     reply(r.result, r.error);
                     return;
                 }
-                const read = await readAgentFile(args.file, { workspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name, maxBytes: WEB_THEME_ASSET_MAX_BYTES });
+                const read = await readAgentFile(args.file, { workspace: this.config.working_directory, configuredWorkspace: this.config.working_directory, stateDir: getAgendHome(), instance: this.name, maxBytes: WEB_THEME_ASSET_MAX_BYTES });
                 // The path as the agent gave it — only a string is shown (an object from raw JSON args is never coerced).
                 const named = typeof args.file === "string" ? args.file.slice(0, 200) : "the file argument";
                 if (!read.ok) {
@@ -11385,14 +11491,39 @@ export class Daemon extends EventEmitter {
         }
         if (ids.length === pending.ids.length)
             return pending;
-        const narrowed = { notice: whatsNewNotice(pending.version, AGENT_WHATS_NEW.filter(e => ids.includes(e.id))), ids, version: pending.version };
+        // #2163: rebuilt as planned — only the entries this instance's roles are told; the rest are recorded with them.
+        const roles = this.whatsNewRoles();
+        const shown = AGENT_WHATS_NEW.filter(e => ids.includes(e.id) && (!e.audience || e.audience.some(r => roles.includes(r))));
+        if (!shown.length) {
+            this.pendingWhatsNew = null;
+            try {
+                recordWhatsNew(this.instanceDir, ids, pending.version);
+            }
+            catch (err) {
+                this.logger.warn({ err }, "what's-new record not written — the notice may repeat once");
+            }
+            return null;
+        }
+        const narrowed = { notice: whatsNewNotice(pending.version, shown), ids, version: pending.version };
         this.pendingWhatsNew = narrowed;
         return narrowed;
     }
+    /**
+     * #2163: who this instance is to the what's-new notices — a ClassicBot room's agent, General, or a fleet worker (with
+     * `coordinator` too when its tool set is coordinator or full, the ones that carry get_/set_web_settings).
+     */
+    whatsNewRoles() {
+        if (this.runtimeIdentity?.kind === "classic")
+            return ["classic"];
+        if (this.config.general_topic === true || this.name === "general")
+            return ["general"];
+        const set = resolveToolSet(this.config, this.name);
+        return set === "coordinator" || set === "full" ? ["worker", "coordinator"] : ["worker"];
+    }
     /** #1633: what this instance has not been told about its AgEnD version yet (see agent-whats-new.ts). */
     prepareWhatsNew(fresh, version = agendVersion()) {
         try {
-            const plan = planWhatsNew({ record: readWhatsNewRecord(this.instanceDir), fresh, version });
+            const plan = planWhatsNew({ record: readWhatsNewRecord(this.instanceDir), fresh, version, roles: this.whatsNewRoles() });
             if (!plan) {
                 this.pendingWhatsNew = null;
                 return;
@@ -11403,6 +11534,7 @@ export class Daemon extends EventEmitter {
                 return;
             }
             this.pendingWhatsNew = plan;
+            this.whatsNewUnwritten = 0;
             this.logger.info({ entries: plan.ids }, "what's-new notice pending for the next delivery");
         }
         catch (err) {