@kr78/pi-coding-agent 17.2.10

package/scripts/embed-mupdf-wasm.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env bun
+
+// Embeds mupdf's `mupdf-wasm.wasm` into the compiled single-file binary.
+//
+// mupdf loads its wasm by reading the `mupdf-wasm.wasm` sibling of its own
+// module via `new URL(..., import.meta.url)` + `readFileSync`. A `bun --compile`
+// binary has no node_modules, so that read fails (`ENOENT .../mupdf-wasm.wasm`),
+// and marking mupdf `--external` instead makes `bun --compile` eagerly fail to
+// resolve the package at startup (the static `import * as mupdf` lives in a lazy
+// chunk but is hoisted). So the binary build bundles mupdf and embeds the wasm
+// bytes here, handing them to the WASM module as `$libmupdf_wasm_Module.wasmBinary`
+// (see src/utils/markit.ts).
+//
+// `--generate` copies the wasm next to src/utils/mupdf-wasm-embed.ts and rewrites
+// that module to import it via `with { type: "file" }`; `--reset` restores the
+// checked-in placeholder and removes the copy. The npm `dist/cli.js` bundle never
+// runs this — it keeps mupdf external and loads the wasm from node_modules.
+
+import * as fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+
+const utilsDir = path.join(import.meta.dir, "..", "src", "utils");
+const helperPath = path.join(utilsDir, "mupdf-wasm-embed.ts");
+const wasmCopyPath = path.join(utilsDir, "mupdf-wasm.wasm");
+
+const placeholder = `// AUTOGENERATED -- managed by scripts/embed-mupdf-wasm.ts. Do not edit by hand.
+//
+// Compiled single-file binaries cannot let mupdf resolve its \`mupdf-wasm.wasm\`
+// sibling from the read-only bunfs, so the binary build (scripts/build-binary.ts
+// and scripts/ci-release-build-binaries.ts) regenerates this module to embed the
+// wasm bytes via \`with { type: "file" }\` and copies the wasm next to it. Source
+// checkouts, \`bun test\`, and the npm \`dist/cli.js\` bundle keep mupdf external and
+// load the wasm from node_modules, so this placeholder returns undefined and the
+// build resets back to it afterward.
+export function loadEmbeddedMupdfWasm(): Uint8Array | undefined {
+\treturn undefined;
+}
+`;
+
+const generated = `// AUTOGENERATED -- managed by scripts/embed-mupdf-wasm.ts. Do not edit or commit.
+import { readFileSync } from "node:fs";
+import wasmPath from "./mupdf-wasm.wasm" with { type: "file" };
+
+export function loadEmbeddedMupdfWasm(): Uint8Array | undefined {
+\treturn readFileSync(wasmPath);
+}
+`;
+
+if (process.argv.includes("--reset")) {
+	await Bun.write(helperPath, placeholder);
+	try {
+		await fs.unlink(wasmCopyPath);
+	} catch (err) {
+		if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+	}
+	process.exit(0);
+}
+
+const wasmSource = path.join(path.dirname(createRequire(import.meta.url).resolve("mupdf")), "mupdf-wasm.wasm");
+const wasmFile = Bun.file(wasmSource);
+if (!(await wasmFile.exists())) {
+	throw new Error(`mupdf wasm not found at ${wasmSource}; run \`bun install\` first.`);
+}
+await Bun.write(wasmCopyPath, wasmFile);
+await Bun.write(helperPath, generated);
+console.log(`Embedded mupdf wasm (${wasmFile.size} bytes) into ${path.relative(process.cwd(), wasmCopyPath)}`);

