@songsid/agend 2.1.5-beta.2 → 2.1.5-beta.20

package/dist/daemon.d.ts

@@ -11,6 +11,33 @@ import type { StormWindow } from "./storm-window.js";
 import type { BackendOutageView } from "./backend-outage.js";
 /** Point a resumed CLI at its one backend-native instruction source. */
 export declare function buildInstructionReloadNotice(binaryName: string, instanceName: string, instanceDir: string): string;
+/**
+ * Whether this backend has to be told in its pane that its instructions moved.
+ *
+ * A backend that re-reads them on resume already received the new ones from the
+ * resume itself, so the notice is pure interruption. Both places that can send
+ * it — the warmup paste and the deferred pendingInstructionsNotice — ask through
+ * here, so the two cannot drift apart again: the warmup path used to omit this
+ * check entirely and told claude-code to reload instructions it had just read.
+ */
+export declare function backendNeedsPaneReloadNotice(backend?: {
+    instructionsReloadedOnResume?: boolean;
+}): boolean;
+/**
+ * What the warmup should do about changed instructions.
+ *
+ * `skip` — nothing to say, or this backend learns of the change by itself.
+ * `defer` — worth saying, but nobody is talking to the instance; say it when a
+ *   real message next arrives rather than provoking an unsolicited reply.
+ * `paste` — say it now, into a pane that already has a delivery in flight.
+ */
+export declare function warmupNoticeAction(opts: {
+    warmupNeeded: boolean;
+    backend?: {
+        instructionsReloadedOnResume?: boolean;
+    };
+    pasteQueueDepth: number;
+}): "skip" | "defer" | "paste";
 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;
@@ -172,7 +199,7 @@ export declare class PendingWorkTracker {
     private lastIdleOrder;
     constructor(now?: number);
     recordInbound(now?: number): void;
-    recordIdle(now?: number): void;
+    recordIdle(now?: number): boolean;
     hasPendingWork(): boolean;
 }
 /**
@@ -380,6 +407,14 @@ export declare class Daemon extends EventEmitter {
     private spawnSettled;
     private resolveSpawnSettled;
     private spawnDepth;
+    /** Monotonic identity for nested beginSpawn/endSpawn lifecycles. */
+    private spawnGeneration;
+    /**
+     * Keeps passive startup-transient checks alive through the first positively
+     * submitted post-spawn message.  Without this tail, a transient painted just
+     * after the startup scan can still swallow that message's Enter.
+     */
+    private inputTransientGuardGeneration;
     private skipResume;
     private startupAborted;
     /** First time the current on-screen blocking dialog was seen (0 = none); drives the parked report. */
