@bridge4dev/runner 0.48.0 → 0.49.0

package/dist/supervisor.d.ts

@@ -116,6 +116,12 @@ export interface SupervisorOptions {
      * suite runs on real timers. Never set in production.
      */
     rateLimitsResendMs?: number;
+    /**
+     * How long a stop waits for the ending it asked for (#373) – a test seam over
+     * `STOP_SETTLE_MS`, for the same reason `emptyTurnSettleMs` exists. Never set
+     * in production.
+     */
+    stopSettleMs?: number;
 }
 export declare class Supervisor {
     private readonly ws;
@@ -144,6 +150,8 @@ export declare class Supervisor {
     /** The window actually used — the constant, or a test's own shorter one. */
     private readonly emptyTurnSettleMs;
     private readonly rateLimitsResendMs;
+    /** The stop-settle window actually used — the constant, or a test's own. */
+    private readonly stopSettleMs;
     /** A finished session's journal is kept this long for a late reconnect. */
     private static readonly JOURNAL_TTL_MS;
     /** Backstop: events the API will never accept must not pile up forever. */
@@ -760,6 +768,90 @@ export declare class Supervisor {
      *   turn it stops would bury the feed under a fact nobody asked about.
      */
     private interruptSession;
+    /**
+     * How long a stop waits for the ending that should follow it (#373).
+     *
+     * The transition out of `interrupting` is the first result, not the
+     * acknowledgement — an ACK only says the request was heard, and the incident
+     * shows an ACK and a result are different events that arrive in either order.
+     * This is the backstop for the case where no result comes at all: an idle
+     * session had no turn to end, and a CLI can always simply not answer.
+     */
+    private static readonly STOP_SETTLE_MS;
+    /**
+     * How long after one stop the next output is still read as its tail (#196).
+     *
+     * The floor under the stop cycle rather than a substitute for it: while a
+     * cycle is open every event joins it, and this is what keeps a burst from
+     * opening a NEW cycle per line in the window after one closed without closing
+     * its process. Far shorter than the gap before a genuinely new turn — a
+     * background subagent finishing — which still gets its own stop.
+     */
+    private static readonly PAUSE_BURST_MS;
+    /**
+     * Stop one agent process once, and own what stopping it produces (#373).
+     *
+     * The shape is deliberate: the interrupt is a round trip that can take half a
+     * minute (a CLI sitting out a provider retry answers only when it comes back
+     * — 28.5 seconds, measured in #357), so nothing here may be on the path the
+     * event pump takes. The cycle is stored before the request goes out, which is
+     * what makes every later request join this one instead of starting a second.
+     */
+    private beginStopCycle;
+    /**
+     * Wait a bounded time for the ending an accepted interrupt should produce.
+     *
+     * «Bounded» rather than «for ever» because two real cases produce no ending
+     * at all: a pause landing between turns (there was nothing to stop), and a
+     * CLI that takes the request and then says nothing. Leaving the cycle open
+     * there would hold the seat and the clock indefinitely.
+     */
+    private armStopSettle;
+    private clearStopSettleTimer;
+    /**
+     * The turn is over — close the process, keeping the session resumable.
+     *
+     * This is the change the whole plan is about. A pause used to leave a live
+     * CLI standing for up to five hours, which is where the second result came
+     * from; now the runner takes the ending it asked for and parks, and the next
+     * message (or the clock's own «continue») starts a process that resumes the
+     * same conversation.
+     */
+    private settleStopCycle;
+    /**
+     * The agent never said yes — say so, and say only what actually happened.
+     *
+     * Invariant 5: a stop the CLI refused must not read as a clean cancellation.
+     * Which sentence is true depends on what came next, so it is written here and
+     * not where the refusal was noticed — a line promising «its process was
+     * closed» over a manual Stop, which closes nothing, is the same class of lie
+     * as the one this ticket is about (gotcha 324).
+     */
+    private sayIfTheStopWasRefused;
+    /**
+     * Why this paused process must NOT be closed, or null when it may be.
+     *
+     * Invariant 8 lives here. `park()` calls the adapter's `stop()`, and `stop()`
+     * answers every pending permission «denied» in the RUNNER's name — a decision
+     * nobody made, in a place that keeps decisions for ninety days. Worse, the API
+     * sends nothing when the clock is lifted over an open card
+     * (`pauseInterruptedTurn` is false while `openAsks > 0`), so the session would
+     * simply stand there, silent, with the card gone.
+     *
+     * A conversation the CLI has not named yet is the other refusal: parking
+     * promises the context is saved, and there is nothing to resume from.
+     */
+    private parkRefusalUnderPause;
+    /**
+     * The one ending a stop cycle publishes (#373).
+     *
+     * `ok` unconditionally: a turn this runner stopped is not a turn that failed,
+     * and `turn_end{ok:false}` is what put a paused session into the terminal
+     * status it could never be woken out of. The facts the turn actually carried
+     * ride along — `limitBlocked` because the API counts refusals with it, and
+     * `produced` because it is what keeps the refusal counter honest (#300).
+     */
+    private publishStoppedTurn;
     /** Is this session held under a clock right now (ticket #196)? */
     private static isPaused;
     /**