package/scripts/format-prompts.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env bun
+import { prompt } from "@oh-my-pi/pi-utils";
+/**
+ * Format prompt files (mixed XML + Markdown + Handlebars).
+ *
+ * Rules:
+ * 1. No blank line before list items
+ * 2. No blank line after opening XML tag or Handlebars block
+ * 3. No blank line before closing XML tag or Handlebars block
+ * 4. Strip leading whitespace from top-level closing XML tags (opened at col 0) and Handlebars (lines starting with {{)
+ * 5. Compact markdown tables (remove padding)
+ * 6. Collapse 2+ blank lines to single blank line
+ * 7. Trim trailing whitespace (preserve indentation)
+ * 8. Trailing newline at EOF (disk only; runtime omits it)
+ * 9. Bold RFC 2119 keywords (MUST, SHOULD, MAY, etc.) in prompt content
+ */
+import { Glob } from "bun";
+
+const PROMPTS_DIR = `${import.meta.dir}/../src/prompts/`;
+const COMMIT_PROMPTS_DIR = `${import.meta.dir}/../src/commit/prompts/`;
+const AGENTIC_PROMPTS_DIR = `${import.meta.dir}/../src/commit/agentic/prompts/`;
+
+const PROMPT_DIRS = [PROMPTS_DIR, COMMIT_PROMPTS_DIR, AGENTIC_PROMPTS_DIR];
+
+const PROMPT_FORMAT_OPTIONS = {
+	renderPhase: "pre-render",
+	replaceAsciiSymbols: true,
+	normalizeRfc2119: true,
+} as const;
+
+async function main() {
+	const glob = new Glob("**/*.md");
+	const files: string[] = [];
+	let changed = 0;
+	const check = process.argv.includes("--check");
+
+	for (const dir of PROMPT_DIRS) {
+		for await (const path of glob.scan(dir)) {
+			files.push(`${dir}${path}`);
+		}
+	}
+
+	for (const fullPath of files) {
+		const original = await Bun.file(fullPath).text();
+		const formatted = prompt.format(original, PROMPT_FORMAT_OPTIONS);
+
+		if (original !== `${formatted}\n`) {
+			if (check) {
+				console.log(`Would format: ${fullPath}`);
+			} else {
+				await Bun.write(fullPath, `${formatted}\n`);
+				console.log(`Formatted: ${fullPath}`);
+			}
+			changed++;
+		}
+	}
+
+	if (check && changed > 0) {
+		console.log(`\n${changed} file(s) need formatting. Run 'bun run format-prompts' to fix.`);
+		process.exit(1);
+	} else if (changed === 0) {
+		console.log("All prompt files are formatted.");
+	} else {
+		console.log(`\nFormatted ${changed} file(s).`);
+	}
+}
+
+main();

