@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitchmultz/pi-subagents",
-  "version": "0.44.7",
+  "version": "0.46.0",
   "description": "Pi extension for subagent orchestration and local session coordination",
   "license": "MIT",
   "type": "module",
@@ -26,12 +26,16 @@
   "files": [
     "dist",
     "src/**/*.ts",
+    "generated",
     "tsconfig.build.json",
     "tsconfig.json",
     "scripts/",
     "agents/",
     "skills/**/*",
     "prompts/**/*",
+    "docs/reference.md",
+    "docs/development.md",
+    "docs/code-quality.md",
     "docs/intercom.md",
     "docs/intercom-bridge.md",
     "docs/performance.md",
@@ -46,10 +50,16 @@
     "test:integration": "node scripts/run-tests.mjs integration",
     "test:all": "node scripts/run-tests.mjs all",
     "check:compat": "node scripts/check-compat.mjs",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "node node_modules/typescript/bin/tsc --noEmit",
     "smoke:package": "node scripts/package-smoke.mjs",
     "smoke:install": "node scripts/local-install-smoke.mjs",
-    "ci": "npm run typecheck && npm run smoke:package && npm run smoke:install && npm run test:all",
+    "generate:schemas": "patch-package --patch-dir patches/npm --error-on-fail && node scripts/generate-run-schemas.mjs",
+    "check:schemas": "patch-package --patch-dir patches/npm --error-on-fail && node scripts/generate-run-schemas.mjs --check",
+    "lint": "oxlint --type-aware .",
+    "lint:fix": "oxlint --type-aware --fix .",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "ci": "npm run lint && npm run format:check && npm run typecheck && npm run smoke:package && npm run smoke:install && npm run test:all",
     "smoke:real-pi": "node scripts/real-pi-smoke.mjs"
   },
   "pi": {
@@ -91,14 +101,25 @@
     "@earendil-works/pi-coding-agent": "1.0.0",
     "@earendil-works/pi-tui": "1.0.0",
     "@types/node": "24.19.1",
+    "@types/sinon": "22.0.0",
+    "ajv": "8.20.0",
+    "oxfmt": "0.72.0",
+    "oxlint": "1.87.0",
+    "oxlint-tsgolint": "7.0.2003",
+    "patch-package": "8.0.1",
+    "sinon": "22.1.0",
     "typebox": "1.3.34",
-    "typescript": "7.0.2"
+    "typescript": "7.0.2",
+    "typescript-json-schema": "0.68.0"
+  },
+  "publishConfig": {
+    "access": "public"
   },
-  "publishConfig": { "access": "public" },
   "engines": {
     "node": ">=24.21.0"
   },
   "dependencies": {
-    "stream-json": "3.7.0"
+    "stream-json": "3.7.0",
+    "type-fest": "5.10.0"
   }
 }

package/prompts/parallel-cleanup.md

@@ -14,6 +14,7 @@ Do not write reviewer output files into the repository unless I explicitly ask f
 Reviewer 1: deslop pass.
 
 If the `deslop` skill is available, pass it to this reviewer. If not, inline the guidance below. Ask this reviewer to look for AI-slop patterns in the changed scope:
+
 - comments that restate code, placeholder text, stale rationale, or debug leftovers;
 - defensive checks that hide useful errors, return vague defaults, or validate trusted internal data after a real boundary was already crossed;
 - type escapes, broad casts, duplicated type definitions, or object-bag typing where a local source-of-truth type exists;
@@ -27,6 +28,7 @@ Tell this reviewer to treat tool output and slop-scan-style findings as leads, n
 Reviewer 2: verbosity pass.
 
 If the `verbosity-cleaner` skill is available, pass it to this reviewer. If not, inline the guidance below. Ask this reviewer to look for needless verbosity in code, tests, docs, status text, grouped messages, receipts, and changelog wording:
+
 - single-use helpers that merely paraphrase an expression;
 - temporary variables that only name obvious expressions;
 - nested returns or branches that can become direct returns without hiding intent;
