@edgehero/pi-dispatch 3.0.0 → 4.0.0

package/src/run-history.mjs

@@ -6,6 +6,7 @@ import { resolveBackendName } from "./backend-registry.mjs";
 import { isForgeKind, targetSeparator } from "./forges.mjs";
 import { MODEL_REF_PATTERN as USAGE_ID_PATTERN } from "./model-ref.mjs";
 import { isProjectId } from "./project-id.mjs";
+import { recordedJobSize } from "./job-size.mjs";
 
 /**
  * Durable per-run history.
@@ -13,7 +14,7 @@ import { isProjectId } from "./project-id.mjs";
  * The PURE HELPERS are total functions over their arguments -- no filesystem, no clock, no
  * `process.env`, no randomness -- so the record shape and the filename/telemetry parsing are testable
  * without a container, a queue, or a disk: `sanitizeJobId`, `parseExitTurns`, `parseExitTokens`,
- * `parseExitSession`, `parseExitUsage`, `buildRecord`.
+ * `parseExitSession`, `parseExitUsage`, `parseExitResources`, `buildRecord`.
  *
  * The I/O factories -- `makeLogSink`, `makeRecordWriter`, `makeFindPreviousRun`, `makeLogReaper` --
  * each inject their own `fs` (and, for the reaper, their own clock via `now`), so they too are testable
@@ -64,7 +65,7 @@ export function sanitizeJobId(id) {
  * END (a mid-write death) has no complete object and is skipped too. A fragment is never MISREAD as a
  * value: a broken one does not parse and an anchorless one is not repaired.
  *
- * NEVER throws, like the six scanners that call it.
+ * NEVER throws, like `decisiveExitLine`, the one caller every scanner goes through.
  */
 function parseTailLine(line) {
 	try {
@@ -83,6 +84,43 @@ function parseTailLine(line) {
 	return null;
 }
 
+/** The signed marker the image's supervisor puts on every exit line it writes (image/runner/src/supervise.mjs). */
+export const EXIT_BY_SUPERVISOR = "supervisor";
+
+/**
+ * THE exit line every `parseExit*` scanner reads (issue #596), parsed, or null when `text` holds none: "the decisive
+ * exit line" everywhere in this file and in the specs means this function's pick, never simply the last line. One
+ * picker, so the scanners cannot disagree about which line decided the run.
+ *
+ * Normally the LAST `exit` event, found from the end with `parseTailLine`'s glue repair. One exception: a line the
+ * image's supervisor wrote (`by: "supervisor"`) when an EARLIER exit line exists that is not the supervisor's. That
+ * order means the runner wrote its own line and was killed afterwards (a tool can SIGKILL it after its decided line, and
+ * so can the kernel), and the supervisor then reported the death. The runner's line is the run's real outcome, with the
+ * tokens, usage and session the supervisor never has, so it decides, and the supervisor's line is ignored by every
+ * scanner: the run reads exactly as it did before the supervisor existed (its container exit `137` still retries).
+ * Read the other way round, the supervisor's `oom-killed` would turn a finished run into a stopped one, its tokens lost
+ * from the daily cap and its dollars settled at the floor.
+ *
+ * With a key the text is `authenticExitLines`' output, so both lines are signed and `by` is inside the MAC. Without
+ * one nothing here is trusted anyway: a tool that writes a `by: "supervisor"` line after the runner's only makes the
+ * runner's line decide, which it could have arranged by writing nothing. NEVER throws.
+ */
+function decisiveExitLine(text) {
+	if (typeof text !== "string") return null;
+	const lines = text.split("\n");
+	let last = null;
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const line = lines[i].trim();
+		if (line === "") continue;
+		const parsed = parseTailLine(line);
+		if (parsed?.event !== "exit") continue;
+		if (parsed?.by !== EXIT_BY_SUPERVISOR) return parsed;
+		// The supervisor's line: it decides only if nothing the runner wrote comes before it.
+		if (last === null) last = parsed;
+	}
+	return last;
+}
+
 /**
  * Recover the agent's turn count from buffered container stdout, or `null` if it is not reported.
  *
@@ -90,9 +128,9 @@ function parseTailLine(line) {
  * own lines. Only the decided-outcome exit line carries `turns` (`image/runner/run-job.mjs:431`); the
  * catch-path exit line (`:446`) omits it. The decided line's `retryTurns` (issue #449, pi's own
  * auto-retry turns, which the turn budget does not count) is not recovered here: it is diagnostic, read
- * from the container log, and the record's `turns` stays the budgeted count. Scan from the end and
- * return the turns of the last `exit` event that reports an integer count, repairing a glued line on
- * the way (`parseTailLine`).
+ * from the container log, and the record's `turns` stays the budgeted count. Return the turns of the
+ * decisive exit line (`decisiveExitLine`, which repairs a glued line on the way through `parseTailLine`)
+ * when it reports an integer count.
  *
  * This is read-only telemetry: it MUST NEVER throw and MUST NOT feed exit-code or retry
  * classification -- that is the container exit code's job (INT-RUNNER-EXIT-CODE-PROTOCOL). Every parse
@@ -101,16 +139,9 @@ function parseTailLine(line) {
  * container exit code alone decides the class, and that parsed reason only picks a label INSIDE exit 2.
  */
 export function parseExitTurns(text) {
-	if (typeof text !== "string") return null;
-	const lines = text.split("\n");
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i].trim();
-		if (line === "") continue;
-		const parsed = parseTailLine(line);
-		if (parsed?.event !== "exit") continue;
-		return Number.isInteger(parsed?.turns) ? parsed.turns : null;
-	}
-	return null;
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return null;
+	return Number.isInteger(parsed?.turns) ? parsed.turns : null;
 }
 
 /**
@@ -132,29 +163,21 @@ export function parseExitTurns(text) {
 export const RUNNER_POLICY_REASONS = new Set(["provider-auth-refused", "cost-cap", "model-not-allowed", "cost-cap-unenforceable", "model-policy-unenforceable"]);
 
 /**
- * The reason off the LAST runner exit line, or `null`: a member of `RUNNER_POLICY_REASONS` and only when
- * that same line says `code: 2`. Scanned from the end exactly as `parseExitTurns` is, repairing a glued
- * line through `parseTailLine`, and NEVER throws.
+ * The reason off the decisive exit line (`decisiveExitLine`), or `null`: a member of `RUNNER_POLICY_REASONS`
+ * and only when that same line says `code: 2`. Read off the same line as `parseExitTurns`, and NEVER throws.
  *
  * Why this may reach the outcome when its five siblings may not: it cannot change the retry class. The
  * processor consults it only inside its container-exit-2 branch, so a container that exits 1 while
  * printing `{"event":"exit","code":2,"reason":"provider-auth-refused"}` is still InfraRetry, and the
  * worst a forged line can do on a real exit 2 is swap one not-retried label for another from a closed
  * set. The `code === 2` check on the line itself is what keeps a stale or mismatched line (a runner
- * that said 1 in its own words) from naming the outcome. Only the LAST exit event counts, because an
- * earlier one in the tail is not the one the runner exited on. A fixed enum, so the PII-free record stays so.
+ * that said 1 in its own words) from naming the outcome. Only the decisive exit line counts, because any
+ * other in the tail is not the one the runner exited on. A fixed enum, so the PII-free record stays so.
  */
 export function parseExitReason(text) {
-	if (typeof text !== "string") return null;
-	const lines = text.split("\n");
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i].trim();
-		if (line === "") continue;
-		const parsed = parseTailLine(line);
-		if (parsed?.event !== "exit") continue;
-		return parsed?.code === 2 && RUNNER_POLICY_REASONS.has(parsed?.reason) ? parsed.reason : null;
-	}
-	return null;
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return null;
+	return parsed?.code === 2 && RUNNER_POLICY_REASONS.has(parsed?.reason) ? parsed.reason : null;
 }
 
 /**
@@ -165,8 +188,8 @@ export function parseExitReason(text) {
 export const COST_CAP_WHYS = Object.freeze(["unboundable", "external", "over-cap"]);
 
 /**
- * The `why` off the LAST runner exit line, or `null`: a member of `COST_CAP_WHYS`, and only when that same line says
- * `code: 2` and `reason: "cost-cap"`. Scanned from the end exactly as `parseExitReason` is, and NEVER throws.
+ * The `why` off the decisive exit line (`decisiveExitLine`), or `null`: a member of `COST_CAP_WHYS`, and only when that
+ * same line says `code: 2` and `reason: "cost-cap"`. Read off the same line as `parseExitReason`, and NEVER throws.
  *
  * The line is container-written, so nothing it carries is trusted as text: a value outside the closed set is null,
  * never a string copied through. It feeds no classification. The processor reads it only in its exit-2 branch, and
@@ -174,46 +197,32 @@ export const COST_CAP_WHYS = Object.freeze(["unboundable", "external", "over-cap
  * wrong rule of the three.
  */
 export function parseExitWhy(text) {
-	if (typeof text !== "string") return null;
-	const lines = text.split("\n");
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i].trim();
-		if (line === "") continue;
-		const parsed = parseTailLine(line);
-		if (parsed?.event !== "exit") continue;
-		return parsed?.code === 2 && parsed?.reason === "cost-cap" && COST_CAP_WHYS.includes(parsed?.why) ? parsed.why : null;
-	}
-	return null;
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return null;
+	return parsed?.code === 2 && parsed?.reason === "cost-cap" && COST_CAP_WHYS.includes(parsed?.why) ? parsed.why : null;
 }
 
 /**
- * The LAST runner exit line's own `code`, an integer, or `null` (issue #501, PR #542's review round 3). Scanned from
- * the end exactly as its siblings are, repairing a glued line through `parseTailLine`, and NEVER throws.
+ * The decisive exit line's own `code` (`decisiveExitLine`), an integer, or `null` (issue #501, PR #542's review round
+ * 3). Read off the same line as its siblings, and NEVER throws.
  *
  * Read for ONE purpose: the dollar settlement trusts an exit line's cost only when the line's `code` equals the
  * container's real exit code (processor.mjs). The runner writes the code it exits with on both exit lines
  * (`image/runner/run-job.mjs`: `...capExitMessage(outcome)` then `return outcome.code` on the decided path, and
- * `code: capped.code` on the catch path; pinned by a test), so a genuine last line always matches, while a line a
+ * `code: capped.code` on the catch path; pinned by a test), so the runner's genuine line always matches, while a line a
  * job's own tool forged before a `docker stop` (exit 137, no genuine line after it) does not. It never feeds the
  * retry class (INT-RUNNER-EXIT-CODE-PROTOCOL).
  */
 export function parseExitCode(text) {
-	if (typeof text !== "string") return null;
-	const lines = text.split("\n");
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i].trim();
-		if (line === "") continue;
-		const parsed = parseTailLine(line);
-		if (parsed?.event !== "exit") continue;
-		return Number.isSafeInteger(parsed?.code) ? parsed.code : null;
-	}
-	return null;
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return null;
+	return Number.isSafeInteger(parsed?.code) ? parsed.code : null;
 }
 
 /**
  * Recover the agent's token usage from buffered container stdout, or `null` if it is not reported.
  *
- * Mirrors `parseExitTurns`: scan from the end for the last `exit` event and read its `tokens` object
+ * Mirrors `parseExitTurns`: read the `tokens` object of the decisive exit line (`decisiveExitLine`)
  * (`{ input, output, total, cost }`). Only the success exit line carries it
  * (`image/runner/run-job.mjs`); the catch-path exit line omits it, and a container that died before the
  * runner's exit line yields none -- all three cases are `null`.
@@ -277,25 +286,18 @@ export const SESSION_REASONS = new Set([
  * `SESSION_REASONS` check below, that sentence is enforced rather than merely intended.
  */
 export function parseExitSession(text) {
-	if (typeof text !== "string") return null;
-	const lines = text.split("\n");
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i].trim();
-		if (line === "") continue;
-		const parsed = parseTailLine(line);
-		if (parsed?.event !== "exit") continue;
-		const sess = parsed?.session;
-		if (sess && typeof sess === "object" && !Array.isArray(sess) && typeof sess.resumed === "boolean") {
-			// The reason is checked against the CLOSED enum, not merely against `typeof === "string"`, which
-			// is what it used to be. The container owns this value, so an unchecked string put an
-			// attacker-shapeable one into a record whose PII-free property rests on holding none -- while
-			// the comment above claimed "a boolean and a fixed enum". An unrecognised token reads as `null`
-			// (the runner said nothing this contract can represent) rather than being carried through: the
-			// enum is documented CLOSED in INT-RUN-HISTORY-FILE-CONTRACT, so a value outside it was already
-			// contract-violating and every consumer already handles null.
-			return { resumed: sess.resumed, reason: SESSION_REASONS.has(sess.reason) ? sess.reason : null };
-		}
-		return null;
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return null;
+	const sess = parsed?.session;
+	if (sess && typeof sess === "object" && !Array.isArray(sess) && typeof sess.resumed === "boolean") {
+		// The reason is checked against the CLOSED enum, not merely against `typeof === "string"`, which
+		// is what it used to be. The container owns this value, so an unchecked string put an
+		// attacker-shapeable one into a record whose PII-free property rests on holding none -- while
+		// the comment above claimed "a boolean and a fixed enum". An unrecognised token reads as `null`
+		// (the runner said nothing this contract can represent) rather than being carried through: the
+		// enum is documented CLOSED in INT-RUN-HISTORY-FILE-CONTRACT, so a value outside it was already
+		// contract-violating and every consumer already handles null.
+		return { resumed: sess.resumed, reason: SESSION_REASONS.has(sess.reason) ? sess.reason : null };
 	}
 	return null;
 }