package/scripts/generate-aria-snapshot.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env bun
+/**
+ * Regenerates the committed browser asset
+ *
+ *   src/tools/browser/aria/aria-snapshot.bundle.txt   ← bundled CJS module
+ *
+ * by fetching Playwright's injected ARIA-snapshot sources (pinned to
+ * PLAYWRIGHT_TAG), wrapping them with a small entry, and bundling — all in a
+ * throwaway temp dir. Only the bundle is committed; the upstream sources are NOT
+ * vendored into the repo (no shipping both source + generated copies). This is a
+ * dev-time, network-bound step, exactly like `generate-models`.
+ *
+ * The tab worker imports the `.txt` with `{ type: "text" }`, wraps it in a
+ * `new Function` worker-side, and runs it via puppeteer's CDP evaluate (it
+ * installs nothing on `window`). The committed output means binary and source
+ * installs need no network or build step at runtime.
+ *
+ * Usage: bun scripts/generate-aria-snapshot.ts
+ */
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const PLAYWRIGHT_TAG = "v1.61.0";
+const RAW_BASE = `https://raw.githubusercontent.com/microsoft/playwright/${PLAYWRIGHT_TAG}/packages`;
+
+const OUTPUT = path.join(import.meta.dir, "..", "src", "tools", "browser", "aria", "aria-snapshot.bundle.txt");
+
+// Upstream source path -> temp path (relative to the temp root).
+const VENDOR_FILES: Array<[string, string]> = [
+	["injected/src/ariaSnapshot.ts", "injected/ariaSnapshot.ts"],
+	["injected/src/roleUtils.ts", "injected/roleUtils.ts"],
+	["injected/src/domUtils.ts", "injected/domUtils.ts"],
+	["isomorphic/ariaSnapshot.ts", "isomorphic/ariaSnapshot.ts"],
+	["isomorphic/stringUtils.ts", "isomorphic/stringUtils.ts"],
+	["isomorphic/cssTokenizer.ts", "isomorphic/cssTokenizer.ts"],
+	["isomorphic/yaml.ts", "isomorphic/yaml.ts"],
+];
+
+// Entry wrapping the upstream modules. Always runs Playwright's `ai` mode so every
+// node carries a `[ref=eN]` id; matched nodes get an `_ariaRef` expando. Existing
+// expandos are cleared first so the fresh module's counter renumbers from e1
+// deterministically (refs are valid until the next snapshot). Installs nothing on
+// `window`.
+const ENTRY_SOURCE = `
+import { generateAriaTree, renderAriaTree } from "./injected/ariaSnapshot";
+
+export interface AriaSnapshotRequest {
+	depth?: number;
+	boxes?: boolean;
+}
+
+function walkElements(fn: (el: Element) => void): void {
+	const walk = (root: { querySelectorAll(s: string): ArrayLike<Element> }): void => {
+		for (const el of Array.from(root.querySelectorAll("*"))) {
+			fn(el);
+			const shadow = (el as Element & { shadowRoot?: { querySelectorAll(s: string): ArrayLike<Element> } | null }).shadowRoot;
+			if (shadow) walk(shadow);
+		}
+	};
+	walk(document as unknown as { querySelectorAll(s: string): ArrayLike<Element> });
+}
+type RefElement = Element & { _ariaRef?: { role: string; name: string; ref: string } };
+
+export function ariaSnapshot(root: Element | null, request: AriaSnapshotRequest = {}): string {
+	walkElements(el => {
+		if ((el as RefElement)._ariaRef) delete (el as RefElement)._ariaRef;
+	});
+	const target = root ?? document.body ?? document.documentElement;
+	const options = { mode: "ai", depth: request.depth, boxes: request.boxes } as const;
+	const tree = generateAriaTree(target, options);
+	return renderAriaTree(tree, options).text;
+}
+
+export function resolveAriaRef(ref: string): Element | null {
+	let found: Element | null = null;
+	walkElements(el => {
+		if (!found && (el as RefElement)._ariaRef?.ref === ref) found = el;
+	});
+	return found;
+}
+`;
+
+async function main(): Promise<void> {
+	const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "omp-aria-"));
+	try {
+		// Fetch pinned upstream sources into the temp dir.
+		for (const [src, dst] of VENDOR_FILES) {
+			const url = `${RAW_BASE}/${src}`;
+			const res = await fetch(url);
+			if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.status}`);
+			await Bun.write(path.join(tmp, dst), await res.text());
+		}
+		const entry = path.join(tmp, "entry.ts");
+		await Bun.write(entry, ENTRY_SOURCE);
+
+		// The injected sources import isomorphic modules via the `@isomorphic/*`
+		// alias and the `yaml` package (type-only). Resolve the alias to the fetched
+		// copies and stub `yaml` (only referenced from erased `import type`).
+		const aliasPlugin: Bun.BunPlugin = {
+			name: "aria-vendor-alias",
+			setup(build) {
+				build.onResolve({ filter: /^@isomorphic\// }, args => ({
+					path: path.join(tmp, "isomorphic", `${args.path.slice("@isomorphic/".length)}.ts`),
+				}));
+				build.onResolve({ filter: /^yaml$/ }, () => ({ path: "yaml", namespace: "aria-yaml-stub" }));
+				build.onLoad({ filter: /.*/, namespace: "aria-yaml-stub" }, () => ({
+					contents: "export {};",
+					loader: "ts",
+				}));
+			},
+		};
+
+		const result = await Bun.build({
+			entrypoints: [entry],
+			target: "browser",
+			format: "cjs",
+			minify: true,
+			plugins: [aliasPlugin],
+		});
+		if (!result.success) {
+			for (const log of result.logs) console.error(log);
+			throw new Error("aria snapshot bundle failed");
+		}
+		const code = await result.outputs[0].text();
+		const header = `// @generated by scripts/generate-aria-snapshot.ts from Playwright ${PLAYWRIGHT_TAG}\n// Bundled from Playwright's injected ARIA-snapshot sources (Apache-2.0, (c) Microsoft).\n// Do not edit by hand. Regenerate with: bun scripts/generate-aria-snapshot.ts\n`;
+		await Bun.write(OUTPUT, header + code);
+		console.log(`bundled ${path.relative(process.cwd(), OUTPUT)} (${code.length}b)`);
+	} finally {
+		await fs.rm(tmp, { recursive: true, force: true });
+	}
+}
+
+await main();

package/scripts/generate-docs-index.ts

