@bridge4dev/runner 0.55.0 → 0.56.0

package/dist/supervisor.js

@@ -26,7 +26,7 @@ import { agentByDbValue } from './agent-registry.js';
 import { invalidateAgentVersions, measureAgentVersions, } from './agent-versions.js';
 import { rememberWorkspacePath } from './environment.js';
 import { hostLoadChangedEnough, hostLoadHeartbeatDue, readHostLoad, HOST_LOAD_HEARTBEAT_MS, HOST_LOAD_SAMPLE_INTERVAL_MS, } from './host-load.js';
-import { markScopeOomKillsSeen, readScopeMemoryStatus, sessionScopeUnitOf, } from './session-cage.js';
+import { markScopeOomKillsSeen, readScopeMemoryStatus, sessionScopeUnitOf, stoppedProcesses, } from './session-cage.js';
 import { composeMessageWithAttachments, saveAttachments, } from './attachments.js';
 import { applyRewind, createCheckpoint, dropCheckpoints, listCheckpoints, MAX_BUSY_SESSIONS, previewRewind, pruneCheckpoints, } from './checkpoints.js';
 import { DeliverMessageArgsSchema, QuestionAnswerArgsSchema } from './protocol.js';
@@ -144,6 +144,8 @@ export class Supervisor {
      * which of the two is running.
      */
     installInFlight = null;
+    /** A restore-point collection is running; a second reconnect must not start another (#388). */
+    checkpointGcInFlight = false;
     /** Session 14: one project-recipe run per machine, and its verdict queue. */
     verify;
     verifyReports = new VerifyReportQueue();
@@ -715,18 +717,15 @@ export class Supervisor {
                 // where it was came from the slice over ALL sessions, and telling this
                 // session it went over its ceiling would be false (measured on this
                 // host: the killed neighbour read `max 0, oom 0, oom_kill 1`).
-                const ownWall = status.ownLimitOom > base.ownOom;
-                const killed = status.oomKills - base.oomKills === 1
-                    ? 'a process'
-                    : `${status.oomKills - base.oomKills} processes`;
+                const ownCeiling = status.ownLimitOom > base.ownOom;
+                const stopped = stoppedProcesses(status.oomKills - base.oomKills);
                 this.sendEvent(running, 'notice', {
                     level: 'warn',
-                    text: ownWall
-                        ? `This session went over its memory ceiling${status.maxBytes === null ? '' : ` of ${mb(status.maxBytes)}`} and the kernel killed ${killed} inside it. ` +
-                            'The session itself is still running; the command that was in flight most likely died with it — check its output before going on.'
-                        : `The machine ran out of memory for agent sessions — they share one ceiling — and the kernel killed ${killed} in this session. ` +
-                            `This session was using ${mb(status.currentBytes)}${status.maxBytes === null ? '' : ` of its own ${mb(status.maxBytes)}`}, so it was not necessarily the greedy one. ` +
-                            'It is still running; the command that was in flight most likely died with it.',
+                    text: ownCeiling
+                        ? `This session reached its${status.maxBytes === null ? '' : ` ${mb(status.maxBytes)}`} memory ceiling and ${stopped} — ` +
+                            'check the output of the command that was running.'
+                        : `The machine ran out of memory for agent sessions and ${stoppedProcesses(status.oomKills - base.oomKills, 'this one')} — ` +
+                            'run fewer sessions at once, or give the machine more memory.',
                 });
                 // So a death minutes later is not blamed on a kill the feed already carries.
                 markScopeOomKillsSeen(running.descriptor.id, status.oomKills);
@@ -744,6 +743,10 @@ export class Supervisor {
              */
             const throttled = status.highEvents > base.highEvents ||
                 (status.highBytes !== null && status.currentBytes > status.highBytes);
+            // `memory.high` reads `max` on a machine where the share never applied —
+            // then there is no number to name, and «its 0 MB share» is worse than no
+            // number at all.
+            const share = status.highBytes === null ? '' : ` ${mb(status.highBytes)}`;
             let { brakedSince, warnedLong, calmTicks } = base;
             if (throttled) {
                 calmTicks = 0;
@@ -752,18 +755,15 @@ export class Supervisor {
                     warnedLong = false;
                     this.sendEvent(running, 'notice', {
                         level: 'warn',
-                        text: `This session is over its memory share (${mb(status.highBytes ?? 0)}, using ${mb(status.currentBytes)}), so the kernel is slowing it down instead of killing it. ` +
-                            'Heavy commands will finish slower until memory is freed.',
+                        text: `This session has hit its${share} memory share — commands run slower until it uses less memory.`,
                     });
                 }
                 else if (!warnedLong && now - brakedSince >= longMs) {
                     warnedLong = true;
                     this.sendEvent(running, 'notice', {
                         level: 'warn',
-                        text: `Still over its memory share after ${Math.round(longMs / 60_000)} min (using ${mb(status.currentBytes)} of a ${mb(status.highBytes ?? 0)} share). ` +
-                            `If the current command is stuck rather than slow, stop it or pause the session.${status.maxBytes === null
-                                ? ''
-                                : ` The hard ceiling, where a process would be killed, is ${mb(status.maxBytes)}.`}`,
+                        text: `This session has been over its${share} memory share for ${Math.round(longMs / 60_000)} min and is now using ${mb(status.currentBytes)} — ` +
+                            'if a command is stuck rather than slow, stop the turn or pause the session.',
                     });
                 }
             }
@@ -776,7 +776,7 @@ export class Supervisor {
                     warnedLong = false;
                     this.sendEvent(running, 'notice', {
                         level: 'info',
-                        text: `Memory is back under the session's share (${mb(status.highBytes ?? 0)}); it runs at full speed again.`,
+                        text: `This session is back under its${share} memory share — it runs at full speed again.`,
                     });
                 }
             }
@@ -3403,9 +3403,20 @@ export class Supervisor {
      * a second session opened. The neighbours are recorded on the point instead —
      * the conversation can always be rewound to it, the files cannot.
      *
-     * Every refusal is now audible. A restore point that was never taken is
-     * invisible until the day somebody reaches for it, and «the button is not
-     * there» is not a sentence anybody can act on.
+     * A refusal is audible when it is a refusal — when the person can do
+     * something about it, or when a way back they might reach for is not there.
+     * A restore point that was never taken is invisible until the day somebody
+     * reaches for it, and «the button is not there» is not a sentence anybody can
+     * act on.
+     *
+     * «This session was still answering» is the exception, and it is the only one
+     * (#384). It is not a fault and not a state to act on: it is what a follow-up
+     * note to a working agent looks like from in here, thirty times in a day on
+     * one machine, and it costs almost nothing — the point in front of the turn
+     * already stands, and rewinding to it takes back the files AND the
+     * conversation, including the note. So it goes to the runner's own log, where
+     * support can answer «why is there no point for that step», and not into the
+     * feed, where it read as breakage.
      */
     async captureCheckpoint(running, kind, messageSeq) {
         const worktreePath = running.worktreePath;
@@ -3423,7 +3434,13 @@ export class Supervisor {
             return;
         }
         if (kind === 'TURN' && this.isSessionMidTurn(running)) {
-            this.noticeOncePerTurn(running, 'checkpoint-self-busy', 'No restore point was taken for this step: this session was still answering when it was due.');
+            // Silent in the feed, on purpose (#384) — see the note above. The `return`
+            // is not cosmetic and does not go: reading a tree the agent is writing
+            // produces a restore point that restores half a file (gotcha 438).
+            log.info('supervisor: no restore point — the session was mid-turn', {
+                sessionId: running.descriptor.id,
+                ...(messageSeq === undefined ? {} : { messageSeq }),
+            });
             return;
         }
         if (await this.isRepoLocked(worktreePath)) {
@@ -3489,16 +3506,18 @@ export class Supervisor {
     /**
      * Say something once per BUSY PERIOD, not once per message (#310).
      *
-     * A folder held by a neighbour stays held for minutes, and a session mid-turn
-     * can be sent three follow-up notes inside one answer. Keying this on the
-     * message seq would have counted each of those as its own turn and said the
-     * same sentence three times — the noise the frequency policy exists to
-     * prevent. The set is cleared when the session next comes to rest
-     * (`reportStatus`), which is exactly when the reason stops being true.
+     * A repository held by another git command stays held for as long as that
+     * command runs, and three follow-up notes can arrive inside one answer.
+     * Keying this on the message seq would have counted each of those as its own
+     * turn and said the same sentence three times — the noise the frequency
+     * policy exists to prevent. The set is cleared when the session next comes to
+     * rest (`reportStatus`), which is exactly when the reason stops being true.
      *
      * A SET of keys, not the last one said: two different reasons can both come
      * up inside one period, and remembering only the most recent would let them
-     * take turns re-announcing each other.
+     * take turns re-announcing each other. One key uses this today — «another git
+     * command holds this repository» — and the set stays a set for that reason,
+     * not out of habit: the mid-turn key left when it stopped being said (#384).
      */
     noticeOncePerTurn(running, key, text) {
         running.noticesThisTurn ??= new Set();
@@ -4277,14 +4296,26 @@ export class Supervisor {
         // switched off leaves restore points — a full copy of a working tree —
         // with no row anywhere pointing at them, and nothing else on this machine
         // would ever collect them.
-        void pruneCheckpoints({ liveSessionIds: known }).then((result) => {
-            if (result.droppedRefs > 0) {
-                log.info('supervisor: collected orphaned restore points', {
-                    sessions: result.droppedSessions.length,
-                    refs: result.droppedRefs,
-                });
-            }
-        }, (error) => log.warn('supervisor: restore-point GC failed', { error: String(error) }));
+        //
+        // One at a time (#388): reconnects come in runs, and since the collection
+        // holds the store while it collects, a second one started on top of the
+        // first would only queue — in front of the restore points of whoever is
+        // working. The next reconnect collects whatever this pass leaves.
+        if (!this.checkpointGcInFlight) {
+            this.checkpointGcInFlight = true;
+            void pruneCheckpoints({ liveSessionIds: known })
+                .then((result) => {
+                if (result.droppedRefs > 0) {
+                    log.info('supervisor: collected orphaned restore points', {
+                        sessions: result.droppedSessions.length,
+                        refs: result.droppedRefs,
+                    });
+                }
+            }, (error) => log.warn('supervisor: restore-point GC failed', { error: String(error) }))
+                .finally(() => {
+                this.checkpointGcInFlight = false;
+            });
+        }
         for (const [sessionId, running] of [...this.sessions]) {
             if (known.has(sessionId))
                 continue;

package/dist/version.d.ts

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

package/package.json

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