@songsid/agend 2.3.2 → 2.3.3-beta.2

package/dist/daemon.d.ts

@@ -23,34 +23,6 @@ import type { KiroLogLaunch } from "./kiro-log-gate.js";
  * often; a long silent tool run shows its own busy row on the pane.
  */
 export declare const TRANSCRIPT_OPEN_TURN_QUIET_MS: number;
-export declare function buildInstructionReloadNotice(binaryName: string, instanceName: string, instanceDir: string, backendSource?: string | null): string;
-/**
- * Whether this backend has to be told in its pane that its instructions moved.
- *
- * A backend that re-reads them on resume already received the new ones from the
- * resume itself, so the notice is pure interruption. Both places that can send
- * it — the warmup paste and the deferred pendingInstructionsNotice — ask through
- * here, so the two cannot drift apart again: the warmup path used to omit this
- * check entirely and told claude-code to reload instructions it had just read.
- */
-export declare function backendNeedsPaneReloadNotice(backend?: {
-    instructionsReloadedOnResume?: boolean;
-}): boolean;
-/**
- * What the warmup should do about changed instructions.
- *
- * `skip` — nothing to say, or this backend learns of the change by itself.
- * `defer` — worth saying, but nobody is talking to the instance; say it when a
- *   real message next arrives rather than provoking an unsolicited reply.
- * `paste` — say it now, into a pane that already has a delivery in flight.
- */
-export declare function warmupNoticeAction(opts: {
-    warmupNeeded: boolean;
-    backend?: {
-        instructionsReloadedOnResume?: boolean;
-    };
-    pasteQueueDepth: number;
-}): "skip" | "defer" | "paste";
 export declare const DEFAULT_STUCK_TIMEOUT_MS: number;
 export declare const DEFAULT_STATE_IDLE_DEBOUNCE_MS = 2000;
 export declare const DEFAULT_STATE_SAFETY_SWEEP_MS = 60000;
@@ -58,6 +30,14 @@ export declare const DEFAULT_STATE_SAFETY_SWEEP_MS = 60000;
 export declare const PERIODIC_REDRAW_PROBE_MS = 25;
 /** Do not turn a streaming Codex turn into one capture-pane per burst. */
 export declare const STRUCTURED_IDLE_PROBE_MS = 500;
+/** #2770 (ii): how often output may schedule a look for a layout that repaints while idle (CliBackend.periodicRedrawFrom). */
+export declare const PERIODIC_LAYOUT_LOOK_MS = 5000;
+/** #2770: how often a delivery waiting for idle asks again whether it can be handed off instead. */
+export declare const HANDOFF_RECHECK_MS = 1000;
+/** #2770: how often a wait for idle asks its stop condition (a cancel, a hand-off that became possible). */
+export declare const WAIT_STOP_POLL_MS = 250;
+/** #2770: human messages a cancel dropped are told in one notice, this long after the last of them. */
+export declare const CANCELLED_HUMANS_NOTICE_MS = 1000;
 /**
  * An instance publishing more than this many execution-state edges inside the
  * window is flapping; its edges stop being logged one by one (#1116). One
@@ -554,6 +534,8 @@ export declare class Daemon extends EventEmitter {
     private bootSkippedResume;
     private recoveryCrashLoopFresh;
     private recoveryFreshChoice;
+    /** The current boot found a crash-loop marker and is attempting resume rather than going fresh immediately. */
+    private bootCrashLoopResume;
     private startupAborted;
     /** First time the current on-screen blocking dialog was seen (0 = none); drives the parked report. */
     private dialogParkedSince;
