@songsid/agend 2.1.12 → 2.2.0-alpha.2

package/dist/daemon.d.ts

@@ -12,7 +12,7 @@ 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";
-export declare function buildInstructionReloadNotice(binaryName: string, instanceName: string, instanceDir: string): string;
+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.
  *
@@ -231,6 +231,19 @@ export declare class BackendUnreachableStartupError extends Error {
     readonly backend: string;
     constructor(backend: string);
 }
+/**
+ * Where a delivery-status reaction belongs. chatId is ALWAYS the platform
+ * chat (Telegram supergroup id, Discord guild id) — never a forum topic id.
+ * threadId carries the topic/thread separately so each adapter can address
+ * the message its own way (Telegram ignores it, Discord reacts in the thread).
+ */
+type DeliveryStatus = {
+    chatId: string;
+    messageId: string;
+    threadId?: string;
+};
+/** Build a status holder from channel metadata, keeping chat and thread apart. */
+export declare function channelStatus(meta: Record<string, string>): DeliveryStatus | undefined;
 /**
  * One-shot timing gate for the first paste after a CLI reaches its ready
  * prompt. A TUI that is still completing its first redraw can swallow Enter.
@@ -523,6 +536,8 @@ export declare class Daemon extends EventEmitter {
     /** Generation/signature fence for safety dialogs while their screen is still visible. */
     private autoResolvedDialogKey;
     private autoResolvedDialogGeneration;
+    /** Per-launch safety phases survive startup handoff, redraws and failed/uncertain key ACKs. */
+    private launchDialogClaims;
     /**
      * (#1103) Proof that THIS spawn's Codex went onto Luna Reserve: AgEnD saw (and
      * answered) the usage-limit menu that codex shows when it switches itself to
@@ -874,6 +889,13 @@ export declare class Daemon extends EventEmitter {
     private abortDurableDelivery;
     private retryDurableDeliveryBeforeBegin;
     private finishDurableDelivery;
+    /**
+     * #1201: a steer or a native-queue hand-off was accepted into the CLI's input (or may have been) — not read. Watch
+     * the transcript from this attempt's checkpoint for the moment the CLI takes it, and record that on the delivery;
+     * an `uncertain` row becomes `delivered` then. Only claude-code and codex write a transcript AgEnD can read. The
+     * watch belongs to this CLI: a stop, pause or respawn ends it (restart reconciliation owns the row after that).
+     */
+    private startConsumedWatch;
     private finishDurableSubmission;
     /**
      * Finish a delivery that only the output edge vouched for, by the delivery's own marker in the CLI's transcript (#758).
@@ -901,6 +923,12 @@ export declare class Daemon extends EventEmitter {
      * one second after it became ready.
      */
     seedActivityNow(now?: number): void;
+    /**
+     * Whether this launch takes a steer into a running turn, for a backend that answers per launch (kiro's TUI vs its
+     * legacy UI, #1405); undefined for every other backend, whose name decides (steer-capability.ts). The backend reads
+     * what it last launched — no probe, no fork, safe on the fleet loop.
+     */
+    launchSupportsSteer(): boolean | undefined;
     /**
      * Phase 2b (design §1.4): why this awake instance is not taking input, in
      * words for a notice, or null when nothing known holds it. Read from the
@@ -918,7 +946,9 @@ export declare class Daemon extends EventEmitter {
      * without driving the real lifecycle.
      */
     private attachPipePaneLog;
-    start(): Promise<void>;
+    private startupAdmission;
+    start(admission?: () => void): Promise<void>;
+    private startAdmitted;
     /**
      * Detect a CRASHED MCP server and report it once.
      *
@@ -1465,6 +1495,8 @@ export declare class Daemon extends EventEmitter {
     private static dialogMatches;
     /** Refresh the separate stdin-blocked observation from one pane capture. */
     private updateInputBlockedState;
+    private hasAutoDialogClaim;
+    private claimAutoDialog;
     /** Whether a runtime prompt currently owns the pane's stdin. */
     isInputBlocked(): boolean;
     /**
@@ -1553,6 +1585,34 @@ export declare class Daemon extends EventEmitter {
      * reporting idle after 10s only to make that gate wait another 10s (#1035).
      */
     private probeDeliveryIdleFallback;
