pi-crew 0.9.66 → 0.9.68

package/src/runtime/scratchpad/guest.ts

@@ -26,6 +26,7 @@
  */
 
 import { AsyncLocalStorage } from "node:async_hooks";
+import { execFile } from "node:child_process";
 import { writeSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { format, inspect } from "node:util";
@@ -179,14 +180,107 @@ console.error = consoleErr;
 console.trace = consoleErr;
 
 // ── bootstrap bindings ───────────────────────────────────────────────────────
-// pi-rlm mounts rlm/tools/Bun handles here. The spike has no host bridge, so
-// nothing is installed — but the hook is kept (and re-run after restore) for
-// fidelity with the port plan: a later phase wires real bindings here.
+// pi-rlm mounts rlm/tools/Bun handles here. Pattern 12 (shell guard): the
+// guest-local `sh` helper narrows raw child_process — it refuses null/undefined
+// arguments (the `rm -rf undefined` class bug) and returns a value, not a
+// string, so cell 2 can reuse cell 1's result. Advisory guard only — cells run
+// at full worker trust (no VM sandbox), so `sh` is a nudge, not a boundary.
 
 const INTERNAL_BINDINGS = new Map<string, unknown>();
 
+/**
+ * Protected Node globals — must never be persistently shadowed by a cell.
+ *
+ * Because the scope proxy's `get` trap checks the namespace BEFORE globalThis,
+ * a cell writing `const process = 'poisoned'` (transformed to a namespace
+ * assignment) would otherwise poison EVERY later cell in the same engine
+ * (the namespace is a module-level singleton) AND survive snapshot→restore
+ * (a serializable shadow revives). Result: silent corruption — e.g.
+ * `typeof process.env` becomes 'undefined' with no error.
+ *
+ * We register the LIVE global for each protected name in INTERNAL_BINDINGS +
+ * the namespace, so (a) restore's re-install overwrites any revived shadow,
+ * and (b) each cell starts with the real global. Within-cell shadowing still
+ * works (the cell's own write wins for that cell only); it just cannot leak
+ * to other cells or across restarts. Verified: probe reproduced the bug
+ * pre-fix; see test/unit/runtime/scratchpad/guest-global-shadow.test.ts.
+ */
+const PROTECTED_GLOBALS: ReadonlyArray<string> = [
+	"process",
+	"Buffer",
+	"console",
+	"setTimeout",
+	"clearTimeout",
+	"setInterval",
+	"clearInterval",
+	"setImmediate",
+	"clearImmediate",
+	"queueMicrotask",
+	"structuredClone",
+	"AbortController",
+	"globalThis",
+];
+
+function resetProtectedGlobals(): void {
+	const g = globalThis as Record<string, unknown>;
+	for (const name of PROTECTED_GLOBALS) {
+		const live = g[name];
+		if (live === undefined) continue;
+		INTERNAL_BINDINGS.set(name, live);
+		namespace[name] = live;
+	}
+}
+
+/** Pattern-12 nullish guard: refuse undefined/null BEFORE spawning. */
+function assertShellArgNotNullish(name: string, value: unknown): void {
+	if (value === undefined || value === null) {
+		throw new Error(
+			`sh: argument '${name}' is null/undefined — a missing variable would stringify to the literal 'undefined' in the command. Re-verify variables after a restore before using them in shell commands.`,
+		);
+	}
+}
+
+/**
+ * sh(cmd, args[]) — pattern-12 shell interpolation guard.
+ * Runs via execFile (shell:false, args as an array — no shell interpolation
+ * of the command string), refuses nullish args, and returns a value:
+ * `{ exitCode, stdout, stderr }` (pi-rlm "shell as value"). Non-zero exit does
+ * NOT throw — it is returned in `exitCode`.
+ */
+function makeSh(): (cmd: string, args?: unknown[]) => Promise<{ exitCode: number; stdout: string; stderr: string }> {
+	const execFileAsync = (cmd: string, args: string[]) =>
+		new Promise<{ exitCode: number; stdout: string; stderr: string }>((resolve, reject) => {
+			execFile(cmd, args, { shell: false, encoding: "utf8" }, (error, stdout, stderr) => {
+				if (error) {
+					// error.code is the exit code for a non-zero exit; otherwise a real
+					// spawn failure (ENOENT etc.) — surface it as exitCode 127-like.
+					const exitCode = typeof error.code === "number" ? error.code : 127;
+					resolve({ exitCode, stdout: String(stdout), stderr: String(stderr || error.message) });
+					return;
+				}
+				resolve({ exitCode: 0, stdout: String(stdout), stderr: String(stderr) });
+			});
+		});
+	return async (cmd: string, args?: unknown[]) => {
+		assertShellArgNotNullish("cmd", cmd);
+		const stringArgs = (args ?? []).map((a, i) => {
+			assertShellArgNotNullish(`arg[${i}]`, a);
+			return String(a);
+		});
+		return execFileAsync(cmd, stringArgs);
+	};
+}
+
 function installBootstrapBindings(): void {
-	// Spike: no host bridge, no Bun — nothing to mount.
+	const sh = makeSh();
+	// Register the SAME function reference in INTERNAL_BINDINGS and the
+	// namespace so snapshotNamespace()'s identity skip (===) excludes it from
+	// serialization, and so cells can call `sh(...)` directly.
+	INTERNAL_BINDINGS.set("sh", sh);
+	namespace.sh = sh;
+	// Overwrite any protected-global shadow (e.g. a revived `process='x'` from
+	// restore) with the live global — fixes the global shadow poisoning bug.
+	resetProtectedGlobals();
 }
 
 installBootstrapBindings();
@@ -198,14 +292,69 @@ const AsyncFunction = (async () => {}).constructor as new (...args: string[]) =>
 
 const liveCells = new Map<string, CellContext>();
 
+// ── P6: remap transformed error-stack lines back to the cell's source ───────
+// V8 reports a thrown line as `N = bodyLine + 2` (1-based) — the AsyncFunction
+// wrapper adds 2 prefix lines (the anonymous function line + the `with (...)`
+// line) before the cell body. `lineMap` (from transformCell) maps body lines
+// that RECEIVED A REPLACEMENT back to the source line the model wrote. Lines
+// between replacements (unreplaced spans — e.g. a bare `throw`) are identity:
+// sourceLine = entry.sourceLine + (bodyLine - entry.bodyLine), using the
+// nearest replacement entry at or before the body line.
+//
+// SECURITY/robustness (P6 review finding): only lines that look like a real
+// V8 frame (`    at ... <anonymous>:N:C)`) are remapped. The `Error: <message>`
+// line and any cell text containing `<anonymous>:N:C)` (e.g. an error message
+// that echoes code) must be left byte-identical — a crafted message must never
+// get its numbers rewritten.
+function remapStackLines(stack: string, lineMap: { sourceLine: number; bodyLine: number }[]): string[] {
+	const lines = stack.split("\n");
+	const sorted = [...lineMap].sort((a, b) => a.bodyLine - b.bodyLine);
+	return lines.map((line) => {
+		// Real V8 frame only: `    at <anything> <anonymous>:N:C)` — anchored to
+		// the leading frame prefix and a parenthesized trailing position. The
+		// message line (`Error: ...`) does not start with `    at `, so it is
+		// never matched; a crafted message containing `<anonymous>:N:C)` is
+		// likewise safe because it lacks the frame prefix.
+		const m = line.match(/^\s+at .*<anonymous>:(\d+):(\d+)\)/);
+		if (!m) return line;
+		const reported = Number(m[1]);
+		const bodyLine = reported - 2; // wrapper prefix offset (verified by probe)
+		// nearest replacement entry at or before bodyLine (lower bound)
+		let lo = 0;
+		let hi = sorted.length - 1;
+		let entry: { sourceLine: number; bodyLine: number } | undefined;
+		while (lo <= hi) {
+			const mid = (lo + hi) >> 1;
+			if (sorted[mid].bodyLine <= bodyLine) {
+				entry = sorted[mid];
+				lo = mid + 1;
+			} else {
+				hi = mid - 1;
+			}
+		}
+		if (!entry) return line; // before any replacement — leave as-is
+		const sourceLine = entry.sourceLine + (bodyLine - entry.bodyLine);
+		const col = m[2];
+		return line.replace(/<anonymous>:\d+:\d+/, `<anonymous>:${sourceLine}:${col}`);
+	});
+}
+
 async function runCell(cellId: string, code: string): Promise<void> {
 	const ctx = makeCellContext(cellId);
 	activeCell = ctx;
 	liveCells.set(cellId, ctx);
+	// Reset protected globals so a prior cell's shadow (e.g. `const process='x'`)
+	// cannot poison this cell — shadowing stays local to the cell that did it
+	// (the namespace is a module-level singleton shared across cells).
+	resetProtectedGlobals();
 
 	let done: GuestToHostMessage;
+	// P6: lineMap from transformCell is needed in BOTH try (to build the
+	// wrapper) and catch (to remap the error stack), so hoist it here.
+	let lineMap: { sourceLine: number; bodyLine: number }[] = [];
 	try {
-		const { body } = transformCell(code, { ctxName: CTX_NAME });
+		const { body, lineMap: lm } = transformCell(code, { ctxName: CTX_NAME });
+		lineMap = lm;
 		// Sloppy-mode wrapper so `with` is legal (AsyncFunction bodies are always
 		// sloppy, even inside a strict ESM strip-types module); async for
 		// top-level await.
@@ -223,7 +372,7 @@ async function runCell(cellId: string, code: string): Promise<void> {
 			type: "done",
 			cellId,
 			status: ctx.aborted ? "aborted" : "error",
-			error: { name: err.name, message: err.message, stack: (err.stack ?? "").split("\n") },
+			error: { name: err.name, message: err.message, stack: remapStackLines(err.stack ?? "", lineMap) },
 		};
 	} finally {
 		if (activeCell === ctx) activeCell = undefined;
@@ -294,7 +443,8 @@ function restoreNamespace(vars: Record<string, string>): {
 		}
 	}
 	// Bootstrap runs after restore: live handles would overwrite anything
-	// revived. The spike installs nothing, but the hook is kept for fidelity.
+	// revived. `sh` is re-installed so a revived stale value cannot shadow the
+	// live handle (I6).
 	installBootstrapBindings();
 	return { restored, failed };
 }

