pi-crew 0.9.56 → 0.9.57

package/src/ui/widget/widget-model.ts

@@ -5,12 +5,12 @@
  */
 
 import { listRecentRuns } from "../../extension/run-index.ts";
-import { reconcileAllStaleRuns } from "../../runtime/crash-recovery.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
-import { evictStaleLiveAgentHandles } from "../../runtime/live-agent-manager.ts";
+import { evictStaleLiveAgentHandles } from "../../runtime/live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../../runtime/manifest-cache.ts";
 import { isDisplayActiveRun } from "../../runtime/process-status.ts";
+import { reconcileAllStaleRuns } from "../../runtime/recovery/crash-recovery.ts";
 import type { TeamRunManifest } from "../../state/types.ts";
 import type { RunSnapshotCache } from "../snapshot-types.ts";
 import type { WidgetRun } from "./widget-types.ts";

package/src/ui/widget/widget-renderer.ts

@@ -4,7 +4,7 @@
  * Extracted from crew-widget.ts.
  */
 
-import { listLiveAgents } from "../../runtime/live-agent-manager.ts";
+import { listLiveAgents } from "../../runtime/live-session/live-agent-manager.ts";
 import { isFinishedRunStatus } from "../../runtime/process-status.ts";
 import { truncate } from "../../utils/visual.ts";
 import { Box, Text } from "../layout-primitives.ts";

package/src/utils/conflict-detect.ts

