omnirush 0.1.1

package/assets/extensions/omnirush/collector.ts

@@ -0,0 +1,100 @@
+// Omnirush workspace collection during agent sessions (pi extension).
+//
+// Owns the lifecycle: start snapshot on session start (pi session id,
+// workspace root = session cwd), trace events per turn/tool/provider
+// response, debounced change snapshots from the collector's watcher, and
+// trace + end snapshots on session shutdown (the shutdown handler is
+// awaited by pi, bounded below so a slow upload can't wedge exit).
+//
+// Silent no-op when there are no device credentials — collection only
+// runs for signed-in omnirush identities.
+
+import path from "node:path";
+
+import { gatewayUrlForOrigin, omniDir, resolveOrigin } from "./auth";
+import { WorkspaceCollector } from "./collector-lib";
+import { sharedRefresher } from "./refresh";
+import { recordGatewayUsage } from "./usage";
+
+const SHUTDOWN_UPLOAD_BUDGET_MS = 15_000;
+
+/** pi session ids are UUIDs; still, never let a foreign format stall us. */
+function sanitizeSessionId(raw: string): string {
+  const id = String(raw || "").replace(/[^A-Za-z0-9._:-]/g, "-").slice(0, 128);
+  return id.length >= 8 ? id : "";
+}
+
+export default function (pi: any) {
+  const origin = resolveOrigin(process.env);
+  const accessToken =
+    (process.env.OMNIRUSH_ACCESS_TOKEN || process.env.OMNIRUSH_TOKEN || "").trim();
+  const collector = new WorkspaceCollector({
+    gatewayUrl: process.env.OMNIRUSH_GATEWAY_URL || gatewayUrlForOrigin(origin),
+    accessToken,
+    stateDir: omniDir(),
+    refresh: accessToken
+      ? async (tokenUsed: string) => {
+          const refresher = sharedRefresher();
+          const ok = await refresher.refresh(tokenUsed).catch(() => false);
+          return ok ? refresher.auth?.accessToken ?? null : null;
+        }
+      : undefined,
+    log: (level, message) => {
+      if (level === "warn") {
+        try {
+          process.stderr.write(`omnirush collector: ${message}\n`);
+        } catch {
+          /* stderr may be closed late in shutdown */
+        }
+      }
+    },
+  });
+  if (!collector.enabled) return;
+
+  let sessionId = "";
+
+  pi.on("session_start", (event: any, ctx: any) => {
+    sessionId = sanitizeSessionId(ctx?.sessionManager?.getSessionId?.() ?? "");
+    const root = ctx?.cwd || process.cwd();
+    if (!sessionId) return;
+    collector.startSession(sessionId, path.basename(root) || "workspace", root);
+    collector.recordTrace(sessionId, "session.start", { reason: event?.reason });
+  });
+
+  pi.on("turn_start", (event: any) => {
+    collector.recordTrace(sessionId, "turn.start", { turn_index: event?.turnIndex });
+  });
+
+  pi.on("turn_end", (event: any) => {
+    collector.recordTrace(sessionId, "turn.end", { turn_index: event?.turnIndex });
+  });
+
+  pi.on("tool_execution_start", (event: any) => {
+    collector.recordTrace(sessionId, "tool.start", { tool: event?.toolName });
+  });
+
+  pi.on("agent_end", () => {
+    collector.recordTrace(sessionId, "agent.end");
+  });
+
+  pi.on("after_provider_response", (event: any) => {
+    const usage = recordGatewayUsage(event?.headers);
+    collector.recordTrace(sessionId, "provider.response", {
+      status: event?.status,
+      ...(usage ? { omnirush: usage } : {}),
+    });
+  });
+
+  pi.on("session_shutdown", async () => {
+    if (!sessionId) return;
+    collector.finishSession(sessionId);
+    await Promise.race([
+      collector.stop(),
+      new Promise((resolve) => {
+        const timer = setTimeout(resolve, SHUTDOWN_UPLOAD_BUDGET_MS);
+        timer.unref?.();
+      }),
+    ]);
+    sessionId = "";
+  });
+}

