@bridge4dev/runner 0.60.0 → 0.61.0

package/dist/supervisor.d.ts

@@ -230,6 +230,8 @@ export interface SupervisorOptions {
      * `BACKGROUND_TASKS_HEARTBEAT_MS`. Real one is five minutes.
      */
     backgroundTasksHeartbeatMs?: number;
+    /** #348: the compaction net, as a test seam over `COMPACTION_WATCHDOG_MS`. */
+    compactionWatchdogMs?: number;
 }
 /**
  * How often a resting session says «I still hold N background tasks» — the
@@ -274,6 +276,8 @@ export declare class Supervisor {
     private static readonly EMPTY_TURN_SETTLE_MS;
     /** The window actually used — the constant, or a test's own shorter one. */
     private readonly emptyTurnSettleMs;
+    /** The compaction net actually used — the constant, or a test's own. */
+    private readonly compactionWatchdogMs;
     private readonly rateLimitsResendMs;
     /** The stop-settle window actually used — the constant, or a test's own. */
     private readonly stopSettleMs;
@@ -328,6 +332,22 @@ export declare class Supervisor {
     private restarting;
     /** A restore-point collection is running; a second reconnect must not start another (#388). */
     private checkpointGcInFlight;
+    /**
+     * Sessions the current `hello_ack` names, while `reconcile` is walking them
+     * (#392).
+     *
+     * The unacked replay at the top of `reconcile` sends every journal's
+     * leftovers before a single session is registered, and the acks come back
+     * while the loop is still awaiting an earlier session's worktree. The ack
+     * handler deletes the journal of a session it does not know once nothing is
+     * unacked — which used to be exactly the journal the loop was about to
+     * restore from: its open cards, its queued messages, its anchor, gone a
+     * moment before they were read. Membership here is what «this session is
+     * known» means until the loop reaches it.
+     */
+    private readonly reconciling;
+    /** How long a dashboard-requested compaction may go unreported before the session is handed back. */
+    private static readonly COMPACTION_WATCHDOG_MS;
     /** Session 14: one project-recipe run per machine, and its verdict queue. */
     private readonly verify;
     private readonly verifyReports;
@@ -913,6 +933,26 @@ export declare class Supervisor {
      * chance, and the alternative there is a card that stays clickable forever.
      */
     private withdrawOpenQuestions;
+    /**
+     * Close out the asks a PREVIOUS process of this runner left open (#392).
+     *
+     * `withdrawOpenQuestions` above reads `running.openQuestions`, and that set
+     * is memory: a process that died without reaching `shutdown()` — killed,
+     * crashed, machine rebooted — took it along, and the restore used to create
+     * a fresh empty set and write only «Runner reconnected». The card in the
+     * browser is closed by one thing, a `question_resolved` with its askId in
+     * the feed, so it stayed answerable for ever, and everything typed into it
+     * was lost (the 07.09.2026 session in the ticket: six restarts, zero
+     * tombstones).
+     *
+     * The journal is the set that survived: `SessionJournal.append` notes every
+     * card this runner published and every resolution it published, whoever
+     * wrote it. That is also the «already closed» check the plan asks to name:
+     * a graceful `shutdown()` sends its `question_resolved` through the same
+     * `append`, so by the time a restore runs, a card closed that way is no
+     * longer in the set — one tombstone per card, never two.
+     */
+    private withdrawJournaledQuestions;
     /**
      * Deliver messages that were held because every slot was taken.
      *
@@ -1019,6 +1059,23 @@ export declare class Supervisor {
      * phantom can never fire after the turn it belonged to has closed properly.
      */
     private clearEmptyTurn;
+    /**
+     * A compaction is over for a reason other than the agent saying so (#348):
+     * the turn it rode on ended, the process died, a new process was launched.
+     * The feed gets its closing line so the pair is complete, and the runner's
+     * own state is dropped so the NEXT compaction opens a new pair — left set,
+     * every later start would be read as a repeat and written nowhere (QA S4).
+     */
+    private endCompaction;
+    /** A compaction has begun: say so in the feed, once, and remember who started it (#348). */
+    private openCompaction;
+    /**
+     * The net under a dashboard-requested compaction (#348) — see
+     * `RunningSession.compactionWatchdog`. Fires only into a session that has
+     * said nothing since: every agent event and every ending clears it.
+     */
+    private armCompactionWatchdog;
+    private clearCompactionWatchdog;
     /**
      * Record how many subagents are alive, and say so when it matters (#236).
      *
@@ -1060,8 +1117,9 @@ export declare class Supervisor {
      * It happens for real: a background subagent's report wakes a new turn inside
      * the agent process (SDK 0.3.226 emits a second `system:init` and a `result`
      * carrying `origin: {kind:'task-notification'}`), and nothing here reports a
-     * turn the runner did not start. Compaction does the same, and so does a
-     * question this runner withdraws by itself.
+     * turn the runner did not start. So does a question this runner withdraws by
+     * itself. (A compaction used to be the third case; `compact_context` reports
+     * RUNNING itself now, and #348 gave the compaction lines of its own.)
      *
      * An open question is the one thing that must survive: there, WAITING_INPUT
      * means a tool call is parked on a person, and the agent narrating around its
@@ -1412,7 +1470,34 @@ export declare class Supervisor {
      * anything down. The name says what it does.
      */
     private finishSession;
+    /**
+     * The terminal status a reconnect should replay for this session instead
+     * of restoring it, or null (QA-96 F1).
+     *
+     * Only a terminal status from THIS life of the session. A resumed session
+     * carries a higher epoch, and replaying the FAILED it was resumed from would
+     * kill it again the moment the runner reconnects. A journal written by a
+     * runner from before session 13 could hold a `DONE` — it is no longer a
+     * status this runner may report, and replaying one would close the session
+     * for the user. Drop it and let the session be picked back up like any
+     * other. Pure: reads the journal and decides, so the pre-registration pass
+     * and the loop answer the question the same way.
+     */
+    private terminalStatusToReplay;
+    /**
+     * Build and register the entry for a session a runner restart interrupted,
+     * and close the cards its dead process left open (#392).
+     *
+     * Synchronous on purpose, and called for EVERY such session before the
+     * reconnect awaits anything: registered, the session is known (a message
+     * for it waits in its queue behind the `starting` gate of #401 instead of
+     * coming back as `session_unknown`), and its cards go dark first thing —
+     * above the line about the restart, so a person reading down sees the card
+     * close before they read why.
+     */
+    private registerRestoredSession;
     private reconcile;
+    private reconcileKnown;
     /**
      * Housekeeping for the journal directory. Safe to call any time: live
      * sessions are skipped and a journal still holding unacked events survives