@@ -41,6 +43,7 @@ Tell this reviewer that shorter is only better when it is clearer and preserves
 Both reviewers are review-only. They must not edit files unless I explicitly ask for a writer pass. Their response should be review feedback, not a context summary. Ask them to return concise, evidence-backed findings with file/line references and suggested fixes.
 
 While reviewers run, do your own narrow inspection if useful. After they return, synthesize the feedback into:
+
 - fixes worth doing now;
 - optional improvements;
 - feedback to ignore or defer, with a short reason.

package/prompts/parallel-context-build.md

@@ -33,6 +33,7 @@ Choose two or three strong builders based on the request. Prefer three only when
    Identify likely failure modes, edge cases, test strategy, commands to run, dependency/API concerns, and escalation rules.
 
 Adapt the angles when the request calls for it:
+
 - Issue or PR URL: include issue requirements, acceptance criteria, linked discussion, and likely affected files.
 - Plan file: include plan consistency, missing context, implementation sequence, and validation readiness.
 - External API/library work: include current docs or primary sources through `web_search` when needed.
@@ -40,6 +41,7 @@ Adapt the angles when the request calls for it:
 - UI/product work: include user flow, accessibility, copy, visual constraints, and implementation touchpoints.
 
 Ask each builder to produce a compact handoff file with:
+
 - relevant files and line ranges;
 - key snippets or patterns, not full dumps;
 - constraints and invariants;
@@ -48,6 +50,7 @@ Ask each builder to produce a compact handoff file with:
 - a `meta-prompt` section for the next planner or role subagent.
 
 After the builders return, synthesize their outputs into:
+
 - the most important context the next agent needs;
 - the recommended meta-prompt to use next;
 - open questions or assumptions;

package/prompts/parallel-handoff-plan.md

@@ -21,6 +21,7 @@ Use the `subagent` tool in chain mode:
 2. Second step: a synthesis `context-builder` that reads the parallel findings and writes the final handoff plan and meta-prompt.
 
 Use distinct output paths, `label` values, and `as` names under the chain directory. Example outputs:
+
 - `handoff/external-reference.md`
 - `handoff/local-context.md`
 - `handoff/implementation-strategy.md`
@@ -33,27 +34,32 @@ Do not write these artifacts into the repository unless I explicitly ask for per
 Role guidance:
 
 External reference researcher:
+
 - Study linked projects, docs, issues, examples, source code, or prompt guidance.
 - Identify the behavior, API, implementation files, constraints, and transferable ideas.
 - Conduct web research if needed. Use `web_search` if it is available; otherwise use whatever equivalent research capability is available.
 - Return source links, repo paths, key evidence, risks, and what matters for this implementation.
 
 Local context-builder:
+
 - Read all files needed to fully understand the local issue, not just the first match.
 - Follow imports, callers, tests, fixtures, configuration, docs, and adjacent patterns until the local problem, solution space, and validation path are clear.
 - Return relevant file paths and line ranges, current architecture, constraints, tests, risks, and open questions.
 
 Implementation-strategy context-builder, when used:
+
 - Compare the external evidence against the local architecture.
 - Propose the safest implementation shape, files likely to change, edge cases, validation commands, and decisions that need approval.
 - Stay review/planning-only unless I explicitly ask for implementation.
 
 Final synthesis context-builder:
+
 - Read the parallel outputs and produce one concise handoff plan.
 - Include what the feature/change should do, what the external reference teaches, what the local codebase implies, the recommended approach, likely files to change, constraints, non-goals, validation, risks, and unresolved questions.
 - End with a compact implementation-ready meta-prompt for the next worker/planner.
 
 After the chain returns, synthesize the result for me with:
+
 - the recommended approach;
 - artifact paths;
 - the final meta-prompt;

package/prompts/parallel-research.md

@@ -8,6 +8,7 @@ Launch parallel research subagents to build a grounded answer to the current que
 Use fresh context, not forked context, unless I explicitly ask for forked context. Researchers and scouts should inspect sources directly instead of relying on the main conversation history.
 
 Use a combination of `researcher` and `scout` subagents:
+
 - Use `researcher` for web, docs, standards, ecosystem, recent changes, benchmarks, and primary-source evidence.
 - Use `scout` for local codebase context, existing implementation patterns, repo constraints, and files that would be affected.
 