package/assets/extensions/omnirush/commands.ts

@@ -0,0 +1,34 @@
+/**
+ * Omnirush commands: /grant (latest gateway grant/usage headers) and
+ * /verify (prove the served model is genuine — full implementation lands
+ * with the gateway's model-attestation endpoint).
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { gatewayUsage } from "./usage";
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("grant", {
+    description: "Show today's Omnirush token grant and usage",
+    handler: async (ctx: any) => {
+      const usage = gatewayUsage();
+      ctx.ui?.notify?.(
+        usage
+          ? `Omnirush gateway usage (latest x-omnirush-* headers): ${JSON.stringify(usage)}`
+          : `Omnirush: no gateway usage seen yet. Provider: ${process.env.PI_PROVIDER ?? "omnirush"}, ` +
+            `model: ${process.env.PI_MODEL ?? "gpt-6-astra"}.`,
+      );
+    },
+  });
+
+  pi.registerCommand("verify", {
+    description: "Verify the model serving your requests is genuine GPT-6 Astra",
+    handler: async (ctx: any) => {
+      // M2: POST /omnirush/verify → signed attestation compared against
+      // observed model behavior. v0 placeholder.
+      ctx.ui?.notify?.(
+        "verify: model attestation arrives with the gateway lane (M2).",
+      );
+    },
+  });
+}

package/assets/extensions/omnirush/index.ts

@@ -0,0 +1,18 @@
+// Omnirush extension entry point.
+//
+// pi discovers either extensions/*.ts files or extensions/<dir>/index.ts —
+// this index makes the whole omnirush extension directory load as one
+// extension (without it, none of these files were ever registered).
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import collector from "./collector";
+import commands from "./commands";
+import recorder from "./recorder";
+import sota from "./sota";
+
+export default function (pi: ExtensionAPI) {
+  commands(pi as any);
+  recorder(pi as any);
+  sota(pi as any);
+  collector(pi as any);
+}

package/assets/extensions/omnirush/recorder.ts

@@ -0,0 +1,38 @@
+/**
+ * Omnirush recorder indicator.
+ *
+ * Displays a persistent "REC" marker in the TUI header while a session is
+ * active. Omnirush captures agent traces + workspace data for consenting
+ * users; this indicator keeps that visible at all times (trust moat).
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+  let recording = false;
+
+  const show = () => {
+    try {
+      // ctx-level UI may not be available in every host mode; fail silent.
+      (pi as any).ctx?.ui?.setHeader?.((theme: any) => {
+        const rec = theme?.fg ? theme.fg("error", "● REC") : "● REC";
+        const name = theme?.fg ? theme.fg("accent", " omnirush") : " omnirush";
+        return [`${rec}${name}`];
+      });
+    } catch {
+      /* non-TUI host */
+    }
+  };
+
+  pi.on("session_start", () => {
+    recording = true;
+    show();
+  });
+
+  pi.on("agent_start", () => {
+    if (!recording) {
+      recording = true;
+      show();
+    }
+  });
+}

package/assets/extensions/omnirush/refresh.ts

@@ -0,0 +1,12 @@
+// Process-wide single-flight refresher shared by the sota guard and the
+// collector (both run inside the pi process). Lazily created from the
+// environment; refreshes rotate both tokens back to the state dir (0600).
+
+import { createRefresher, omniDir, resolveOrigin } from "./auth";
+
+let instance: ReturnType<typeof createRefresher> | null = null;
+
+export function sharedRefresher() {
+  instance ??= createRefresher({ dir: omniDir(), origin: resolveOrigin(process.env) });
+  return instance;
+}

package/assets/extensions/omnirush/sota-lib.ts

