@songsid/agend 2.2.0-alpha.9 → 2.2.0-beta.10

package/dist/daemon.d.ts

@@ -13,6 +13,13 @@ import type { StormWindow } from "./storm-window.js";
 import type { BackendOutageView } from "./backend-outage.js";
 import { type DaemonDeliveryPort } from "./delivery-outbox.js";
 import type { InteractionSnapshot } from "./backend/types.js";
+import type { KiroLogLaunch } from "./kiro-log-gate.js";
+/**
+ * #1641: an open turn in the CLI's transcript holds the instance busy (no paste, whatever the pane shows) only while the
+ * transcript is still moving: a turn whose end was missed must not pin the instance busy forever. A live turn writes
+ * 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.
@@ -224,6 +231,25 @@ export declare class PendingWorkTracker {
     recordIdle(now?: number): boolean;
     hasPendingWork(): boolean;
 }
+/** #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;
+/** #1690: what AgEnD's own runtime switch came to — sent back to the fleet (IPC runtime_switch_result). */
+export type OwnSwitchOutcome = {
+    outcome: "switched";
+    confirmed: boolean;
+    shown?: string;
+} | {
+    outcome: "mismatch";
+    shown: string;
+    answered: boolean;
+} | {
+    outcome: "not_confirmed";
+    shown?: string;
+} | {
+    outcome: "not_sent";
+};
+/** #1691: a prompt no table knows must sit unchanged this long (monotonic) before it holds deliveries and is reported. */
+export declare const UNRECOGNISED_PROMPT_STABLE_MS = 60000;
 /**
  * Startup failed because the CLI's backend is unreachable (see backend-outage.ts).
  * The session-id is deliberately KEPT; the fleet schedules a delayed retry.
@@ -422,6 +448,10 @@ export declare class Daemon extends EventEmitter {
     private ipcServer;
     private messageBus;
     private transcriptMonitor;
+    /** #1218: the transcript this instance's monitor follows now (the Log tab reads it on demand; nothing runs for it here). */
+    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;
     private guardian;
     private adapter;
     private pendingIpcRequests;