@@ -0,0 +1,58 @@
+import * as path from "node:path";
+import { gunzipSync, gzipSync } from "node:zlib";
+import { Glob } from "bun";
+
+const packageDir = path.resolve(import.meta.dir, "..");
+const docsDir = path.resolve(packageDir, "../../docs");
+
+export interface DocsIndexPayload {
+	readonly files: readonly string[];
+	readonly bodies: readonly string[];
+	readonly payload: string;
+}
+
+export interface DecodedDocsIndexPayload {
+	readonly files: readonly string[];
+	readonly bodies: readonly string[];
+}
+
+function isStringArray(value: unknown): value is string[] {
+	return Array.isArray(value) && value.every(item => typeof item === "string");
+}
+
+/** Build the exact two-line `omp://` docs embed from the source `docs` Markdown corpus. */
+export async function buildDocsIndexPayload(): Promise<DocsIndexPayload> {
+	const glob = new Glob("**/*.md");
+	const files: string[] = [];
+	for await (const relativePath of glob.scan(docsDir)) {
+		files.push(relativePath.split(path.sep).join("/"));
+	}
+	files.sort();
+
+	const bodies = await Promise.all(files.map(file => Bun.file(path.join(docsDir, file)).text()));
+	const bodiesB64 = Buffer.from(gzipSync(Buffer.from(JSON.stringify(bodies)), { level: 9 })).toString("base64");
+	return {
+		files,
+		bodies,
+		payload: `${JSON.stringify(files)}\n${bodiesB64}`,
+	};
+}
+
+/** Decode a populated docs embed payload into filenames and index-aligned Markdown bodies. */
+export function decodeDocsIndexPayload(embed: string): DecodedDocsIndexPayload | null {
+	const newline = embed.indexOf("\n");
+	if (newline === -1) return null;
+
+	const filenames: unknown = JSON.parse(embed.slice(0, newline));
+	if (!isStringArray(filenames)) {
+		throw new Error("Embedded docs index filename line is not a JSON string array.");
+	}
+
+	const inflated = gunzipSync(Buffer.from(embed.slice(newline + 1), "base64"));
+	const bodies: unknown = JSON.parse(inflated.toString("utf8"));
+	if (!isStringArray(bodies)) {
+		throw new Error("Embedded docs index body blob is not a JSON string array.");
+	}
+
+	return { files: filenames, bodies };
+}

package/scripts/generate-share-viewer.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+/**
+ * Build the standalone share-viewer page the omp relay serves at `GET /s/<id>`.
+ *
+ * Same template as HTML exports, but with no embedded session: share-loader.js
+ * (injected right after the empty #session-data tag) fetches the sealed blob
+ * (gist or relay store), decrypts it with the `#<key>` fragment in-browser, and
+ * hands the JSON to template.js via `window.__OMP_SESSION_DATA__`.
+ *
+ * The relay repo's build script runs this and embeds the output via go:embed.
+ */
+import * as path from "node:path";
+import { generateThemeStyles, getTemplate } from "../src/export/html";
+
+const outPath = process.argv[2];
+if (!outPath) {
+	console.error("usage: bun scripts/generate-share-viewer.ts <output.html>");
+	process.exit(2);
+}
+
+const loaderJs = await Bun.file(new URL("../src/export/html/share-loader.js", import.meta.url).pathname).text();
+// Public artifacts use the bundled omp web themes rather than TUI themes.
+const themeStyles = await generateThemeStyles("web");
+
+const html = getTemplate()
+	.replace("<theme-vars/>", () => `<style>${themeStyles}</style>`)
+	.replace("<title>Session Export</title>", () => "<title>omp session</title>")
+	.replace("{{SESSION_DATA}}</script>", () => `</script>\n  <script>${loaderJs}</script>`);
+
+if (html.includes("{{SESSION_DATA}}")) throw new Error("session-data placeholder survived substitution");
+if (!html.includes("__OMP_SESSION_DATA__")) throw new Error("share loader not injected");
+
+await Bun.write(outPath, html);
+console.log(`Generated ${path.resolve(outPath)} (${(html.length / 1024).toFixed(0)} KB)`);

package/scripts/legacy-pi-virtual-module.ts

