@songsid/agend 2.1.11-beta.3 → 2.1.11-beta.5

package/dist/daemon.d.ts

@@ -169,10 +169,12 @@ export declare class PaneStateMachine {
     private readonly busyPattern;
     private lastPaneHash;
     private lastPaneChangeAt;
+    private lastProgressTick;
+    private readonly progressTick;
     private lastObservedAt;
     private stateChangedAt;
     private currentState;
-    constructor(readyPattern: RegExp, stuckTimeoutMs?: number, now?: number, busyPattern?: RegExp | null);
+    constructor(readyPattern: RegExp, stuckTimeoutMs?: number, now?: number, busyPattern?: RegExp | null, progressTick?: ((pane: string) => number | null) | null);
     /** Ready, unless the backend can positively see that it is still generating. */
     private isReady;
     /**
@@ -480,6 +482,22 @@ export declare class Daemon extends EventEmitter {
      * dialog on screen at every poll and ignores nothing.
      */
     private dialogAnswers;
+    /**
+     * The last error occurrence handed to the lifecycle: what an action that needs the screen it was seen on (a
+     * `nudge_continue` arming) reads back, with the spawn / monitors it was seen under.
+     */
+    private lastErrorEpisode;
+    /**
+     * An armed "tell the agent to keep going" (Codex model at capacity). One per episode; the monitor owns it: every poll
+     * cancels it when anything changed, and it fires at most once. The due time is on the monotonic clock.
+     */
+    /**
+     * How many occurrences of each `nudge_continue` pattern were already on screen when this spawn first showed a live
+     * composer (null until then): resumed scrollback, i.e. HISTORY. An occurrence is a new episode only beyond that — a
+     * resumed session whose scrollback holds an old capacity line must not be told to "keep going" for it (#949).
+     */
+    private nudgeBaselines;
+    private capacityNudge;
     /** Current stdin-owning runtime dialog, independent from execution state. */
     private inputBlockedDialogKey;
     /** Generation/signature fence for safety dialogs while their screen is still visible. */
@@ -618,6 +636,8 @@ export declare class Daemon extends EventEmitter {
      *  comes from. See PaneWriteLock for why interleaving is destructive. */
     private readonly paneWriteLock;
     private deliveryWritesStopping;
+    /** #829: the latest pastes, by spawn generation (see ownedInputDraft). */
+    private recentPastes;
     private pendingInstructionsUpdate;
     private pendingInstructionsNotice;
     private warmupNeeded;
@@ -1122,6 +1142,8 @@ export declare class Daemon extends EventEmitter {
     private startReplyRecovery;
     private reportReplyDropWithoutRetry;
     private queueReplyRecoveryPrompt;
+    /** Recheck after queue waits and IO; cancellation must not become a failure notice. */
+    private currentReplyRecovery;
     private queueMalformedReplyRecovery;
     private reportUnrecoveredReplyDrop;
     /** Relay the pane's final text to the channel, marked as a daemon proxy reply. */
@@ -1207,6 +1229,12 @@ export declare class Daemon extends EventEmitter {
      */
     private systemPasteOptions;
     private summarizeTool;
+    /**
+     * A steered message reads like a queued one plus a banner. The delivery marker (`[agend-delivery-id:…]`, when the message
+     * is a durable delivery) must LEAD the persisted user message — restart reconciliation recognises a delivery only by a
+     * marker at the start of the body (#1197) — so the banner goes right after it, not in front of it.
+     */
+    private static steerEnvelope;
     /**
      * The one place an inbound message grows its metadata wrapper ([user:]/
      * [from:] prefix, pending reactions, handoff metadata, reply instructions).
@@ -1338,6 +1366,26 @@ export declare class Daemon extends EventEmitter {
      * within a bound and then fail loudly.
      */
     private probeBlockingDialog;
+    /**
+     * Arm the "keep going" nudge for the error occurrence just reported (`pattern` must be the one the lifecycle was
+     * handed). The nudge is sent once, `delayMs` from now on the MONOTONIC clock (a wall-clock step changes nothing),
+     * and only if nothing has changed by then — see {@link tickCapacityNudge}. Returns false when there is nothing to arm.
+     */
+    armCapacityNudge(pattern: RegExp, delayMs: number): boolean;
+    /** Drop an armed nudge (the user stopped / paused the instance, or the lifecycle gave up on it). */
+    cancelCapacityNudge(reason: string): void;
+    /** The first live composer of a spawn fixes what is history (see {@link nudgeBaselines}). */
+    private takeNudgeBaselines;
+    private static countOccurrences;
+    /**
+     * One monitor poll's look at an armed nudge. It is CANCELLED — never postponed — when anything about the instance
+     * moved: a stop / pause / respawn (spawn generation or monitor epoch), a user cancel (delivery epoch), the pane no
+     * longer being exactly the one the error was seen on (it moved on by itself, a person typed, another dialog), the
+     * agent working, or a message waiting for delivery. Only when it is due and still untouched is it fired — once — and
+     * the injection re-verifies everything under the pane-write lock.
+     */
+    private tickCapacityNudge;
+    private sendCapacityNudge;
     /** What identifies the request on screen: the backend's own identity when it has one, else the whole screen verbatim. */
     private static screenOf;
     private static answerKey;
@@ -1447,6 +1495,35 @@ export declare class Daemon extends EventEmitter {
      * else submitted it); "failed" = the Enter could not be sent (the delivery
      * must fail rather than paste on top of the stranded text).
      */
+    /** #829: remember what this pane generation was given, so a draft can be proven to be ours. */
+    /**
+     * #829: remember what was pasted, under the spawn generation it was written
+     * to — fixed by the caller BEFORE its paste await, so a write that lands
+     * while the CLI is replaced is never credited to the replacement.
+     */
+    private rememberPaste;
+    /**
+     * #829: whether the input box shows one of this generation's own pastes —
+     * exactly as the backend draws it, wrapping included (inputDraftShows). A
+     * marker that looks like AgEnD's, a collapsed paste whose content cannot be
+     * seen, or text that differs only in spacing proves nothing.
+     */
+    private ownsInputDraft;
+    /**
+     * #829: empty the CLI's input box of a draft the CLI put back there itself
+     * (muse restores a cancelled prompt) before a delivery is pasted. Only for a
+     * backend that can read its box and names the keys that clear it; every other
+     * backend is untouched.
+     *
+     * Only a draft that is provably one of this pane's own pastes is cleared, one
+     * line per round, and every round must leave the first or last rows of what
+     * was there — anything else in the box is somebody's typing and stops the
+     * clearing. `current` is the caller's fixed fence (cancel, stop, freeze,
+     * pause, spawn): it is asked after every await, and a stale answer means
+     * nothing more is sent. A capture that fails, a box that does not empty or a
+     * draft that is not ours stops the delivery; it is never pasted onto.
+     */
+    private clearRestoredInputDraft;
     private submitStrandedInputIfAny;
     /**
      * "stranded": an AgEnD message sits in the input row; "clear": no strand is
@@ -1531,6 +1608,13 @@ export declare class Daemon extends EventEmitter {
      * — fall back to "the pane printed something" whenever a paste left no trace,
      * which is the same false confirmation one layer down.
      */
+    /**
+     * The acceptance evidence for a steer whose input row cannot be read: a FRESH capture shows this delivery's trusted unique
+     * marker more often than the pre-paste baseline did, no blocking dialog owns the pane, and it is still the spawn and the
+     * window the paste went into. (The marker is the `message_id:` value AgEnD put in the handoff metadata — never text
+     * scanned out of a body — so an older or quoted line cannot match it.)
+     */
+    private steerMarkerAccepted;
     private canProveSubmission;
     /** Positive submission retires the startup transient guard for this spawn. */
     private submittedProof;
@@ -1578,6 +1662,12 @@ export declare class Daemon extends EventEmitter {
      * Best effort by design: these notices must never fail a delivery or throw.
      * The caller already holds paneWriteLock.
      */
+    /**
+     * `guard` is for a paste that must not outlive the reason it was made (the continue nudge): `accept` judges the ONE
+     * capture taken here — the same picture is the baseline, the expected-screen check and the idle check — and `current`
+     * is asked again after every await that precedes a write, so a cancelled paste adds no further paste and no key
+     * (the retries included). Without a guard it is exactly the old unconditional path.
+     */
     private submitSystemPaste;
     /** Re-resolve this instance's tmux window by name (stale id after crash/respawn). */
     private recoverWindow;
@@ -1733,6 +1823,8 @@ export declare class Daemon extends EventEmitter {
      * a live turn. Fail closed: an unreadable pane is never idle.
      */
     private isPaneAuthoritativelyIdle;
+    /** The verdict of {@link isPaneAuthoritativelyIdle} on a capture the caller already holds. */
+    private paneAuthoritativelyIdle;
     /**
      * Poll the authoritative pane check until it reports idle or the budget runs
      * out. Each poll is a fresh capture, so a turn that ends mid-wait is seen.