@@ -311,27 +313,86 @@ export function parseExitSession(text) {
  * reads that as "no measurement" and passes rather than inventing a denominator.
  */
 export function parseExitContext(text) {
-	if (typeof text !== "string") return null;
-	const lines = text.split("\n");
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i].trim();
-		if (line === "") continue;
-		const parsed = parseTailLine(line);
-		if (parsed?.event !== "exit") continue;
-		const c = parsed?.context;
-		// A window of 0 is not a denominator, and a negative count is not a measurement. SAFE integers
-		// specifically: `Number.isInteger` accepts up to ~1.8e308, and anything from 1e21 up stringifies to
-		// exponential notation, which the session store's own decimal round-trip then rejects on read --
-		// so a value in that range would be written into the store and be unreadable forever after, with
-		// the gate failing open on a measurement that said the context was full.
-		if (c && typeof c === "object" && !Array.isArray(c) && Number.isSafeInteger(c.tokens) && Number.isSafeInteger(c.window) && c.tokens >= 0 && c.window > 0) {
-			return { tokens: c.tokens, window: c.window };
-		}
-		return null;
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return null;
+	const c = parsed?.context;
+	// A window of 0 is not a denominator, and a negative count is not a measurement. SAFE integers
+	// specifically: `Number.isInteger` accepts up to ~1.8e308, and anything from 1e21 up stringifies to
+	// exponential notation, which the session store's own decimal round-trip then rejects on read --
+	// so a value in that range would be written into the store and be unreadable forever after, with
+	// the gate failing open on a measurement that said the context was full.
+	if (c && typeof c === "object" && !Array.isArray(c) && Number.isSafeInteger(c.tokens) && Number.isSafeInteger(c.window) && c.tokens >= 0 && c.window > 0) {
+		return { tokens: c.tokens, window: c.window };
 	}
 	return null;
 }
 