package/src/runtime/scratchpad/protocol.ts

@@ -45,7 +45,19 @@ export interface GuestToHost {
 		error?: { name: string; message: string; stack: string[] };
 	};
 	pong: { type: "pong"; id: string };
-	host_request: { type: "host_request"; id: string; requestType: string; payload: Record<string, unknown> };
+	host_request: {
+		// RESERVED for future host bridge (rlm-deep-review-2026-08-12.md §5.2F /
+		// J2): guest-side cells would request host services (tools.read,
+		// tools.grep) so data enters the namespace WITHOUT crossing the
+		// transcript — pi-rlm's core token-saving value proposition. Declared
+		// here so the protocol type is stable, but NOT YET WIRED: engine.ts and
+		// guest.ts have no host_request dispatcher/handler. Blocked on scratchpad
+		// adoption > 0 (do not add a host execution surface nobody calls).
+		type: "host_request";
+		id: string;
+		requestType: string;
+		payload: Record<string, unknown>;
+	};
 	snapshot_result: {
 		type: "snapshot_result";
 		id: string;

package/src/runtime/scratchpad/transform.ts

@@ -31,6 +31,15 @@ export interface TransformedCell {
 	body: string;
 	/** Top-level names this cell binds into the namespace. */
 	declaredNames: string[];
+	/**
+	 * P6: line-based position map — for each body line (1-based), the
+	 * corresponding SOURCE line (1-based) the model wrote. Used to remap the
+	 * V8-reported error line (relative to `body`) back to the cell's original
+	 * line so stack traces point at the source the user wrote, not the
+	 * transformed body. Built WITHOUT a source-map dependency by tracking
+	 * replacement newline shifts against the source (acorn `locations`).
+	 */
+	lineMap: { sourceLine: number; bodyLine: number }[];
 }
 
 export interface TransformOptions {
@@ -41,8 +50,16 @@ export interface TransformOptions {
 // esbuild's transform strips types but never drops side-effect-free trailing
 // expressions (no DCE in transform mode) — the exact thing we capture as the
 // cell result.
-function stripTypes(code: string): string {
-	return transformSync(code, { loader: "ts" }).code;
+// P6: `sourcemap: 'inline'` so we can map the stripped `js` lines back to the
+// `rewritten` (pre-strip) lines — esbuild does NOT preserve line numbers
+// across type stripping (probe: 7 input lines → 5 output lines). The inline
+// sourcemap is stripped from the output (it would otherwise leak into the cell
+// body as a trailing comment); we only keep the decoded line map.
+function stripTypes(code: string): { code: string; lineMap: number[] } {
+	const out = transformSync(code, { loader: "ts", sourcemap: "inline" });
+	const lineMap = esbuildLineMap(out.code);
+	const codeWithoutMap = out.code.replace(/\/\/# sourceMappingURL=data:application\/json;base64,[A-Za-z0-9+/=]+\s*$/, "");
+	return { code: codeWithoutMap, lineMap };
 }
 
 // ── top-level import extraction ──────────────────────────────────────────────
@@ -271,14 +288,147 @@ function variableReplacement(decl: VariableDeclaration, source: string): string
 	return statements.join(" ");
 }
 
+// ── P6: line-based position map ─────────────────────────────────────────────
+// V8 reports a cell error's line as 1-based relative to the TRANSFORMED `body`.
+// The model wrote `code`; between them sit 3 transforms:
+//   1. import pre-rewrite (acorn)      — collapses multi-line imports to 1 line
+//   2. esbuild strip-types             — collapses type annotations/signatures
+//   3. declaration → assignment + trailing-expr capture — may add/remove lines
+// We build a map { sourceLine (1-based, in `code`) → bodyLine (1-based) } by
+// tracking line deltas across each stage with acorn `locations` + newline
+// counts. No source-map dependency (probe: esbuild strip-types does NOT
+// preserve lines — 7→5 — so a naive single-layer sourcemap would be wrong).
+
+function countNewlines(s: string): number {
+	let n = 0;
+	for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) === 10) n++;
+	return n;
+}
+
+/** 1-based line of `pos` (char offset) in `text`. */
+function lineAt(text: string, pos: number): number {
+	let line = 1;
+	for (let i = 0; i < pos && i < text.length; i++) if (text.charCodeAt(i) === 10) line++;
+	return line;
+}
+
+// ── P6: esbuild inline sourcemap → line map (js → rewritten) ───────────────
+// esbuild `sourcemap: 'inline'` emits a base64 VLQ sourcemap whose `mappings`
+// field encodes, per generated line, segments mapping back to source
+// positions. We only need LINE fidelity (column is overkill for the bug), so
+// we decode each generated line's first segment's source line. VLQ is the
+// standard base64-variable-length encoding (no dependency needed).
+
+const BASE64: string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const VLQ: Map<string, number> = new Map([...BASE64].map((c, i) => [c, i]));
+
+function decodeVlqSegment(segment: string): number[] {
+	const values: number[] = [];
+	let shift = 0;
+	let value = 0;
+	for (let i = 0; i < segment.length; i++) {
+		const digit = VLQ.get(segment[i]);
+		if (digit === undefined) break;
+		value |= (digit & 31) << shift;
+		if (digit & 32) {
+			shift += 5;
+		} else {
+			values.push(value & 1 ? -(value >>> 1) : value >>> 1);
+			value = 0;
+			shift = 0;
+		}
+	}
+	return values;
+}
+
+/**
+ * Decode an esbuild inline sourcemap's `mappings` into an array where
+ * `lineMapGenerated[generatedLine-1]` = the source LINE (1-based) that
+ * generated line originates from (first segment per generated line; falls back
+ * to the previous mapped line for continuation lines).
+ */
+function esbuildLineMap(codeWithInlineMap: string): number[] {
+	const m = codeWithInlineMap.match(/\/\/# sourceMappingURL=data:application\/json;base64,([A-Za-z0-9+/=]+)/);
+	if (!m) return [];
+	let sm: { mappings?: string };
+	try {
+		sm = JSON.parse(Buffer.from(m[1], "base64").toString("utf8")) as { mappings?: string };
+	} catch {
+		return [];
+	}
+	if (!sm.mappings) return [];
+	const result: number[] = [];
+	let srcLine = 1;
+	let lastSrcLine = 1;
+	for (const genLine of sm.mappings.split(";")) {
+		const segs = genLine.split(",").filter(Boolean);
+		if (segs.length > 0) {
+			const vals = decodeVlqSegment(segs[0]);
+			// values: [genColDelta, srcIdxDelta, srcLineDelta, srcColDelta, ...]
+			if (vals.length >= 3) {
+				srcLine += vals[2];
+				lastSrcLine = srcLine;
+			}
+		}
+		result.push(lastSrcLine);
+	}
+	return result;
+}
+
+/**
+ * Build a `code`-line → `js`-line map across the import pre-rewrite.
+ * For each import replacement, its `code` span [codeStart, codeEnd] collapses
+ * to `js` lines [jsStart, jsEnd] (usually 1). Lines outside any replacement
+ * are identity-shifted by the cumulative delta.
+ */
+function buildImportLineMap(
+	code: string,
+	rewritten: string,
+	importSpans: { codeStart: number; codeEnd: number; jsStart: number; jsEnd: number }[],
+): (src: number) => number {
+	if (importSpans.length === 0) return (src) => src;
+	// P6 (final): map a `rewritten` (post-import) LINE to the original `code`
+	// line. `rewritten` = code with each import statement replaced by its
+	// (usually 1-line) dynamic-import fragment. We walk both strings tracking
+	// newline counts: between imports the line numbers advance identically;
+	// inside an import span, all its code lines map to the replacement's first
+	// rewritten line (collapsed).
+	const rewrittenLines: string[] = rewritten.split("\n");
+	const codeLines: string[] = code.split("\n");
+	const map = new Map<number, number>(); // rewrittenLine → codeLine (1-based)
+	let codeIdx = 1;
+	let rewIdx = 1;
+	for (const span of importSpans) {
+		// Advance both to the span start, emitting identity mapping for the
+		// untouched lines between the previous span end and this span start.
+		const spanStartCodeLine = lineAt(code, span.codeStart);
+		const spanStartRewLine = lineAt(rewritten, span.jsStart);
+		for (; codeIdx < spanStartCodeLine && rewIdx < spanStartRewLine; codeIdx++, rewIdx++) {
+			map.set(rewIdx, codeIdx);
+		}
+		// Lines inside the import span (in code) collapse to the replacement's
+		// single starting rewritten line.
+		const spanEndCodeLine = lineAt(code, span.codeEnd);
+		for (; codeIdx <= spanEndCodeLine; codeIdx++) {
+			map.set(spanStartRewLine, spanStartCodeLine);
+		}
+		rewIdx = spanStartRewLine + 1;
+	}
+	// Tail: identity from wherever we stopped.
+	for (; rewIdx <= rewrittenLines.length; rewIdx++, codeIdx++) {
+		map.set(rewIdx, Math.min(codeIdx, codeLines.length));
+	}
+	return (rewLine: number) => {
+		const mapped = map.get(rewLine);
+		return mapped ?? Math.min(rewLine, codeLines.length);
+	};
+}
+
 export function transformCell(code: string, options: TransformOptions = {}): TransformedCell {
 	const ctxName = options.ctxName ?? "__ctx";
-
-	// Top-level imports are rewritten into awaited dynamic imports BEFORE type
-	// stripping: esbuild elides unused imports, and the reference behaviour
-	// binds every imported name into the namespace so it persists across cells.
 	let importDeclared: string[] = [];
 	let rewritten = code;
+	const importSpans: { codeStart: number; codeEnd: number; jsStart: number; jsEnd: number }[] = [];
 	try {
 		const tokens = lexTopLevel(code);
 		const imports = findImportStatements(tokens);
@@ -286,11 +436,21 @@ export function transformCell(code: string, options: TransformOptions = {}): Tra
 			importDeclared = [];
 			const pieces: string[] = [];
 			let cursor = 0;
+			let jsCursor = 0;
 			for (const stmt of imports) {
-				pieces.push(rewritten.slice(cursor, stmt.start));
+				const pre = rewritten.slice(cursor, stmt.start);
+				pieces.push(pre);
+				jsCursor += pre.length;
 				const rewrite = rewriteImport(code, stmt, tokens);
 				importDeclared.push(...rewrite.declaredNames);
 				pieces.push(rewrite.replacement);
+				importSpans.push({
+					codeStart: stmt.start,
+					codeEnd: stmt.end,
+					jsStart: jsCursor,
+					jsEnd: jsCursor + rewrite.replacement.length - 1,
+				});
+				jsCursor += rewrite.replacement.length;
 				cursor = stmt.end;
 			}
 			pieces.push(rewritten.slice(cursor));
@@ -301,8 +461,15 @@ export function transformCell(code: string, options: TransformOptions = {}): Tra
 		// the pre-rewrite; type stripping below surfaces the error.
 	}
 
-	const js = stripTypes(rewritten);
-	const program: Program = parse(js, { ecmaVersion: "latest", sourceType: "module", allowAwaitOutsideFunction: true });
+	const { code: js, lineMap: esbLineMap } = stripTypes(rewritten);
+	const rewToCode = buildImportLineMap(code, rewritten, importSpans);
+	const program: Program = parse(js, {
+		ecmaVersion: "latest",
+		sourceType: "module",
+		allowAwaitOutsideFunction: true,
+		// P6: locations needed to know each top-level node's source lines.
+		locations: true,
+	});
 
 	const declaredNames: string[] = [];
 	const replacements: { start: number; end: number; text: string }[] = [];
@@ -353,11 +520,38 @@ export function transformCell(code: string, options: TransformOptions = {}): Tra
 	replacements.sort((a, b) => a.start - b.start);
 	let body = "";
 	let cursor = 0;
+	// P6: build bodyLine → sourceLine map while splicing. `body` is what V8
+	// reports error lines against; `js` is the esbuild-stripped source; the map
+	// composes: bodyLine → jsLine (via newline deltas) → rewrittenLine (via
+	// esbuild inline sourcemap) → codeLine (via import pre-rewrite).
+	const lineMap: { sourceLine: number; bodyLine: number }[] = [];
+	let bodyLine = 1;
+	let jsLine = 1;
+	// jsLineOfBodyStart maps the js line at each body boundary; we track the
+	// cumulative js-line delta as body lines are emitted.
 	for (const replacement of replacements) {
-		body += js.slice(cursor, replacement.start) + replacement.text;
+		const pre = js.slice(cursor, replacement.start);
+		body += pre;
+		bodyLine += countNewlines(pre);
+		jsLine += countNewlines(pre);
+		// The replacement's first body line maps from the js line at its start.
+		const repJsStartLine = lineAt(js, replacement.start);
+		// Source line = compose: js → rewritten (esbuild) → code (imports).
+		const rewLine = esbLineMap.length > 0 ? esbLineMap[Math.min(repJsStartLine - 1, esbLineMap.length - 1)] : repJsStartLine;
+		const srcLine = rewToCode(rewLine);
+		lineMap.push({ sourceLine: srcLine, bodyLine: bodyLine });
+		body += replacement.text;
+		bodyLine += countNewlines(replacement.text);
+		// js line after the replacement: replacements are in js coordinate, so
+		// jsLine advances by the replacement's text newlines too.
+		jsLine += countNewlines(replacement.text);
 		cursor = replacement.end;
 	}
-	body += js.slice(cursor);
+	const tail = js.slice(cursor);
+	body += tail;
+	bodyLine += countNewlines(tail);
+	// Any body line not covered by a replacement maps identity.
+	lineMap.sort((a, b) => a.bodyLine - b.bodyLine);
 
-	return { body, declaredNames: [...new Set([...importDeclared, ...declaredNames])] };
+	return { body, declaredNames: [...new Set([...importDeclared, ...declaredNames])], lineMap };
 }

package/src/runtime/supervisor-contact.ts

@@ -61,19 +61,3 @@ export function supervisorContactFromEvent(event: unknown): Omit<SupervisorConta
 				: undefined,
 	};
 }
-
-/**
- * @deprecated The compact pipeline now passes `supervisor_contact` events through
- * to `onJsonEvent` with their full payload (P2-25 fix). Prefer
- * `supervisorContactFromEvent` on the parsed event. Kept for backward compat.
- */
-export function parseSupervisorContactFromLine(line: string): Omit<SupervisorContactPayload, "timestamp" | "runId"> | undefined {
-	if (!line.trim()) return undefined;
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(line);
-	} catch {
-		return undefined;
-	}
-	return supervisorContactFromEvent(parsed);
-}