@@ -23,6 +24,7 @@ Give each subagent a distinct angle. Unless I specify angles, use these three:
    Use `researcher` or `scout`, whichever fits the question, to compare options, risks, edge cases, maintenance cost, and what would be easiest to validate.
 
 Adapt the angles when the question calls for it:
+
 - Library/API questions: include official docs and recent examples.
 - Architecture decisions: include local module boundaries, dependency direction, and migration cost.
 - Debugging questions: include likely failure modes, local call paths, and exact error evidence.
@@ -32,6 +34,7 @@ Adapt the angles when the question calls for it:
 Prefer two or three strong subagents over many vague ones. The parent agent should frame the question and assign angles; the child agents should research or scout, not invent broad plans.
 
 Ask each subagent to return concise findings with evidence:
+
 - file paths and line ranges for local findings
 - source links for external findings
 - confidence level and gaps
@@ -40,6 +43,7 @@ Ask each subagent to return concise findings with evidence:
 Do not ask subagents to edit files. This is a research pass only unless I explicitly ask for implementation.
 
 After the subagents return, synthesize the answer into:
+
 - what we know
 - what the local codebase implies
 - tradeoffs and risks

package/prompts/parallel-review.md

@@ -25,6 +25,7 @@ These are examples, not fixed defaults:
    Check for unnecessary complexity, duplicate structure, single-use wrappers, brittle abstractions, confusing names, verbosity, and cleanup that is clearly worth doing.
 
 Choose or adapt angles when the work calls for it:
+
 - TypeScript-heavy changes: include type safety, source-of-truth types, casts, and error-boundary discipline.
 - UI-heavy changes: include UX, accessibility, copy, and visual quality.
 - Security-sensitive changes: include unsafe input/output handling, auth boundaries, privacy, and data exposure.
@@ -36,6 +37,7 @@ Prefer three strong reviewers over many vague reviewers.
 Give every reviewer a specific task prompt naming its angle. Ask reviewers to return concise, evidence-backed findings with file/line references and suggested fixes. The response should be review feedback, not a context summary. Reviewers must not edit files unless I explicitly ask for a writer pass.
 
 While reviewers run, do your own narrow inspection if useful. After they return, synthesize the feedback into:
+
 - fixes worth doing now
 - optional improvements
 - feedback to ignore or defer, with a short reason

package/prompts/review-loop.md

@@ -16,6 +16,7 @@ For each review round, launch fresh-context `reviewer` agents as separate async
 Choose review angles from the actual change. Common angles are correctness/regressions, tests/validation, and simplicity/maintainability. Add security, performance, docs/API contracts, or user-flow validation when the work calls for it. Prefer three strong reviewers over many vague reviewers.
 
 After reviewers return, synthesize their feedback into:
+
 - concrete blockers or decisions outside the existing authority;
 - fixes worth doing now;
 - optional improvements;
@@ -30,6 +31,7 @@ When there are fixes worth doing now and the workflow is implementation-authoriz
 After a fix worker returns, run another review round only when it made material changes or addressed non-trivial findings. Do not keep looping for optional polish, speculative improvements, or findings already deferred by the parent.
 
 Stop and summarize when one of these is true:
+
 - reviewers find no blockers or fixes worth doing now;
 - remaining feedback is optional, speculative, or intentionally deferred;
 - reviewers surface a concrete decision outside the existing authority that needs me;

package/scripts/build.mjs

