@songsid/agend 2.1.12-beta.2 → 2.1.12-beta.4

package/dist/daemon.d.ts

@@ -219,6 +219,8 @@ export declare class PendingWorkTracker {
     private lastIdleOrder;
     constructor(now?: number);
     recordInbound(now?: number): void;
+    /** #1241 P2-1: when the latest delivery entered, bounding pre-arm activity. */
+    lastInboundTimestamp(): number;
     recordIdle(now?: number): boolean;
     hasPendingWork(): boolean;
 }
@@ -561,6 +563,11 @@ export declare class Daemon extends EventEmitter {
     private instanceStateIdleDebounceMs;
     private instanceStateStuckTimeoutMs;
     private instanceStateReadyPattern;
+    /**
+     * #1241 P2-2: an execution snapshot was suppressed by a blocking dialog.
+     * When the block lifts, the silence since counts as a fresh interval.
+     */
+    private sawBlockedInput;
     private instanceStateBusyPattern;
     private instanceStateMonitorActive;
     private sessionCheckpointWarningEmitted;
@@ -570,6 +577,35 @@ export declare class Daemon extends EventEmitter {
     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
+     * it to a real recovery, while a delivered reply, cancel, or newly observed
+     * work dissolves it. Scoped to one guard generation. Split clock domains
+     * (R3): edgeAt is wall-clock (compared only against lastBusyAt, also wall —
+     * event ordering, never a deadline), while confirmAt is monotonic
+     * (performance.now, same domain as the setTimeout firing the deadline), so
+     * a wall jump can neither shorten nor stretch the window.
+     */
+    private replyGuardIdleConfirm;
+    /**
+     * #1241 P3: the confirmation window's own wake-up. Monitor ticks may be up
+     * to 60 s apart, so without this the real delay could approach two windows.
+     * At the deadline a fresh, fenced capture re-observes the pane instead.
+     */
+    private replyGuardConfirmTimer;
+    /** #1241: dissolve a pending confirmation and its deadline, if any. */
+    private clearReplyGuardConfirm;
+    /** #1241: arm a confirmation window with its own deadline capture. */
+    private armReplyGuardConfirm;
+    /**
+     * #1241 P3: the window elapsed with no verdict from monitor ticks — drive
+     * one fresh observation. Generation-fenced twice: a stale record returns
+     * before capturing, and the resulting snapshot still flows through the
+     * normal confirmed evaluation. When the capture cannot run (paused, frozen,
+     * spawning), the record stays and the next monitor tick promotes instead.
+     */
+    private fireReplyGuardConfirm;
     private autoPauseController;
     private pauseRequested;
     /**
@@ -1122,6 +1158,15 @@ export declare class Daemon extends EventEmitter {
      * bounded SIGTERM -> SIGKILL fallback instead of typing into an unknown pane.
      */
     private drainBusyKiroForStop;
+    /**
+     * #1217: the CLI answered its quit command with a confirmation that a stray
+     * key would answer for us (Claude's "Background work is running": Enter
+     * picks "Exit and stop tasks"). Never choose an option: cancel the prompt
+     * with Escape and let the caller stop the process itself (SIGTERM), which is
+     * what the bounded grace would have come to anyway — just without waiting
+     * it out. True when that prompt was on screen.
+     */
+    private cancelQuitConfirmation;
     stop(): Promise<void>;
     getHangDetector(): HangDetector | null;
     getInstanceState(): InstanceState | "paused";
@@ -1129,6 +1174,8 @@ export declare class Daemon extends EventEmitter {
     private interactionOwner;
     /** Cached, pure observation read; it never captures, constructs a backend or writes stdin. */
     getInteractionSnapshot(): InteractionSnapshot;
+    /** Key of the last interaction snapshot actually emitted + broadcast (#1219). */
+    private lastPublishedInteractionKey;
     private publishInteraction;
     private clearInteractionConfirmation;
     private unverifyInteraction;
@@ -1197,6 +1244,12 @@ export declare class Daemon extends EventEmitter {
      * manager does not pass through the dead MCP server. Consuming the turn state
      * here (edge-triggered, then reset) is what makes it at most once per turn.
      */
+    /**
+     * #1241: promote a pending idle-edge confirmation once the window has
+     * elapsed. Steady idle with no reply and no work since the edge is proven
+     * idle; anything else dissolves the confirmation and leaves the turn armed.
+     */
+    private maybeConfirmReplyGuardIdle;
     private maybeProxyReplyOnTurnEnd;
     private isClaudeCodeBackend;
     private replyCompletionGuardEnabled;
@@ -1810,10 +1863,28 @@ export declare class Daemon extends EventEmitter {
      * the conversation is gone.
      */
     private paneSaysNoConversation;
-    /** How many consecutive startups have failed without proving the session is gone. */
-    private unprovenResumeFailures;
     /** After this many, start fresh anyway — loudly — so a truly broken session still recovers. */
     private static readonly MAX_UNPROVEN_RESUME_FAILURES;
+    /**
+     * #1217: the unproven-failure count lives in the instance directory, keyed by
+     * the session id. Each start builds a new Daemon, so a count kept on the
+     * object was always "attempt 1/3": the escape hatch could never fire, and an
+     * unresumable session failed every start forever. A different session id (or
+     * none) starts the count again; a successful resume or a set-aside ends it.
+     */
+    private bumpUnprovenResumeFailures;
+    private clearUnprovenResumeFailures;
+    /**
+     * #1217: a session id belongs to the backend that made it. After a backend
+     * switch the old id names nothing the new CLI knows (a Claude id handed to
+     * muse is "retained session not found"), so resuming it can only fail. The
+     * owner is recorded on every successful start; an id recorded for another
+     * backend is set aside (kept on disk, as always) and this start is fresh.
+     * An id with no recorded owner (from before this was recorded) is left to
+     * the resume itself — its failure is proven or counted like any other.
+     */
+    private setAsideForeignSession;
+    private recordSessionOwner;
     /**
      * Set the session aside instead of deleting it.
      *