@bridge4dev/runner 0.58.2 → 0.59.1

package/dist/adapters/claude.js

@@ -1798,10 +1798,17 @@ class ClaudeSession {
         // as work. The id is forgotten when that task settles instead, which is the
         // moment it stops being able to come back.
         this.turnEpoch += 1;
-        // Straight through `flushTasks` rather than an empty frame of its own: the
-        // counters changed, so the fingerprint differs and it will publish — and
-        // what it publishes is the truth about what is still running.
+        // Straight through `flushTasks` rather than an empty frame of its own, and
+        // with the de-duplication disarmed for this one frame (plan
+        // `workflow-mode-fixes` S1 p.10). The turn's counters usually changed, but
+        // not always: a task started in an earlier turn and still running, and a
+        // turn that started nothing new, produce exactly the frame the last turn
+        // ended on — and the end of a turn is the moment the API and the tray most
+        // need to hear what is still running, whether or not it is news. The
+        // supervisor de-duplicates the COUNT on its own side; this frame is the
+        // tray's freshness, not the database's.
         this.taskPublishedAt = 0;
+        this.lastTaskFingerprint = '';
         this.flushTasks();
     }
     /**

package/dist/supervisor.d.ts

@@ -210,7 +210,30 @@ export interface SupervisorOptions {
     readScopeHold?: (unit: string) => ScopeHold | null;
     /** #398 S4: the heartbeat for the memory frame. Real one is a minute. */
     sessionLimitsHeartbeatMs?: number;
+    /**
+     * S1 of plan `workflow-mode-fixes`: how often a resting session re-asserts
+     * a background count it still holds — a test seam over
+     * `BACKGROUND_TASKS_HEARTBEAT_MS`. Real one is five minutes.
+     */
+    backgroundTasksHeartbeatMs?: number;
 }