@@ -0,0 +1,62 @@
+// Pure helpers for the Omnirush SOTA guard (charter rule 1: SOTA models
+// only). Loaded by the sota extension and by node:test via jiti — keep
+// this module free of imports and side effects.
+
+/**
+ * Extract the served model from an OpenAI Responses SSE `data:` payload.
+ * Returns undefined for anything that is not a response.created /
+ * response.completed frame carrying a non-empty model string.
+ */
+export function servedModelFromSseData(data: string): string | undefined {
+  if (!data || data === "[DONE]") return undefined;
+  let obj: any;
+  try {
+    obj = JSON.parse(data);
+  } catch {
+    return undefined;
+  }
+  if (obj === null || typeof obj !== "object") return undefined;
+  if (obj.type !== "response.created" && obj.type !== "response.completed") {
+    return undefined;
+  }
+  const model = obj.response?.model;
+  return typeof model === "string" && model.length > 0 ? model : undefined;
+}
+
+/**
+ * Feed SSE text chunks in; every complete `data:` line is handed to
+ * `onData` (payload only, whitespace trimmed). Handles events split
+ * across chunk boundaries.
+ */
+export function createSseDataScanner(
+  onData: (data: string) => void,
+): (chunk: string) => void {
+  let buffer = "";
+  return (chunk: string) => {
+    buffer += chunk;
+    let idx: number;
+    while ((idx = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, idx).replace(/\r$/, "");
+      buffer = buffer.slice(idx + 1);
+      if (line.startsWith("data:")) onData(line.slice(5).trim());
+    }
+  };
+}
+
+/**
+ * The exact user-facing warning line for a served-model mismatch.
+ */
+export function formatSotaWarning(expected: string, served: string): string {
+  return (
+    `OMNIRUSH SOTA VIOLATION: requested ${expected} but received ${served} — ` +
+    "this turn violates the SOTA-only guarantee"
+  );
+}
+
+/**
+ * Charter rule 1 check: did the gateway serve something other than the
+ * requested model?
+ */
+export function isSotaViolation(expected: string, served: string): boolean {
+  return served !== expected;
+}

package/assets/extensions/omnirush/sota.ts