@@ -24,111 +24,155 @@ const RENAME_RETRY_MS = 50;
 // Use the current Node binary without a shell, including install paths with spaces.
 const tscPath = process.argv[2] ?? join(process.cwd(), "node_modules", "typescript", "bin", "tsc");
 
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+  console.log(
+    "Usage: node scripts/build.mjs [compiler-path]\n\nCompile into PID-owned staging, stamp the package version/content hash, then publish dist.\nA failed compiler preserves existing dist. Concurrent publishers retain the winning tree.\nExample: npm run build\nExit codes: 0 published or concurrent winner retained; 1 compile/publish failed.",
+  );
+  process.exit(0);
+}
+
 async function discardStaging(path) {
-	try {
-		await rm(path, RM_OPTIONS);
-	} catch (error) {
-		// Cleanup is always best-effort: it must not turn a successful race loss
-		// into failure or replace the compiler/publish error that matters.
-		console.warn(`could not remove staging ${path}: ${error?.message ?? error}`);
-	}
+  try {
+    await rm(path, RM_OPTIONS);
+  } catch (error) {
+    // Cleanup is always best-effort: it must not turn a successful race loss
+    // into failure or replace the compiler/publish error that matters.
+    console.warn(`could not remove staging ${path}: ${error?.message ?? error}`);
+  }
 }
 
 function isOwnerGone(pid) {
-	try {
-		process.kill(pid, 0);
-		return false;
-	} catch (error) {
-		return error?.code === "ESRCH";
-	}
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (error) {
+    return error?.code === "ESRCH";
+  }
 }
 
 async function hasPublishedDist(path) {
-	try {
-		return (await readdir(path)).length > 0;
-	} catch {
-		return false;
-	}
+  try {
+    return (await readdir(path)).length > 0;
+  } catch {
+    return false;
+  }
 }
 
 async function reapStrandedStaging(cwd) {
-	// Signal 0 proves only that the owner was gone at probe time. Pid reuse
-	// between this probe and removal is inherent to pid-based reaping.
-	for (const entry of await readdir(cwd, { withFileTypes: true })) {
-		const match = /^dist\.staging\.(\d+)$/.exec(entry.name);
-		if (!match || !entry.isDirectory()) continue;
-		const ownerPid = Number(match[1]);
-		if (ownerPid === process.pid || !isOwnerGone(ownerPid)) continue;
-		await discardStaging(join(cwd, entry.name));
-	}
+  // Signal 0 proves only that the owner was gone at probe time. Pid reuse
+  // between this probe and removal is inherent to pid-based reaping.
+  for (const entry of await readdir(cwd, { withFileTypes: true })) {
+    const match = /^dist\.staging\.(\d+)$/.exec(entry.name);
+    if (!match || !entry.isDirectory()) {
+      continue;
+    }
+    const ownerPid = Number(match[1]);
+    if (ownerPid === process.pid || !isOwnerGone(ownerPid)) {
+      continue;
+    }
+    // Reap abandoned trees sequentially to bound filesystem removal pressure.
+    // oxlint-disable-next-line no-await-in-loop
+    await discardStaging(join(cwd, entry.name));
+  }
 }
 
 async function compileToStaging(cwd, stagingDir) {
-	try {
-		const { stderr, stdout } = await execFile(
-			process.execPath,
-			[tscPath, "-p", "tsconfig.build.json", "--outDir", stagingDir],
-			{ cwd, maxBuffer: 10 * 1024 * 1024 },
-		);
-		if (stdout) process.stdout.write(stdout);
-		if (stderr) process.stderr.write(stderr);
-		const stamp = "extension/build-info.js";
-		const hash = createHash("sha256");
-		for (const file of (await readdir(stagingDir, { recursive: true })).filter((file) => file.endsWith(".js") && file !== stamp).sort()) {
-			hash.update(file).update("\0").update(await readFile(join(stagingDir, file))).update("\0");
-		}
-		const { version } = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
-		await writeFile(join(stagingDir, stamp), `export const EXTENSION_BUILD = Object.freeze(${JSON.stringify({ version, sha256: hash.digest("hex") })});\n`);
-	} catch (error) {
-		if (error?.stdout) process.stdout.write(error.stdout);
-		if (error?.stderr) process.stderr.write(error.stderr);
-		await discardStaging(stagingDir);
-		throw error;
-	}
+  try {
+    const { stderr, stdout } = await execFile(
+      process.execPath,
+      [tscPath, "-p", "tsconfig.build.json", "--outDir", stagingDir],
+      { cwd, maxBuffer: 10 * 1024 * 1024 },
+    );
+    if (stdout) {
+      process.stdout.write(stdout);
+    }
+    if (stderr) {
+      process.stderr.write(stderr);
+    }
+    await stampBuild(cwd, stagingDir);
+  } catch (error) {
+    if (error?.stdout) {
+      process.stdout.write(error.stdout);
+    }
+    if (error?.stderr) {
+      process.stderr.write(error.stderr);
+    }
+    await discardStaging(stagingDir);
+    throw error;
+  }
+}
+
+async function stampBuild(cwd, stagingDir) {
+  const stamp = "extension/build-info.js";
+  const hash = createHash("sha256");
+  const files = (await readdir(stagingDir, { recursive: true }))
+    .filter((entry) => entry.endsWith(".js") && entry !== stamp)
+    .sort();
+  for (const file of files) {
+    // Hash sorted path/content pairs in order without buffering the whole emitted tree.
+    // oxlint-disable-next-line no-await-in-loop
+    const content = await readFile(join(stagingDir, file));
+    hash.update(file).update("\0").update(content).update("\0");
+  }
+  const { version } = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
+  await writeFile(
+    join(stagingDir, stamp),
+    `export const EXTENSION_BUILD = Object.freeze(${JSON.stringify({ version, sha256: hash.digest("hex") })});\n`,
+  );
+}
+
+async function tryPublish(stagingDir, distDir, retry) {
+  try {
+    await rename(stagingDir, distDir);
+    return true;
+  } catch (error) {
+    // A bare directory is not proof that a concurrent publisher finished.
+    if (await hasPublishedDist(distDir)) {
+      console.warn(
+        "dist/ was published by a concurrent build; discarding this build's staging tree.",
+      );
+      return true;
+    }
+    if (!existsSync(stagingDir) || retry >= RENAME_RETRY_LIMIT) {
+      throw error;
+    }
+    await delay(RENAME_RETRY_MS);
+    return false;
+  }
 }
 
 async function publishStaging(stagingDir, distDir) {
-	try {
-		// A failed dist removal must fail loudly; keep it outside the retry loop.
-		// Remove dist exactly once so retries never delete a concurrent winner.
-		await rm(distDir, RM_OPTIONS);
-		for (let retry = 0; ; retry++) {
-			try {
-				await rename(stagingDir, distDir);
-				return;
-			} catch (error) {
-				// A completed staged build is non-empty; a bare directory is not proof
-				// that a concurrent publisher won the race.
-				if (await hasPublishedDist(distDir)) {
-					console.warn("dist/ was published by a concurrent build; discarding this build's staging tree.");
-					return;
-				}
-				// At most 50 retries (~2.5s) keep persistent filesystem errors bounded.
-				if (existsSync(stagingDir) && retry < RENAME_RETRY_LIMIT) {
-					await delay(RENAME_RETRY_MS);
-					continue;
-				}
-				throw error;
-			}
-		}
-	} finally {
-		// Safe after success too: rename moved stagingDir, so force makes this a no-op.
-		await discardStaging(stagingDir);
-	}
+  try {
+    // A failed dist removal must fail loudly; keep it outside the retry loop.
+    // Remove dist exactly once so retries never delete a concurrent winner.
+    await rm(distDir, RM_OPTIONS);
+    for (let retry = 0; ; retry++) {
+      // Each retry must observe publication before another rename can race it.
+      // oxlint-disable-next-line no-await-in-loop
+      if (await tryPublish(stagingDir, distDir, retry)) {
+        return;
+      }
+    }
+  } finally {
+    // Safe after success too: rename moved stagingDir, so force makes this a no-op.
+    await discardStaging(stagingDir);
+  }
 }
 
 async function main() {
-	const cwd = process.cwd();
-	if (!existsSync(tscPath)) throw new Error(`typescript is not installed at ${tscPath}; run npm install first.`);
-	await reapStrandedStaging(cwd);
-	// Pid-scoped staging isolates concurrent emits; only a complete tree publishes.
-	const stagingDir = join(cwd, `dist.staging.${process.pid}`);
-	await rm(stagingDir, RM_OPTIONS);
-	await compileToStaging(cwd, stagingDir);
-	await publishStaging(stagingDir, join(cwd, "dist"));
+  const cwd = process.cwd();
+  if (!existsSync(tscPath)) {
+    throw new Error(`typescript is not installed at ${tscPath}; run npm install first.`);
+  }
+  await reapStrandedStaging(cwd);
+  // Pid-scoped staging isolates concurrent emits; only a complete tree publishes.
+  const stagingDir = join(cwd, `dist.staging.${process.pid}`);
+  await rm(stagingDir, RM_OPTIONS);
+  await compileToStaging(cwd, stagingDir);
+  await publishStaging(stagingDir, join(cwd, "dist"));
 }
 
 main().catch((error) => {
-	console.error(error instanceof Error ? error.message : String(error));
-	process.exitCode = 1;
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
 });

