oma-coding-agent 1.1.4

package/scripts/build-binary.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env bun
+
+import { createRequire } from "node:module";
+import * as path from "node:path";
+
+const packageDir = path.join(import.meta.dir, "..");
+const repoRoot = path.join(packageDir, "..", "..");
+const outputPath = path.join(packageDir, "dist", "omp");
+
+// Transformers.js is an optional, native-heavy dependency that is never bundled
+// into the binary; the tiny-model worker `bun install`s it into a runtime cache
+// on first use. The `catalog:` spec cannot be resolved from inside the compiled
+// bunfs (issue #1763), so embed the concrete installed version here for the
+// worker to pin its runtime install against.
+const transformersVersion = (
+	createRequire(import.meta.url)("@huggingface/transformers/package.json") as { version: string }
+).version;
+
+function shouldAdhocSignDarwinBinary(): boolean {
+	return process.platform === "darwin";
+}
+
+async function runCommand(
+	command: string[],
+	env: NodeJS.ProcessEnv = Bun.env,
+	cwd: string = packageDir,
+): Promise<void> {
+	const proc = Bun.spawn(command, {
+		cwd,
+		env,
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	const exitCode = await proc.exited;
+	if (exitCode !== 0) {
+		throw new Error(`Command failed with exit code ${exitCode}: ${command.join(" ")}`);
+	}
+}
+
+async function main(): Promise<void> {
+	// Generate inside the try so the finally always restores the empty checked-in
+	// placeholders (stats client archive, docs index) even on failure.
+	try {
+		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
+		await runCommand(["bun", "scripts/generate-docs-index.ts", "--generate"]);
+		await runCommand(["bun", "--cwd=../natives", "run", "embed:native"]);
+		await runCommand(["bun", "scripts/embed-mupdf-wasm.ts", "--generate"]);
+		try {
+			const buildEnv = shouldAdhocSignDarwinBinary() ? { ...Bun.env, BUN_NO_CODESIGN_MACHO_BINARY: "1" } : Bun.env;
+			await runCommand(
+				[
+					"bun",
+					"build",
+					"--compile",
+					"--no-compile-autoload-bunfig",
+					"--no-compile-autoload-dotenv",
+					"--no-compile-autoload-tsconfig",
+					"--no-compile-autoload-package-json",
+					"--keep-names",
+					"--define",
+					'process.env.PI_COMPILED="true"',
+					"--define",
+					`process.env.PI_TINY_TRANSFORMERS_VERSION=${JSON.stringify(transformersVersion)}`,
+					"--external",
+					"fastembed",
+					"--external",
+					"onnxruntime-node",
+					"--root",
+					".",
+					"./packages/coding-agent/src/cli.ts",
+					// Legacy pi-* extension compat entrypoints served by
+					// `legacy-pi-compat.ts`. These are reached via computed bunfs paths
+					// (which `--compile`'s static analyzer cannot trace), so each must be
+					// listed here to land in bunfs at
+					// `/$bunfs/root/packages/<pkg>/<entry>.js`. The coding-agent's own
+					// `./src/index.ts` is intentionally NOT listed: bun --compile silently
+					// breaks the CLI entry when the same package's barrel appears as an
+					// extra entrypoint (issue #1474), so legacy `pi-coding-agent` imports
+					// resolve through `legacy-pi-coding-agent-shim.ts` instead.
+					"./packages/agent/src/index.ts",
+					"./packages/natives/native/index.js",
+					"./packages/tui/src/index.ts",
+					"./packages/utils/src/index.ts",
+					"./packages/coding-agent/src/extensibility/typebox.ts",
+					"./packages/coding-agent/src/extensibility/legacy-pi-ai-shim.ts",
+					"./packages/coding-agent/src/extensibility/legacy-pi-coding-agent-shim.ts",
+					"--outfile",
+					"packages/coding-agent/dist/omp",
+				],
+				buildEnv,
+				repoRoot,
+			);
+
+			// Bun 1.3.12 emits a truncated Mach-O signature on darwin builds.
+			if (shouldAdhocSignDarwinBinary()) {
+				await runCommand(["codesign", "--force", "--sign", "-", outputPath]);
+			}
+		} finally {
+			await runCommand(["bun", "scripts/embed-mupdf-wasm.ts", "--reset"]);
+			await runCommand(["bun", "--cwd=../natives", "run", "embed:native", "--reset"]);
+		}
+	} finally {
+		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--reset"]);
+		await runCommand(["bun", "scripts/generate-docs-index.ts", "--reset"]);
+	}
+}
+
+await main();

package/scripts/bundle-dist.ts

@@ -0,0 +1,110 @@
+#!/usr/bin/env bun
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+
+const packageDir = path.join(import.meta.dir, "..");
+const outDir = path.join(packageDir, "dist");
+const cliPath = path.join(outDir, "cli.js");
+const shebang = "#!/usr/bin/env bun\n";
+
+// Native / optional / platform-specific deps that are never bundled — installed on
+// demand (transformers/fastembed/onnxruntime) or shipped as their own artifact
+// (native addon, mupdf).
+const ALWAYS_EXTERNAL = ["mupdf", "@oh-my-pi/pi-natives", "@huggingface/transformers", "fastembed", "onnxruntime-node"];
+
+// Heavy, lazily-used third-party leaf deps. Each is a declared `dependency`, so the
+// published package resolves it from node_modules at runtime; bundling only embeds a
+// redundant copy that bloats dist/cli.js. NEVER add a patched dependency here — the
+// bundle is where a root `patchedDependencies` patch is baked in, so an externalized
+// import would load the unpatched npm package in users' installs (currently
+// @ark/schema is patched, so it — and arktype, which pulls @ark/schema — stay
+// bundled).
+const RUNTIME_EXTERNAL = [
+	"puppeteer-core",
+	"@puppeteer/browsers",
+	"@babel/parser",
+	"@xterm/headless",
+	"turndown",
+	"turndown-plugin-gfm",
+	"@mozilla/readability",
+	"linkedom",
+	"@agentclientprotocol/sdk",
+];
+
+async function runCommand(command: string[]): Promise<void> {
+	const proc = Bun.spawn(command, {
+		cwd: packageDir,
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	const exitCode = await proc.exited;
+	if (exitCode !== 0) throw new Error(`Command failed with exit code ${exitCode}: ${command.join(" ")}`);
+}
+
+async function ensureShebang(): Promise<void> {
+	const text = await Bun.file(cliPath).text();
+	if (text.startsWith(shebang)) return;
+	const withoutExisting = text.startsWith("#!") ? text.slice(text.indexOf("\n") + 1) : text;
+	await Bun.write(cliPath, shebang + withoutExisting);
+}
+
+function formatBytes(bytes: number): string {
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(2)}MB`;
+}
+
+async function cleanBundleOutputs(): Promise<void> {
+	// dist/ is shared with the dev binary (dist/omp); only remove this
+	// script's own outputs (entry bundle + copied native assets).
+	let entries: string[];
+	try {
+		entries = await fs.readdir(outDir);
+	} catch (err) {
+		if (isEnoent(err)) return;
+		throw err;
+	}
+	await Promise.all(
+		entries
+			.filter(entry => entry === "cli.js" || entry.endsWith(".node") || entry.endsWith(".js.map"))
+			.map(entry => fs.rm(path.join(outDir, entry), { force: true })),
+	);
+}
+
+async function main(): Promise<void> {
+	const start = Bun.nanoseconds();
+	await cleanBundleOutputs();
+	// The npm bundle ships no stats dashboard sources or prebuilt dist/client,
+	// so embed the dashboard archive the same way compiled binaries do
+	// (scripts/build-binary.ts). Reset afterwards to keep the checked-in
+	// placeholder empty.
+	await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
+	try {
+		await runCommand([
+			"bun",
+			"build",
+			"--target=bun",
+			"--outdir",
+			"dist",
+			// Full minify (whitespace + syntax + identifiers); --keep-names retains
+			// fn/class .name where code depends on it.
+			"--minify",
+			"--keep-names",
+			...[...ALWAYS_EXTERNAL, ...RUNTIME_EXTERNAL].flatMap(dep => ["--external", dep]),
+			"--define",
+			'process.env.PI_BUNDLED="true"',
+			"./src/cli.ts",
+		]);
+	} finally {
+		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--reset"]);
+	}
+	await ensureShebang();
+	const stat = await fs.stat(cliPath);
+	const elapsedMs = (Bun.nanoseconds() - start) / 1_000_000;
+	process.stdout.write(
+		`Bundled coding-agent CLI to dist/cli.js (${formatBytes(stat.size)}) in ${elapsedMs.toFixed(0)}ms\n`,
+	);
+}
+
+await main();

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-docs-index.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env bun
+
+/**
+ * Populate (or reset) the embedded harness documentation index for `omp://`.
+ *
+ * `--generate` writes `src/internal-urls/docs-index.generated.txt` as two lines:
+ * a plain JSON array of the sorted `docs/**\/*.md` file names, then a base64
+ * gzip blob of the index-aligned doc bodies (`string[]`). Keeping the filename
+ * list out of the blob lets the loader list docs without inflating it.
+ * Compiled binaries and the prepacked npm bundle inline this (~0.5MB) instead of
+ * the ~1.6MB raw map; `--reset` restores the checked-in empty placeholder so the
+ * dev tree reads `docs/` from disk. Mirrors the stats / model-catalog embeds.
+ */
+
+import * as path from "node:path";
+import { gzipSync } from "node:zlib";
+import { Glob } from "bun";
+
+const docsDir = path.resolve(import.meta.dir, "../../../docs");
+const outputPath = path.resolve(import.meta.dir, "../src/internal-urls/docs-index.generated.txt");
+const GENERATE_FLAG = "--generate";
+const RESET_FLAG = "--reset";
+
+async function main(): Promise<void> {
+	const rel = path.relative(process.cwd(), outputPath);
+
+	if (process.argv.includes(RESET_FLAG)) {
+		await Bun.write(outputPath, "");
+		console.log(`Reset ${rel}`);
+		return;
+	}
+
+	if (!process.argv.includes(GENERATE_FLAG)) {
+		console.log(`Skipping ${rel}; pass ${GENERATE_FLAG} to embed docs (the dev tree reads docs/ from disk)`);
+		return;
+	}
+
+	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();
+
+	// Index-aligned bodies (Promise.all preserves order), kept separate from the
+	// filename list so the loader can list docs without inflating the blob.
+	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");
+	// Two lines: plain filename array, then the base64 gzip blob.
+	const payload = `${JSON.stringify(files)}\n${bodiesB64}`;
+	await Bun.write(outputPath, payload);
+	console.log(`Generated ${rel} (${files.length} docs, ${payload.length} bytes)`);
+}
+
+await main();

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 { generateThemeVars, 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();
+// Pin a built-in theme: the viewer is a public artifact, not a per-user export.
+const themeVars = await generateThemeVars("dark");
+
+const html = getTemplate()
+	.replace("<theme-vars/>", () => `<style>:root { ${themeVars} }</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/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)})`);

package/scripts/omp

@@ -0,0 +1,42 @@
+#!/bin/sh
+# Dev launcher for the omp CLI, installed by `bun run setup`.
+#
+# Problem it solves: Bun reads `bunfig.toml` from the *current working
+# directory* at startup and evaluates its `preload` entries before running the
+# script. A bun-shebang bin (what `bun link` creates for `src/cli.ts`)
+# therefore inherits whatever `preload` the directory you happen to be in
+# declares. Running `omp`/`pi` inside an unrelated Bun project can execute — and
+# crash on — that project's preload, e.g.
+#   error: Cannot find module '@v12sh/utils/frontmatter' from '.../loader.ts'
+#
+# Bun only reads the *exact* cwd (it does not walk parents) and ignores
+# `--config`/`BUN_BE_BUN` for this, so the fix is to launch Bun from an empty,
+# bunfig-free directory and restore the real cwd inside the process via the
+# preload shim alongside this file.
+set -e
+
+# Resolve this script's real location even when invoked through a symlink
+# (`$HOME/.bun/bin/omp` -> this file).
+self=$0
+while [ -L "$self" ]; do
+	link=$(readlink "$self")
+	case $link in
+	/*) self=$link ;;
+	*) self=$(dirname "$self")/$link ;;
+	esac
+done
+scripts_dir=$(CDPATH= cd -- "$(dirname -- "$self")" && pwd -P)
+cli=$scripts_dir/../src/cli.ts
+preload=$scripts_dir/omp.ts
+timing_preload=$scripts_dir/../../utils/src/module-timer.ts
+
+launch_dir=${OMP_DEV_LAUNCH_DIR:-${HOME}/.omp/.dev-cwd}
+mkdir -p "$launch_dir"
+
+OMP_LAUNCH_CWD=$PWD
+export OMP_LAUNCH_CWD
+cd "$launch_dir"
+if [ -n "${PI_TIMING:-}" ]; then
+	exec bun --preload "$preload" --preload "$timing_preload" "$cli" "$@"
+fi
+exec bun --preload "$preload" "$cli" "$@"

package/scripts/omp.ts

@@ -0,0 +1,19 @@
+/**
+ * Bun `--preload` shim for the omp dev launcher (`scripts/omp`).
+ *
+ * The launcher starts Bun from an empty, bunfig-free directory so a foreign
+ * project's `bunfig.toml` `preload` cannot run inside the omp CLI: Bun reads
+ * `bunfig.toml` from the *current working directory* on startup and evaluates
+ * its `preload` entries before the entrypoint, so a bun-shebang bin inherits
+ * whatever `preload` the directory you launched from declares (and crashes if
+ * that preload can't resolve). This shim is loaded before the entrypoint's
+ * imports run, so it restores the user's real working directory in time for
+ * import-time snapshots (e.g. `getProjectDir()` in `@oh-my-pi/pi-utils/dirs`).
+ */
+const launchCwd = process.env.OMP_LAUNCH_CWD;
+if (launchCwd) {
+	delete process.env.OMP_LAUNCH_CWD;
+	try {
+		process.chdir(launchCwd);
+	} catch {}
+}