@@ -0,0 +1,221 @@
+// Omnirush SOTA guard (charter rule 1: SOTA models only).
+//
+// pi reports the served model for anthropic/openai-completions APIs, but
+// the openai-responses stream never surfaces it (pi-ai only extracts
+// response.id from response.created). So this extension registers a
+// native omnirush provider whose stream delegates to the built-in
+// openai-responses implementation with a tapped `fetch`. The tap:
+//   - reads response.created / response.completed frames as they stream
+//     through, compares the served model against the requested one, and
+//     warns loudly on stderr; --strict-sota makes that fatal (exit 3).
+//   - on a 401 from the gateway, runs the single-flight device-token
+//     refresh (rotate both tokens, persisted 0600) and retries the
+//     request exactly once — the GUI gateway-broker pattern.
+//
+// Registered during the extension factory, so the provider is queued and
+// becomes the composition base at runner init: every omnirush request is
+// guarded, including the very first.
+
+import fs from "node:fs";
+import { openAIResponsesApi } from "@earendil-works/pi-ai";
+import { sharedRefresher } from "./refresh";
+import {
+  createSseDataScanner,
+  formatSotaWarning,
+  servedModelFromSseData,
+} from "./sota-lib";
+
+const PROVIDER_ID = "omnirush";
+const GATEWAY_DEFAULT = "https://omnirush.ai/omnirush/v1";
+const STRICT_EXIT_CODE = 3;
+
+// Must mirror the models.json payload bin.js installs (src/lib.js
+// modelsConfig) so provider composition keeps serving the same catalog.
+// The `api` field is load-bearing: provider composition routes streams to
+// this base only when the model's api matches one of base.getModels().
+const CATALOG_MODEL = {
+  id: "gpt-6-astra",
+  name: "GPT-6 Astra",
+  api: "openai-responses",
+  reasoning: true,
+  input: ["text", "image"],
+  cost: { input: 10, output: 50, cacheRead: 2.5, cacheWrite: 12.5 },
+  contextWindow: 400000,
+  compat: { supportsMaxOutputTokens: false },
+};
+
+function warnStderr(line: string): void {
+  try {
+    fs.writeSync(2, `\n${line}\n`);
+  } catch {
+    // stderr may be closed late in shutdown; never crash the agent for a
+    // warning. The violation still influences the exit path below.
+  }
+}
+
+const debug = (line: string): void => {
+  if (process.env.OMNIRUSH_DEBUG === "1") warnStderr(`omnirush debug: ${line}`);
+};
+
+function reportViolation(strictSota: boolean, expected: string, served: string): void {
+  warnStderr(formatSotaWarning(expected, served));
+  if (strictSota) {
+    // Deliberately abrupt: in --print mode the non-zero exit is the
+    // contract (pipelines must not ship traces from a downgraded model);
+    // in the TUI refusing the turn is the honest behavior.
+    process.exit(STRICT_EXIT_CODE);
+  }
+}
+
+function bearerFromInit(init: any): string {
+  const headers = init?.headers;
+  try {
+    let authorization = "";
+    if (headers && typeof headers.get === "function") {
+      authorization = headers.get("authorization") ?? "";
+    } else if (Array.isArray(headers)) {
+      authorization =
+        headers.find(([name]: any) => String(name).toLowerCase() === "authorization")?.[1] ?? "";
+    } else if (headers && typeof headers === "object") {
+      for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === "authorization") authorization = String(value);
+      }
+    }
+    return authorization.startsWith("Bearer ") ? authorization.slice(7).trim() : "";
+  } catch {
+    return "";
+  }
+}
+
+function withBearer(init: any, token: string): any {
+  const headers = new Headers();
+  const original = init?.headers;
+  try {
+    if (original) {
+      if (typeof original.forEach === "function" && !Array.isArray(original)) {
+        original.forEach((value: any, name: string) => headers.set(name, value));
+      } else if (Array.isArray(original)) {
+        for (const [name, value] of original) headers.set(String(name), String(value));
+      } else {
+        for (const [name, value] of Object.entries(original)) headers.set(name, String(value));
+      }
+    }
+  } catch {
+    /* fall through with just the auth header */
+  }
+  headers.set("Authorization", `Bearer ${token}`);
+  return { ...(init ?? {}), headers };
+}
+
+/**
+ * Wrap a fetch implementation so that:
+ *   - 401 responses trigger one single-flight device-token refresh and a
+ *     single retry with the rotated token (gateway-broker pattern), and
+ *   - SSE response bodies stream through a pass-through tap that observes
+ *     the served model. Bytes are forwarded unmodified and non-SSE
+ *     responses (errors, JSON) are returned as-is.
+ */
+function tapFetch(
+  baseFetch: any,
+  expectedModelId: string,
+  onViolation: (expected: string, served: string) => void,
+): any {
+  return async (input: any, init: any) => {
+    let response = await baseFetch(input, init);
+    debug(`provider fetch ${typeof input === "string" ? input : input?.url} -> ${response?.status}`);
+    if (response?.status === 401) {
+      const tokenUsed = bearerFromInit(init) || bearerFromInit(input);
+      debug(`401 seen; bearer present: ${Boolean(tokenUsed)}`);
+      if (tokenUsed) {
+        const refresher = sharedRefresher();
+        const refreshed = await refresher.refresh(tokenUsed).catch((error) => {
+          debug(`refresh threw: ${error?.message ?? error}`);
+          return false;
+        });
+        const next = refresher.auth?.accessToken;
+        debug(`refresh ok: ${refreshed}, next token present: ${Boolean(next)}`);
+        if (refreshed && next) {
+          response = await baseFetch(input, withBearer(init, next));
+          debug(`retry status: ${response?.status}`);
+        }
+      }
+    }
+    try {
+      const contentType = String(response?.headers?.get?.("content-type") ?? "");
+      if (!response?.body || !contentType.includes("text/event-stream")) {
+        return response;
+      }
+      let reported = false;
+      const onData = (data: string) => {
+        if (reported) return;
+        const served = servedModelFromSseData(data);
+        if (served === undefined || served === expectedModelId) return;
+        reported = true;
+        onViolation(expectedModelId, served);
+      };
+      const scanner = createSseDataScanner(onData);
+      const decoder = new TextDecoder();
+      const passthrough = new TransformStream({
+        transform(chunk: any, controller: any) {
+          controller.enqueue(chunk);
+          scanner(decoder.decode(chunk, { stream: true }));
+        },
+      });
+      const body = response.body.pipeThrough(passthrough);
+      return new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    } catch {
+      // A tap failure must never break the request itself.
+      return response;
+    }
+  };
+}
+
+export default function (pi: any) {
+  pi.registerFlag("strict-sota", {
+    description:
+      "Exit non-zero if the gateway serves a different model than the requested Omnirush SOTA model",
+    type: "boolean",
+    default: false,
+  });
+
+  const responses = openAIResponsesApi();
+  const strictSota = (): boolean => pi.getFlag("strict-sota") === true;
+
+  const streamWith =
+    (simple: boolean) =>
+    (model: any, context: any, options: any) => {
+      const baseFetch = options?.fetch ?? globalThis.fetch;
+      const tapped = {
+        ...(options ?? {}),
+        fetch: tapFetch(baseFetch, model.id, (expected, served) =>
+          reportViolation(strictSota(), expected, served),
+        ),
+      };
+      return simple
+        ? responses.streamSimple(model, context, tapped)
+        : responses.stream(model, context, tapped);
+    };
+
+  pi.registerProvider({
+    id: PROVIDER_ID,
+    name: "Omnirush",
+    baseUrl: process.env.OMNIRUSH_GATEWAY_URL || GATEWAY_DEFAULT,
+    auth: {
+      apiKey: {
+        name: "Omnirush token",
+        async resolve() {
+          const key = process.env.OMNIRUSH_TOKEN;
+          if (!key) return undefined;
+          return { auth: { apiKey: key }, source: "environment" };
+        },
+      },
+    },
+    getModels: () => [CATALOG_MODEL],
+    stream: streamWith(false),
+    streamSimple: streamWith(true),
+  });
+}

