@intentic/constants 1.389.0 → 1.390.0

package/README.md

@@ -37,7 +37,10 @@ flowchart LR
   on a Vue package, 4 GiB).
 - `memory-room` is the one formula for whether the sandbox has room (limit, used, free, stall, and what each workload
   class costs). The daemon's resource budget judges by it, and it is also the `memory-room` command `queue-run` asks:
-  it asks the daemon's room socket, and applies the formula itself where no daemon answers.
+  it asks the daemon's room socket, and applies the formula itself where no daemon answers. (2026-11-02) A reading may
+  carry `host`, the machine the sandbox runs on as the daemon last heard from it: work nobody waits on then also waits
+  while its cost would take that machine under `host.reserveBytes`. Only the daemon adds it, so the fallback formula
+  never has a host to answer to.
 - `dev-previews` is the record of a conversation's managed dev preview (its demo server): where the records live
   (`/tmp/intentic-previews`), what makes one trustworthy (pid, start tick, conversation stamp, pid namespace), the cap
   of three and the ten-minute idle bound, the conversation's own port in 47150-47199, and how a preview is stopped

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentic/constants",
-  "version": "1.389.0",
+  "version": "1.390.0",
   "description": "Shared constants for the intentic packages, ports, paths, and image references the daemon, CLIs and desktop app all agree on",
   "license": "MIT",
   "type": "module",

package/src/memory-room.d.mts

@@ -40,6 +40,18 @@ export interface MemoryReading {
     readonly ioStallSustainedPercent?: number | undefined;
     // memory.events `oom_kill`, cumulative; undefined without a cgroup.
     readonly oomKills: number | undefined;
+    // (2026-11-02) The machine this sandbox runs on, as its agent last said, added by the daemon only while that is
+    // fresh; absent is "no host to answer to", never "no room". Work nobody waits on waits while it would take the host
+    // under `reserveBytes`.
+    readonly host?: HostRoom | undefined;
+}
+
+export interface HostRoom {
+    // The machine's name as the owner knows it (its device card), for the sentence a held command is given.
+    readonly name: string;
+    readonly availableBytes: number;
+    readonly totalBytes: number;
+    readonly reserveBytes: number;
 }
 
 export interface ShortMemory {

package/src/memory-room.mjs

@@ -209,6 +209,11 @@ export const judge = (reading, { workload, attended, reservedBytes = 0, size })
     const stallSustainedPercent = reading.stallSustainedPercent ?? 0;
     const unreserved = freeBytesOf(reading);
     const counted = countedBytesOf(reading);
+    // Asked before the sandbox's own figures, which may measure nothing: a VM with room says nothing of the PC under it.
+    const hostHeld = hostWait(reading, { workload, attended, reservedBytes, size }, need, unreserved);
+    if (hostHeld !== undefined) {
+        return hostHeld;
+    }
     if (limitBytes === undefined || usedBytes === undefined || counted === undefined || unreserved === undefined) {
         return { verdict: "run", needBytes: need, freeBytes: undefined, reservedBytes };
     }
@@ -252,6 +257,29 @@ export const judge = (reading, { workload, attended, reservedBytes = 0, size })
     return shortOf(`Sandbox memory is low: ${used}${held}`, { limitBytes, residentBytes: usedBytes - swapBytes, swapBytes });
 };
 
+// (2026-11-02) Why work nobody is waiting on should wait for the machine this sandbox runs on, or undefined while it need
+// not. Everything else here reads the sandbox's own cgroup and the kernel under it, which on a Windows PC is Docker
+// Desktop's WSL2 VM: on 2026-11-02 that VM read as roomy while Windows had 1.1 GB left and froze for 43 s. The daemon adds
+// `reading.host` from what the host's agent last said (hosts/host-memory.ts), only while that is fresh, so a reading
+// without it is "no host to answer to", never "no room". Work waits while starting it would take the host below its
+// reserve, the line under which the host's agent starts giving the VM's cache back. Only the work's own cost counts here:
+// the person's share in `needBytes` is room inside the sandbox, which the sandbox's own figures already keep.
+const hostShortOf = (host, costBytes, reservedBytes) => {
+    if (host === undefined || host.availableBytes - host.reserveBytes - reservedBytes >= costBytes) {
+        return undefined;
+    }
+    const held = reservedBytes > 0 ? `, ${gib(reservedBytes)} of it held for work that just started` : "";
+    return `${host.name}, the machine this sandbox runs on, is low on memory: it has ${gib(host.availableBytes)} available of ${gib(host.totalBytes)}${held}, and heavy work waits while starting it would leave it under ${gib(host.reserveBytes)}`;
+};
+
+// The verdict that holds work nobody waits on for the host, or undefined while the host has room for it (hostShortOf).
+const hostWait = (reading, { workload, attended, reservedBytes, size }, need, unreserved) => {
+    const diagnosis = attended ? undefined : hostShortOf(reading.host, costBytesOf(workload, size), reservedBytes);
+    return diagnosis === undefined
+        ? undefined
+        : { verdict: "wait", needBytes: need, freeBytes: unreserved === undefined ? undefined : Math.max(0, unreserved - reservedBytes), reservedBytes, diagnosis };
+};
+
 // Why work nobody is waiting on should wait for the disk, or undefined while it need not (the `disk` clause).
 const diskStalled = (reading) => {
     const recent = reading.ioStallPercent ?? 0;