+/**
+ * How often a resting session says «I still hold N background tasks» — the
+ * same `session_status` frame, the same status, sent again (plan
+ * `workflow-mode-fixes` S1 p.9).
+ *
+ * The count is a level the API stamps on arrival, and every reader over there
+ * — the workflow gate, its reminder, the «Agents» badge, the Inbox — believes
+ * it for an hour from that stamp. A task that simply runs (a forty-minute
+ * build) changes nothing in the tray, so nothing else would ever send the
+ * count again, and the platform would stop believing a live task after an
+ * hour. This is the frame that keeps it believed for as long as it is true.
+ *
+ * Mirrored by value in `@devbridge/shared` (`constants/dev-sessions.ts`),
+ * which this package cannot import; `supervisor.test.ts` holds the two copies
+ * together and keeps this well inside the API's trust window.
+ */
+export declare const BACKGROUND_TASKS_HEARTBEAT_MS: number;
 export declare class Supervisor {
     private readonly ws;
     private readonly opts;
@@ -438,6 +461,14 @@ export declare class Supervisor {
     private publishSlots;
     /** The heartbeat window actually used — the constant, or a test's own. */
     private readonly hostLoadHeartbeatMs;
+    /** S1 p.9: how often a held background count is said again. */
+    private readonly backgroundTasksHeartbeatMs;
+    /**
+     * The API has answered this socket's `hello` (S1 p.9). Frames sent before
+     * that are closed with 4002; the reconnect path re-sends every status in
+     * `reconcile` anyway, so the heartbeat has nothing to say until then.
+     */
+    private helloAcked;
     private readonly hostLoadTimer;
     /** #398 S2: the stall detector's clock, and the deadline it enforces. */
     private readonly stallTimer;
@@ -655,6 +686,28 @@ export declare class Supervisor {
      */
     private idleSessionCeiling;
     private publishSessionLimits;
+    /**
+     * Re-assert the background count of every resting session that still holds
+     * one (S1 p.9) — the same `session_status`, the same status, sent again.
+     *
+     * Only at rest, and only in the two statuses somebody over there reads the
+     * age of the number in: `REVIEW` and `WAITING_INPUT`. NOT in
+     * `WAITING_PERMISSION` — after a denied card `lastReported` stays there
+     * until the turn ends while the API has already healed its row to `RUNNING`,
+     * and repeating the old status would put the row back to «waiting for
+     * permission» with no card behind it, a fresh `statusChangedAt` and a
+     * needless nudge of the workflow engine. Not mid-turn either: a turn ends
+     * with a status frame of its own.
+     *
+     * Straight through `reportStatus`, past the equality check in
+     * `setBackgroundTasks`: that one exists to stay quiet when nothing changed,
+     * and «nothing changed» is exactly what this frame is for. Measured from the
+     * last status frame of ANY kind — every one carries the count — so a session
+     * that just reported is not reported twice, and a reconnect (which re-sends
+     * every tracked session's status in `reconcile`) restarts the five minutes
+     * by itself.
+     */
+    private publishBackgroundHeartbeats;
     private publishHostLoad;
     private onFrame;
     private startSession;

package/dist/supervisor.js

@@ -80,6 +80,23 @@ function freshLevels() {
     };
 }
 const LAUNCH_REFUSED = { ok: false, reason: 'refused' };
+/**
+ * How often a resting session says «I still hold N background tasks» — the
+ * same `session_status` frame, the same status, sent again (plan
+ * `workflow-mode-fixes` S1 p.9).
+ *
+ * The count is a level the API stamps on arrival, and every reader over there
+ * — the workflow gate, its reminder, the «Agents» badge, the Inbox — believes
+ * it for an hour from that stamp. A task that simply runs (a forty-minute
+ * build) changes nothing in the tray, so nothing else would ever send the
+ * count again, and the platform would stop believing a live task after an
+ * hour. This is the frame that keeps it believed for as long as it is true.
+ *
+ * Mirrored by value in `@devbridge/shared` (`constants/dev-sessions.ts`),
+ * which this package cannot import; `supervisor.test.ts` holds the two copies
+ * together and keeps this well inside the API's trust window.
+ */
+export const BACKGROUND_TASKS_HEARTBEAT_MS = 5 * 60 * 1000;
 export class Supervisor {
     ws;
     opts;
@@ -177,6 +194,9 @@ export class Supervisor {
         ws.on('frame', (frame) => {
             void this.onFrame(frame).catch((error) => log.error('supervisor: frame handler failed', { type: frame.type, error: String(error) }));
         });
+        ws.on('close', () => {
+            this.helloAcked = false;
+        });
         /**
          * The seat report is on a heartbeat, not only on the events that change it.
          *
@@ -233,8 +253,14 @@ export class Supervisor {
          * actually moved (or the heartbeat came due).
          */
         this.hostLoadHeartbeatMs = opts.hostLoadHeartbeatMs ?? HOST_LOAD_HEARTBEAT_MS;
+        this.backgroundTasksHeartbeatMs =
+            opts.backgroundTasksHeartbeatMs ?? BACKGROUND_TASKS_HEARTBEAT_MS;
         this.hostLoadTimer = setInterval(() => {
             this.publishHostLoad();
+            // The fourth thing only a tick can notice (S1 p.9): a background task
+            // that is simply still running produces no event, and the API's belief
+            // in the count runs out an hour after it was last said.
+            this.publishBackgroundHeartbeats();
             // Same cadence, same reason: what a session's cgroup is going through is
             // something that happens to it, and only a tick can notice (#387).
             this.watchSessionCages();
@@ -641,6 +667,14 @@ export class Supervisor {
     }
     /** The heartbeat window actually used — the constant, or a test's own. */
     hostLoadHeartbeatMs;
+    /** S1 p.9: how often a held background count is said again. */
+    backgroundTasksHeartbeatMs;
+    /**
+     * The API has answered this socket's `hello` (S1 p.9). Frames sent before
+     * that are closed with 4002; the reconnect path re-sends every status in
+     * `reconcile` anyway, so the heartbeat has nothing to say until then.
+     */
+    helloAcked = false;
     hostLoadTimer;
     /** #398 S2: the stall detector's clock, and the deadline it enforces. */
     stallTimer;
@@ -1531,6 +1565,58 @@ export class Supervisor {
             this.lastLimitsSentAt = measuredAt;
         }
     }
+    /**
+     * Re-assert the background count of every resting session that still holds
+     * one (S1 p.9) — the same `session_status`, the same status, sent again.
+     *
+     * Only at rest, and only in the two statuses somebody over there reads the
+     * age of the number in: `REVIEW` and `WAITING_INPUT`. NOT in
+     * `WAITING_PERMISSION` — after a denied card `lastReported` stays there
+     * until the turn ends while the API has already healed its row to `RUNNING`,
+     * and repeating the old status would put the row back to «waiting for
+     * permission» with no card behind it, a fresh `statusChangedAt` and a
+     * needless nudge of the workflow engine. Not mid-turn either: a turn ends
+     * with a status frame of its own.
+     *
+     * Straight through `reportStatus`, past the equality check in
+     * `setBackgroundTasks`: that one exists to stay quiet when nothing changed,
+     * and «nothing changed» is exactly what this frame is for. Measured from the
+     * last status frame of ANY kind — every one carries the count — so a session
+     * that just reported is not reported twice, and a reconnect (which re-sends
+     * every tracked session's status in `reconcile`) restarts the five minutes
+     * by itself.
+     */
+    publishBackgroundHeartbeats() {
+        // `helloAcked` and not merely `connected`: the socket is open from the
+        // `open` event, but the gateway answers any frame that reaches it before
+        // its own `hello` bookkeeping is done with a close (4002) — a window of
+        // tens of milliseconds on every reconnect that a tick can land in.
+        if (!this.ws.connected || !this.helloAcked)
+            return;
+        const now = Date.now();
+        for (const running of this.sessions.values()) {
+            if (running.backgroundTasks <= 0)
+                continue;
+            // Only a session with a process behind it. The count is zeroed when the
+            // process is found gone, but not on every path that loses one: a
+            // relaunch that crashed leaves the entry with `session = null` and the
+            // count it was holding, and re-asserting that would be the platform
+            // confirming work nobody is doing.
+            if (!running.session)
+                continue;
+            if (running.lastReported !== 'REVIEW' && running.lastReported !== 'WAITING_INPUT')
+                continue;
+            const sinceLastSent = now - (running.statusSentAt ?? 0);
+            // A backwards clock step is «due», not «early» — same allowance as the
+            // host-load heartbeat, for the same reason.
+            if (sinceLastSent < this.backgroundTasksHeartbeatMs && sinceLastSent >= 0)
+                continue;
+            this.reportStatus(running.descriptor.id, running.lastReported, {
+                costUsd: running.costUsd,
+                activeMs: Supervisor.spentMs(running),
+            });
+        }
+    }
     publishHostLoad() {
         const sample = (this.opts.readHostLoad ?? readHostLoad)();
         if (!sample)
@@ -1549,6 +1635,7 @@ export class Supervisor {
     async onFrame(frame) {
         switch (frame.type) {
             case 'hello_ack':
+                this.helloAcked = true;
                 // A new connection knows nothing about the seats we reported to the
                 // last one — the API keeps that beside the socket, not in the database,
                 // because it is only true while the socket is. Forget what we told the
@@ -6978,6 +7065,10 @@ export class Supervisor {
             // would mean it goes on claiming background work forever.
             ...(running ? { backgroundTasks: running.backgroundTasks } : {}),
         });
+        // …and the count's age starts here (S1 p.9): the background heartbeat is
+        // due five minutes after the last frame that carried it, whichever it was.
+        if (running)
+            running.statusSentAt = Date.now();
         // Every seat change is accompanied by a status report — a session starting,
         // parking, ending. Hooking the seat report here rather than at each of those
         // is the whole point: «remember to also tell the API» is the rule that had

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const RUNNER_VERSION = "0.58.2";
+export declare const RUNNER_VERSION = "0.59.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.58.2';
+export const RUNNER_VERSION = '0.59.1';
 //# sourceMappingURL=version.js.map

package/package.json

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