package/assets/extensions/omnirush/usage.ts

@@ -0,0 +1,21 @@
+// Latest x-omnirush-* gateway headers (grant/usage info the manager
+// attaches to /v1 responses). Kept for /grant and trace events; never
+// contains credentials.
+
+let latest: Record<string, string> | null = null;
+
+export function recordGatewayUsage(headers: unknown): Record<string, string> | null {
+  if (!headers || typeof headers !== "object") return null;
+  const found: Record<string, string> = {};
+  for (const [name, value] of Object.entries(headers as Record<string, unknown>)) {
+    if (!name.toLowerCase().startsWith("x-omnirush-")) continue;
+    found[name] = String(value);
+  }
+  const hasAny = Object.keys(found).length > 0;
+  latest = hasAny ? found : latest;
+  return hasAny ? found : null;
+}
+
+export function gatewayUsage(): Record<string, string> | null {
+  return latest;
+}

package/assets/models.json

@@ -0,0 +1,21 @@
+{
+  "providers": {
+    "omnirush": {
+      "name": "Omnirush",
+      "baseUrl": "https://omnirush.ai/omnirush/v1",
+      "api": "openai-responses",
+      "apiKey": "$OMNIRUSH_TOKEN",
+      "models": [
+        {
+          "id": "gpt-6-astra",
+          "name": "GPT-6 Astra",
+          "reasoning": true,
+          "input": ["text", "image"],
+          "cost": { "input": 10, "output": 50, "cacheRead": 2.5, "cacheWrite": 12.5 },
+          "contextWindow": 400000,
+          "compat": { "supportsMaxOutputTokens": false },
+        }
+      ]
+    }
+  }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "omnirush",
+  "version": "0.1.1",
+  "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "omnirush": "src/bin.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "0.86.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/omnirush-ai/omnirush-cli.git"
+  },
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "cli"
+  ],
+  "files": [
+    "src",
+    "assets",
+    "scripts",
+    "README.md"
+  ]
+}

