@songsid/agend 2.1.11 → 2.1.12-beta.2

package/dist/daemon.d.ts

@@ -11,6 +11,7 @@ import type { SpawnGate } from "./spawn-gate.js";
 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";
 /** Point a resumed CLI at its one backend-native instruction source. */
 export declare function buildInstructionReloadNotice(binaryName: string, instanceName: string, instanceDir: string): string;
 /**
@@ -354,6 +355,8 @@ export declare class InteractivePromptDetector {
     private lastOutputAt;
     private notifiedSignature;
     constructor(stableMs?: number);
+    /** Recognition is persistent; observe() separately deduplicates notifications. */
+    match(pane: string): InteractivePromptDetection | null;
     observe(pane: string, now?: number, outputAt?: number): InteractivePromptDetection | null;
     reset(): void;
 }
@@ -470,11 +473,18 @@ export declare class Daemon extends EventEmitter {
      */
     private launchAttempt;
     private skipResume;
+    /**
+     * #1209: whether THIS boot was asked to skip resume by a crash-loop
+     * (crash-state.json). Captured at boot before spawnClaudeWindow resets
+     * skipResume — the #1209 gate reads this, never the resettable flag.
+     */
+    private bootSkippedResume;
     private startupAborted;
     /** First time the current on-screen blocking dialog was seen (0 = none); drives the parked report. */
     private dialogParkedSince;
     /** Identity of that dialog: its pattern, not its description (two tables may describe one screen differently). */
     private dialogParkedKey;
+    private dialogParkedInteractionEpisode;
     private dialogParkedReported;
     /**
      * The runtime dialog the monitor is answering, and how many of its answers in a row did nothing (the dialog was
@@ -500,6 +510,13 @@ export declare class Daemon extends EventEmitter {
     private capacityNudge;
     /** Current stdin-owning runtime dialog, independent from execution state. */
     private inputBlockedDialogKey;
+    private readonly interactionObservation;
+    private interactionConfirmationTimer;
+    private interactionOutputRevision;
+    private interactionObservedOutputRevision;
+    private interactionCaptureSerial;
+    private interactionDialogKey;
+    private acceptedInstanceSnapshot;
     /** Generation/signature fence for safety dialogs while their screen is still visible. */
     private autoResolvedDialogKey;
     private autoResolvedDialogGeneration;
@@ -821,6 +838,21 @@ export declare class Daemon extends EventEmitter {
     private retryDurableDeliveryBeforeBegin;
     private finishDurableDelivery;
     private finishDurableSubmission;
+    /**
+     * Finish a delivery that only the output edge vouched for, by the delivery's own marker in the CLI's transcript (#758).
+     *
+     *  - marker found       → delivered (`transcript-marker`; `transcript-marker-queued` when the CLI has it queued, not yet read);
+     *  - delta read, no marker for the whole window → uncertain (`unverifiable-no-transcript-marker`) — the pane printed
+     *    something, yet the CLI never took the message in. Never a re-paste: the message may still land;
+     *  - transcript unreadable on the last look → today's outcome, labelled — there is nothing to hold against it.
+     *
+     * It runs after the paste lock is released, but the fleet lane and the shared pump budget stay held until the
+     * verdict settles the row (Phase 2c "lane held until verdict", Option A #1207): a success settles in about a
+     * second, a delivery whose marker never arrives holds them for the bounded proof window (see
+     * TRANSCRIPT_PROOF_WINDOW_MS). It never finishes a row that stop has handed to reconciliation; a pause or respawn
+     * only ends the wait, falling back to today's outcome.
+     */
+    private proveDeliveryFromTranscript;
     private deferDurableDelivery;
     /** Restart the idle clock for work that reached the CLI, and persist it like a user inbound. */
     private noteWorkActivity;
@@ -842,6 +874,13 @@ export declare class Daemon extends EventEmitter {
     /** Lifecycle-provided: whether the fleet holds a work lease on this instance. */
     setWorkLeaseCheck(check: (() => boolean) | undefined): void;
     private workLeaseActive;
+    /**
+     * #1206: rotate + attach the pipe-pane log feed. An attach failure warns
+     * (like the wake path) instead of vanishing silently and leaving the
+     * instance with no log feed. Extracted so the failure path is unit-testable
+     * without driving the real lifecycle.
+     */
+    private attachPipePaneLog;
     start(): Promise<void>;
     /**
      * Detect a CRASHED MCP server and report it once.
@@ -1087,6 +1126,14 @@ export declare class Daemon extends EventEmitter {
     getHangDetector(): HangDetector | null;
     getInstanceState(): InstanceState | "paused";
     getInstanceStateSnapshot(): InstanceStateSnapshot;
+    private interactionOwner;
+    /** Cached, pure observation read; it never captures, constructs a backend or writes stdin. */
+    getInteractionSnapshot(): InteractionSnapshot;
+    private publishInteraction;
+    private clearInteractionConfirmation;
+    private unverifyInteraction;
+    private interactionEvidence;
+    private observeInteractionPane;
     /**
      * Answer a FleetManager state query. Most callers only need the cached state,
      * but lifecycle decisions such as post-reply Cancel retirement need an
@@ -1129,6 +1176,20 @@ export declare class Daemon extends EventEmitter {
      * the PREVIOUS turn's idle edge consume (and reset) the new turn's state.
      */
     private markTurnStarted;
+    /** #1209: which seam reader serves this instance (live config preferred). */
+    private resolveResumeBackend;
+    /** #1209: whether the marker's delivery is still owned by the durable path. */
+    private isMarkerDeliveryPending;
+    /**
+     * #1209 ACP-resume-like gate: one bounded continuation for the turn that
+     * was in flight when the process died. The one-shot marker is consumed
+     * FIRST (episode-once: at most one continuation per interrupted turn, even
+     * if the inject below throws or the process dies holding the grace wait),
+     * then the pure gate in turn-resume.ts decides. A hold inside the flush
+     * grace sleeps once and re-gates with a fresh read; a second hold denies
+     * rather than waiting forever. Returns a short outcome for logs/tests.
+     */
+    private maybeResumeInterruptedTurn;
     /**
      * Turn ended (busy→idle edge): if the MCP server is dead and none of the
      * channel tools verifiably delivered anything this turn, the agent's answer is