@@ -649,6 +631,10 @@ export declare class Daemon extends EventEmitter {
     /** Consecutive structural idle captures for a noisy, periodically-redrawing
      * pane.  Two are required before a working -> idle transition. */
     private instanceStatePeriodicIdleConfirmations;
+    /** #2770 (ii): the latest capture showed a layout that repaints while idle (CliBackend.periodicRedrawFrom). */
+    private periodicRedrawLayout;
+    /** When output last scheduled a look for that layout (monotonic ms), so a busy pane is not captured on every chunk. */
+    private periodicLayoutLookAt;
     /** Recent execution-state edge times, for the flap log limiter (#1116). */
     private stateEdgeTimes;
     private stateEdgesNotLogged;
@@ -687,7 +673,6 @@ export declare class Daemon extends EventEmitter {
     /** Prevent a visible stale XML fragment from being recovered on later turns. */
     private lastMalformedToolCallSignature;
     private proxyReplySeq;
-    private lastReplyDropWarningAt;
     /**
      * #1241: an idle edge that has not yet proven the turn ended. Armed instead
      * of recovering immediately; a steady idle snapshot past confirmAt promotes
@@ -746,6 +731,8 @@ export declare class Daemon extends EventEmitter {
     private authFailureUnresolved;
     /** One login-screen auth report per spawn — the screen persists across polls. */
     private loginScreenReported;
+    /** #2795: the auth pattern match the token-free check is still to judge; it arms nothing until confirmAuthFailure(). */
+    private unverifiedAuthMatch;
     /**
      * While the lifecycle is still starting this daemon, `pty_error` has no
      * listener and `InstanceLifecycle.daemons` has no entry — so an incident the
@@ -802,15 +789,12 @@ export declare class Daemon extends EventEmitter {
     private deliveryWritesStopping;
     /** #829: the latest pastes, by spawn generation (see ownedInputDraft). */
     private recentPastes;
-    private pendingInstructionsUpdate;
-    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;
+    /** #2770: a person's messages a cancel dropped before they reached the CLI, told together (noteCancelledHuman). */
+    private cancelledHumans;
+    private cancelledHumansTimer;
     private firstDeliveryDelay;
     /** Orders /steer pastes against each other. Deliberately NOT pasteLock:
      *  a steer must not queue behind the normal deliveries it exists to
@@ -947,6 +931,35 @@ export declare class Daemon extends EventEmitter {
     private lastErrorCount;
     private seededErrorCountBaselines;
     private lastDetectedErrorType;
+    /**
+     * #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.
+     */
+    private usageLimitHold;
+    /** Transcript events in Claude's order (prompts, output, every API error): the newest, and the latest limit error. */
+    private transcriptEventSeq;
+    private usageLimitErrorSeq;
+    static readonly MODEL_USAGE_LIMIT: RegExp;
+    /** #2822: the usage-limit hold, while it lasts — Needs you lists it. */
+    usageHold(): {
+        model: string;
+        since: number;
+    } | null;
+    /** #2822: Claude recorded a failed API call. */
+    private noteClaudeApiError;
+    /** #2822: Claude produced output (text or a tool call): the model answers again, so a hold ends. */
+    private noteClaudeOutput;
+    /** #2822: a prompt reached Claude (recorded in its transcript). */
+    private noteClaudePrompt;
+    /**
+     * #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.
+     */
+    private personTurnEndedOnUsageLimit;
     private static errorPatternKey;
     /** 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). */
@@ -960,21 +973,21 @@ export declare class Daemon extends EventEmitter {
     releaseStartupIncidents(): void;
     emit(event: string | symbol, ...args: unknown[]): boolean;
     /**
-     * Undo the auth suspicion a pattern match armed, once the backend's token-free
-     * probe has said the credentials are fine.
-     *
-     * emitErrorPattern arms these BEFORE the pty_error reaches the lifecycle, and
-     * the lifecycle's "valid" verdict used to just drop the incident — leaving the
-     * daemon permanently suspicious of an auth failure that never existed. That
-     * state is not inert: authFailureUnresolved suppresses the stuck/hang
-     * notification and holds MCP auto-restart (a later real MCP death is then read
-     * as already-confirmed auth trouble rather than re-verified), and the recovery
-     * gate suppresses further error detection until a ready pattern shows up.
-     *
-     * Only what an auth match armed is rolled back. If some other pattern has
-     * since armed the recovery gate, that one is still live and stays.
+     * Undo an auth suspicion once the backend's token-free probe has said the credentials are fine. Since #2795 a pane
+     * pattern match arms nothing before that probe (its pending match is just dropped); what is left to undo is a
+     * login-screen report, which arms authFailureUnresolved itself. That state is not inert: it suppresses the
+     * stuck/hang notification and holds MCP auto-restart. If some other pattern has armed the recovery gate, that one
+     * is still live and stays.
      */
     clearSuspectedAuthFailure(): boolean;
+    private armErrorRecoveryGate;
+    /**
+     * #2795: the token-free check did not vouch for the credentials behind an auth pattern match. Only now does the
+     * match become an auth failure: the state the detector used to arm at match time. Remembered for as long as it is
+     * unresolved — an auth-broken CLI cannot finish the turn it is holding, so every other detector would otherwise
+     * keep reporting the same dead instance. A login-screen report arms its own state and has no match to confirm.
+     */
+    confirmAuthFailure(): boolean;
     private clearErrorRecoveryGate;
     constructor(name: string, config: InstanceConfig, instanceDir: string, topicMode?: boolean, backend?: CliBackend | undefined, controlClient?: TmuxControlClient | undefined, rootLogger?: Logger, runtimeIdentity?: FleetInstructionsParams["runtimeIdentity"], spawnGate?: SpawnGate | undefined, stormWindow?: StormWindow | undefined, 
     /** Fleet-level "is this CLI's backend down?" memory — see backend-outage.ts. */
@@ -1466,8 +1479,6 @@ export declare class Daemon extends EventEmitter {
     private currentReplyRecovery;
     private queueMalformedReplyRecovery;
     private reportUnrecoveredReplyDrop;
-    /** Channel notice for a reply-drop. `rateLimit` shares the per-instance cooldown (#2544). */
-    private deliverReplyDropNotice;
     /** Relay the pane's final text to the channel, marked as a daemon proxy reply. */
     private sendProxyReply;
     /** Context-bound reply path shared by dead-MCP and malformed-call recovery. */
@@ -1485,6 +1496,12 @@ export declare class Daemon extends EventEmitter {
     private scheduleInstanceStateIdleCapture;
     private captureAndEvaluateInstanceState;
     private handleInstancePaneOutput;
+    /**
+     * The backend's structural idle proof for periodically repainting panes, when it applies to the current layout: always
+     * for a backend that repaints in every layout (Codex, Muse), only while the latest capture showed such a layout for one
+     * that names it (CliBackend.periodicRedrawFrom — Claude's background-agent list, #2770 (ii)).
+     */
+    private periodicIdleProof;
     private bindInstanceStateOutputListener;
     private startInstanceStateMonitor;
     private stopInstanceStateMonitor;
@@ -1572,6 +1589,13 @@ export declare class Daemon extends EventEmitter {
     /** The same formatter/sanitizer used by the actual write; snapshot only. */
     humanReceiptWire(content: string, meta: Record<string, string>, kind: string): string;
     private humanReceiptAttempt;
+    /**
+     * #2770: a person's message a cancel dropped before it reached the CLI is told, not left as a silent "uncertain":
+     * the messages dropped together go out as one `human_messages_cancelled` (the fleet marks each ❌ and says so once).
+     * Agents' messages are not a person's, and a durable row (delivery_id) is retried by the outbox: neither is ❌'d. A
+     * message with no chat to mark has nowhere to say it.
+     */
+    private noteCancelledHuman;
     private finishHumanReceipt;
     /**
      * Whether ONE delivery reached a verdict, carried by that delivery.
@@ -1945,6 +1969,9 @@ export declare class Daemon extends EventEmitter {
      * Enter-dropping TUIs. Polls at a coarse cadence (each poll is a capture-pane)
      * only after the pane is already quiet, so the common fast-idle delivery still
      * costs a single capture.
+     *
+     * #2770: with `stop`, the wait also ends ("stopped") as soon as `stop` says so — asked every WAIT_STOP_POLL_MS while
+     * the pane is busy, and before every re-poll — so a cancel or a hand-off that became possible never waits out the pane.
      */
     private waitForPaneReadyForDelivery;
     /**
@@ -2046,6 +2073,11 @@ export declare class Daemon extends EventEmitter {
      */
     private isPaneIdleForDelivery;
     private waitForPaneIdleForDelivery;
+    /**
+     * #2770: waitForPaneIdleForDelivery that also ends as soon as `stop` says so ("stopped"). The same idle readings
+     * (tmux silence, or the state machine where its idle is trusted), polled here so nothing outlives a stopped wait.
+     */
+    private waitForPaneIdleOrStop;
     /**
      * Antigravity has always opted into pane-state delivery readiness because its
      * footer redraws while idle.  Codex's structural idle proof is useful only
@@ -2419,22 +2451,17 @@ export declare class Daemon extends EventEmitter {
      */
     private switchMuseToDirect;
     /**
-     * Tell the agent its instructions moved, once the CLI is idle.
-     *
-     * A named method rather than an inline closure so the wiring itself is
-     * testable: warmupNoticeAction's own tests pass even if this call site stops
-     * consulting it, which is exactly the bug this path had — the decision was
-     * made inline and never asked whether the backend needed telling at all.
-     *
-     * Never throws: a missed reload notice must not fail a spawn.
+     * #1633 (#1639 review): the pending notice as things stand NOW, just before the paste — it was decided at launch, and
+     * the record, a switch or the instance's tools may have changed while the delivery waited. Planned again from the
+     * record (#2800: the running release only, tools it has now); nothing left to tell → recorded, nothing pending.
      */
-    private runWarmupInstructionNotice;
+    private currentWhatsNew;
+    private recordWhatsNewSent;
     /**
-     * #1633 (#1639 review): the pending notice as the record stands NOW, just before the paste — it was decided at launch,
-     * and the record may have changed while the delivery waited. Unreadable → nothing is sent (and nothing pending);
-     * entries recorded meanwhile are dropped from it; none left → nothing.
+     * #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.
      */
-    private currentWhatsNew;
+    private whatsNewTools;
     /**
      * #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).