@songsid/agend 2.1.1-beta.16 → 2.1.1-beta.18

package/dist/daemon.d.ts

@@ -11,8 +11,6 @@ export declare function buildInstructionReloadNotice(binaryName: string, instanc
 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;
-/** @deprecated State detection is event-driven; this now aliases the safety sweep. */
-export declare const DEFAULT_STATE_POLL_INTERVAL_MS = 60000;
 /**
  * Whether two working directories belong to the same project, so a fleet-scoped
  * decision recorded in one reaches the other. Covers the worktree/checkout
@@ -82,16 +80,32 @@ export declare class AutoPauseController {
  * Pane motion wins over a ready match because several backends keep their ready
  * marker in a persistent header/footer while generating. A stable ready pane is
  * idle; changing content is working; stable non-ready content eventually sticks.
+ *
+ * ## Why an optional busy pattern exists
+ *
+ * "Motion wins" degrades badly when a backend's ready marker is *always* on
+ * screen. `stuck` requires `!ready`, so for such a backend the state can only ever
+ * be idle or working — the stuck edge, and with it `handleStuckTransition` and the
+ * hang notification, is unreachable. A frozen CLI is then reported as idle, which
+ * also clears pending work: the message the user sent is quietly booked as done.
+ *
+ * claude-code was exactly this case (see ClaudeCodeBackend.getReadyPattern). A
+ * backend that can point at a marker meaning "generating right now" supplies
+ * `getBusyPattern()`, and that match vetoes ready regardless of what the ready
+ * pattern says.
  */
 export declare class PaneStateMachine {
     private readonly stuckTimeoutMs;
     private readonly readyPattern;
+    private readonly busyPattern;
     private lastPaneHash;
     private lastPaneChangeAt;
     private lastObservedAt;
     private stateChangedAt;
     private currentState;
-    constructor(readyPattern: RegExp, stuckTimeoutMs?: number, now?: number);
+    constructor(readyPattern: RegExp, stuckTimeoutMs?: number, now?: number, busyPattern?: RegExp | null);
+    /** Ready, unless the backend can positively see that it is still generating. */
+    private isReady;
     observe(pane: string, now?: number): InstanceStateSnapshot;
     /** Record pane motion from tmux control mode without capturing pane content. */
     recordOutput(now?: number): InstanceStateSnapshot;
@@ -136,7 +150,6 @@ export declare class Daemon extends EventEmitter {
     private ipcServer;
     private messageBus;
     private transcriptMonitor;
-    private toolTracker;
     private guardian;
     private adapter;
     private pendingIpcRequests;
@@ -144,6 +157,8 @@ export declare class Daemon extends EventEmitter {
     private lastThreadId;
     private lastAdapterId;
     private pendingAckMessage;
+    /** Last activity published to the fleet manager; null when nothing is running. */
+    private currentActivity;
     private toolStatusMessageId;
     private toolStatusLines;
     private toolStatusDebounce;
@@ -161,6 +176,15 @@ export declare class Daemon extends EventEmitter {
     /** CLI pane availability, independent from the daemon process and tri-state. */
     private processStatus;
     private spawning;
+    /**
+     * Resolves when the in-flight spawn finishes; null when none is running.
+     *
+     * `spawning` alone can only be polled. Delivery needs to *wait*, and a boolean
+     * poll would either busy-loop or race the flag being cleared.
+     */
+    private spawnSettled;
+    private resolveSpawnSettled;
+    private spawnDepth;
     private skipResume;
     private backgroundSessionRecoveryAttempted;
     /** Whether the last spawn started a fresh session (not resumed). */
@@ -182,6 +206,7 @@ export declare class Daemon extends EventEmitter {
     private instanceStateIdleDebounceMs;
     private instanceStateStuckTimeoutMs;
     private instanceStateReadyPattern;
+    private instanceStateBusyPattern;
     private instanceStateMonitorActive;
     private statePollInFlight;
     private autoPauseController;
@@ -200,7 +225,13 @@ export declare class Daemon extends EventEmitter {
     private recentEvents;
     private recentToolActivity;
     private snapshotConsumed;
+    /** Orders inbound channel messages against each other (queue-depth accounting
+     *  and ⏳/👀/✅ reactions live here). It does NOT cover the other writers that
+     *  reach the pane — {@link paneWriteLock} does. */
     private pasteLock;
+    /** Mutual exclusion for *every* write into the pane, whichever subsystem it
+     *  comes from. See PaneWriteLock for why interleaving is destructive. */
+    private readonly paneWriteLock;
     private pendingInstructionsUpdate;
     private pendingInstructionsNotice;
     private warmupNeeded;
@@ -259,6 +290,19 @@ export declare class Daemon extends EventEmitter {
      * A dead remain-on-exit pane still contains the old ready prompt, so allowing
      * the pane monitor to capture it would re-create a false idle state.
      */
+    /**
+     * Announce that this instance is no longer being supervised.
+     *
+     * Four health-check exits set `healthCheckPaused = true` and returned without
+     * telling anyone: a clean CLI exit, `max_retries <= 0`, crash retries exhausted,
+     * and the instance directory being deleted. Only the crash-LOOP case emitted an
+     * event, so a fleet could quietly contain a dead instance that still looked fine
+     * on the dashboard — while messages routed to it queued or failed with a bare ❌.
+     *
+     * `crash_loop` already had this treatment; this is the same bridge for the other
+     * four, carrying a human-readable cause and the operator's next step.
+     */
+    private emitSupervisionEnded;
     private setProcessStatus;
     /**
      * Periodically scan PTY output for backend-defined error patterns.
@@ -285,6 +329,12 @@ export declare class Daemon extends EventEmitter {
      * Interrupt the CLI's current generation (cancel button / `/cancel`).
      * Direct tmux key event (not a paste) so it registers as the interrupt key.
      * kiro-cli interrupts on Ctrl+C; the others (claude-code, codex, …) on Escape.
+     *
+     * Deliberately NOT taken through `paneWriteLock`. Cancel is the user's way out
+     * of a pane that is busy or wedged — queueing it behind the very delivery chain
+     * it exists to unblock would make the button useless exactly when it is needed.
+     * The cost is accepted: an Escape landing between a paste and its Enter discards
+     * that message, which is what the user asked for anyway.
      */
     sendEscape(): Promise<void>;
     /** Send the backend-specific graceful quit command/key sequence. */
@@ -319,6 +369,18 @@ export declare class Daemon extends EventEmitter {
     /** Restore the same monitor objects after wake without adding event listeners. */
     private resumeRuntimeMonitors;
     getMessageBus(): MessageBus;
+    /**
+     * Tell the fleet manager what this instance is doing right now, for the live
+     * progress line on the cancel button.
+     *
+     * Purely cosmetic — nothing decides anything from it, so it is fine that only
+     * backends with a transcript feed report at all (claude-code today). For the
+     * rest the progress line keeps showing just elapsed time.
+     *
+     * Repeats are dropped: the ticker only edits the channel message when the text
+     * changes, and a stream of identical broadcasts would defeat that.
+     */
+    private publishActivity;
     private summarizeTool;
     private addToolStatus;
     /** Debounce tool status updates to avoid channel rate limits */
@@ -349,6 +411,14 @@ export declare class Daemon extends EventEmitter {
      * serial in both cases so separate PTY writes can never overlap.
      */
     private deliverMessage;
+    /**
+     * The write half of a delivery: paste → Enter → confirm, with retries.
+     *
+     * Always called under {@link paneWriteLock}. Split out from `deliverMessage`
+     * precisely so the lock's scope is visible at the call site rather than being
+     * an invariant maintained by comments.
+     */
+    private writeMessageToPane;
     /**
      * True when a busy native-queue paste appears to have landed: Codex shows a
      * `↳` queue marker, or a distinctive slice of the pasted text is on screen.
@@ -357,7 +427,21 @@ export declare class Daemon extends EventEmitter {
     private nativeQueuePasteVisible;
     /** Re-resolve this instance's tmux window by name (stale id after crash/respawn). */
     private recoverWindow;
-    /** Poll up to ~2s (200ms × 10) for the pane to emit output after `since`. */
+    /**
+     * Poll up to ~2s (200ms × 10) for the pane to emit output after `since`.
+     *
+     * A `false` here is not "no output" — it is read as **"the message was pasted but
+     * never submitted"**, which re-sends Enter and then reports ❌ to the user. So a
+     * false negative costs a possible double submit and a failure notice for a
+     * message that actually arrived.
+     *
+     * That is exactly what a control-mode reconnect used to produce. `connect()`
+     * drops every output timestamp, so `hasOutputSince` answers `false` for a pane
+     * that did react — the evidence was thrown away, not absent. Blind time is
+     * therefore not counted against the budget: after a reset the poll restarts from
+     * the moment observation resumed. A hard wall-clock cap keeps a reconnect loop
+     * from extending this forever.
+     */
     private confirmBusyAfterEnter;
     private getWindowId;
     /** Find the IPC socket for a given sessionName */
@@ -375,6 +459,31 @@ export declare class Daemon extends EventEmitter {
      * This replaces the old system-prompt injection approach.
      */
     private injectSnapshotMessage;
+    /**
+     * Depth, not a flag: the wake path marks a spawn and then calls trySpawn, which
+     * marks another. With a plain boolean the inner one's completion would clear the
+     * latch while the outer spawn was still dismissing dialogs, releasing delivery
+     * into exactly the window this exists to close.
+     */
+    private beginSpawn;
+    private endSpawn;
+    /**
+     * Hold until the CLI has finished starting up.
+     *
+     * Startup is not a quiet period: `dismissDialogsUntilReady` is clicking through
+     * trust prompts and session pickers. A pane showing a modal dialog produces no
+     * output, so `waitUntilIdle` reports it idle and a queued message gets pasted
+     * *into the dialog* — where the text is discarded and the Enter picks a menu
+     * item. The paste and the Enter both "succeed", so this loses the message
+     * without even a ❌.
+     *
+     * The pane write lock (#414) does not cover this: it serialises each key
+     * sequence, but it is released between one dialog and the next.
+     *
+     * Bounded, and called BEFORE the pane lock is taken — waiting on the spawn while
+     * holding the lock the spawn itself needs would deadlock.
+     */
+    private waitForSpawnToSettle;
     /** Spawn a CLI window. Returns true if --resume was used successfully. */
     private spawnClaudeWindow;
     /** Kill the entire process tree of the current tmux pane (CLI + MCP server). */