package/scripts/check-compat.mjs

@@ -6,18 +6,28 @@ import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 
 if (process.argv.includes("--help") || process.argv.includes("-h")) {
-  console.log("Usage: node scripts/check-compat.mjs\n\nRun selected-host full CI and native package checks with actual editor receipts.\nAn owned temporary editor checkout is removed after checks; supplied sources stay read-only.\nEnvironment: PI_EDITOR_RECEIPT_TEST_ROOT optionally supplies a clean frozen Git checkout.\nExamples:\n  npm run check:compat\n  PI_EDITOR_RECEIPT_TEST_ROOT=/path/to/pi-apply-edits npm run check:compat\nExit codes: 0 passed; 1 invalid input, unavailable source or failed checks.");
+  console.log(
+    "Usage: node scripts/check-compat.mjs\n\nRun selected-host full CI and native package checks with actual editor receipts.\nAn owned temporary editor checkout is removed after checks; supplied sources stay read-only.\nEnvironment: PI_EDITOR_RECEIPT_TEST_ROOT optionally supplies a clean frozen Git checkout.\nExamples:\n  npm run check:compat\n  PI_EDITOR_RECEIPT_TEST_ROOT=/path/to/pi-apply-edits npm run check:compat\nExit codes: 0 passed; 1 invalid input, unavailable source or failed checks.",
+  );
   process.exit(0);
 }
 assert.equal(process.argv.length, 2, "Expected no arguments; use --help");
 await import("./compat-host.mjs");
 const run = (command, args, options = {}) => {
-  const result = spawnSync(command, args, { stdio: "inherit", timeout: 1_200_000, ...options });
-  if (result.error) throw result.error;
-  assert.equal(result.status, 0, `${command} ${args.join(" ")} failed (${result.status ?? result.signal})`);
+  // Outlasts the 1_200_000 ms integration watchdog in scripts/run-tests.mjs.
+  const result = spawnSync(command, args, { stdio: "inherit", timeout: 1_500_000, ...options });
+  if (result.error) {
+    throw result.error;
+  }
+  assert.equal(
+    result.status,
+    0,
+    `${command} ${args.join(" ")} failed (${result.status ?? result.signal})`,
+  );
   return result.stdout?.trim();
 };