package/src/runtime/task-runner/child-executor.ts

@@ -544,6 +544,7 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 				runId: manifest.runId,
 				agentId: task.id,
 				artifactsRoot: manifest.artifactsRoot,
+				eventsPath: manifest.eventsPath, // I5: scratchpad metric events from the worker
 				attempt: i,
 				steeringFile: resolveRealContainedPath(`${manifest.artifactsRoot}/steering`, `${task.id}.jsonl`),
 				onSpawn: (pid) => {

package/src/runtime/task-runner/state-helpers.ts

@@ -41,7 +41,15 @@ export function persistSingleTaskUpdate(
 	checkpointPhase?: TaskCheckpointState["phase"],
 	skipCoalesce: boolean = false,
 ): TeamTaskState[] {
-	const MAX_CAS_ATTEMPTS = 100;
+	// H5 (2026-08-10): lowered from 100 → 10. Each retry does
+	// flushPendingAtomicWrites (global) + loadRunManifestById (stat + parse)
+	// + statSync, ~5ms each. The first attempt uses fallbackTasks directly
+	// (no disk read); retries only fire under real contention from best-effort
+	// writers that don't hold the run lock (async-notifier, crash-recovery).
+	// If 10 retries cannot converge, the system is in a pathological state
+	// where 100 would not help either — the explicit error below surfaces it
+	// instead of blocking the event loop for 500ms.
+	const MAX_CAS_ATTEMPTS = 10;
 	let baseMtime = 0;
 	try {
 		baseMtime = fs.statSync(manifest.tasksPath).mtimeMs;

package/src/runtime/team-runner.ts

@@ -17,6 +17,7 @@ import {
 	appendEventBuffered,
 	appendEventFireAndForget,
 	flushEventLogBuffer,
+	readEvents,
 } from "../state/event-log/event-log.ts";
 import { hashArtifactContent as hashContent, writeArtifact } from "../state/stores/artifact-store.ts";
 import { HealthStore } from "../state/stores/health-store.ts";
@@ -415,6 +416,27 @@ function runEffectivenessLines(
 	);
 }
 
+// I5 (plan): surface scratchpad adoption in the run summary — but ONLY when
+// non-zero, so the 3 armed roles that never call it add no noise. Counts the
+// metric events the workers appended to the run events log (fire-and-forget
+// scratchpad.cell / scratchpad.restored). Silent when the feature is unused or
+// the events path is missing (no throw).
+function scratchpadSummaryLines(manifest: TeamRunManifest): string[] {
+	if (!manifest.eventsPath) return [];
+	const events = readEvents(manifest.eventsPath);
+	const cells = events.filter((e) => e.type === "scratchpad.cell");
+	const restores = events.filter((e) => e.type === "scratchpad.restored");
+	if (cells.length === 0 && restores.length === 0) return [];
+	return [
+		`## Scratchpad (RLM adoption) — I5 metric`,
+		`- cells executed: ${cells.length}`,
+		`- snapshot restores: ${restores.length}`,
+		...(cells.length > 0
+			? [`- total cell time: ${Math.round(cells.reduce((s, e) => s + ((e.data?.durationMs as number) ?? 0), 0))} ms`]
+			: []),
+	];
+}
+
 // P6 (perf): Cache the last-rendered progress content so we can skip the
 // artifact write + redaction + atomic write + size/hash read when nothing
 // material changed (rare between batches, but happens between idle heartbeats).
@@ -964,8 +986,22 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 			);
 			manifest = updateRunStatus(manifest, "failed", `Unhandled error in team runner: ${message}`);
 			await saveRunManifestAsync(manifest);
-		} catch {
-			// Best-effort — state write may also fail
+		} catch (error) {
+			// H8 (2026-08-10): surface the silent failure. This is the
+			// unhandled-error recovery branch — if the state save ALSO fails
+			// (disk full, run-dir gone, permissions), the manifest stays in
+			// its pre-failure state (possibly still "running") and crash
+			// recovery will treat it as stale. Previously the failure was
+			// swallowed with no signal; now it lands in the internal-error
+			// channel so operators can see when recovery itself failed.
+			// We do NOT re-throw — the run must still be reported as failed
+			// to the caller (rejectRunPromise below) regardless of state-save
+			// outcome.
+			logInternalError(
+				"team-runner.recovery-save-failed",
+				error instanceof Error ? error : new Error(String(error)),
+				`runId=${manifest.runId} — state may be inconsistent; crash-recovery will reconcile on next launch`,
+			);
 		}
 		const result = { manifest, tasks };
 		rejectRunPromise(manifest.runId, error instanceof Error ? error : new Error(message));
@@ -2260,6 +2296,7 @@ async function finalizeRun(ctx: SchedulerContext): Promise<{ manifest: TeamRunMa
 			"## Policy decisions",
 			...(manifest.policyDecisions?.length ? summarizePolicyDecisions(manifest.policyDecisions) : ["- (none)"]),
 			"",
+			...scratchpadSummaryLines(manifest),
 		].join("\n"),
 	});
 	// Build the complete manifest BEFORE acquiring the lock so the artifacts array

package/src/state/contracts.ts

@@ -114,6 +114,9 @@ export const TEAM_EVENT_TYPES = [
 	"dwf.failed",
 	"dwf.trust_denied", // F-01: project .dwf.ts denied without PI_CREW_TRUST_PROJECT_DWF
 	"dwf.log",
+	// RLM/scratchpad adoption metrics (plan I5)
+	"scratchpad.cell",
+	"scratchpad.restored",
 ] as const;
 export type TeamEventType = (typeof TEAM_EVENT_TYPES)[number];