@@ -412,15 +447,11 @@ export declare class Daemon extends EventEmitter {
     private instanceStateMonitorActive;
     private sessionCheckpointWarningEmitted;
     private statePollInFlight;
-    private turnHadInbound;
-    private turnOutboundDelivered;
-    /** Successful `reply` specifically; cross-instance tools do not satisfy #648. */
-    private turnReplyDelivered;
-    private turnCorrelationId;
-    private turnInboundMarker;
+    private turnReplyGuard;
     /** Prevent a visible stale XML fragment from being recovered on later turns. */
     private lastMalformedToolCallSignature;
     private proxyReplySeq;
+    private lastReplyDropWarningAt;
     private autoPauseController;
     private pauseRequested;
     /**
@@ -573,6 +604,22 @@ export declare class Daemon extends EventEmitter {
     private lastErrorCount;
     private lastDetectedErrorType;
     private static errorPatternKey;
+    /**
+     * Undo the auth suspicion a pattern match armed, once the backend's token-free
+     * probe has said the credentials are fine.
+     *
+     * emitErrorPattern arms these BEFORE the pty_error reaches the lifecycle, and
+     * the lifecycle's "valid" verdict used to just drop the incident — leaving the
+     * daemon permanently suspicious of an auth failure that never existed. That
+     * state is not inert: authFailureUnresolved suppresses the stuck/hang
+     * notification and holds MCP auto-restart (a later real MCP death is then read
+     * as already-confirmed auth trouble rather than re-verified), and the recovery
+     * gate suppresses further error detection until a ready pattern shows up.
+     *
+     * Only what an auth match armed is rolled back. If some other pattern has
+     * since armed the recovery gate, that one is still live and stays.
+     */
+    clearSuspectedAuthFailure(): boolean;
     private clearErrorRecoveryGate;
     constructor(name: string, config: InstanceConfig, instanceDir: string, topicMode?: boolean, backend?: CliBackend | undefined, controlClient?: TmuxControlClient | undefined, rootLogger?: Logger, runtimeIdentity?: FleetInstructionsParams["runtimeIdentity"], spawnGate?: SpawnGate | undefined, stormWindow?: StormWindow | undefined, 
     /** Fleet-level "is this CLI's backend down?" memory — see backend-outage.ts. */
@@ -787,10 +834,14 @@ export declare class Daemon extends EventEmitter {
      */
     private maybeProxyReplyOnTurnEnd;
     private isClaudeCodeBackend;
+    private replyCompletionGuardEnabled;
+    private startReplyRecovery;
+    private reportReplyDropWithoutRetry;
+    private queueReplyRecoveryPrompt;
+    private queueMalformedReplyRecovery;
+    private reportUnrecoveredReplyDrop;
     /** Relay the pane's final text to the channel, marked as a daemon proxy reply. */
     private sendProxyReply;
-    /** Send a narrowly extracted #648 reply; operator notification is a separate event. */
-    private sendRecoveredMalformedReply;
     /** Context-bound reply path shared by dead-MCP and malformed-call recovery. */
     private deliverDaemonReply;
     private clearInstanceStateIdleTimer;
@@ -937,6 +988,18 @@ export declare class Daemon extends EventEmitter {
      * on purpose ("I trust", "Yes, continue") and would match ordinary prose.
      */
     private deliveryBlockingDialogs;
+    /** Passive input-unavailable phases relevant to the current spawn only. */
+    private guardedInputTransients;
+    /** Match a passive transient against the current interactive screen. */
+    private inputTransientInPane;
+    /** Capture failure is unknown, never evidence that input is available. */
+    private probeInputTransient;
+    /**
+     * Wait under the pane lock for a passive transient to disappear. Unlike a
+     * dialog, this state clears by itself, so the wait cannot starve a keypress
+     * dismisser. Stop or a replacement spawn invalidates the captured identity.
+     */
+    private waitForInputTransientToClear;
     private static dialogKey;
     /** A dialog counts only when it is the CURRENT interactive region, if the backend can tell; else by pattern. */
     private static dialogMatches;
@@ -977,10 +1040,10 @@ export declare class Daemon extends EventEmitter {
     private isPaneReadyForDelivery;
     /**
      * Why a pane is not deliverable matters. "busy" may be handed to a native
-     * input queue or steered (after its own dialog probe); "dialog" and "unknown"
-     * must never be — a paste + Enter into a dialog answers it with its default,
-     * and an unreadable pane proves nothing. The silence gate comes first and
-     * costs no capture, so a CLI that is simply working never pays for the probe.
+     * input queue or steered (after its own dialog probe); "dialog", "transient"
+     * and "unknown" must never be — a paste + Enter into a dialog answers it
+     * with its default, while a startup transient swallows it and an unreadable
+     * pane proves nothing. The silence gate comes first and costs no capture.
      */
     private paneReadinessForDelivery;
     /**
@@ -1005,10 +1068,10 @@ export declare class Daemon extends EventEmitter {
      */
     private submitStrandedInputIfAny;
     /**
-     * "stranded": an AgEnD message sits in the input row; "clear": the prompt is
-     * at the bottom with no stranded text; "busy": generating, or the prompt is
-     * not at the bottom (incl. a blank frame); "unknown": the pane could not be
-     * read. Only "clear" is positive evidence.
+     * "stranded": an AgEnD message sits in the input row; "clear": no strand is
+     * visible under the backend's readiness policy; "busy": generating, or (for
+     * a bottom-gated backend) the prompt is not at the bottom; "unknown": the
+     * pane could not be read. Only "clear" permits the next paste.
      */
     private strandedInputState;
     /**
@@ -1054,11 +1117,71 @@ export declare class Daemon extends EventEmitter {
     private sendDeliveryEnter;
     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.
-     * Used only to detect silent paste loss — not as a general ready check.
+     * The single place a pasted message is judged submitted, shared by the
+     * native-queue handoff, the idle-gated redelivery and the system pastes.
+     *
+     * It replaces three divergent weak checks, the weakest of which accepted "the
+     * pasted text is visible somewhere in the pane". That one was satisfied BY
+     * the failure it was meant to catch: text stranded in the input row is on
+     * screen, so a message nobody submitted was confirmed ✅ with no warning
+     * anywhere. Evidence is weighed in order of what it can prove, and the
+     * disqualifying evidence is checked first.
+     */
+    /**
+     * Whether this backend exposes an input row we can actually read, i.e. whether
+     * confirmSubmitted can ever return a verdict stronger than a guess.
+     *
+     * This is a property of the BACKEND, not of one delivery's verdict. Keying the
+     * output-signal fallback off the verdict instead let codex — which can be read
+     * — fall back to "the pane printed something" whenever a paste left no trace,
+     * which is the same false confirmation one layer down.
+     */
+    private canProveSubmission;
+    /** Positive submission retires the startup transient guard for this spawn. */
+    private submittedProof;
+    /**
+     * Decide a submission after an Enter, with one bounded retry.
+     *
+     * Backends we can read must SHOW the text left the input row: neither a
+     * strand nor a vanished paste may be upgraded to success by output, because
+     * the output that would do the upgrading is usually the very redraw the Enter
+     * was lost to. Backends we cannot read keep the legacy output signal — there
+     * is nothing better available for them, and taking it away would fail every
+     * one of their deliveries.
+     *
+     * One ladder, used by every post-Enter confirmation, so an escape hatch
+     * cannot reappear in just one of them (it did: three copies, two of which
+     * still confirmed on output alone).
+     */
+    private confirmAfterEnter;
+    private confirmSubmitted;
+    /**
+     * What the pane currently shows of a given message. Taken once before the
+     * paste and once after, so confirmSubmitted can require a NEW marker or a NEW
+     * echo rather than accepting whatever was already there.
+     */
+    private capturePaneEvidence;
+    private paneEvidence;
+    /**
+     * What identifies THIS message on screen. The routing envelope carries a
+     * message_id that no earlier transcript entry can share, so prefer it: the
+     * body alone is not distinctive enough — short repeated instructions ("carry
+     * on", a status ping) recur verbatim, and an older copy would vouch for a
+     * paste that never landed. System pastes carry no envelope and fall back to
+     * the body signature, which the baseline comparison still ties to this paste.
+     */
+    private submissionSignature;
+    /**
+     * Paste + submit + confirm for the SYSTEM messages that used to go out via
+     * tmux.pasteText: one Enter (two for queue-less backends) and no verification
+     * at all, so a swallowed Enter left the notice sitting in the input row where
+     * the next delivery submitted both as one message. Shares confirmSubmitted
+     * with the delivery path — having one primitive is the point.
+     *
+     * Best effort by design: these notices must never fail a delivery or throw.
+     * The caller already holds paneWriteLock.
      */
-    private nativeQueuePasteVisible;
+    private submitSystemPaste;
     /** Re-resolve this instance's tmux window by name (stale id after crash/respawn). */
     private recoverWindow;
     /**
@@ -1119,6 +1242,32 @@ export declare class Daemon extends EventEmitter {
      */
     private waitForSpawnToSettle;
     /** Spawn a CLI window. Returns true if --resume was used successfully. */
+    /**
+     * Positive proof from the CLI that there is no conversation left to resume.
+     *
+     * Only this may justify abandoning a session. A startup that merely ran out of
+     * budget proves nothing: a healthy cold start on a loaded host looks exactly
+     * the same, which is how 9 instances silently lost their history.
+     *
+     * Deliberately does NOT match a bare "--continue": the pane text can mention
+     * the flag (a usage error, an echoed invocation) without the CLI ever saying
+     * 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;
+    /**
+     * Set the session aside instead of deleting it.
+     *
+     * The whole defect being fixed here is silent, irreversible loss of a user's
+     * conversation. Renaming costs nothing and turns a wrong call into something
+     * recoverable: the id is still on disk under a dated name.
+     */
+    private setSessionAside;
+    /** Keep the newest few set-aside sessions; they are insurance, not an archive. */
+    private pruneAbandonedSessions;
     private spawnClaudeWindow;
     /**
      * Startup budget for this launch: the backend's override (resume-aware), never
@@ -1172,6 +1321,17 @@ export declare class Daemon extends EventEmitter {
      * Returns true if CLI is ready, false if it failed or got stuck.
      */
     private trySpawn;
+    /**
+     * Tell the agent its instructions moved, once the CLI is idle.
+     *
+     * A named method rather than an inline closure so the wiring itself is
+     * testable: warmupNoticeAction's own tests pass even if this call site stops
+     * consulting it, which is exactly the bug this path had — the decision was
+     * made inline and never asked whether the backend needed telling at all.
+     *
+     * Never throws: a missed reload notice must not fail a spawn.
+     */
+    private runWarmupInstructionNotice;
     private trySpawnInsideGate;
     /**
      * The last leg of a spawn: confirm the pane is not positively dead, then run