@@ -0,0 +1,205 @@
+import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils/fs-error";
+
+/** Build-time specifier resolved to bundled legacy Pi module namespaces. */
+export const LEGACY_PI_MODULES_SPECIFIER = "omp-legacy-pi-modules";
+
+const VIRTUAL_NAMESPACE = "omp-legacy-pi-modules-build";
+const packageDir = path.resolve(import.meta.dir, "..");
+const repoRoot = path.resolve(packageDir, "..", "..");
+
+interface BundledPackage {
+	readonly dir: string;
+	readonly identifier: string;
+	readonly rootShim: string | null;
+}
+
+const BUNDLED_PACKAGES: readonly BundledPackage[] = [
+	{ dir: "agent", identifier: "PiAgentCore", rootShim: null },
+	{ dir: "ai", identifier: "PiAi", rootShim: "legacy-pi-ai-shim.ts" },
+	{ dir: "coding-agent", identifier: "PiCodingAgent", rootShim: "legacy-pi-coding-agent-shim.ts" },
+	{ dir: "natives", identifier: "PiNatives", rootShim: null },
+	{ dir: "tui", identifier: "PiTui", rootShim: "legacy-pi-tui-shim.ts" },
+	{ dir: "utils", identifier: "PiUtils", rootShim: null },
+];
+
+const TYPEBOX_MODULE_KEY = "typebox";
+const TYPEBOX_COMPAT_MODULE = "legacy-typebox.ts";
+const SKIPPED_WILDCARD_BASENAMES = new Set(["index"]);
+const MAIN_THREAD_UNSAFE_WILDCARD_BASENAMES = new Set(["worker-entry"]);
+
+/** One namespace module the binary must retain for legacy extension imports. */
+export interface BundledPiEntry {
+	/** Canonical import key exposed to extensions. */
+	readonly key: string;
+	/** Unique identifier used by the virtual module's generated import. */
+	readonly binding: string;
+	/** Package or absolute source specifier compiled into the binary. */
+	readonly importSpecifier: string;
+}
+
+interface WildcardPattern {
+	readonly exportPrefix: string;
+	readonly exportSuffix: string;
+	readonly sourcePrefix: string;
+	readonly sourceSuffix: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function bindingForSubpath(identifier: string, subpath: string): string {
+	const segments = subpath
+		.split("/")
+		.filter(Boolean)
+		.map(segment =>
+			segment
+				.split(/[-_]/)
+				.filter(Boolean)
+				.map(part => part.charAt(0).toUpperCase() + part.slice(1))
+				.join(""),
+		);
+	return `bundled${identifier}${segments.join("")}`;
+}
+
+function isSafeWildcardBasename(basename: string): boolean {
+	if (!basename || basename.startsWith(".") || basename.startsWith("_")) return false;
+	if (SKIPPED_WILDCARD_BASENAMES.has(basename)) return false;
+	if (MAIN_THREAD_UNSAFE_WILDCARD_BASENAMES.has(basename)) return false;
+	return !/\.(test|spec|d|generated|bench)$/.test(basename);
+}
+
+function parseWildcardPattern(exportKey: string, sourcePattern: string): WildcardPattern | null {
+	const exportStar = exportKey.indexOf("*");
+	const sourceStar = sourcePattern.indexOf("*");
+	if (exportStar === -1 || sourceStar === -1) return null;
+	if (exportKey.indexOf("*", exportStar + 1) !== -1) return null;
+	if (sourcePattern.indexOf("*", sourceStar + 1) !== -1) return null;
+	if (!sourcePattern.startsWith("./")) return null;
+	return {
+		exportPrefix: exportKey.slice(2, exportStar),
+		exportSuffix: exportKey.slice(exportStar + 1),
+		sourcePrefix: sourcePattern.slice(2, sourceStar),
+		sourceSuffix: sourcePattern.slice(sourceStar + 1),
+	};
+}
+
+function exportImportTarget(value: unknown): string | null {
+	if (typeof value === "string") return value;
+	if (isRecord(value) && typeof value.import === "string") return value.import;
+	return null;
+}
+
+function shimSpecifier(file: string): string {
+	return path.join(packageDir, "src", "extensibility", file);
+}
+
+/**
+ * Derive the bundled legacy Pi module surface from current package exports.
+ * Named wildcard exports are expanded from source; root catch-alls stay out to
+ * avoid importing CLI entrypoints and other non-extension surfaces.
+ */
+export async function collectBundledPiEntries(): Promise<BundledPiEntry[]> {
+	const entries: BundledPiEntry[] = [];
+	const seenKeys = new Set<string>();
+	const seenBindings = new Set<string>();
+	function addEntry(key: string, binding: string, importSpecifier: string): void {
+		if (seenKeys.has(key)) return;
+		if (seenBindings.has(binding)) {
+			throw new Error(`Duplicate bundled Pi binding ${binding} for ${key}`);
+		}
+		seenKeys.add(key);
+		seenBindings.add(binding);
+		entries.push({ key, binding, importSpecifier });
+	}
+
+	for (const pkg of BUNDLED_PACKAGES) {
+		const packageRoot = path.join(repoRoot, "packages", pkg.dir);
+		const manifestPath = path.join(packageRoot, "package.json");
+		const manifest: unknown = await Bun.file(manifestPath).json();
+		if (!isRecord(manifest) || typeof manifest.name !== "string") {
+			throw new Error(`Bundled Pi package manifest has no name: ${manifestPath}`);
+		}
+		const exportsField = isRecord(manifest.exports) ? manifest.exports : {};
+		const rootSpecifier = pkg.rootShim ? shimSpecifier(pkg.rootShim) : manifest.name;
+		addEntry(manifest.name, `bundled${pkg.identifier}`, rootSpecifier);
+
+		for (const exportKey in exportsField) {
+			if (!exportKey.startsWith("./") || exportKey === "." || exportKey.includes("*")) continue;
+			const subpath = exportKey.slice(2);
+			const key = `${manifest.name}/${subpath}`;
+			addEntry(key, bindingForSubpath(pkg.identifier, subpath), key);
+		}
+
+		for (const exportKey in exportsField) {
+			if (!exportKey.startsWith("./") || exportKey === "." || !exportKey.includes("*")) continue;
+			const sourcePattern = exportImportTarget(exportsField[exportKey]);
+			if (!sourcePattern) continue;
+			const pattern = parseWildcardPattern(exportKey, sourcePattern);
+			if (!pattern || !/\.(ts|tsx|mts|cts|js|mjs|cjs|jsx)$/.test(pattern.sourceSuffix)) continue;
+			if (pattern.exportPrefix === "" || pattern.exportPrefix === "/") continue;
+
+			const sourceDir = path.join(packageRoot, pattern.sourcePrefix);
+			try {
+				// Recursive on purpose: Node matches `*` in an `exports` pattern across
+				// `/`, so `./slash-commands/*` genuinely serves
+				// `slash-commands/helpers/active-oauth-account`. Enumerating only the
+				// top level left every nested key out of the compiled registry, where
+				// it fell through to `Bun.resolveSync` and died under bunfs — so such
+				// an import worked from source and failed inside a binary.
+				const glob = new Bun.Glob(`**/*${pattern.sourceSuffix}`);
+				const matches: string[] = [];
+				for await (const match of glob.scan({ cwd: sourceDir, onlyFiles: true })) {
+					matches.push(match);
+				}
+				matches.sort();
+				for (const match of matches) {
+					if (!match.endsWith(pattern.sourceSuffix)) continue;
+					const basename = match.slice(0, match.length - pattern.sourceSuffix.length);
+					const segments = basename.split("/");
+					// Every directory on the way has to be importable too: a private or
+					// hidden folder is no more exported than a private file.
+					if (segments.some(segment => segment.startsWith(".") || segment.startsWith("_"))) continue;
+					if (!isSafeWildcardBasename(segments.at(-1) ?? "")) continue;
+					const subpath = `${pattern.exportPrefix}${basename}${pattern.exportSuffix}`;
+					const key = `${manifest.name}/${subpath}`;
+					addEntry(key, bindingForSubpath(pkg.identifier, subpath), key);
+				}
+			} catch (error) {
+				if (!isEnoent(error)) throw error;
+			}
+		}
+	}
+
+	addEntry(TYPEBOX_MODULE_KEY, "bundledTypeBoxShim", shimSpecifier(TYPEBOX_COMPAT_MODULE));
+	return entries;
+}
+
+/** Render the lazy loader registry; exported so tests can execute the generated module. */
+export function __renderLegacyPiVirtualModule(entries: readonly BundledPiEntry[]): string {
+	const loaders = entries.map(
+		entry => `const ${entry.binding} = () => import(${JSON.stringify(entry.importSpecifier)});`,
+	);
+	const modules = entries.map(entry => `\t${JSON.stringify(entry.key)}: ${entry.binding},`);
+	return [...loaders, "", "export const BUNDLED_PI_MODULE_LOADERS = {", ...modules, "};", ""].join("\n");
+}
+
+/**
+ * Build plugin that materializes lazy legacy Pi module loaders entirely in
+ * memory. Literal dynamic imports retain every compile-time edge without
+ * evaluating unrelated host modules during extension bootstrap.
+ */
+export async function createLegacyPiVirtualModulePlugin(): Promise<Bun.BunPlugin> {
+	const source = __renderLegacyPiVirtualModule(await collectBundledPiEntries());
+	return {
+		name: "omp:legacy-pi-modules",
+		setup(build) {
+			build.onResolve({ filter: /^omp-legacy-pi-modules$/ }, () => ({
+				path: LEGACY_PI_MODULES_SPECIFIER,
+				namespace: VIRTUAL_NAMESPACE,
+			}));
+			build.onLoad({ filter: /.*/, namespace: VIRTUAL_NAMESPACE }, () => ({ contents: source, loader: "ts" }));
+		},
+	};
+}

package/scripts/measure-prompt-tokens.ts

@@ -0,0 +1,63 @@
+import { countTokens } from "@oh-my-pi/pi-agent-core";
+import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
+import { estimateToolSchemaTokens } from "@oh-my-pi/pi-coding-agent/modes/utils/context-usage";
+import { buildSystemPrompt } from "@oh-my-pi/pi-coding-agent/system-prompt";
+import { createTools, type Tool, type ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
+
+function bytes(s: string): number {
+	return Buffer.byteLength(s, "utf-8");
+}
+function est(s: string): number {
+	return (bytes(s) + 3) >> 2;
+}
+
+await Settings.init({ inMemory: true, cwd: process.cwd() });
+const settings = Settings.isolated({});
+
+const session: ToolSession = {
+	cwd: process.cwd(),
+	hasUI: false,
+	getSessionFile: () => null,
+	getSessionSpawns: () => "*",
+	settings,
+} as ToolSession;
+
+const tools = await createTools(session);
+const toolsMap = new Map<string, Tool>(tools.map(t => [t.name, t]));
+
+console.log(`active tools (${tools.length}): ${tools.map(t => t.name).join(", ")}\n`);
+
+const rows: Array<{ name: string; descBytes: number; tok: number; schemaTok: number }> = [];
+for (const t of tools) {
+	const tok = estimateToolSchemaTokens([t as never]);
+	const descBytes = bytes(t.description ?? "");
+	const descTok = est(t.description ?? "");
+	rows.push({ name: t.name, descBytes, tok, schemaTok: tok - descTok });
+}
+rows.sort((a, b) => b.tok - a.tok);
+
+const totalTok = estimateToolSchemaTokens(tools as never);
+console.log("per-tool tokens (sorted): name | total tok | desc bytes | ~schema tok");
+for (const r of rows) {
+	console.log(
+		`  ${r.name.padEnd(20)} ${String(r.tok).padStart(6)}  ${String(r.descBytes).padStart(7)}  ${String(r.schemaTok).padStart(6)}`,
+	);
+}
+console.log(`\nTOOLS TOTAL tokens: ${totalTok}\n`);
+
+const built = await buildSystemPrompt({
+	tools: toolsMap as never,
+	toolNames: tools.map(t => t.name),
+	inlineToolDescriptors: false,
+	nativeTools: true,
+	cwd: process.cwd(),
+	skills: [],
+	contextFiles: [],
+	workspaceTree: { rootPath: process.cwd(), rendered: "", truncated: false, totalLines: 0, agentsMdFiles: [] },
+});
+const parts = built.systemPrompt;
+const part0 = parts[0] ?? "";
+const rest = parts.slice(1).join("\n");
+console.log(`system prompt parts: ${parts.length}`);
+console.log(`SYSTEM PROMPT tokens (part0, no skills): ${countTokens(part0)}  (bytes=${bytes(part0)})`);
+console.log(`SYSTEM CONTEXT tokens (parts[1..]): ${countTokens(rest)}  (bytes=${bytes(rest)})`);