+/**
+ * The keys of the runner's `resources` block (issue #596), in its emission order. A copy of the runner's
+ * `RESOURCE_KEYS` (image/runner/src/cgroup-usage.mjs), which the worker cannot import at run time; a test holds the
+ * two lists equal.
+ */
+export const RESOURCE_KEYS = Object.freeze(["memPeak", "swapPeak", "oomKills", "memSomeUsec", "memFullUsec", "cpuUsec", "throttledUsec", "throttled", "pidsPeak"]);
+
+/**
+ * What the job's container used, off the decisive exit line (`decisiveExitLine`, issue #596): `{ memPeak, swapPeak,
+ * oomKills, memSomeUsec, memFullUsec, cpuUsec, throttledUsec, throttled, pidsPeak }`, each a safe non-negative integer
+ * or null, or null.
+ *
+ * REBUILT as an explicit literal over RESOURCE_KEYS, never passed through: extra keys are dropped, and a key the
+ * runner could not read arrives as null (or absent) and stays null. A present value that is not a safe non-negative
+ * integer (a string, a float, a negative, anything past 2^53) nulls the WHOLE block, the malformed->null rule
+ * `parseExitUsage` follows: such a line was not written by a conformant runner, and half of a forged block is not a
+ * measurement. Null when the line has no `resources` (an image from before this field, a runner that could read no
+ * cgroup file) or when every key is null. Read off the line `decisiveExitLine` picks, like every sibling, and NEVER
+ * throws. Telemetry, with ONE exception: `oomKills` and `memPeak` gate the OOM classification (`parseExitOomKilled`
+ * needs `oomKills` above 0, and the processor needs `memPeak` at 90% of the container's memory limit or more). These
+ * numbers are produced inside the job's container, so a job can inflate them; nothing else reads them for a decision.
+ */
+export function parseExitResources(text) {
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return null;
+	return rebuildResources(parsed?.resources);
+}
+
+/** The reason the image's supervisor writes when the runner was killed for memory (image/runner/supervise.mjs). */
+export const EXIT_OOM_KILLED = "oom-killed";
+
+/**
+ * Whether the decisive exit line (`decisiveExitLine`) is the supervisor's report that the runner was killed for memory
+ * (issue #596): `by: "supervisor"`, `code: 137`, `reason: "oom-killed"`, and a `resources` block whose `oomKills` is
+ * above 0, all on that one line. False for anything else, including a line with no resources, and a supervisor's line
+ * that follows one the runner wrote (that runner finished and was killed afterwards). NEVER throws.
+ *
+ * The processor reads it only beside a container exit of 137 that the worker did not cause, only from a line the
+ * per-job key verified (the supervisor runs in images that declare `exitAuth`, so an unsigned line saying this was
+ * written by a job's own tool), and only when the line's `memPeak` reached 90% of the container's memory limit
+ * (`oom_kill` also counts a kill by the HOST's OOM killer, which a job at 1000 meets first). A child killed for memory
+ * while the runner lives writes no such line (the runner ends on its own code), so it never reads as one.
+ */
+export function parseExitOomKilled(text) {
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return false;
+	const used = rebuildResources(parsed?.resources);
+	return parsed?.by === EXIT_BY_SUPERVISOR && parsed?.code === 137 && parsed?.reason === EXIT_OOM_KILLED && used !== null && used.oomKills !== null && used.oomKills > 0;
+}
+
+/** The validating rebuild behind `parseExitResources` and the record's `resources`: null on any violation. */
+function rebuildResources(r) {
+	if (r === null || typeof r !== "object" || Array.isArray(r)) return null;
+	const out = {};
+	for (const key of RESOURCE_KEYS) {
+		const v = Object.hasOwn(r, key) ? r[key] : null;
+		if (v === null || v === undefined) {
+			out[key] = null;
+			continue;
+		}
+		if (!Number.isSafeInteger(v) || v < 0) return null;
+		out[key] = v;
+	}
+	return RESOURCE_KEYS.some((key) => out[key] !== null) ? out : null;
+}
+
 /**
  * The keys the runner actually emits, in its own emission order: the metered snapshot
  * (`image/runner/src/usage-meter.mjs` -> `snapshot`) plus the token-budget fallback
@@ -393,17 +454,10 @@ function rebuildTokens(t) {
 }
 
 export function parseExitTokens(text) {
-	if (typeof text !== "string") return null;
-	const lines = text.split("\n");
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i].trim();
-		if (line === "") continue;
-		const parsed = parseTailLine(line);
-		if (parsed?.event !== "exit") continue;
-		const t = parsed?.tokens;
-		if (t && typeof t === "object" && !Array.isArray(t) && typeof t.total === "number") return rebuildTokens(t);
-		return null;
-	}
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return null;
+	const t = parsed?.tokens;
+	if (t && typeof t === "object" && !Array.isArray(t) && typeof t.total === "number") return rebuildTokens(t);
 	return null;
 }
 
@@ -435,16 +489,9 @@ const USAGE_ROW_NUMERIC_KEYS = ["calls", "input", "output", "cacheRead", "cacheW
  * classification (INT-RUNNER-EXIT-CODE-PROTOCOL).
  */
 export function parseExitUsage(text) {
-	if (typeof text !== "string") return null;
-	const lines = text.split("\n");
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i].trim();
-		if (line === "") continue;
-		const parsed = parseTailLine(line);
-		if (parsed?.event !== "exit") continue;
-		return rebuildUsage(parsed?.usage);
-	}
-	return null;
+	const parsed = decisiveExitLine(text);
+	if (parsed === null) return null;
+	return rebuildUsage(parsed?.usage);
 }
 
 /** The validating rebuild behind `parseExitUsage`: explicit literals only, null on ANY violation. */
