@bridge4dev/runner 0.55.0 → 0.55.1

package/dist/index.js

@@ -1443,10 +1443,10 @@ async function cmdDoctor(args) {
     print(`                  ${devbridgeSliceOverridePath()}`);
     if (cage.mode === 'scope') {
         const mb = (bytes) => bytes === null ? 'infinity' : `${Math.round(bytes / 1024 / 1024)} MB`;
-        print(`  per session     MemoryHigh ${mb(cage.memoryHighBytes)} (brake: slows, never kills), MemoryMax ${mb(cage.memoryMaxBytes)} (wall), MemorySwapMax ${mb(cage.swapMaxBytes)}, TasksMax ${SESSION_TASKS_MAX}`);
-        print(`  at the wall     ${cage.oomContinue
-            ? 'OOMPolicy=continue — the kernel kills the hungriest process, the session stays up'
-            : 'this systemd does not take OOMPolicy on a scope (it is newer than the rest of the cage), so what happens at the wall is its own default — on systemd 253+ that is «stop the whole session»'}`);
+        print(`  per session     share ${mb(cage.memoryHighBytes)} (MemoryHigh — allocations are throttled above it), ceiling ${mb(cage.memoryMaxBytes)} (MemoryMax), swap ${mb(cage.swapMaxBytes)} (MemorySwapMax), TasksMax ${SESSION_TASKS_MAX}`);
+        print(`  at the ceiling  ${cage.oomContinue
+            ? 'OOMPolicy=continue — the kernel stops the largest process in the session'
+            : 'this systemd does not take OOMPolicy on a scope, so its own default applies — on systemd 253+ that stops the whole session'}`);
         // What systemd has IN FORCE on the slice, beside the paths of the files
         // that were supposed to put it there. «В файле 7680M, действует 6.0G» is the
         // lesson of §5.5, and the drop-in of a slice can fail to land in exactly the
@@ -1457,7 +1457,7 @@ async function cmdDoctor(args) {
             print('                  NOT CAPPED — the drop-in above has not been applied.');
             print(`                  Apply with: ${systemctlHint('daemon-reload')}`);
         }
-        print(`  service ceiling ${mb(cage.serviceMemoryMaxBytes)} (the per-session brake is half of the containing ceiling, capped at 2.5 GiB; the wall IS the containing ceiling)`);
+        print(`  service ceiling ${mb(cage.serviceMemoryMaxBytes)} (a session's share is a third of the containing ceiling, its own ceiling is that minus one share)`);
         print(`  expand-env flag ${cage.expandEnvironmentFlag ? 'passed (systemd ≥ 254)' : 'not passed — this systemd does not know it, and --scope does not expand anyway'}`);
     }
     else {

package/dist/session-cage.d.ts

@@ -433,6 +433,12 @@ export declare function parseScopeMemoryStatus(files: {
  */
 export declare function readScopeMemoryStatus(unit: string, readFile?: (p: string) => string): ScopeMemoryStatus | null;
 export declare function markScopeOomKillsSeen(id: string, oomKills: number): void;
+/**
+ * «a process in it was stopped» / «3 processes in it were stopped», so the verb
+ * agrees. Shared with the supervisor's feed notices, which count the same
+ * thing and must not word it differently.
+ */
+export declare function stoppedProcesses(count: number, where?: 'it' | 'this one'): string;
 /**
  * Snapshot the cgroup's verdict before systemd can take it away.
  *

package/dist/session-cage.js

@@ -891,6 +891,16 @@ const oomKillsSeen = new Map();
 export function markScopeOomKillsSeen(id, oomKills) {
     oomKillsSeen.set(id, oomKills);
 }
+/**
+ * «a process in it was stopped» / «3 processes in it were stopped», so the verb
+ * agrees. Shared with the supervisor's feed notices, which count the same
+ * thing and must not word it differently.
+ */
+export function stoppedProcesses(count, where = 'it') {
+    return count === 1
+        ? `a process in ${where} was stopped`
+        : `${count} processes in ${where} were stopped`;
+}
 const deaths = new Map();
 /**
  * Snapshot the cgroup's verdict before systemd can take it away.
@@ -909,7 +919,7 @@ export function rememberDeath(id, unit, readStatus = readScopeMemoryStatus) {
         maxBytes: status.maxBytes,
         // `oom` moves only where the limit that was hit belongs. A kill with our
         // own counter still at zero came from an ancestor — the pool.
-        ownWall: status.ownLimitOom > 0,
+        reached: status.ownLimitOom > 0 ? 'own-ceiling' : 'shared-pool',
     });
 }
 /**
@@ -928,9 +938,9 @@ function rememberDeathFromResult(id) {
     deaths.set(id, {
         oomKills: 1,
         maxBytes: sessionCage().memoryMaxBytes,
-        // systemd stopped the unit for an OOM inside it; which limit was hit is not
-        // in `Result`, and «your own wall» is the claim that must not be guessed.
-        ownWall: false,
+        // systemd stopped the unit for an OOM inside it; which limit was reached is
+        // not in `Result`, and neither claim may be guessed.
+        reached: 'unknown',
     });
 }
 /**
@@ -947,16 +957,21 @@ export function explainMemoryDeath(id) {
     if (!death)
         return null;
     deaths.delete(id);
-    const killed = death.oomKills === 1 ? 'a process' : `${death.oomKills} processes`;
-    const wall = death.maxBytes === null ? '' : ` of ${Math.round(death.maxBytes / MIB)} MB`;
-    if (death.ownWall) {
-        return (`The session ran out of memory: it went over its own memory ceiling${wall} and the kernel killed ` +
-            `${killed} inside it. ` +
-            'Resume it and avoid re-running the command that was in flight, or give the machine more memory or swap.');
+    const stopped = stoppedProcesses(death.oomKills);
+    const ceiling = death.maxBytes === null ? '' : ` of ${Math.round(death.maxBytes / MIB)} MB`;
+    if (death.reached === 'own-ceiling') {
+        return (`This session reached its memory ceiling${ceiling} and ${stopped} — ` +
+            'send a message to carry on; if it keeps happening, the machine needs more memory.');
+    }
+    if (death.reached === 'shared-pool') {
+        return (`The machine ran out of memory for agent sessions and ${stoppedProcesses(death.oomKills, 'this one')} — ` +
+            'send a message to carry on; if it keeps happening, run fewer sessions at once or give the machine more memory.');
     }
-    return (`The machine ran out of memory for agent sessions — all sessions on it share one ceiling — and the kernel killed ` +
-        `${killed} in this one. This session was not necessarily the greedy one. ` +
-        'Resume it; if it keeps happening, run fewer sessions at once or give the machine more memory or swap.');
+    // Which ceiling was reached is unknowable here, so the sentence names no
+    // culprit: it has to be true whether this session was the greedy one or a
+    // bystander.
+    return (`There was not enough memory for this session and ${stopped} — ` +
+        'send a message to carry on; if it keeps happening, run fewer sessions at once or give the machine more memory.');
 }
 const realSystemctl = async (args) => {
     const { stdout, stderr } = await execFileAsync('systemctl', ['--user', ...args], {

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';
@@ -715,18 +715,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 +741,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 +753,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 +774,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.`,
                     });
                 }
             }

package/dist/version.d.ts

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

package/package.json

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