@bridge4dev/runner 0.45.0 → 0.45.1

package/dist/supervisor.d.ts

@@ -53,6 +53,15 @@ export interface SupervisorOptions {
      * announced and no rewind can be started.
      */
     checkpointsEnabled?: boolean;
+    /**
+     * How long a turn that produced nothing is held before it counts (#300).
+     *
+     * A test seam, like `proposeCommitMessage` above: the real window is 25
+     * seconds and no suite can wait that out, so the behaviour would go
+     * unverified — which is exactly how the independent review found the hold
+     * firing over a working agent (QA-2026-08-16 M-4). Never set in production.
+     */
+    emptyTurnSettleMs?: number;
 }
 export declare class Supervisor {
     private readonly ws;
@@ -78,6 +87,8 @@ export declare class Supervisor {
      * agent mid-thought.
      */
     private static readonly EMPTY_TURN_SETTLE_MS;
+    /** The window actually used — the constant, or a test's own shorter one. */
+    private readonly emptyTurnSettleMs;
     /** 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. */
@@ -351,6 +362,21 @@ export declare class Supervisor {
      * phantom can never fire after the turn it belonged to has closed properly.
      */
     private clearEmptyTurn;
+    /**
+     * Record how many subagents are alive, and say so when it matters (#236).
+     *
+     * One place, because there are now two callers with opposite news — a frame
+     * from the adapter, and the process going away — and «is it the human's turn»
+     * must be answered the same way by both.
+     *
+     * The report on reaching zero is the whole point: the agent is already
+     * sitting in a resting status, so nothing else will ever tell the API that
+     * the session finally became the person's. `REVIEW` counts as well as
+     * `WAITING_INPUT` — a TICKET session waiting on its own subagent is in the
+     * same position, and leaving it out was how one of the two statuses kept its
+     * notification suppressed for good (QA-2026-08-16 M-5).
+     */
+    private setBackgroundTasks;
     private isParkable;
     /**
      * Stop the agent process but keep the session resumable.

package/dist/supervisor.js

@@ -77,6 +77,8 @@ export class Supervisor {
      * agent mid-thought.
      */
     static EMPTY_TURN_SETTLE_MS = 25_000;
+    /** The window actually used — the constant, or a test's own shorter one. */
+    emptyTurnSettleMs;
     /** A finished session's journal is kept this long for a late reconnect. */
     static JOURNAL_TTL_MS = 72 * 3_600_000;
     /** Backstop: events the API will never accept must not pile up forever. */
@@ -114,6 +116,7 @@ export class Supervisor {
         this.ws = ws;
         this.opts = opts;
         this.journals = opts.journals ?? new JournalStore();
+        this.emptyTurnSettleMs = opts.emptyTurnSettleMs ?? Supervisor.EMPTY_TURN_SETTLE_MS;
         this.verify = new VerifyRunner({
             enabled: opts.verifyEnabled !== false,
             onReport: (report) => {
@@ -376,7 +379,7 @@ export class Supervisor {
         if (orphaned) {
             this.orphanMessages.delete(descriptor.id);
             for (const message of orphaned) {
-                this.acceptUserMessage(descriptor.id, message.text, message.attachments);
+                this.acceptUserMessage(descriptor.id, message.text, message.attachments, message.messageId);
             }
         }
         try {
@@ -1063,6 +1066,20 @@ export class Supervisor {
             // Idle process ended (parked or died between turns) — stay resumable.
             running.session = null;
             running.parkRequested = false;
+            /**
+             * The subagents died with it (QA-2026-08-16 M-5).
+             *
+             * Here rather than in `park()`, because parking only ASKS the process to
+             * stop and this is where it actually went. The adapter stops publishing
+             * the moment it is told to stop, so without this the last frame's count
+             * stands for ever: the strip says «Working in background» over a parked
+             * session and — far worse — the API goes on suppressing that session's
+             * «your turn» notification for the rest of its life, because the number
+             * it stored never reaches zero again.
+             *
+             * Before the `reportStatus` just below, so the zero rides out on it.
+             */
+            running.backgroundTasks = 0;
             running.costBaseUsd = running.costUsd; // next process starts from here
             // Persist the clock: a parked session can sit for hours and the runner
             // may be restarted before it ever runs again.
@@ -1301,6 +1318,11 @@ export class Supervisor {
         if (event.ok && event.produced !== true && this.holdEmptyTurn(running, descriptor, event)) {
             return;
         }
+        // Not held — so any phantom still waiting from an earlier turn is stale and
+        // must not outlive this ending. Cleared HERE and not before the decision
+        // above, or `holdEmptyTurn`'s «two in a row is a quiet agent, not two
+        // phantoms» rule could never see the first one (QA-2026-08-16 M-6).
+        this.clearEmptyTurn(running);
         this.settleTurnStatus(running, descriptor, event);
     }
     /**
@@ -1364,7 +1386,7 @@ export class Supervisor {
             return false;
         log.info('supervisor: holding a turn that produced nothing', {
             sessionId: descriptor.id,
-            settleMs: Supervisor.EMPTY_TURN_SETTLE_MS,
+            settleMs: this.emptyTurnSettleMs,
         });
         const timer = setTimeout(() => {
             running.emptyTurnTimer = undefined;
@@ -1374,7 +1396,7 @@ export class Supervisor {
                 return;
             log.info('supervisor: the empty turn was real after all', { sessionId: descriptor.id });
             this.settleTurnStatus(running, descriptor, event);
-        }, Supervisor.EMPTY_TURN_SETTLE_MS);
+        }, this.emptyTurnSettleMs);
         timer.unref();
         running.emptyTurnTimer = timer;
         return true;
@@ -1392,6 +1414,35 @@ export class Supervisor {
         clearTimeout(running.emptyTurnTimer);
         running.emptyTurnTimer = undefined;
     }
+    /**
+     * Record how many subagents are alive, and say so when it matters (#236).
+     *
+     * One place, because there are now two callers with opposite news — a frame
+     * from the adapter, and the process going away — and «is it the human's turn»
+     * must be answered the same way by both.
+     *
+     * The report on reaching zero is the whole point: the agent is already
+     * sitting in a resting status, so nothing else will ever tell the API that
+     * the session finally became the person's. `REVIEW` counts as well as
+     * `WAITING_INPUT` — a TICKET session waiting on its own subagent is in the
+     * same position, and leaving it out was how one of the two statuses kept its
+     * notification suppressed for good (QA-2026-08-16 M-5).
+     */
+    setBackgroundTasks(running, live) {
+        if (live === running.backgroundTasks)
+            return;
+        const finished = running.backgroundTasks > 0 && live === 0;
+        running.backgroundTasks = live;
+        const resting = running.lastReported === 'WAITING_INPUT' || running.lastReported === 'REVIEW'
+            ? running.lastReported
+            : null;
+        if (finished && resting) {
+            this.reportStatus(running.descriptor.id, resting, {
+                costUsd: running.costUsd,
+                activeMs: Supervisor.spentMs(running),
+            });
+        }
+    }
     isParkable(running) {
         return ((running.lastReported === 'REVIEW' || running.lastReported === 'WAITING_INPUT') &&
             running.openQuestions.size === 0 &&
@@ -1522,11 +1573,6 @@ export class Supervisor {
                 // when it finally succeeds or finally gives up.
                 if (!event.ok && this.armApiRetry(running, descriptor, event))
                     return;
-                // A previous turn's phantom, if any, is over: this turn has ended for
-                // real, and a timer still holding its predecessor would report a status
-                // for a turn that is two turns old (#300 — the hold itself lives in
-                // `completeTurn`, where the decision belongs).
-                this.clearEmptyTurn(running);
                 this.completeTurn(running, descriptor, event);
                 return;
             }
@@ -1757,21 +1803,7 @@ export class Supervisor {
                  * turn (`endTaskTurn` keeps the live set).
                  */
                 const live = event.tasks.filter((task) => task.status === 'running').length;
-                if (live !== running.backgroundTasks) {
-                    const wasWaiting = running.backgroundTasks > 0 && live === 0;
-                    running.backgroundTasks = live;
-                    // The moment the last subagent finishes is the moment the session
-                    // really does become the human's — and the agent is sitting in
-                    // WAITING_INPUT, so nothing else will ever say so. `reportStatus`
-                    // carries the new number and the API turns it into the notification
-                    // it withheld earlier.
-                    if (wasWaiting && running.lastReported === 'WAITING_INPUT') {
-                        this.reportStatus(running.descriptor.id, 'WAITING_INPUT', {
-                            costUsd: running.costUsd,
-                            activeMs: Supervisor.spentMs(running),
-                        });
-                    }
-                }
+                this.setBackgroundTasks(running, live);
                 return;
             }
             case 'notice': {
@@ -1884,7 +1916,20 @@ export class Supervisor {
             // instead of dropping it silently.
             log.warn('supervisor: message for unknown session — requesting descriptor', { sessionId });
             const queued = this.orphanMessages.get(sessionId) ?? [];
-            queued.push({ text, ...(attachments?.length ? { attachments } : {}) });
+            /**
+             * The name travels with the words (QA-2026-08-16 M-2).
+             *
+             * Without it the replay below took the message a SECOND time under no
+             * name, and the API's redelivery of the row it queued for the same
+             * `unknown_session` then looked brand new to `deliveredMessageIds` — the
+             * agent got one instruction twice, in the one scenario that reliably
+             * produces both copies.
+             */
+            queued.push({
+                text,
+                ...(attachments?.length ? { attachments } : {}),
+                ...(messageId ? { messageId } : {}),
+            });
             this.orphanMessages.set(sessionId, queued.slice(-Supervisor.ORPHAN_MESSAGE_CAP));
             this.ws.send({ type: 'session_unknown', sessionId });
             return 'unknown_session';
@@ -2202,6 +2247,11 @@ export class Supervisor {
                 this.sendEvent(running, 'message_delivered', { targetSeqs: delivered });
             }
         };
+        // M-4 (QA-2026-08-16): a new turn is starting, so a phantom held from the
+        // previous one must not fire 25 seconds from now and report WAITING_INPUT
+        // over an agent that is working — the very lie #300 is about, and this time
+        // with an irreversible notification behind it.
+        this.clearEmptyTurn(running);
         if (running.session && !running.parkRequested) {
             // #252: the words this turn is actually running. `lastPrompt` deliberately
             // stays put — three older latches relaunch a PROCESS with it, and handing

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const RUNNER_VERSION = "0.45.0";
+export declare const RUNNER_VERSION = "0.45.1";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in sync with package.json by the release script (manual for now).
-export const RUNNER_VERSION = '0.45.0';
+export const RUNNER_VERSION = '0.45.1';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge4dev/runner",
-  "version": "0.45.0",
+  "version": "0.45.1",
   "description": "DevBridge dev runner — connects a dev server to DevBridge and runs agent sessions (Claude Code / Codex)",
   "homepage": "https://bridge4.dev",
   "license": "MIT",