@@ -341,11 +341,20 @@ export function parseConflictUri(raw: string): ParsedConflictUri | null {
  * Works by locating the recorded marker block by content (anchored to
  * `entry.startLine` as the preferred match), so out-of-band edits earlier
  * in the file that shift line numbers don't break resolution.
+ *
+ * EOL preservation: lines are split keeping each line's original ending
+ * bytes (CRLF / LF / none). Only the conflicting region is rewritten; every
+ * other line is round-tripped byte-for-byte, so a mixed-EOL file produces a
+ * minimal git diff (previously every line ending was normalised, rewriting
+ * the whole file even when only a few lines conflicted).
  */
 export function spliceConflict(originalText: string, entry: ConflictEntry, replacement: string): string {
-	// Preserve the original line ending (CRLF or LF) for a byte-accurate round-trip.
-	const eol = originalText.includes("\r\n") ? "\r\n" : "\n";
-	const lines = originalText.split(/\r?\n/);
+	// Split preserving each line's original EOL so non-conflicting lines are
+	// round-tripped byte-for-byte (minimal git diff on mixed-EOL files).
+	const segments = splitPreservingEol(originalText);
+	// Content-only view (CR stripped) — identical to the old `split(/\r?\n/)`,
+	// so conflict detection / region matching behaviour is unchanged.
+	const lines = segments.map((s) => s.content);
 	const expected = buildRecordedRegion(entry);
 	const match = locateRegion(lines, expected, entry.startLine - 1);
 	if (!match) {
@@ -356,8 +365,52 @@ export function spliceConflict(originalText: string, entry: ConflictEntry, repla
 
 	const trimmed = normalizeTrailingNewline(replacement);
 	const replacementLines = trimmed.split("\n");
-	const next = [...lines.slice(0, match.startIdx), ...replacementLines, ...lines.slice(match.endIdx + 1)];
-	return next.join(eol);
+	// EOL for the inserted lines: prefer the EOL that originally terminated the
+	// conflict region (local style); fall back to the file's dominant EOL.
+	const regionEol = segments[match.endIdx]?.eol ?? "";
+	const interEol = regionEol || (originalText.includes("\r\n") ? "\r\n" : "\n");
+
+	const out: string[] = [];
+	// Lines before the conflict — verbatim (original content + original EOL).
+	for (let i = 0; i < match.startIdx; i++) out.push(segments[i].content, segments[i].eol);
+	// Replacement lines — intermediate ones use the local EOL; the final one
+	// reuses the boundary EOL that originally separated the region from the
+	// following line, preserving that line's leading boundary exactly.
+	for (let i = 0; i < replacementLines.length; i++) {
+		out.push(replacementLines[i]);
+		out.push(i < replacementLines.length - 1 ? interEol : regionEol);
+	}
+	// Lines after the conflict — verbatim.
+	for (let i = match.endIdx + 1; i < segments.length; i++) out.push(segments[i].content, segments[i].eol);
+	return out.join("");
+}
+
+/**
+ * Split `text` into `{ content, eol }` segments keeping each line's exact
+ * ending bytes. The `content` view equals `text.split(/\r?\n/)`, but the
+ * original EOL (`"\r\n"`, `"\n"`, or `""` for the final line) is retained
+ * so callers can reconstruct the text byte-for-byte.
+ */
+function splitPreservingEol(text: string): { content: string; eol: string }[] {
+	const segments: { content: string; eol: string }[] = [];
+	const n = text.length;
+	let i = 0;
+	while (i <= n) {
+		const nl = text.indexOf("\n", i);
+		if (nl === -1) {
+			segments.push({ content: text.slice(i), eol: "" });
+			break;
+		}
+		let contentEnd = nl;
+		let eol = "\n";
+		if (nl > 0 && text.charCodeAt(nl - 1) === 13 /* \r */) {
+			contentEnd = nl - 1;
+			eol = "\r\n";
+		}
+		segments.push({ content: text.slice(i, contentEnd), eol });
+		i = nl + 1;
+	}
+	return segments;
 }
 
 /** Reconstruct the recorded marker block as it should appear in the file. */

package/src/utils/ndjson.ts

@@ -2,7 +2,7 @@
  * ndjson.ts — Canonical broker NDJSON framing primitives (encoder + decoder
  *              + typed errors). Newline-delimited JSON, one frame per `\\n`.
  *
- * Moved out of the parallel-work stub `src/runtime/crew-broker-deps.ts`.
+ * Moved out of the parallel-work stub `src/runtime/broker/crew-broker-deps.ts`.
  * The public surface (MAX_BROKER_FRAME_BYTES, BrokerError, BrokerErrorCode,
  * encodeBrokerFrame, NdjsonDecoder) is preserved verbatim so importers
  * can be updated with a single import-path change.
@@ -112,4 +112,4 @@ export class NdjsonDecoder {
 // External re-exports
 // ============================================================================
 // Re-exported here for callers that import all broker primitives from ndjson.ts.
-export { newBrokerToken } from "../runtime/crew-broker-tokens.ts";
+export { newBrokerToken } from "../runtime/broker/crew-broker-tokens.ts";

package/src/utils/socket-path.ts

@@ -1,7 +1,7 @@
 /**
  * socket-path.ts — Canonical broker Unix-socket / named-pipe path utilities.
  *
- * Moved out of the parallel-work stub `src/runtime/crew-broker-deps.ts`.
+ * Moved out of the parallel-work stub `src/runtime/broker/crew-broker-deps.ts`.
  * The public surface (hashSessionId, getBrokerSocketPath,
  * prepareBrokerSocketDir, removeStaleBrokerSocket) is preserved verbatim
  * so importers can be updated with a single import-path change.

package/src/workflows/workflow-config.ts

@@ -63,7 +63,7 @@ export interface WorkflowConfig {
 	 *  multiple ready tasks sharing role + cwd are grouped into a single
 	 *  multi-task worker prompt to reduce per-task cold-start cost. Disabled
 	 *  in v0.9.17 unless the workflow author opts in. See
-	 *  src/runtime/coalesce-tasks.ts. */
+	 *  src/runtime/scheduling/coalesce-tasks.ts. */
 	coalesceMicroTasks?: boolean;
 }
 

package/src/worktree/cleanup.ts

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
+import { writeArtifact } from "../state/stores/artifact-store.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";

package/src/worktree/worktree-manager.ts

@@ -5,7 +5,7 @@ import * as path from "node:path";
 import { promisify } from "node:util";
 import { loadConfig } from "../config/config.ts";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
+import { writeArtifact } from "../state/stores/artifact-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
@@ -583,7 +583,7 @@ export function overlaySeedPaths(repoRoot: string, worktreePath: string, seedPat
  * recovered via `git apply` / manual restore. Best-effort: a snapshot failure
  * only logs (it must not block the clean-slate reuse flow).
  */
-function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, worktreePath: string, dirtyStatus: string): boolean {
+export function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, worktreePath: string, dirtyStatus: string): boolean {
 	try {
 		const parts: string[] = [
 			`# Worktree recovery snapshot`,
@@ -591,15 +591,18 @@ function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, w
 			`capturedAt: ${new Date().toISOString()}`,
 			"",
 		];
+		// ST-1: use --binary so tracked binary modifications are recoverable via `git apply`.
 		let trackedDiff = "";
 		try {
-			trackedDiff = git(worktreePath, ["diff", "HEAD"]);
+			trackedDiff = git(worktreePath, ["diff", "HEAD", "--binary"]);
 		} catch {
 			trackedDiff = "";
 		}
 		if (trackedDiff.trim()) {
-			parts.push("## Tracked changes (`git diff HEAD`)", "```diff", trackedDiff, "```", "");
+			parts.push("## Tracked changes (`git diff HEAD --binary`)", "```diff", trackedDiff, "```", "");
 		}
+		// ST-1: per-file byte cap — skip/truncate larger files with a note to avoid OOM.
+		const MAX_FILE_BYTES = 256 * 1024;
 		for (const line of dirtyStatus.split("\n")) {
 			if (!line.startsWith("?? ")) continue;
 			// Strip the "?? " prefix and surrounding git quotes.
@@ -608,8 +611,27 @@ function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, w
 			try {
 				const abs = path.join(worktreePath, rel);
 				if (!fs.existsSync(abs) || fs.statSync(abs).isDirectory()) continue;
-				const content = fs.readFileSync(abs, "utf-8");
-				parts.push(`## Untracked file: ${rel}`, "```", content, "```", "");
+				// ST-1: read raw bytes (not utf-8) so binary files are not corrupted.
+				const buf = fs.readFileSync(abs);
+				const originalSize = buf.byteLength;
+				let data: Buffer = buf;
+				let note = "";
+				if (originalSize > MAX_FILE_BYTES) {
+					data = buf.subarray(0, MAX_FILE_BYTES);
+					note = ` (truncated: ${originalSize} → ${MAX_FILE_BYTES} bytes)`;
+				}
+				// ST-1: detect non-UTF-8 via fatal TextDecoder; base64-encode binary files.
+				let isUtf8 = true;
+				try {
+					new TextDecoder("utf-8", { fatal: true }).decode(data);
+				} catch {
+					isUtf8 = false;
+				}
+				if (isUtf8) {
+					parts.push(`## Untracked file: ${rel}${note}`, "```", data.toString("utf-8"), "```", "");
+				} else {
+					parts.push(`## Untracked file: ${rel}${note} (base64-encoded binary)`, "```base64", data.toString("base64"), "```", "");
+				}
 			} catch {
 				/* skip unreadable/unstat-able entry */
 			}
@@ -744,8 +766,8 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		if (currentBranch !== branch) {
 			throw new Error(`Existing worktree branch mismatch at ${worktreePath}: expected '${branch}', got '${currentBranch}'.`);
 		}
-		// Check for uncommitted changes from previous run before reusing
-		const dirtyStatus = git(worktreePath, ["status", "--porcelain"]);
+		// ST-1: use -uall so untracked directories are expanded to individual files.
+		const dirtyStatus = git(worktreePath, ["status", "--porcelain", "-uall"]);
 		if (dirtyStatus.trim()) {
 			// Snapshot uncommitted work to a recovery artifact BEFORE discarding, so the
 			// previous run's changes are never silently destroyed on reuse.
@@ -904,7 +926,8 @@ export async function prepareTaskWorkspaceAsync(
 		if (currentBranch !== branch) {
 			throw new Error(`Existing worktree branch mismatch at ${worktreePath}: expected '${branch}', got '${currentBranch}'.`);
 		}
-		const dirtyStatus = await gitAsync(worktreePath, ["status", "--porcelain"]);
+		// ST-1: use -uall so untracked directories are expanded to individual files.
+		const dirtyStatus = await gitAsync(worktreePath, ["status", "--porcelain", "-uall"]);
 		if (dirtyStatus.trim()) {
 			const snapshotOk = snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
 			if (snapshotOk) {
@@ -1060,52 +1083,78 @@ export async function captureWorktreeDiffAsync(worktreePath: string): Promise<st
  * assertCleanLeader, pruneStaleWorktrees, sanitizeBranchPart,
  * linkNodeModulesIfPresent) but with a minimal, task-free signature.
  *
- * Returns `undefined` when worktree creation is unavailable (no git repo, dirty
- * leader, git error) so the caller (`ctx.agent`) can fall back gracefully.
+ * Returns `undefined` when worktree isolation is genuinely unavailable (no git
+ * repo, dirty leader) so the caller (`ctx.agent`) can fall back gracefully.
+ * ST-15: when creation was attempted but failed (e.g. disk full), this THROWS
+ * instead of returning undefined so the caller never silently runs in the
+ * leader repo. The branch + path suffix is non-deterministic so a 2nd call for
+ * the same agentId always produces a distinct worktree.
  */
 export function prepareAgentWorktree(manifest: TeamRunManifest, agentId: string): PreparedTaskWorkspace | undefined {
+	// ST-15: Split preconditions from worktree creation.
+	// Precondition failures (no git repo, dirty leader) → return undefined so the
+	// caller falls back gracefully (worktree isolation is genuinely unavailable).
+	let repoRoot: string;
+	let loadedConfig: ReturnType<typeof loadConfig>;
 	try {
-		const repoRoot = findGitRoot(manifest.cwd);
-		const loadedConfig = loadConfig(manifest.cwd);
+		repoRoot = findGitRoot(manifest.cwd);
+		loadedConfig = loadConfig(manifest.cwd);
 		if (loadedConfig.config.requireCleanWorktreeLeader !== false) assertCleanLeader(repoRoot);
-		const sanitizedRunId = manifest.runId.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "run";
-		const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, sanitizedRunId);
-		fs.mkdirSync(worktreeRoot, { recursive: true });
-		const sanitizedAgentId = sanitizeBranchPart(agentId);
-		const worktreePath = path.join(worktreeRoot, sanitizedAgentId);
-		const branch = `pi-crew/${sanitizedRunId}/${sanitizedAgentId}`;
-		pruneStaleWorktrees(repoRoot);
-		git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
-		const nodeModulesLinked =
-			loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
-		return { cwd: worktreePath, worktreePath, branch, nodeModulesLinked };
 	} catch {
-		// Graceful fallback: no git repo, dirty leader, or git error → run normally.
+		// Graceful fallback: no git repo or dirty leader → run normally in cwd.
 		return undefined;
 	}
+
+	// ST-15: NON-DETERMINISTIC branch + path suffix. The OLD deterministic name
+	// (`pi-crew/<runId>/<agentId>`) made a 2nd call for the same agent collide
+	// ("already exists") → catch → returned undefined → the run silently fell
+	// back to the leader repo (isolation lost, no error). The timestamp +
+	// short-uuid suffix makes every call produce a distinct worktree.
+	// Creation failures here THROW (not undefined) so callers never silently lose
+	// isolation when worktree creation was requested but failed.
+	const sanitizedRunId = manifest.runId.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "run";
+	const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, sanitizedRunId);
+	fs.mkdirSync(worktreeRoot, { recursive: true });
+	const sanitizedAgentId = sanitizeBranchPart(agentId);
+	const stamp = `${Date.now()}-${randomBytes(4).toString("hex")}`;
+	const worktreePath = path.join(worktreeRoot, `${sanitizedAgentId}-${stamp}`);
+	const branch = `pi-crew/${sanitizedRunId}/${sanitizedAgentId}-${stamp}`;
+	pruneStaleWorktrees(repoRoot);
+	git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+	const nodeModulesLinked =
+		loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
+	return { cwd: worktreePath, worktreePath, branch, nodeModulesLinked };
 }
 
 /** Async version of prepareAgentWorktree — yields the event loop during git operations. */
 export async function prepareAgentWorktreeAsync(manifest: TeamRunManifest, agentId: string): Promise<PreparedTaskWorkspace | undefined> {
+	// ST-15: Split preconditions from worktree creation (see prepareAgentWorktree).
+	let repoRoot: string;
+	let loadedConfig: ReturnType<typeof loadConfig>;
 	try {
-		const repoRoot = await findGitRootAsync(manifest.cwd);
-		const loadedConfig = loadConfig(manifest.cwd);
+		repoRoot = await findGitRootAsync(manifest.cwd);
+		loadedConfig = loadConfig(manifest.cwd);
 		if (loadedConfig.config.requireCleanWorktreeLeader !== false) await assertCleanLeaderAsync(repoRoot);
-		const sanitizedRunId = manifest.runId.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "run";
-		const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, sanitizedRunId);
-		fs.mkdirSync(worktreeRoot, { recursive: true });
-		const sanitizedAgentId = sanitizeBranchPart(agentId);
-		const worktreePath = path.join(worktreeRoot, sanitizedAgentId);
-		const branch = `pi-crew/${sanitizedRunId}/${sanitizedAgentId}`;
-		await pruneStaleWorktreesAsync(repoRoot);
-		await gitAsync(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
-		const nodeModulesLinked =
-			loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
-		return { cwd: worktreePath, worktreePath, branch, nodeModulesLinked };
 	} catch {
-		// Graceful fallback: no git repo, dirty leader, or git error → run normally.
+		// Graceful fallback: no git repo or dirty leader → run normally in cwd.
 		return undefined;
 	}
+
+	// ST-15: NON-DETERMINISTIC branch + path suffix — a 2nd call for the same
+	// agentId creates a DISTINCT worktree instead of colliding. Creation failures
+	// here THROW so callers never silently fall back to the leader repo.
+	const sanitizedRunId = manifest.runId.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "run";
+	const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, sanitizedRunId);
+	fs.mkdirSync(worktreeRoot, { recursive: true });
+	const sanitizedAgentId = sanitizeBranchPart(agentId);
+	const stamp = `${Date.now()}-${randomBytes(4).toString("hex")}`;
+	const worktreePath = path.join(worktreeRoot, `${sanitizedAgentId}-${stamp}`);
+	const branch = `pi-crew/${sanitizedRunId}/${sanitizedAgentId}-${stamp}`;
+	await pruneStaleWorktreesAsync(repoRoot);
+	await gitAsync(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+	const nodeModulesLinked =
+		loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
+	return { cwd: worktreePath, worktreePath, branch, nodeModulesLinked };
 }
 
 /**

package/workflows/chain.workflow.md

@@ -6,7 +6,7 @@ topology: dynamic
 
 # Chain Workflow - Sequential execution with context passing
 
-**Source:** `docs/pi-boomerang-integration-plan.md`  
+**Source:** pi-boomerang integration plan  
 **Syntax:** `step1 -> step2 -> step3`  
 **Version:** 1.0.0
 
@@ -255,4 +255,4 @@ pi team run --chain "@step1 -> @step2" --continue-on-error
 
 ---
 
-*Generated from pi-boomerang integration plan. See `docs/pi-boomerang-integration-plan.md` for full specification.*
+*Generated from pi-boomerang integration plan.*

package/index.bundle.ts

@@ -1,25 +0,0 @@
-/**
- * Bundle entry point — NO shell logic.
- *
- * Bundled by `scripts/build-bundle.mjs` into `dist/index.mjs`. Keep this
- * file minimal — the bundle should NOT try to recursively load itself
- * or do path resolution. The shell (load-with-fallback) lives in
- * `index.ts`; this file just re-exports the inner extension API so the
- * bundle is a single self-contained module the shell can `import()`.
- *
- * Why a separate file from `index.ts`:
- *   - `index.ts` runs at the package root and resolves `dist/index.mjs`
- *     relative to its own location.
- *   - If the bundle were built FROM `index.ts`, the bundled code would
- *     resolve `dist/index.mjs` relative to ITS OWN location (inside
- *     `dist/`), producing `dist/dist/index.mjs` and a recursion error.
- *   - Building from `index.bundle.ts` (which has no shell) sidesteps
- *     this chicken-and-egg entirely.
- */
-import { registerPiTeams } from "./src/extension/register.ts";
-import { waitForRun } from "./src/runtime/run-tracker.ts";
-
-export { waitForRun, registerPiTeams };
-export default function (pi: Parameters<typeof registerPiTeams>[0]): void {
-	registerPiTeams(pi);
-}

package/scripts/bench-check.mjs

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-/**
- * Compare test/bench/results.json against test/bench/baseline.json.
- *
- * Fails if any p95 metric regresses by more than the allowed threshold.
- *
- * Usage:
- *   npm run bench:check                      # default 15% threshold
- *   THRESHOLD_PCT=10 npm run bench:check     # tighter
- *   BASELINE=test/bench/baseline.json npm run bench:check
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-const root = path.resolve(import.meta.dirname, "..");
-const benchDir = path.join(root, "test", "bench");
-const resultsPath = path.join(benchDir, "results.json");
-const baselinePath = process.env.BASELINE ? path.resolve(process.env.BASELINE) : path.join(benchDir, "baseline.json");
-const threshold = Number(process.env.THRESHOLD_PCT ?? 15) / 100;
-
-if (!fs.existsSync(resultsPath)) {
-	console.error(`[bench:check] missing ${resultsPath}; run \`npm run bench\` first.`);
-	process.exit(2);
-}
-if (!fs.existsSync(baselinePath)) {
-	console.error(`[bench:check] missing baseline ${baselinePath}.`);
-	console.error("              Capture baseline with: npm run bench && cp test/bench/results.json test/bench/baseline.json");
-	process.exit(2);
-}
-
-const results = JSON.parse(fs.readFileSync(resultsPath, "utf-8"));
-const baseline = JSON.parse(fs.readFileSync(baselinePath, "utf-8"));
-
-/**
- * Walk each bench's nested numeric metrics and pair with baseline.
- * Reports any p95 metric where current > baseline * (1 + threshold).
- */
-const regressions = [];
-const improvements = [];
-for (const [benchName, current] of Object.entries(results.results)) {
-	const base = baseline.results?.[benchName];
-	if (!base) {
-		console.log(`[bench:check] no baseline for ${benchName} — skipping`);
-		continue;
-	}
-	for (const metric of metricKeys(current)) {
-		const cur = readPath(current, metric);
-		const ref = readPath(base, metric);
-		if (typeof cur !== "number" || typeof ref !== "number" || ref === 0) continue;
-		// Sub-ms metrics are dominated by GC / OS jitter — applying a strict
-		// percentage gate causes false positives. Use absolute delta cap instead.
-		if (ref < 1.0) {
-			const absDelta = cur - ref;
-			if (absDelta > 0.5) regressions.push({ bench: benchName, metric: metric.join("."), baseline: ref, current: cur, deltaPct: round(((cur - ref) / ref) * 100), reason: "abs > 0.5ms" });
-			else if (absDelta < -0.05) improvements.push({ bench: benchName, metric: metric.join("."), baseline: ref, current: cur, deltaPct: round(((cur - ref) / ref) * 100) });
-			continue;
-		}
-		const delta = (cur - ref) / ref;
-		if (delta > threshold) regressions.push({ bench: benchName, metric: metric.join("."), baseline: ref, current: cur, deltaPct: round(delta * 100) });
-		else if (delta < -0.05) improvements.push({ bench: benchName, metric: metric.join("."), baseline: ref, current: cur, deltaPct: round(delta * 100) });
-	}
-}
-
-if (improvements.length) {
-	console.log("[bench:check] improvements:");
-	for (const item of improvements) console.log(`  ${item.bench}.${item.metric}: ${item.baseline} → ${item.current} (${item.deltaPct}%)`);
-}
-if (regressions.length) {
-	console.error(`[bench:check] regressions (>${(threshold * 100).toFixed(0)}%):`);
-	for (const item of regressions) console.error(`  ${item.bench}.${item.metric}: ${item.baseline} → ${item.current} (+${item.deltaPct}%)`);
-	process.exit(1);
-}
-console.log(`[bench:check] all benches within ${(threshold * 100).toFixed(0)}% of baseline.`);
-
-function metricKeys(obj, prefix = []) {
-	const skip = new Set(["name", "unit", "iters", "tasks", "events", "eventsPerIter"]);
-	const keys = [];
-	for (const [k, v] of Object.entries(obj)) {
-		if (skip.has(k)) continue;
-		if (k === "p50" || k === "p95" || k === "p99" || k === "min" || k === "max") {
-			// We only gate on p95; min/max printed but not enforced.
-			if (k === "p95") keys.push([...prefix, k]);
-			continue;
-		}
-		if (v && typeof v === "object" && !Array.isArray(v)) keys.push(...metricKeys(v, [...prefix, k]));
-	}
-	return keys;
-}
-
-function readPath(obj, parts) {
-	let cur = obj;
-	for (const p of parts) cur = cur?.[p];
-	return cur;
-}
-
-function round(n) { return Math.round(n * 100) / 100; }