@@ -522,7 +569,7 @@ function rebuildUsage(u) {
  * default to `null` when the outcome does not carry them, so the record shape is stable whether or not
  * the source reports those fields.
  */
-export function buildRecord({ job, result, error, startedAt, endedAt, host = null, defaultBackend = null, project = null }) {
+export function buildRecord({ job, result, error, startedAt, endedAt, host = null, defaultBackend = null, project = null, size = null }) {
 	const data = job.data ?? {};
 	const kind = data.kind ?? job.name;
 	const source = result ?? error ?? {};
@@ -658,9 +705,45 @@ export function buildRecord({ job, result, error, startedAt, endedAt, host = nul
 		// with no portfolio trigger; a confirmed one that wrote none says `plan-absent` (issue #507). Never
 		// the plan's weights or its reasons: those are in the allocation audit file, and a reason is agent text.
 		plan: planOf(source.plan),
+		// What the container used (issue #596, INT-RUN-HISTORY-FILE-CONTRACT): peak memory, OOM kills, memory pressure, CPU
+		// time and throttling, peak processes, read by the runner from its own cgroup just before its exit line. Additive,
+		// nullable, an explicit literal REBUILT here, TAIL position after `plan` on the same contract. Integers only, so
+		// PII-free by construction. A runner killed before its line still has one: the image's supervisor reads the cgroup
+		// when it reports the death, so a job killed for memory carries the block that shows it. Null when no exit line
+		// carried it: an older image, one whose supervisor died too, or a venue that hides the cgroup. Produced inside the
+		// job's container, so a job can inflate every number: advisory (docs/insights.md).
+		resources: rebuildResources(source.resources),
+		// The size the job was given (issue #596, INT-RUN-HISTORY-FILE-CONTRACT): `{ memMiB, cpuCenti, source }`, resolved
+		// at the pickup gate from the limits snapshot and passed in beside `project` (start.mjs `recordRun`), so the record
+		// says what the job was promised next to what it used (`resources`). Additive, nullable, an explicit literal REBUILT
+		// here (`recordedJobSize`), TAIL position after `resources` on the same contract. Two integers and a fixed word
+		// (`project` | `env` | `default`), so PII-free by construction. Present on every record written after the pickup
+		// gate, including a refusal there that started no container (it is the size the job WOULD have had); null on a record
+		// written before it (the wait gate's refusals) and from a caller that passes none.
+		size: recordedJobSize(size),
+		// The host budget a never-fits refusal judged the size against (issue #596, phase 2, INT-RUN-HISTORY-FILE-CONTRACT):
+		// `{ memMiB, cpuCenti, hostShare }`, so the record names BOTH sizes where the forge comment names neither. Additive,
+		// nullable, an explicit literal REBUILT here (`recordedHostBudget`), TAIL position after `size` on the same
+		// contract. Each budget an integer, `"off"` for a dimension switched off, or null for one unknown (the OTHER dimension
+		// refused: an off or unknown dimension never refuses by itself); `hostShare` an integer or null. Present only on
+		// the `job-size-exceeds-host` and `-share` records; null on every other.
+		hostBudget: recordedHostBudget(source.hostBudget),
 	};
 }
 
+/**
+ * A refusal's host budget as a record carries it: `{ memMiB, cpuCenti, hostShare }`, else null. A budget is a safe
+ * integer, `"off"` (the budget's `Infinity`, or the word itself) or null (unknown); the share a safe integer or null.
+ * `"off"` rather than null for a switched-off dimension (gate round 1 of phase 2): null already means unknown,
+ * and a record that cannot tell "not limited" from "not known" names neither.
+ */
+export function recordedHostBudget(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+	const int = (v) => (Number.isSafeInteger(v) && v >= 0 ? v : null);
+	const budget = (v) => (v === Infinity || v === "off" ? "off" : int(v));
+	return { memMiB: budget(value.memMiB), cpuCenti: budget(value.cpuCenti), hostShare: int(value.hostShare) };
+}
+
 /** What became of a collected plan. */
 export const PLAN_RECORD_OUTCOMES = Object.freeze(["applied", "duplicate", "refused"]);
 /**
@@ -749,8 +832,9 @@ const SIGNED_TAIL = /,"auth":"([0-9a-f]{64})"\}$/;
  *
  * The worker hands each job a fresh random key on the container's stdin, and the runner signs its exit line with
  * HMAC-SHA256 over the line's unsigned bytes. A job's own tool can write any bytes it likes to the container's stdout,
- * but not that MAC: the key left the pipe before any tool existed and the runner's memory is closed to the job's uid
- * (the image's exec-only node). So when a key was issued, only these lines are the runner's, and every `parseExit*`
+ * but not that MAC: the key left the pipe before any tool existed, and the processes holding it (the supervisor and
+ * the runner) are closed to the job's uid on /proc (the image's exec-only node) and on the Node inspector (both start
+ * with `--disable-sigusr1`). So when a key was issued, only these lines are the runner's, and every `parseExit*`
  * scanner runs over this text instead of the raw tail: a forged line, before or after the genuine one, is not in it.
  *
  * Each candidate starts at a `{"event":"exit"` anchor, the `parseTailLine` repair's reasoning: those raw bytes cannot
@@ -853,6 +937,8 @@ export function makeLogSink({ logsDir, enabled, fs = nodeFs, log = () => {} }) {
 			const session = parseExitSession(exitText);
 			const usage = parseExitUsage(exitText);
 			const context = parseExitContext(exitText);
+			const resources = parseExitResources(exitText);
+			const oomKilled = parseExitOomKilled(exitText);
 			try {
 				if (stream !== null) {
 					const s = stream;
@@ -878,7 +964,8 @@ export function makeLogSink({ logsDir, enabled, fs = nodeFs, log = () => {} }) {
 			}
 			// `exitAuth` only when a key was issued, so a keyless close returns exactly the object it always did. `exitWhy`
 			// (issue #507) only when the line named one, for the same reason.
-			return { turns, tokens, session, usage, context, exitReason, exitLineCode, ...(exitWhy !== null ? { exitWhy } : {}), ...(keyed ? { exitAuth } : {}) };
+			// `resources` (issue #596) only when the line carried a block, and `exitOomKilled` only when true, for the same reason.
+			return { turns, tokens, session, usage, context, exitReason, exitLineCode, ...(exitWhy !== null ? { exitWhy } : {}), ...(resources !== null ? { resources } : {}), ...(oomKilled ? { exitOomKilled: true } : {}), ...(keyed ? { exitAuth } : {}) };
 		}
 
 		return { write, close };

package/src/sandbox-store.mjs

@@ -129,7 +129,7 @@ const defaultFs = { chmodSync, chownSync, lstatSync, mkdirSync, readFileSync, re
  * nothing was retained -- and on `null` the caller has nothing left to do, because every failure path
  * here removes `jobDir` itself. Retention must never leave debris behind.
  *
- * `prepared.sandbox` is `{ jobId, kind, image, backend, jobUser? }`, stamped by `makePrepareWorkspace` (`jobUser`
+ * `prepared.sandbox` is `{ jobId, kind, image, backend, jobUser?, podmanStore?, size? }`, stamped by `makePrepareWorkspace` (`jobUser`
  * only when the processor decided one, issue #341). Absent (a bare construction, a test, an unwired dispatcher)
  * means no retention, which keeps such a caller on exactly
  * the pre-feature path.
@@ -182,6 +182,10 @@ export function retainJobDir(prepared, { sandboxDir, retentionHours = null, fs =
 			// other manifest is the shape it always was. A sandbox refuses to open under another store, and the sweep
 			// holds the run while the podman it asks uses another, because that podman's `ps` answers empty (measured).
 			...(typeof meta.podmanStore === "string" ? { podmanStore: meta.podmanStore } : {}),
+			// Issue #596: the run's size (`{ memMiB, cpuCenti, source }`), so a sandbox reopens the run at it. Written only when
+			// known, so every other manifest is the shape it always was; a manifest without it reopens at the built-in 4g
+			// and 2, the size every run had before sizes existed.
+			...(meta.size && typeof meta.size === "object" ? { size: meta.size } : {}),
 			workspace: rebaseWorkspace(prepared.workspace, jobDir, dest),
 			createdAt: new Date(created).toISOString(),
 			// Issue #446: the deadline THIS worker's window gives the run, written down, so an opener whose own