@songsid/agend 2.3.2-beta.9 → 2.3.3-beta.1

package/dist/daemon.d.ts

@@ -8,6 +8,7 @@ import { type PauseReason } from "./pause-marker.js";
 import { MessageBus } from "./channel/message-bus.js";
 import type { CliBackend, ErrorPattern, InstanceState, InstanceStateSnapshot } from "./backend/types.js";
 import { HangDetector } from "./hang-detector.js";
+import { type RemoteCardAction, type RemoteCardOutcome } from "./remote-card-answer.js";
 import type { TmuxControlClient } from "./tmux-control.js";
 import type { FleetInstructionsParams } from "./instructions.js";
 import type { SpawnGate } from "./spawn-gate.js";
@@ -22,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;
@@ -57,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
@@ -460,6 +441,13 @@ export declare class Daemon extends EventEmitter {
     logTranscriptPath(): string | null;
     /** #1218 (kiro): the launch this daemon's backend last built, for the Log's reason only (kiro-log-gate.ts). */
     logLaunch(): KiroLogLaunch | null;
+    kiroMigrationIdle(): Promise<boolean>;
+    /** One read-only migration observation. Never types into a pane or selects a picker. */
+    kiroMigrationObservation(): Promise<{
+        sessionId: string;
+        model: string;
+        transcript: string;
+    } | null>;
     private guardian;
     private adapter;
     private pendingIpcRequests;
@@ -553,6 +541,12 @@ export declare class Daemon extends EventEmitter {
     private dialogParkedKey;
     private dialogParkedInteractionEpisode;
     private dialogParkedReported;
+    /** #2675: the card on screen that a person can answer from the chat — what it asks, since when, and whether it was posted. */
+    private remoteCardShown;
+    /** #2675: when (performance.now, taken before its capture) the newest read the card tracker used was started. */
+    private remoteCardReadAt;
+    /** #2675: an answer from the chat is being keyed in (one at a time). */
+    private remoteCardAnswering;
     /**
      * #1691: the prompt at the bottom of the pane that no backend table knows — its block, since when (performance.now)
      * it has been unchanged, and whether that has lasted UNRECOGNISED_PROMPT_STABLE_MS. Updated by the runtime scan.
@@ -635,6 +629,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;
@@ -673,7 +671,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
@@ -732,6 +729,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
@@ -788,15 +787,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
@@ -946,21 +942,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. */
@@ -1452,8 +1448,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. */
@@ -1471,6 +1465,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;
@@ -1558,6 +1558,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.
@@ -1783,6 +1790,22 @@ export declare class Daemon extends EventEmitter {
      * dialog's static description and a count, never the pane: a pane can hold anything the agent printed.
      */
     private noteDialogAnswer;
+    /**
+     * #2675: a held card a person can answer from the chat (the dialog's remoteCard reader) is posted once it has stayed
+     * the same card for REMOTE_CARD_STABLE_MS — `remote_card` with what it asks; the fleet posts it with its buttons. When
+     * it closes or another card replaces it, `remote_card_gone` retires that post. Moving through the card (ours or the
+     * person's in the pane) is the same card: its identity has no cursor. `readAt` is when the pane's capture was started
+     * (performance.now): a read that started before the newest one used here finishes late and says nothing about now —
+     * it may neither retire a newer card nor bring an older one back (#2677 review).
+     */
+    private trackRemoteCard;
+    /** #2675: the card's post was used up without answering it (refused, stopped part-way): post it again once it holds still. */
+    repostRemoteCard(): void;
+    /**
+     * #2675: answer the card on screen from the chat, as the person chose: only while it is the card they saw
+     * (`identity`), on a verified cursor, under the pane write lock (remote-card-answer.ts). Never logs the answer.
+     */
+    answerRemoteCard(identity: string, action: RemoteCardAction): Promise<RemoteCardOutcome>;
     /**
      * 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
@@ -1822,8 +1845,26 @@ export declare class Daemon extends EventEmitter {
      * while a fresh capture reads its composer as "steer" — or "idle" once the turn has ended (`allowIdle`, the pre-write
      * re-check). "queue" (the user's choice), text in the box, or a screen it cannot read: not now — the caller waits for
      * the idle prompt as for any message. AgEnD never switches the mode. Backends without the reader are not asked.
+     * #2676: an ordinary message (`steerOnly` false) goes in on "queue" too — kiro takes it into the same tray either way,
+     * held for the turn's end instead of steered into it.
      */
     private steerComposerAdmits;
+    /** #2682: a busy composer's typed input reaches the CLI's own turn (busyTurnTakesInput); an idle box, or no reader: yes. */
+    private busyInputReachesTurn;
+    /**
+     * #2676: whether an ordinary message may be typed into this CLI's busy composer — a mode-switched one (kiro TUI) on a
+     * launch whose busy composer AgEnD drives (the same evidence as a steer: KIRO_STEER_VERIFIED). The legacy UI, an
+     * unlisted version and every backend without the reader answer false; claude and codex hand off by
+     * supportsQueuedInput instead.
+     */
+    private composerTakesBusyInput;
+    /**
+     * #2676: whether the box can show this payload as this delivery's paste before the Enter (steerPasteIsOurs): its
+     * first line, or a collapsed paste's line count. A one-line payload kiro would collapse (over 500 characters) shows only
+     * a character count, which kiro's own normalisation (tabs widened) makes no proof: it waits for the idle prompt.
+     * kiro measures after widening each tab to its 2-column stop, so a tab is counted as 2 here (at most what it becomes).
+     */
+    private composerCanShowPaste;
     /**
      * #1405: one look at a mode-switched composer for a steer's own proof: on the tmux of this write, inside `deadline`
      * (monotonic) — the capture is raced against the time left and a late answer dropped — and `current` asked after the
@@ -1897,6 +1938,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;
     /**
@@ -1998,6 +2042,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
@@ -2276,6 +2325,24 @@ export declare class Daemon extends EventEmitter {
      * silently, confirming and removing nothing. Never throws into the spawn.
      */
     private ensureBackendAgent;
+    /**
+     * M-2025: after a tui/V3 launch is ready, type `/session-id` and `/title` once
+     * each, under the pane-write lock, with the same fences as {@link ensureBackendAgent}.
+     * Does not touch the delivery epoch. A mismatch with the #2617 pin is surfaced;
+     * the pin is never replaced by a file-store guess. Legacy backends return null
+     * from sessionProof().
+     *
+     * #2683: these are AgEnD's own housekeeping, so unlike a delivery (which may join
+     * a person's draft) each one goes only into a composer the final capture shows
+     * positively EMPTY; Enter only once a capture shows exactly the command in the box;
+     * and it counts as run only once the box is empty again — a command left in the
+     * box stops here (it is taken back when the box shows exactly it), and nothing
+     * else is typed after it. The id is taken only from kiro's `/session-id` alert
+     * (readSessionIdAlert) on a capture after the command ran, and never when that
+     * alert was already on the final capture before it was typed: an announcement
+     * that was there before is not an answer to this request.
+     */
+    private ensureKiroSessionProof;
     /**
      * Startup budget for this launch: the backend's override (resume-aware), never
      * below a user-configured startup_timeout_ms; undefined = trySpawn's default.
@@ -2353,22 +2420,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).