-const git = (cwd, args) => run("git", args, { cwd, stdio: ["ignore", "pipe", "inherit"], encoding: "utf8" });
+const git = (cwd, args) =>
+  run("git", args, { cwd, stdio: ["ignore", "pipe", "inherit"], encoding: "utf8" });
 const root = mkdtempSync(join(tmpdir(), "ps-editor-"));
 const editor = join(root, "source");
 try {
@@ -26,20 +36,47 @@ try {
   if (supplied) {
     const source = resolve(supplied);
     expectedRef = git(source, ["rev-parse", "HEAD"]);
-    assert.equal(git(source, ["status", "--porcelain", "--untracked-files=all"]), "", "Supplied editor source must be clean");
+    assert.equal(
+      git(source, ["status", "--porcelain", "--untracked-files=all"]),
+      "",
+      "Supplied editor source must be clean",
+    );
     run("git", ["clone", "--no-hardlinks", "--quiet", source, editor]);
     git(editor, ["checkout", "--quiet", "--detach", expectedRef]);
   } else {
-    run("git", ["clone", "--depth", "1", "--branch", "main", "--single-branch", "--quiet", "https://github.com/fitchmultz/pi-apply-edits.git", editor]);
+    run("git", [
+      "clone",
+      "--depth",
+      "1",
+      "--branch",
+      "main",
+      "--single-branch",
+      "--quiet",
+      "https://github.com/fitchmultz/pi-apply-edits.git",
+      editor,
+    ]);
   }
   const ref = git(editor, ["rev-parse", "HEAD"]);
   assert.match(ref, /^[a-f0-9]{40}$/);
-  if (expectedRef) assert.equal(ref, expectedRef);
-  assert.ok(existsSync(join(editor, "extensions", "apply-edits.ts")), "Editor source lacks its native extension");
+  if (expectedRef) {
+    assert.equal(ref, expectedRef);
+  }
+  assert.ok(
+    existsSync(join(editor, "extensions", "apply-edits.ts")),
+    "Editor source lacks its native extension",
+  );
   // Only the editor's real third-party runtime dependencies; Pi supplies its own peers through the loader.
-  run("npm", ["ci", "--omit=dev", "--ignore-scripts", "--legacy-peer-deps", "--no-audit", "--no-fund"], { cwd: editor });
+  run(
+    "npm",
+    ["ci", "--omit=dev", "--ignore-scripts", "--legacy-peer-deps", "--no-audit", "--no-fund"],
+    { cwd: editor },
+  );
   git(editor, ["diff", "--exit-code"]);
-  console.log(JSON.stringify({ nativeEditor: { ref, source: editor, supplied: supplied ? resolve(supplied) : null } }));
+  console.log(
+    JSON.stringify({
+      nativeEditor: { ref, source: editor, supplied: supplied ? resolve(supplied) : null },
+    }),
+  );
   const env = { ...process.env, PI_EDITOR_RECEIPT_TEST_ROOT: editor };
   run("npm", ["run", "ci"], { env });
   run(process.execPath, ["scripts/native-package-smoke.mjs"], { env });

package/scripts/compat-host.mjs

@@ -6,14 +6,42 @@ import { findPackageJSON } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-export const hostRoot = realpathSync(dirname(findPackageJSON("@earendil-works/pi-coding-agent", import.meta.url)));
+export const hostRoot = realpathSync(
+  dirname(findPackageJSON("@earendil-works/pi-coding-agent", import.meta.url)),
+);
 export const hostIndex = join(hostRoot, "dist/index.js");
 const manifest = JSON.parse(readFileSync(join(hostRoot, "package.json"), "utf8"));
 export const hostCli = realpathSync(join(hostRoot, manifest.bin.pi));
-for (const [name, actual] of [["PI_COMPAT_EXPECTED_PACKAGE_DIR", hostRoot], ["PI_HOST_INDEX", hostIndex], ["PI_HOST_CLI", hostCli]]) {
-  if (process.env[name]) assert.equal(realpathSync(process.env[name]), realpathSync(actual), `${name} must select the installed graph`);
+for (const [name, actual] of [
+  ["PI_COMPAT_EXPECTED_PACKAGE_DIR", hostRoot],
+  ["PI_HOST_INDEX", hostIndex],
+  ["PI_HOST_CLI", hostCli],
+]) {
+  if (process.env[name]) {
+    assert.equal(
+      realpathSync(process.env[name]),
+      realpathSync(actual),
+      `${name} must select the installed graph`,
+    );
+  }
 }
-if (process.env.PI_COMPAT_EXPECTED_VERSION) assert.equal(manifest.version, process.env.PI_COMPAT_EXPECTED_VERSION);
-assert.equal(realpathSync(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))), realpathSync(hostIndex));
-const hash = path => createHash("sha256").update(readFileSync(path)).digest("hex");
-console.log(JSON.stringify({ host: process.env.PI_COMPAT_HOST ?? "local", version: manifest.version, node: process.version, hostRoot, hostIndex, hostCli, indexSha256: hash(hostIndex), cliSha256: hash(hostCli) }));
+if (process.env.PI_COMPAT_EXPECTED_VERSION) {
+  assert.equal(manifest.version, process.env.PI_COMPAT_EXPECTED_VERSION);
+}
+assert.equal(
+  realpathSync(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))),
+  realpathSync(hostIndex),
+);
+const hash = (path) => createHash("sha256").update(readFileSync(path)).digest("hex");
+console.log(
+  JSON.stringify({
+    host: process.env.PI_COMPAT_HOST ?? "local",
+    version: manifest.version,
+    node: process.version,
+    hostRoot,
+    hostIndex,
+    hostCli,
+    indexSha256: hash(hostIndex),
+    cliSha256: hash(hostCli),
+  }),
+);