@@ -503,6 +533,27 @@ export declare class Daemon extends EventEmitter {
     private dialogParkedKey;
     private dialogParkedInteractionEpisode;
     private dialogParkedReported;
+    /**
+     * #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.
+     */
+    private unrecognisedPrompt;
+    /**
+     * #1691: when (performance.now) the newest pane read that decided the evidence above was taken — a scan or a fresh
+     * read, confirming, restarting or ending it. A read taken before it finishes late and says nothing about now: it may
+     * neither clear, restart nor confirm (#1695 r4).
+     */
+    private unrecognisedPromptReadAt;
+    /**
+     * #1691: the catch-all for that prompt, as a hold-only runtime dialog — so the delivery hold, awaiting_input, the
+     * Needs-you item and the single parked report are the existing ones. Never answered (hold-only, no keys).
+     */
+    private readonly unrecognisedPromptDialog;
+    /**
+     * #1690: AgEnD's own runtime `/model` in flight — from the moment its paste went in until its "Switch model?" dialog
+     * (if any) is answered. Every delivery is held meanwhile: the dialog's default cursor is Yes, a stray Enter confirms it.
+     */
+    private ownSwitch;
     /**
      * The runtime dialog the monitor is answering, and how many of its answers in a row did nothing (the dialog was
      * still on screen right after the keys). Not the on-screen duration: a burst of FRESH prompts, each answered, has a
@@ -592,6 +643,11 @@ export declare class Daemon extends EventEmitter {
     private turnReplyGuard;
     /** #1510: turn boundaries from the CLI's transcript, for a backend whose guard reads its turn end there. */
     private transcriptTurns;
+    /** #1641: when this launch's transcript monitor last read anything (a turn boundary, a tool, assistant text); performance.now(). */
+    private transcriptActivityAt;
+    /** #1641: the launch and composer a stuck pane's idle evidence is about, and since when (performance.now()); see recoverStuck. */
+    private stuckRecoveryKey;
+    private stuckRecoverySince;
     /** #1510: since when (monotonic) this generation has been held as running in the transcript. */
     private transcriptRunningSince;
     /** Prevent a visible stale XML fragment from being recovered on later turns. */
@@ -714,6 +770,8 @@ export declare class Daemon extends EventEmitter {
     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;
     private warmupNeeded;
     private lastBuiltInstructions;
     private pasteQueueDepth;
@@ -1137,6 +1195,20 @@ export declare class Daemon extends EventEmitter {
     private queueRawPaste;
     /** Keep the IPC raw route's durable mode attached to the parsed attempt. */
     private handleRawPasteIpcMessage;
+    /**
+     * #1690 (the user's choice A): after AgEnD's own `/model <name>`, claude may ask "Switch model?" (a warm cache for
+     * another model). When the model it names is the one asked for, answer Yes; otherwise No (Escape — `Kept model as …`),
+     * and say so. Every key goes on a freshly read, verified dialog under the pane write lock: the same target, and for
+     * Enter the cursor on "1. Yes"; the cursor is walked there with Up, one verified step at a time, never a blind key.
+     * Without the dialog, claude's own "Set model to …" line after the command is the result.
+     */
+    private answerOwnSwitchDialog;
+    /**
+     * #1690: claude's "Set model to …" line under our `/model <requested>` (no dialog was needed). Only the newest command
+     * on the pane counts: an older identical `/model` with its result further up (switched away and back) must not pass
+     * for this one before it has even painted — that left its dialog unanswered (live, 2.1.296).
+     */
+    static switchResultAfterCommand(pane: string, requested: string): boolean;
     /**
      * Confirm a backend's terminal-level /clear prompt after the channel-level
      * admin confirmation has already succeeded. Poll instead of pasting `/clear\ny`
@@ -1297,6 +1369,19 @@ export declare class Daemon extends EventEmitter {
      * with it — a new monitor re-baselines at the transcript's end, so nothing the old one read can be attributed.
      */
     private buildTranscriptMonitor;
+    /**
+     * #1641: what the CLI's own transcript (codex's rollout) says about its turn. `open`: a turn started and has not ended,
+     * and the transcript moved within TRANSCRIPT_OPEN_TURN_QUIET_MS. `closed`: every turn read since this launch's monitor
+     * began has ended. `unknown`: not a transcript backend, nothing followed, or an open turn gone quiet (a missed end).
+     */
+    private transcriptTurnState;
+    /**
+     * #1641: a stuck pane that is in fact an idle CLI (a footer this build cannot read) must not stay stuck for hours with
+     * every delivery parked behind it. It recovers when the backend sees its own live, EMPTY composer with no busy, queued
+     * or dialog marker (isStableUnknownLayoutIdlePane) AND the transcript shows no open turn — or, with no transcript to
+     * ask, that same composer held unchanged for UNKNOWN_LAYOUT_STABLE_MS (#978's rule). An open turn never recovers.
+     */
+    private recoverStuck;
     private replyCompletionGuardEnabled;
     private startReplyRecovery;
     private reportReplyDropWithoutRetry;
@@ -1401,7 +1486,15 @@ export declare class Daemon extends EventEmitter {
      * here — a steered message must read EXACTLY like a queued one to the
      * agent, or the two drift apart in what the agent is told about replying.
      */
+    /** #1650: how this instance talks to the fleet — MCP tools, or agend-agent commands (agent_mode: cli). */
+    private agentMode;
     private formatInboundMessage;
+    /** Pure cached owner: no pane/process query on ingress. */
+    captureHumanReceiptOwner(): string | null;
+    /** The same formatter/sanitizer used by the actual write; snapshot only. */
+    humanReceiptWire(content: string, meta: Record<string, string>, kind: string): string;
+    private humanReceiptAttempt;
+    private finishHumanReceipt;
     /**
      * Whether ONE delivery reached a verdict, carried by that delivery.
      *
@@ -1476,6 +1569,44 @@ export declare class Daemon extends EventEmitter {
      * on purpose ("I trust", "Yes, continue") and would match ordinary prose.
      */
     private deliveryBlockingDialogs;
+    /**
+     * The backend's runtime dialogs, then #1691's catch-all for a prompt none of them knows (last: known ones win). The
+     * catch-all is listed only while such a prompt is active: otherwise it could match nothing, and a backend with no
+     * dialogs keeps its empty list (its delivery path skips the dialog probe, as before).
+     */
+    private runtimeDialogs;
+    /**
+     * #1691: is the pane at the CLI's own idle composer? Then whatever looks like a prompt above it is transcript output
+     * (an agent's numbered list, a quoted "[y/n]"), not a prompt. The backend's own reading, most specific first.
+     */
+    private cliComposerShowing;
+    /**
+     * #1691: the prompt shape this pane shows, when nothing else explains it (no known dialog, login, idle composer, and
+     * the CLI is not showing its busy indicator).
+     */
+    private unrecognisedPromptCandidate;
+    /**
+     * #1691, from each runtime scan: the same unexplained prompt block unchanged for UNRECOGNISED_PROMPT_STABLE_MS
+     * becomes active (held, awaiting_input, reported once by trackDialogParked). Any other screen ends it. A turn keeps
+     * changing the pane (spinner, timer, streamed text), so its clock never completes mid-turn.
+     */
+    private trackUnrecognisedPrompt;
+    /** #1691: the tracked evidence, if it still belongs to this launch (else it is dropped). */
+    private unrecognisedPromptCurrent;
+    /**
+     * #1691: the catch-all's predicate — the tracked prompt is active and this pane still shows exactly it (any reader:
+     * the scan, a probe, an interaction re-capture). Ending the evidence on a read without it is noteFreshPaneRead's.
+     */
+    private unrecognisedPromptActive;
+    /**
+     * #1691: a fresh pane read outside the scan (a delivery probe, an accepted state re-capture), taken at `mono`. When it
+     * no longer shows exactly the tracked prompt, the evidence ends — counting or active, so a return needs a fresh minute
+     * (#1695 r2). When it does, it is the newest confirmation. Either way only a read newer than the newest read that
+     * decided the evidence counts: an older one, finishing late, says nothing about now (#1695 r3, r4).
+     */
+    private noteFreshPaneRead;
+    /** #1691: the screen as the stability clock compares it (trailing blanks are not motion). */
+    private static stableScreen;
     /** Passive input-unavailable phases relevant to the current spawn only. */
     private guardedInputTransients;
     /** Stop honouring passive transients for the current spawn. */
@@ -1743,6 +1874,18 @@ export declare class Daemon extends EventEmitter {
      * (dropped) Enter — and an unreadable pane is not a verified absence either.
      */
     private confirmSubmittedAfterEnter;
+    /**
+     * #1647: whether a raw paste on a pane with no transcript (kiro) was taken: its text gone from the input row (or the
+     * CLI's own busy marker shown instead — pasteResidue's rule) with output after the Enter. That is the confirmation's
+     * own rule, looked at more than once: kiro repaints its composer late, so the single look right after Enter misread
+     * pastes it took. A generic `working` reading is not evidence (#1663 P1-3: a repaint looks like work).
+     *
+     * Bounded by the budget that confirmation already has, measured from the Enter (#1663 P2-1): the busy wait plus the
+     * post-Enter proof window. Every reading is asked again after its await — still this write's owner (`current`: the
+     * caller's fence, no stop, the same tmux and spawn, #1663 P2-2) and still inside the budget — before it counts; a late
+     * or fenced answer proves nothing. Null: not shown — the caller settles uncertain, never a second Enter.
+     */
+    private rawPasteTakenOnPane;
     /** Once Kiro returns to its prompt, its unique envelope id in history proves submission. */
     private kiroSubmissionEvidence;
     /** Observe the Kiro paste outside paneWriteLock; a long agent turn must not block dialog handling. */
@@ -2039,7 +2182,7 @@ export declare class Daemon extends EventEmitter {
      * the same tmux window, not aborted, writes not stopping — re-checked after every await, and between the paste and
      * its Enter. The whole step, every await included, ends at one monotonic deadline: a late capture never confirms
      * and a late admission never writes; a paste whose Enter would land past it is taken back. Not confirmed in time:
-     * the old setup stays, a launch warning says so, the next launch tries again. A stop, pause or respawn ends it
+     * the old setup stays, the next launch tries again, and a quiet launch warning (#1794: logged and on the Log tab, not posted) says so. A stop, pause or respawn ends it
      * silently, confirming and removing nothing. Never throws into the spawn.
      */
     private ensureBackendAgent;
@@ -2130,6 +2273,14 @@ export declare class Daemon extends EventEmitter {
      * Never throws: a missed reload notice must not fail a spawn.
      */
     private runWarmupInstructionNotice;
+    /**
+     * #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.
+     */
+    private currentWhatsNew;
+    /** #1633: what this instance has not been told about its AgEnD version yet (see agent-whats-new.ts). */
+    private prepareWhatsNew;
     private trySpawnInsideGate;
     /**
      * The last leg of a spawn: confirm the pane is not positively dead, then run
@@ -2207,6 +2358,10 @@ export declare class Daemon extends EventEmitter {
     private recordRecentEvent;
     private recordRecentToolActivity;
     writeRotationSnapshot(reason: string): RotationSnapshot;
+    /** #1699: the claude config dir this instance's CLI uses — its credential profile's, else exactly as before. */
+    private claudeConfigDir;
+    /** Where this instance's CLI keeps the conversation a turn resume is judged on (#1699: claude's follows the profile). */
+    private resumeRoots;
     /**
      * The credential profile's store this instance's CLI writes to, if any.
      *