@oh-my-pi/pi-coding-agent 16.4.2 → 16.4.3

package/dist/types/vibe/runtime.d.ts

@@ -0,0 +1,124 @@
+import type { AsyncJobManager } from "../async/job-manager.js";
+import type { ToolSession } from "../tools/index.js";
+/** The two worker CLI flavors the director drives. */
+export type VibeCli = "fast" | "good";
+/**
+ * CLI flavor → bundled agent type. This IS the model-tier mapping: `sonic`
+ * carries `model: "pi/smol"` (the configured fast/low-latency role) and `task`
+ * carries `model: "pi/task"` (inherits the session's strong model).
+ * Resolution goes through {@link resolveAgentModelPatterns} exactly like a
+ * `task` spawn, so `task.agentModelOverrides` and model-role settings apply.
+ */
+export declare const VIBE_CLI_AGENT: Record<VibeCli, string>;
+/** Worker session lifecycle as shown to the director. */
+export type VibeSessionState = "starting" | "running" | "idle" | "dead";
+/**
+ * Live per-session "screen" for rich rendering: what the worker is doing right
+ * now (tool trace, current tool, streamed text tail) plus roster metadata.
+ * Every string is already one-line sanitized.
+ */
+export interface VibeScreenSnapshot {
+    id: string;
+    cli: VibeCli;
+    state: VibeSessionState;
+    model?: string;
+    turns: number;
+    queued: number;
+    /** Start of the in-flight turn, when running. */
+    turnStartedAt?: number;
+    /** Gist of the message that started the in-flight turn. */
+    turnMessage?: string;
+    currentTool?: string;
+    currentToolArgs?: string;
+    lastIntent?: string;
+    /** Completed tool calls of the in-flight turn, oldest first (tail). */
+    trace: string[];
+    /** Latest streamed worker text lines, oldest first. */
+    outputTail: string[];
+    lastActivity?: string;
+    lastActivityAt: number;
+}
+export interface VibeSpawnOutcome {
+    id: string;
+    jobId: string;
+}
+export interface VibeSendOutcome {
+    id: string;
+    /**
+     * - `turn`: a new background turn was started (`jobId` set).
+     * - `steered`: worker was mid-turn and streaming; delivered as steering.
+     * - `queued`: worker was mid-turn but not steerable; drained into the next turn.
+     */
+    mode: "turn" | "steered" | "queued";
+    jobId?: string;
+}
+export interface VibeKillOutcome {
+    id: string;
+    /** True when an in-flight turn job was cancelled along the way. */
+    cancelledTurn: boolean;
+}
+export interface VibeWaitOutcome {
+    /** Watched sessions whose snapshotted turn settled during (or before) the wait.
+     * May overlap `stillRunning` when a queued follow-up turn already started. */
+    settled: Array<{
+        id: string;
+        jobId: string;
+        status: "completed" | "failed" | "cancelled";
+        resultText: string;
+    }>;
+    /** Watched sessions with a turn in flight when the wait returned. */
+    stillRunning: string[];
+    timedOut: boolean;
+}
+/** Thrown from a turn job body so the job manager marks the job failed while carrying the formatted result. */
+export declare class VibeTurnError extends Error {
+}
+/**
+ * Process-global registry of vibe worker sessions, scoped per owner agent id
+ * (same convention as AsyncJobManager owner filters). The interactive mode
+ * kills an owner's sessions on vibe-mode exit via {@link killAll}.
+ */
+export declare class VibeSessionRegistry {
+    #private;
+    static global(): VibeSessionRegistry;
+    /** Reset the global registry. Test-only. */
+    static resetGlobalForTests(): void;
+    listIds(owner: string): string[];
+    /**
+     * Live screen snapshots for rich rendering (the "TV wall"): one entry per
+     * session in creation order, carrying the in-flight turn's trace, current
+     * tool, and streamed text tail. All strings are one-line sanitized here so
+     * renderers can print them verbatim.
+     */
+    screens(owner: string, ids?: string[]): VibeScreenSnapshot[];
+    /** Spawn a persistent worker session and start its first turn in the background. */
+    spawn(session: ToolSession, args: {
+        cli: VibeCli;
+        name?: string;
+        prompt: string;
+    }): Promise<VibeSpawnOutcome>;
+    /**
+     * Send a message to a worker. Mid-turn and streaming → steering; mid-turn
+     * otherwise → queued for the next turn; idle/parked → starts a new
+     * background turn immediately.
+     */
+    send(session: ToolSession, args: {
+        session: string;
+        message: string;
+    }): Promise<VibeSendOutcome>;
+    /**
+     * Block until one watched session's in-flight turn settles, the timeout
+     * elapses, or `signal` aborts — `job` poll semantics. Settled turns are
+     * acknowledged against the job manager so their results are not delivered
+     * a second time as async follow-ups.
+     */
+    wait(session: ToolSession, args: {
+        sessions?: string[];
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<VibeWaitOutcome>;
+    /** Terminate a worker: cancel its in-flight turn and dispose + unregister its session. */
+    kill(session: ToolSession, id: string): Promise<VibeKillOutcome>;
+    /** Kill every session belonging to `owner` (vibe-mode exit / teardown). Returns the number killed. */
+    killAll(owner: string, manager?: AsyncJobManager): Promise<number>;
+}

package/dist/types/vibe/state.d.ts

@@ -0,0 +1,4 @@
+/** Vibe mode session-level state, mirroring {@link ../plan-mode/state.ts}. */
+export interface VibeModeState {
+    enabled: boolean;
+}

package/dist/types/web/search/provider.d.ts

@@ -22,6 +22,8 @@ export declare function getSearchProvider(id: SearchProviderId): Promise<SearchP
 export declare function setPreferredSearchProvider(provider: SearchProviderId | "auto"): void;
 /** Set providers that web search should never use, including fallbacks. */
 export declare function setExcludedSearchProviders(providers: readonly SearchProviderId[]): void;
+/** `true` when settings exclude `id` from web search (auto chain and the Public Web fan-out). */
+export declare function isSearchProviderExcluded(id: SearchProviderId): boolean;
 /**
  * Determine which providers are configured and currently available.
  * Each candidate is loaded (and its `isAvailable()` called) only as the chain

package/dist/types/web/search/providers/bing.d.ts

@@ -0,0 +1,14 @@
+import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import type { SearchResponse } from "../../../web/search/types.js";
+import type { SearchParams } from "./base.js";
+import { SearchProvider } from "./base.js";
+/** Execute a Bing web search via the server-rendered HTML results page. */
+export declare function searchBing(params: SearchParams): Promise<SearchResponse>;
+/** Search provider for Bing (no API key required). */
+export declare class BingProvider extends SearchProvider {
+    readonly id = "bing";
+    readonly label = "Bing";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    isExplicitlyAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}

package/dist/types/web/search/providers/browser-headers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Build a fresh, internally consistent desktop navigation fingerprint for one HTTP request.
+ * By default, this randomizes across valid modern versions of Chrome, Firefox, Edge, and Safari
+ * using real-world traffic data. Set `randomized` to `false` when a fetch must preserve a
+ * stable Mac Chrome identity.
+ */
+export declare function buildBrowserNavigationHeaders(options?: {
+    randomized?: boolean;
+}): Record<string, string>;

package/dist/types/web/search/providers/browser-page.d.ts

@@ -0,0 +1,32 @@
+import type { FetchImpl } from "@oh-my-pi/pi-ai";
+import type { Page } from "puppeteer-core";
+/** HTML plus the response status and final URL after redirects or browser navigation. */
+export interface LoadedHtmlPage {
+    html: string;
+    status: number;
+    url: string;
+}
+interface BrowserFallbackOptions {
+    homeUrl?: string;
+    ready?: {
+        selector: string;
+        timeoutMs: number;
+    };
+    afterNavigation?: (page: Page, signal: AbortSignal) => Promise<void>;
+    shouldFallback: (page: LoadedHtmlPage) => boolean;
+    attempts?: number;
+    retryDelayMs?: number;
+}
+/** Controls a browser-profiled fetch and its optional headless-browser fallback. */
+export interface BrowserFetchOptions {
+    fetch?: FetchImpl;
+    signal: AbortSignal;
+    randomizeHeaders?: boolean;
+    referer?: string;
+    init?: Omit<RequestInit, "headers" | "signal">;
+    headers?: Readonly<Record<string, string>>;
+    browser?: BrowserFallbackOptions;
+}
+/** Fetch with a fresh browser profile, escalating rejected production responses to the stealth browser. */
+export declare function browserFetch(url: string, options: BrowserFetchOptions): Promise<LoadedHtmlPage>;
+export {};

package/dist/types/web/search/providers/ecosia.d.ts

@@ -0,0 +1,14 @@
+import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import type { SearchResponse } from "../../../web/search/types.js";
+import type { SearchParams } from "./base.js";
+import { SearchProvider } from "./base.js";
+/** Execute an Ecosia web search and parse the server-rendered result page. */
+export declare function searchEcosia(params: SearchParams): Promise<SearchResponse>;
+/** Search provider for Ecosia (no API key required). */
+export declare class EcosiaProvider extends SearchProvider {
+    readonly id = "ecosia";
+    readonly label = "Ecosia";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    isExplicitlyAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}

package/dist/types/web/search/providers/google.d.ts

@@ -0,0 +1,13 @@
+import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import type { SearchResponse } from "../../../web/search/types.js";
+import type { SearchParams } from "./base.js";
+import { SearchProvider } from "./base.js";
+/** Execute a Google web search with fetch-first loading and a headless-browser fallback. */
+export declare function searchGoogle(params: SearchParams): Promise<SearchResponse>;
+/** Fetch-first Google Search provider with a headless-browser fallback; no API key is required. */
+export declare class GoogleProvider extends SearchProvider {
+    readonly id = "google";
+    readonly label = "Google";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}

package/dist/types/web/search/providers/mojeek.d.ts

@@ -0,0 +1,14 @@
+import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import type { SearchResponse } from "../../../web/search/types.js";
+import type { SearchParams } from "./base.js";
+import { SearchProvider } from "./base.js";
+/** Execute a Mojeek web search against the standard HTML results page. */
+export declare function searchMojeek(params: SearchParams): Promise<SearchResponse>;
+/** Search provider for Mojeek (independent index, no API key required). */
+export declare class MojeekProvider extends SearchProvider {
+    readonly id = "mojeek";
+    readonly label = "Mojeek";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    isExplicitlyAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}

package/dist/types/web/search/providers/public.d.ts

@@ -0,0 +1,37 @@
+import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import type { SearchResponse } from "../types.js";
+import type { SearchParams } from "./base.js";
+import { SearchProvider } from "./base.js";
+/** Deadline overrides — test seam; production callers use the defaults. */
+export interface PublicWebDeadlines {
+    softMs?: number;
+    hardMs?: number;
+}
+/**
+ * Execute a web search against every credential-free engine in parallel and
+ * consolidate the results: URLs are deduplicated across engines, ranked by
+ * cross-engine consensus (how many engines returned them), then by best
+ * per-engine rank.
+ *
+ * The fan-out races three exits and returns at the earliest: every engine
+ * settled; the soft deadline elapsed with at least one success in hand; the
+ * hard deadline elapsed regardless. If the soft deadline fires before any
+ * engine has delivered, the aggregate keeps waiting (up to the hard cap) for
+ * the first success, so a slow field degrades to fewer engines rather than
+ * an empty answer. Stragglers are aborted once the race resolves. Individual
+ * engine failures (bot challenges, timeouts) are tolerated; the call fails
+ * only when every engine fails.
+ */
+export declare function searchPublicWeb(params: SearchParams, deadlines?: PublicWebDeadlines): Promise<SearchResponse>;
+/**
+ * Aggregate meta-provider over every credential-free engine. Explicit-only:
+ * the auto chain already walks the individual engines sequentially, so
+ * fanning out to all of them is a deliberate user choice, not a fallback.
+ */
+export declare class PublicWebProvider extends SearchProvider {
+    readonly id = "public";
+    readonly label = "Public Web";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    isExplicitlyAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}

package/dist/types/web/search/providers/startpage.d.ts

@@ -0,0 +1,14 @@
+import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import type { SearchResponse } from "../../../web/search/types.js";
+import type { SearchParams } from "./base.js";
+import { SearchProvider } from "./base.js";
+/** Execute a Startpage web search via the homepage-token form flow. */
+export declare function searchStartpage(params: SearchParams): Promise<SearchResponse>;
+/** Search provider for Startpage (no API key required). */
+export declare class StartpageProvider extends SearchProvider {
+    readonly id = "startpage";
+    readonly label = "Startpage";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    isExplicitlyAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}

package/dist/types/web/search/providers/yahoo.d.ts

@@ -0,0 +1,14 @@
+import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import type { SearchResponse } from "../../../web/search/types.js";
+import type { SearchParams } from "./base.js";
+import { SearchProvider } from "./base.js";
+/** Execute a Yahoo web search via the server-rendered HTML results page. */
+export declare function searchYahoo(params: SearchParams): Promise<SearchResponse>;
+/** Search provider for Yahoo (no API key required). */
+export declare class YahooProvider extends SearchProvider {
+    readonly id = "yahoo";
+    readonly label = "Yahoo";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    isExplicitlyAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}

package/dist/types/web/search/types.d.ts

@@ -75,10 +75,38 @@ export declare const SEARCH_PROVIDER_OPTIONS: readonly [{
     readonly value: "searxng";
     readonly label: "SearXNG";
     readonly description: "Requires SEARXNG_ENDPOINT or searxng.endpoint";
+}, {
+    readonly value: "startpage";
+    readonly label: "Startpage";
+    readonly description: "Credential-free scrape of Startpage (Google-backed) results; may be bot-challenged";
 }, {
     readonly value: "duckduckgo";
     readonly label: "DuckDuckGo";
     readonly description: "Credential-free best-effort fallback; may be bot-challenged on datacenter/shared-egress IPs";
+}, {
+    readonly value: "bing";
+    readonly label: "Bing";
+    readonly description: "Credential-free HTML scrape of Bing results; may be bot-challenged";
+}, {
+    readonly value: "yahoo";
+    readonly label: "Yahoo";
+    readonly description: "Credential-free HTML scrape of Yahoo (Bing-backed) results";
+}, {
+    readonly value: "ecosia";
+    readonly label: "Ecosia";
+    readonly description: "Credential-free browser-backed scrape of Ecosia (Google-backed) results";
+}, {
+    readonly value: "google";
+    readonly label: "Google";
+    readonly description: "Credential-free browser-backed fallback; slower and may be bot-challenged";
+}, {
+    readonly value: "mojeek";
+    readonly label: "Mojeek";
+    readonly description: "Credential-free browser-backed scrape of Mojeek's independent index";
+}, {
+    readonly value: "public";
+    readonly label: "Public Web";
+    readonly description: "Queries every credential-free engine in parallel and consolidates deduplicated results";
 }];
 /** Supported web search providers (every option except `auto`). */
 export type SearchProviderId = Exclude<(typeof SEARCH_PROVIDER_OPTIONS)[number]["value"], "auto">;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.4.2",
+	"version": "16.4.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -32,41 +32,37 @@
 	},
 	"scripts": {
 		"build": "bun scripts/build-binary.ts",
-		"check": "biome check . && bun run check:docs && bun run check:types",
-		"check:docs": "bun scripts/generate-docs-index.ts --check",
+		"check": "biome check . && bun run check:types",
 		"check:types": "tsgo -p tsconfig.json --noEmit",
 		"lint": "biome lint .",
 		"test": "bun ../../scripts/ci-test-ts.ts coding-agent-heavy --full",
 		"fix": "biome check --write --unsafe . && bun run format-prompts",
 		"fmt": "biome format --write . && bun run format-prompts",
 		"format-prompts": "bun scripts/format-prompts.ts",
-		"gen:docs": "bun scripts/generate-docs-index.ts --generate",
-		"gen:docs:reset": "bun scripts/generate-docs-index.ts --reset",
 		"gen:tool-views": "bun --cwd=../collab-web run gen:tool-views",
 		"gen:bundle": "bun scripts/bundle-dist.ts",
 		"gen:mupdf": "bun scripts/embed-mupdf-wasm.ts --generate",
 		"gen:mupdf:reset": "bun scripts/embed-mupdf-wasm.ts --reset",
 		"gen:native": "bun --cwd=../natives run gen:native",
 		"gen:native:reset": "bun --cwd=../natives run gen:native:reset",
-		"prepack": "bun run gen:docs && bun run gen:tool-views && bun run gen:bundle || ( bun run gen:docs:reset; exit 1 )",
-		"postpack": "bun run gen:docs:reset",
+		"prepack": "bun run gen:tool-views && bun run gen:bundle",
 		"bench:guard": "bun scripts/bench-guard.ts"
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.4.2",
-		"@oh-my-pi/omp-stats": "16.4.2",
-		"@oh-my-pi/pi-agent-core": "16.4.2",
-		"@oh-my-pi/pi-ai": "16.4.2",
-		"@oh-my-pi/pi-catalog": "16.4.2",
-		"@oh-my-pi/pi-mnemopi": "16.4.2",
-		"@oh-my-pi/pi-natives": "16.4.2",
-		"@oh-my-pi/pi-tui": "16.4.2",
-		"@oh-my-pi/pi-utils": "16.4.2",
-		"@oh-my-pi/pi-wire": "16.4.2",
-		"@oh-my-pi/snapcompact": "16.4.2",
+		"@oh-my-pi/hashline": "16.4.3",
+		"@oh-my-pi/omp-stats": "16.4.3",
+		"@oh-my-pi/pi-agent-core": "16.4.3",
+		"@oh-my-pi/pi-ai": "16.4.3",
+		"@oh-my-pi/pi-catalog": "16.4.3",
+		"@oh-my-pi/pi-mnemopi": "16.4.3",
+		"@oh-my-pi/pi-natives": "16.4.3",
+		"@oh-my-pi/pi-tui": "16.4.3",
+		"@oh-my-pi/pi-utils": "16.4.3",
+		"@oh-my-pi/pi-wire": "16.4.3",
+		"@oh-my-pi/snapcompact": "16.4.3",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",
@@ -81,6 +77,7 @@
 		"diff": "^9.0.0",
 		"fast-xml-parser": "^5.9.0",
 		"handlebars": "^4.7.9",
+		"header-generator": "^2.1.82",
 		"linkedom": "^0.18.12",
 		"lru-cache": "11.5.1",
 		"mammoth": "^1.12.0",

package/scripts/build-binary.ts

@@ -2,17 +2,41 @@
 
 import { createRequire } from "node:module";
 import * as path from "node:path";
+import { compileCodingAgent } from "./compile-binary";
 
 const packageDir = path.join(import.meta.dir, "..");
 const repoRoot = path.join(packageDir, "..", "..");
-// Optional cross-compile target, e.g. CROSS_TARGET=linux-arm64 → bun build
-// --target=bun-linux-arm64, embeds the matching native, outputs dist/omp-<target>.
-const crossTarget = Bun.env.CROSS_TARGET || null;
-const [crossPlatform, crossArch] = crossTarget ? crossTarget.split("-") : [null, null];
-// x64 uses the baseline bun runtime so it runs under Rosetta / pre-AVX2 CPUs
-// (the modern bun-linux-x64 target SIGILLs under Apple-Silicon Rosetta).
-const bunTarget = crossTarget ? (crossTarget === "linux-x64" ? "bun-linux-x64-baseline" : `bun-${crossTarget}`) : null;
-const outName = crossTarget ? `omp-${crossTarget}` : "omp";
+
+interface CrossBuild {
+	readonly id: string;
+	readonly platform: string;
+	readonly arch: string;
+	readonly target: Bun.Build.CompileTarget;
+}
+
+function resolveCrossBuild(value: string | undefined): CrossBuild | null {
+	switch (value) {
+		case undefined:
+		case "":
+			return null;
+		case "darwin-arm64":
+			return { id: value, platform: "darwin", arch: "arm64", target: "bun-darwin-arm64" };
+		case "darwin-x64":
+			return { id: value, platform: "darwin", arch: "x64", target: "bun-darwin-x64" };
+		case "linux-arm64":
+			return { id: value, platform: "linux", arch: "arm64", target: "bun-linux-arm64" };
+		case "linux-x64":
+			return { id: value, platform: "linux", arch: "x64", target: "bun-linux-x64-baseline" };
+		case "win32-x64":
+		case "windows-x64":
+			return { id: value, platform: "win32", arch: "x64", target: "bun-windows-x64-modern" };
+		default:
+			throw new Error(`Unsupported CROSS_TARGET: ${value}`);
+	}
+}
+
+const crossBuild = resolveCrossBuild(Bun.env.CROSS_TARGET);
+const outName = crossBuild ? `omp-${crossBuild.id}` : "omp";
 const outputPath = path.join(packageDir, "dist", outName);
 
 // Transformers.js is an optional, native-heavy dependency that is never bundled
@@ -20,12 +44,19 @@ const outputPath = path.join(packageDir, "dist", outName);
 // 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;
+const transformersManifest: unknown = createRequire(import.meta.url)("@huggingface/transformers/package.json");
+if (
+	typeof transformersManifest !== "object" ||
+	transformersManifest === null ||
+	!("version" in transformersManifest) ||
+	typeof transformersManifest.version !== "string"
+) {
+	throw new Error("@huggingface/transformers package manifest has no string version");
+}
+const transformersVersion = transformersManifest.version;
 
 function shouldAdhocSignDarwinBinary(): boolean {
-	return process.platform === "darwin" && !crossTarget;
+	return process.platform === "darwin" && !crossBuild;
 }
 
 async function runCommand(
@@ -50,73 +81,26 @@ async function main(): Promise<void> {
 	// placeholders (stats client archive, docs index) even on failure.
 	try {
 		await runCommand(["bun", "--cwd=../stats", "run", "gen:stats"]);
-		await runCommand(["bun", "run", "gen:docs"]);
-		// `legacy-pi-bundled-registry.ts` static-imports
-		// `@oh-my-pi/pi-coding-agent/export/html` (one of pi-coding-agent's
-		// named subpath exports, see scripts/generate-legacy-pi-bundled-registry.ts),
-		// whose source pulls in `tool-views.generated.js`. The root
-		// `package.json` "prepare" lifecycle hook builds that file on
-		// `bun install`, but a clean binary build that skips install hooks
-		// would `bun build --compile` against the registry entry and fail
-		// resolving the missing generated bundle. Rebuilding the tool views
-		// here makes the compile self-contained and matches what `prepack`
-		// does for the npm bundle.
+		// The in-memory legacy Pi virtual module reaches the coding-agent
+		// `export/html` subpath, whose source imports `tool-views.generated.js`.
+		// Rebuild it before compilation so clean checkouts that skipped install
+		// hooks still contain that generated bundle.
 		await runCommand(["bun", "--cwd=../collab-web", "run", "gen:tool-views"]);
 		await runCommand(
 			["bun", "--cwd=../natives", "run", "gen:native"],
-			crossTarget
-				? { ...Bun.env, TARGET_PLATFORM: crossPlatform as string, TARGET_ARCH: crossArch as string }
-				: Bun.env,
+			crossBuild ? { ...Bun.env, TARGET_PLATFORM: crossBuild.platform, TARGET_ARCH: crossBuild.arch } : Bun.env,
 		);
 		await runCommand(["bun", "run", "gen:mupdf"]);
-		// Regenerate the bundled-pi registry + key set before the compile so any
-		// new pi-* subpath export added under `packages/*/package.json` is served
-		// from the host's in-process copy. Without this, `bun build --compile`
-		// would freeze whatever the committed registry happened to enumerate at
-		// the time of the last manual `--generate`, and a new subpath added
-		// since then would crash extension validation with `Cannot find module`
-		// (issue #3442). The generator also normalizes formatting, so the diff
-		// against the committed copy stays clean.
-		await runCommand(["bun", "scripts/generate-legacy-pi-bundled-registry.ts", "--generate"]);
 		try {
-			const buildEnv = shouldAdhocSignDarwinBinary() ? { ...Bun.env, BUN_NO_CODESIGN_MACHO_BINARY: "1" } : Bun.env;
-			await runCommand(
-				[
-					"bun",
-					"build",
-					"--compile",
-					...(bunTarget ? ["--target", bunTarget] : []),
-					"--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 surfaces (host packages + shims)
-					// were previously listed as explicit `--compile` entries so the
-					// rewrite path could emit `/$bunfs/root/...` URLs against them.
-					// Bun 1.3.14 made bunfs files unreachable at runtime (issue
-					// #3423), so `legacy-pi-compat.ts` now serves them through a
-					// virtual namespace backed by `legacy-pi-bundled-registry.ts`,
-					// which static-imports each surface — the bundler already
-					// includes them via the main module graph, so no `--compile`
-					// extras are required.
-					"--outfile",
-					`packages/coding-agent/dist/${outName}`,
-				],
-				buildEnv,
+			await compileCodingAgent({
 				repoRoot,
-			);
+				entrypoint: path.join(packageDir, "src", "cli.ts"),
+				outfile: outputPath,
+				transformersVersion,
+				target: crossBuild?.target,
+				external: ["fastembed", "onnxruntime-node"],
+				skipBuiltinCodesign: shouldAdhocSignDarwinBinary(),
+			});
 
 			// Bun 1.3.12 emits a truncated Mach-O signature on darwin builds.
 			if (shouldAdhocSignDarwinBinary()) {
@@ -128,7 +112,6 @@ async function main(): Promise<void> {
 		}
 	} finally {
 		await runCommand(["bun", "--cwd=../stats", "run", "gen:stats:reset"]);
-		await runCommand(["bun", "run", "gen:docs:reset"]);
 	}
 }