package/scripts/package.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Build a per-platform omnirush-cli package from this repo (local use).
+# Usage: scripts/package.sh [platform]   (linux-x64|darwin-aarch64|darwin-x64|windows-x64)
+set -euo pipefail
+PLATFORM="${1:-linux-x64}"
+STAGE="omnirush-cli-$PLATFORM"
+rm -rf "$STAGE" && mkdir -p "$STAGE"
+cp -r src assets package.json "$STAGE/"
+mkdir -p "$STAGE/.runtime/bin"
+if [ "$PLATFORM" = "linux-x64" ]; then
+  cp .runtime/bin/bun "$STAGE/.runtime/bin/bun"
+elif [ "$PLATFORM" = "windows-x64" ]; then
+  cp ".runtime/bun-windows-x64/bin/bun.exe" "$STAGE/.runtime/bin/bun.exe"
+else
+  cp ".runtime/bun-$PLATFORM/bin/bun" "$STAGE/.runtime/bin/bun"
+fi
+if [[ "$PLATFORM" == windows* ]]; then
+  zip -q -r "$STAGE.zip" "$STAGE"
+else
+  tar -czf "$STAGE.tar.gz" "$STAGE"
+fi
+echo "built $STAGE archive"

package/scripts/postinstall.js

@@ -0,0 +1,78 @@
+// Downloads the platform bun runtime (v1.4.2) on install so `omnirush`
+// works immediately on linux / macOS / Windows.
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import https from "node:https";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const VERSION = "bun-v1.4.2";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, "..");
+const RUNTIME = path.join(ROOT, ".runtime", "bin");
+
+function platform() {
+  const plat = process.platform; // linux | darwin | win32
+  const arch = process.arch === "arm64" ? "aarch64" : "x64";
+  if (plat === "win32") return "windows-x64";
+  return `${plat}-${arch}`;
+}
+
+function get(url, redirects = 0) {
+  if (redirects > 5) throw new Error("too many redirects");
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        return resolve(get(res.headers.location, redirects + 1));
+      }
+      if (res.statusCode !== 200) {
+        res.resume();
+        return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+      }
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+      res.on("error", reject);
+    }).on("error", reject);
+  });
+}
+
+function extractZip(buf, dest) {
+  // Zero-dependency zip extraction via the system unzip/tar when present,
+  // else fall back to PowerShell on Windows.
+  const tmp = path.join(dest, "omnirush-bun.zip");
+  fs.writeFileSync(tmp, buf);
+  const isWin = process.platform === "win32";
+  try {
+    if (isWin) {
+      execFileSync("powershell", ["-NoProfile", "-Command",
+        `Expand-Archive -Path '${tmp}' -DestinationPath '${dest}' -Force`]);
+    } else {
+      execFileSync("python3", ["-m", "zipfile", "-e", tmp, dest]);
+    }
+  } catch {
+    execFileSync("unzip", ["-o", "-q", tmp, "-d", dest]);
+  }
+  fs.rmSync(tmp, { force: true });
+}
+
+async function main() {
+  // Skip when bundled (GitHub release packages ship .runtime prebuilt).
+  const existing = path.join(RUNTIME, process.platform === "win32" ? "bun.exe" : "bun");
+  if (fs.existsSync(existing)) return;
+  const plat = platform();
+  const zipUrl = `https://github.com/oven-sh/bun/releases/download/${VERSION}/bun-${plat}.zip`;
+  process.stdout.write(`omnirush: downloading agent runtime (bun for ${plat})...\n`);
+  const buf = await get(zipUrl);
+  fs.mkdirSync(RUNTIME, { recursive: true });
+  extractZip(buf, ROOT);
+  const exe = process.platform === "win32" ? "bun.exe" : "bun";
+  const src = path.join(ROOT, `bun-${plat}`, exe);
+  fs.copyFileSync(src, existing);
+  if (process.platform !== "win32") fs.chmodSync(existing, 0o755);
+  fs.rmSync(path.join(ROOT, `bun-${plat}`), { recursive: true, force: true });
+  console.log("omnirush: runtime ready");
+}
+
+main().catch((e) => { console.error("omnirush postinstall:", e.message); process.exit(1); });