+    /**
+     * #1405: a steer is handed to the busy pane only if THIS launch takes one — asked of the backend again at delivery,
+     * not just by the hub when it was sent: a durable steer can outlive the launch it was meant for (a restart onto a
+     * legacy UI or an unverified version), and must then wait for the idle prompt like any message. Backends that do not
+     * answer per launch leave it to the hub's name table.
+     */
+    private launchTakesSteer;
+    /**
+     * #1405: a steer into a CLI whose busy input steers or queues by a mode the user switches (kiro TUI) goes in only
+     * 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.
+     */
+    private steerComposerAdmits;
+    /**
+     * #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
+     * await. Null when unreadable, late or no longer this write's: never evidence of an empty or a full box. The pane
+     * comes back with the mode, so what follows judges the same capture.
+     */
+    private steerComposerWithin;
+    /**
+     * #1405: the composer's text is THIS delivery's paste. kiro paints a multi-line paste's first line on the `›` row (live,
+     * 2.27.1 and 2.28.0, TUI v2 and v3); that row must show the payload's first line COMPLETE — for a durable steer that
+     * is its `[agend-delivery-id:<this attempt's id>]` marker, so a draft, someone else's paste, our paste appended to a
+     * draft, or a marker cut short (wrapped, collapsed, truncated) is never taken for it: not attributable, no Enter.
+     */
+    private steerPasteIsOurs;
     /**
      * Codex can paint a prompt before the TTY enters raw mode. Both are required.
      *
@@ -1711,6 +1771,8 @@ export declare class Daemon extends EventEmitter {
      * an invariant maintained by comments.
      */
     private sendDeliveryEnter;
+    /** Write half only: callers must finish the availability wait before any final recovery ownership proof. */
+    private sendDeliveryEnterAfterAvailability;
     private writeMessageToPane;
     /**
      * The single place a pasted message is judged submitted, shared by the
@@ -1759,8 +1821,8 @@ export declare class Daemon extends EventEmitter {
     private confirmAfterEnter;
     private confirmSubmitted;
     /**
-     * The CLI's transcript, from this attempt's checkpoint, holds this delivery's exact marker: a user entry (read) or
-     * one it queued (taken into its queue). Either is the CLI having taken the
+     * The CLI's transcript, from this attempt's checkpoint, holds this delivery's exact marker: a user entry (read), an
+     * entry Claude absorbed mid-turn, or one it queued (taken into its queue). Any of them is the CLI having taken the
      * message, so it outranks the pane — including a box that still shows the paste a moment after Enter (Claude paints
      * the submit late, captured live on 2.1.293), which on its own reads as a strand. Positive only; never a downgrade.
      */
@@ -1941,6 +2003,34 @@ export declare class Daemon extends EventEmitter {
     /** Keep the newest few set-aside sessions; they are insurance, not an archive. */
     private pruneAbandonedSessions;
     private spawnClaudeWindow;
+    /** The whole agent switch after a resume, on the monotonic clock (#906 §3). */
+    private static readonly AGENT_SWITCH_BUDGET_MS;
+    private static readonly AGENT_SWITCH_POLL_MS;
+    /** Each tmux call of the write (load, paste, Enter, take-back) is bounded by this. */
+    private static readonly AGENT_SWITCH_TMUX_OP_MS;
+    /**
+     * The paste is started only with this much budget left, checked at the paste itself: the load and the paste, the
+     * settle, the Enter — each bounded by AGENT_SWITCH_TMUX_OP_MS — fit in it.
+     */
+    private static readonly AGENT_SWITCH_WRITE_RESERVE_MS;
+    /** Between the paste and its Enter, as tmux pastes elsewhere (pasteText). */
+    private static readonly AGENT_SWITCH_PASTE_SETTLE_MS;
+    /**
+     * #906 §3: after a resume, make the CLI run as this instance's own agent. Reads the agent off the live layout
+     * (backend.agentSwitch().readActive — the supported bottom layout only, never a name quoted in the conversation);
+     * when it is another one, types the switch command ONCE, under the pane-write lock, and only when ONE final capture
+     * taken there shows the live layout naming another agent AND an idle, input-ready pane (ready, not busy, no
+     * blocking dialog, no input transient) — after the delivery path's own readiness check. It confirms only on a
+     * later capture of the live layout naming ours.
+     *
+     * Fenced like a delivery, from entry on: the spawn generation, launch fence, the pause/wake phase it started in,
+     * 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
+     * silently, confirming and removing nothing. Never throws into the spawn.
+     */
+    private ensureBackendAgent;
     /**
      * Startup budget for this launch: the backend's override (resume-aware), never
      * below a user-configured startup_timeout_ms; undefined = trySpawn's default.
@@ -2123,3 +2213,4 @@ export declare class Daemon extends EventEmitter {
     private handleReleaseRepo;
     private buildSnapshotPrompt;
 }
+export {};