omnirush 0.1.1 → 0.2.0

package/assets/extensions/omnirush/commands.ts

@@ -1,22 +1,38 @@
 /**
- * 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).
+ * Omnirush commands: /grant (today's token grant + usage) and /verify
+ * (prove the served model is genuine — full implementation lands with the
+ * gateway's model-attestation endpoint), plus the footer status line that
+ * keeps grant/model info visible while the agent runs.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { gatewayUsage } from "./usage";
+import { deviceMe, resolveOrigin } from "./auth";
+import { formatGrantLines, formatGrantStatusLine, gatewayUsage } from "./usage";
+
+/** Fetch the signed-in identity + server-side usage, best effort. */
+async function fetchIdentity(): Promise<any> {
+  const token = (process.env.OMNIRUSH_TOKEN || "").trim();
+  if (!token) return null;
+  try {
+    return await deviceMe(resolveOrigin(process.env), {
+      accessToken: token,
+      fetchImpl: globalThis.fetch,
+    });
+  } catch {
+    return null;
+  }
+}
 
 export default function (pi: ExtensionAPI) {
   pi.registerCommand("grant", {
     description: "Show today's Omnirush token grant and usage",
     handler: async (ctx: any) => {
       const usage = gatewayUsage();
+      const me = await fetchIdentity();
+      const sessionId = ctx?.sessionManager?.getSessionId?.() ?? undefined;
+      const lines = formatGrantLines({ usage, me, sessionId });
       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"}.`,
+        ["Omnirush usage:", ...lines.map((line) => `  ${line}`)].join("\n"),
       );
     },
   });
@@ -31,4 +47,14 @@ export default function (pi: ExtensionAPI) {
       );
     },
   });
+
+  // Footer status: grant remaining + served model, refreshed on every
+  // provider response (the sota tap records the headers into the shared
+  // usage store before this event fires) and on model switches.
+  const refreshStatus = (ctx: any) => {
+    const line = formatGrantStatusLine(gatewayUsage());
+    if (line) ctx?.ui?.setStatus?.("omnirush-grant", line);
+  };
+  pi.on("after_provider_response", (_event: any, ctx: any) => refreshStatus(ctx));
+  pi.on("model_select", (_event: any, ctx: any) => refreshStatus(ctx));
 }

package/assets/extensions/omnirush/sota.ts

@@ -24,25 +24,39 @@ import {
   formatSotaWarning,
   servedModelFromSseData,
 } from "./sota-lib";
+import { recordGatewayUsage } from "./usage";
 
 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 },
-};
+// modelsConfig / MODELS) 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_MODELS = [
+  {
+    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 },
+  },
+  {
+    id: "gpt-5.6-sol",
+    name: "GPT-5.6 Sol",
+    api: "openai-responses",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+  },
+];
 
 function warnStderr(line: string): void {
   try {
@@ -123,6 +137,14 @@ function tapFetch(
   return async (input: any, init: any) => {
     let response = await baseFetch(input, init);
     debug(`provider fetch ${typeof input === "string" ? input : input?.url} -> ${response?.status}`);
+    // Capture the gateway's grant/usage headers (x-omnirush-* plus the
+    // x-ratelimit-*-tokens grant pair) straight from the raw response —
+    // guaranteed availability here, independent of pi's event plumbing.
+    try {
+      recordGatewayUsage(response?.headers);
+    } catch {
+      /* usage capture must never break the request */
+    }
     if (response?.status === 401) {
       const tokenUsed = bearerFromInit(init) || bearerFromInit(input);
       debug(`401 seen; bearer present: ${Boolean(tokenUsed)}`);
@@ -214,7 +236,7 @@ export default function (pi: any) {
         },
       },
     },
-    getModels: () => [CATALOG_MODEL],
+    getModels: () => CATALOG_MODELS.map((model) => ({ ...model })),
     stream: streamWith(false),
     streamSimple: streamWith(true),
   });

package/assets/extensions/omnirush/usage.ts

@@ -1,16 +1,54 @@
-// Latest x-omnirush-* gateway headers (grant/usage info the manager
-// attaches to /v1 responses). Kept for /grant and trace events; never
-// contains credentials.
+// Latest gateway grant/usage state, captured from response headers the
+// manager attaches to /v1 responses. Kept for /grant and the footer status
+// line; never contains credentials.
+//
+// Live header contract (verified 2026-09-22 against the production
+// gateway, omnirush/manager gateway.py):
+//   x-omnirush-model                  - resolved request model
+//   x-omnirush-effort                 - requested reasoning effort (set when present)
+//   x-ratelimit-limit-tokens          - daily grant size
+//   x-ratelimit-remaining-tokens      - grant remaining after settlement lag
 
-let latest: Record<string, string> | null = null;
+export const GRANT_HEADER_NAMES = [
+  "x-ratelimit-limit-tokens",
+  "x-ratelimit-remaining-tokens",
+];
 
-export function recordGatewayUsage(headers: unknown): Record<string, string> | null {
-  if (!headers || typeof headers !== "object") return null;
+function* headerPairs(headers: unknown): Generator<[string, string]> {
+  if (!headers) return;
+  if (typeof (headers as any).forEach === "function") {
+    // Fetch Headers instance (the sota tap sees the raw Response).
+    const pairs: [string, string][] = [];
+    (headers as Headers).forEach((value, name) => pairs.push([name, value]));
+    for (const pair of pairs) yield pair;
+    return;
+  }
+  if (typeof headers === "object") {
+    for (const [name, value] of Object.entries(headers as Record<string, unknown>)) {
+      if (value !== undefined && value !== null) yield [name, String(value)];
+    }
+  }
+}
+
+/** Extract the gateway usage headers from a Headers object or plain record. */
+export function pickGatewayUsage(headers: unknown): Record<string, string> {
   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);
+  for (const [name, value] of headerPairs(headers)) {
+    const lower = name.toLowerCase();
+    if (
+      lower.startsWith("x-omnirush-") ||
+      GRANT_HEADER_NAMES.includes(lower)
+    ) {
+      found[lower] = value;
+    }
   }
+  return found;
+}
+
+let latest: Record<string, string> | null = null;
+
+export function recordGatewayUsage(headers: unknown): Record<string, string> | null {
+  const found = pickGatewayUsage(headers);
   const hasAny = Object.keys(found).length > 0;
   latest = hasAny ? found : latest;
   return hasAny ? found : null;
@@ -19,3 +57,97 @@ export function recordGatewayUsage(headers: unknown): Record<string, string> | n
 export function gatewayUsage(): Record<string, string> | null {
   return latest;
 }
+
+/** Ints from the grant header pair, when both are present. */
+export function grantFromUsage(usage: Record<string, string> | null): {
+  limitTokens: number;
+  remainingTokens: number;
+} | null {
+  const limit = Number(usage?.["x-ratelimit-limit-tokens"]);
+  const remaining = Number(usage?.["x-ratelimit-remaining-tokens"]);
+  if (!Number.isFinite(limit) || !Number.isFinite(remaining)) return null;
+  return { limitTokens: limit, remainingTokens: remaining };
+}
+
+/** Compact human token count: 1.0B / 997.2M / 12.3k / 972. */
+export function formatTokenCount(value: number): string {
+  if (!Number.isFinite(value)) return "?";
+  const abs = Math.abs(value);
+  if (abs >= 1e9) return `${(value / 1e9).toFixed(1)}B`;
+  if (abs >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
+  if (abs >= 1e3) return `${(value / 1e3).toFixed(1)}k`;
+  return String(Math.round(value));
+}
+
+function intOr(value: unknown): number | null {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+/**
+ * The lines /grant shows. Everything is best-effort: header data when the
+ * agent has made a request, /device/me identity+usage otherwise.
+ */
+export function formatGrantLines({
+  usage,
+  me,
+  sessionId,
+}: {
+  usage: Record<string, string> | null;
+  me?: any;
+  sessionId?: string;
+}): string[] {
+  const lines: string[] = [];
+  const model =
+    usage?.["x-omnirush-model"] ?? me?.current_model ?? null;
+  const effort = usage?.["x-omnirush-effort"] ?? null;
+  lines.push(`model (last turn): ${model ?? "no request yet"}`);
+  if (effort) lines.push(`reasoning effort: ${effort}`);
+
+  const fromHeaders = grantFromUsage(usage);
+  const meUsage = me?.usage ?? null;
+  const limit =
+    fromHeaders?.limitTokens ?? intOr(meUsage?.token_limit) ?? null;
+  const remaining =
+    fromHeaders?.remainingTokens ?? intOr(meUsage?.remaining_tokens) ?? null;
+  const usedFromMe = intOr(meUsage?.used_tokens);
+  const used =
+    usedFromMe ??
+    (limit !== null && remaining !== null ? limit - remaining : null);
+
+  if (limit !== null && remaining !== null) {
+    lines.push(
+      `grant: ${formatTokenCount(remaining)} of ${formatTokenCount(limit)} tokens remaining` +
+        (used !== null ? ` (used ${formatTokenCount(used)})` : ""),
+    );
+  } else if (used !== null) {
+    lines.push(`grant used: ${formatTokenCount(used)} tokens`);
+  }
+  if (meUsage?.grant_date) lines.push(`grant date: ${meUsage.grant_date}`);
+
+  const devices = Array.isArray(me?.devices) ? me.devices.length : null;
+  if (devices !== null) {
+    lines.push(`devices signed in: ${devices}`);
+  }
+  if (sessionId) {
+    lines.push(`session: ${sessionId.slice(0, 8)}`);
+  }
+  return lines;
+}
+
+/** One-line footer summary for the TUI status area, or null with no data. */
+export function formatGrantStatusLine(
+  usage: Record<string, string> | null,
+): string | null {
+  const fromHeaders = grantFromUsage(usage);
+  const model = usage?.["x-omnirush-model"];
+  if (!fromHeaders && !model) return null;
+  const parts: string[] = [];
+  if (fromHeaders) {
+    parts.push(
+      `${formatTokenCount(fromHeaders.remainingTokens)} tok left`,
+    );
+  }
+  if (model) parts.push(model);
+  return parts.length > 0 ? parts.join(" · ") : null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",
@@ -12,7 +12,7 @@
   },
   "scripts": {
     "test": "node --test",
-    "postinstall": "node scripts/postinstall.js"
+    "postinstall": "node scripts/patch-pi-branding.js && node scripts/postinstall.js"
   },
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.86.1"

package/scripts/package.sh

@@ -14,6 +14,17 @@ elif [ "$PLATFORM" = "windows-x64" ]; then
 else
   cp ".runtime/bun-$PLATFORM/bin/bun" "$STAGE/.runtime/bin/bun"
 fi
+# Search tools (fd, rg): bundled so the agent never attempts its own
+# GitHub download at startup.
+TOOL_EXT=""
+[ "$PLATFORM" = "windows-x64" ] && TOOL_EXT=".exe"
+for tool in fd rg; do
+  if [ -f ".runtime/bin/$tool$TOOL_EXT" ]; then
+    cp ".runtime/bin/$tool$TOOL_EXT" "$STAGE/.runtime/bin/$tool$TOOL_EXT"
+  else
+    echo "warning: .runtime/bin/$tool$TOOL_EXT missing — run scripts/postinstall.js first" >&2
+  fi
+done
 if [[ "$PLATFORM" == windows* ]]; then
   zip -q -r "$STAGE.zip" "$STAGE"
 else

package/scripts/patch-pi-branding.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+// Rebrand the vendored agent core (@earendil-works/pi-coding-agent) so
+// users see "omnirush", never "pi"/"Pi". Runs on postinstall (before the
+// bun download) and is safe to re-run (idempotent).
+//
+// Two mechanisms:
+//   1. package.json `piConfig.name = "omnirush"` — pi's supported rebrand
+//      hook. APP_NAME/APP_TITLE (banner logo "omnirush v0.86.1", terminal
+//      title, --help usage lines, auth hints, debug-log name, the
+//      <APP>_CODING_AGENT_DIR env var) all derive from it, in dist and in
+//      the runtime bundle. It also disables pi's official-distribution
+//      first-time-setup wizard (upstream treats forks/rebrands that way).
+//   2. Literal string replacements across the installed dist/*.js (the
+//      standalone files and the runtime bundle chunks) for the handful of
+//      user-visible strings that do not go through APP_NAME.
+//
+// Never renamed: file paths, config/session directory names, function or
+// variable identifiers, env-var names (PI_OFFLINE, PI_TELEMETRY, ... are
+// the core's real env contract), or the `pi` admin-subcommand aliases —
+// only display strings.
+//
+// Fail-soft: a core update that moved a string logs a warning; it never
+// breaks `npm install`.
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PKG = "@earendil-works/pi-coding-agent";
+const BRAND = "omnirush";
+
+// Display strings that do not flow through APP_NAME. `from` must match the
+// installed dist exactly; applied with replaceAll to every dist/**/*.js.
+export const REPLACEMENTS = [
+  {
+    label: "TUI banner onboarding line",
+    from: "Pi can explain its own features and look up its docs. Ask it how to use or extend Pi.",
+    to: "Omnirush can explain its own features and look up its docs. Ask it how to use or extend Omnirush.",
+  },
+  {
+    label: "system prompt persona",
+    from: "operating inside pi, a coding agent harness",
+    to: "operating inside omnirush, a coding agent harness",
+  },
+  {
+    label: "system prompt docs section header",
+    from:
+      "Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):",
+    to: "Omnirush documentation (read only when the user asks about the agent itself, its SDK, extensions, themes, skills, or TUI):",
+  },
+  {
+    label: "system prompt docs reading rule",
+    from: "When reading pi docs or examples",
+    to: "When reading the bundled docs or examples",
+  },
+  {
+    label: "system prompt packages doc reference",
+    from: "pi packages (docs/packages.md)",
+    to: "agent packages (docs/packages.md)",
+  },
+  {
+    label: "system prompt topics rule",
+    from: "When working on pi topics, read the docs and examples",
+    to: "When working on agent topics, read the docs and examples",
+  },
+  {
+    label: "system prompt read-fully rule",
+    from: "Always read pi .md files completely",
+    to: "Always read the agent .md files completely",
+  },
+  {
+    label: "bug report persona",
+    from: "about pi, the coding agent they are talking to",
+    to: "about omnirush, the coding agent they are talking to",
+  },
+  {
+    label: "bug report recipient",
+    from: "Write a report for the pi developers",
+    to: "Write a report for the omnirush developers",
+  },
+  {
+    label: "--help update line",
+    from: "Update pi, extensions, or model catalogs",
+    to: "Update the agent, extensions, or model catalogs",
+  },
+  {
+    label: "--help update alias token",
+    from: "[source|self|pi]",
+    to: "[source|self]",
+  },
+  {
+    label: "update subcommand description",
+    from: "Update pi only (self works as alias to pi)",
+    to: "Update the agent only (self works as an alias)",
+  },
+];
+
+function findPiRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 8; i++) {
+    const candidate = path.join(dir, "node_modules", PKG);
+    if (fs.existsSync(path.join(candidate, "package.json"))) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+
+function listDistFiles(root) {
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (entry.isFile() && entry.name.endsWith(".js")) out.push(full);
+    }
+  }
+  return out;
+}
+
+/**
+ * Apply the rebrand to the installed core. Returns a report:
+ *   { piRoot, packageJsonPatched, applied: [{label, files}], missing: [{label, reason}] }
+ */
+export function applyBrandingPatches(startDir) {
+  const piRoot = findPiRoot(startDir);
+  if (!piRoot) {
+    return { piRoot: null, packageJsonPatched: false, applied: [], missing: [{ label: "core", reason: `${PKG} not installed` }] };
+  }
+
+  // 1. The supported rebrand hook.
+  let packageJsonPatched = false;
+  const pkgPath = path.join(piRoot, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  if (pkg.piConfig?.name !== BRAND) {
+    pkg.piConfig = { ...(pkg.piConfig || {}), name: BRAND };
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    packageJsonPatched = true;
+  }
+
+  // 2. Literal display strings, everywhere under dist/.
+  const applied = [];
+  const missing = [];
+  const files = listDistFiles(path.join(piRoot, "dist"));
+  for (const replacement of REPLACEMENTS) {
+    let hits = 0;
+    for (const file of files) {
+      let content;
+      try {
+        content = fs.readFileSync(file, "utf8");
+      } catch {
+        continue;
+      }
+      if (!content.includes(replacement.from)) continue;
+      fs.writeFileSync(file, content.replaceAll(replacement.from, replacement.to));
+      hits++;
+    }
+    if (hits > 0) applied.push({ label: replacement.label, files: hits });
+    else missing.push({ label: replacement.label, reason: "target string not found (already applied or core updated)" });
+  }
+  return { piRoot, packageJsonPatched, applied, missing };
+}
+
+function main() {
+  const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+  const report = applyBrandingPatches(repoRoot);
+  if (!report.piRoot) {
+    console.log("omnirush: agent core not installed; skipped branding patch");
+    return;
+  }
+  const patched = report.packageJsonPatched ? "package.json + " : "";
+  console.log(
+    `omnirush: branding applied (${patched}${report.applied.length} display strings)` +
+      (report.missing.length > 0 ? `; ${report.missing.length} already-applied/absent` : ""),
+  );
+}
+
+// CLI entry (postinstall). Imported as a module by tests — never exit there.
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    main();
+  } catch (error) {
+    // Fail-soft: a cosmetic patch must never break `npm install`.
+    console.warn("omnirush: branding patch skipped:", error?.message ?? error);
+  }
+}

package/scripts/postinstall.js

@@ -1,12 +1,24 @@
-// Downloads the platform bun runtime (v1.4.2) on install so `omnirush`
-// works immediately on linux / macOS / Windows.
+// Postinstall runtime fetcher:
+//   1. bun (v1.4.2)   — required; the agent core runs on it.
+//   2. fd (v10.5.0)   — optional; the agent's file search + autocomplete.
+//   3. rg (v15.2.0)   — optional; the agent's content search.
+//
+// Binaries land in .runtime/bin/ (per-platform release packages ship the
+// same layout prebuilt). The launcher copies fd/rg into the agent's
+// managed-bin dir on every run, so the agent never attempts its own
+// GitHub download at startup (which fails on restricted networks and
+// repeats on every launch). fd/rg failures are warnings: search degrades
+// gracefully without them. A bun failure stays fatal.
 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 BUN_VERSION = "bun-v1.4.2";
+// fd release tags are v-prefixed; ripgrep tags are bare ("15.2.0").
+const FD_VERSION = "v10.5.0";
+const RG_VERSION = "15.2.0";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, "..");
 const RUNTIME = path.join(ROOT, ".runtime", "bin");
@@ -18,6 +30,10 @@ function platform() {
   return `${plat}-${arch}`;
 }
 
+function exe(name) {
+  return name + (process.platform === "win32" ? ".exe" : "");
+}
+
 function get(url, redirects = 0) {
   if (redirects > 5) throw new Error("too many redirects");
   return new Promise((resolve, reject) => {
@@ -57,22 +73,98 @@ function extractZip(buf, 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");
+function extractTarGz(buf, dest, stamp) {
+  const tmp = path.join(dest, stamp);
+  fs.writeFileSync(tmp, buf);
+  // tar handles .tar.gz on linux/macOS; Windows 10+ ships bsdtar in
+  // System32 (the agent core relies on the same thing).
+  try {
+    execFileSync("tar", ["xzf", tmp, "-C", dest]);
+  } catch {
+    execFileSync("python3", ["-m", "tarfile", "-e", tmp, "-C", dest]);
+  }
+  fs.rmSync(tmp, { force: true });
+}
+
+function findFile(rootDir, fileName) {
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isFile() && entry.name === fileName) return full;
+      if (entry.isDirectory()) stack.push(full);
+    }
+  }
+  return null;
+}
+
+async function fetchBun(plat) {
+  const existing = path.join(RUNTIME, exe("bun"));
   if (fs.existsSync(existing)) return;
-  const plat = platform();
-  const zipUrl = `https://github.com/oven-sh/bun/releases/download/${VERSION}/bun-${plat}.zip`;
+  const zipUrl = `https://github.com/oven-sh/bun/releases/download/${BUN_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);
+  const src = path.join(ROOT, `bun-${plat}`, exe("bun"));
   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");
 }
 
+// fd/rg release archives both nest the binary under a versioned directory
+// (fd-v10.5.0-x86_64-unknown-linux-musl/fd, ripgrep-15.2.0-.../rg).
+async function fetchSearchTool(name, version, repo, archiveName, plat) {
+  const existing = path.join(RUNTIME, exe(name));
+  if (fs.existsSync(existing)) return;
+  const isZip = plat === "windows-x64";
+  const asset = isZip ? `${archiveName}.zip` : `${archiveName}.tar.gz`;
+  const url = `https://github.com/${repo}/releases/download/${version}/${asset}`;
+  process.stdout.write(`omnirush: downloading ${name} (${plat})...\n`);
+  const buf = await get(url);
+  fs.mkdirSync(RUNTIME, { recursive: true });
+  const extractDir = path.join(RUNTIME, `extract-${name}`);
+  fs.mkdirSync(extractDir, { recursive: true });
+  if (isZip) extractZip(buf, extractDir);
+  else extractTarGz(buf, extractDir, asset);
+  const found = findFile(extractDir, exe(name));
+  if (!found) throw new Error(`${exe(name)} not found in ${asset}`);
+  fs.copyFileSync(found, existing);
+  if (process.platform !== "win32") fs.chmodSync(existing, 0o755);
+  fs.rmSync(extractDir, { recursive: true, force: true });
+}
+
+function fdAsset(plat) {
+  const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
+  if (plat === "windows-x64") return `fd-${FD_VERSION}-${arch}-pc-windows-msvc`;
+  if (plat === "darwin-x64" || plat === "darwin-aarch64") return `fd-${FD_VERSION}-${arch}-apple-darwin`;
+  return `fd-${FD_VERSION}-${arch}-unknown-linux-musl`;
+}
+
+function rgAsset(plat) {
+  const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
+  if (plat === "windows-x64") return `ripgrep-${RG_VERSION}-${arch}-pc-windows-msvc`;
+  if (plat === "darwin-x64" || plat === "darwin-aarch64") return `ripgrep-${RG_VERSION}-${arch}-apple-darwin`;
+  return `ripgrep-${RG_VERSION}-${arch}-unknown-linux-musl`;
+}
+
+async function main() {
+  const plat = platform();
+  await fetchBun(plat);
+  for (const [name, version, repo, archive] of [
+    ["fd", FD_VERSION, "sharkdp/fd", fdAsset(plat)],
+    ["rg", RG_VERSION, "BurntSushi/ripgrep", rgAsset(plat)],
+  ]) {
+    try {
+      await fetchSearchTool(name, version, repo, archive, plat);
+    } catch (error) {
+      // Optional tools: warn and continue (the launcher only installs what
+      // exists; the agent degrades to PATH lookup / built-in search).
+      console.warn(`omnirush: ${name} download failed (search may be degraded):`, error.message);
+    }
+  }
+}
+
 main().catch((e) => { console.error("omnirush postinstall:", e.message); process.exit(1); });

package/src/bin.js

@@ -18,10 +18,12 @@
 //   OMNIRUSH_GATEWAY_URL  provider base URL override ({origin}/v1)
 //   OMNIRUSH_DIR          state dir override (default ~/.omnirush)
 //   OMNIRUSH_MODEL        model override for plain runs (default
-//                         gpt-6-astra; user --model still wins)
+//                         gpt-6-astra; gpt-5.6-sol also available; user
+//                         --model still wins)
 //
-// Agent runs default to `--provider omnirush --model gpt-6-astra` (SOTA
-// only — charter rule 1). The sota extension watches every response,
+// Agent runs default to `--provider omnirush --model gpt-6-astra`; the
+// catalog also carries gpt-5.6-sol (`--model gpt-5.6-sol` or
+// OMNIRUSH_MODEL=gpt-5.6-sol). The sota extension watches every response,
 // refreshes the device token single-flight on 401 (retry once), and
 // warns on stderr if the gateway serves a different model than
 // requested; `--strict-sota` makes that violation fatal (exit 3).
@@ -42,6 +44,7 @@ import {
   withModelDefaults,
   resolveModelDefaults,
 } from "./lib.js";
+import { installManagedTools } from "./tools.js";
 import {
   clearAuth,
   deviceAuthorize,
@@ -99,6 +102,11 @@ function ensureDirs() {
   fs.mkdirSync(OMNI_DIR, { recursive: true, mode: 0o700 });
   fs.mkdirSync(PI_AGENT_DIR, { recursive: true });
   fs.mkdirSync(PI_EXT_DIR, { recursive: true });
+  try {
+    installManagedTools({ agentDir: PI_AGENT_DIR, runtimeRoot: path.resolve(__dirname, "..", ".runtime") });
+  } catch {
+    /* best effort — pi falls back to PATH, then its own downloader */
+  }
 }
 
 // Merge our provider into the user's models.json without clobbering
@@ -355,8 +363,39 @@ async function cmdDoctor() {
 
   installModelsJson(gateway);
   installExtensions();
-  ok("pi config", true, PI_MODELS_JSON);
+  try {
+    installManagedTools({ agentDir: PI_AGENT_DIR, runtimeRoot: path.resolve(__dirname, "..", ".runtime") });
+  } catch {
+    /* best effort */
+  }
+  ok("agent config", true, PI_MODELS_JSON);
   ok("extensions", true, PI_EXT_DIR);
+  // Search tools: bundled fd/rg (or system ones) keep the agent off its
+  // GitHub download path, which fails on restricted networks.
+  const toolsRoot = path.join(PI_AGENT_DIR, "bin");
+  for (const tool of ["fd", "rg"]) {
+    const exe = process.platform === "win32" ? ".exe" : "";
+    const managed = path.join(toolsRoot, tool + exe);
+    const hasManaged = fs.existsSync(managed);
+    let viaPath = false;
+    if (!hasManaged) {
+      for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+        if (!dir) continue;
+        try {
+          fs.accessSync(path.join(dir, tool + exe), fs.constants.X_OK);
+          viaPath = true;
+          break;
+        } catch {
+          /* next */
+        }
+      }
+    }
+    ok(
+      `search tool ${tool}`,
+      hasManaged || viaPath,
+      hasManaged ? managed : viaPath ? "found on PATH" : "missing — find/autocomplete degraded",
+    );
+  }
   process.exit(healthy ? 0 : 1);
 }
 
@@ -385,9 +424,13 @@ function childEnv(auth) {
     OMNIRUSH_ORIGIN: origin,
     OMNIRUSH_GATEWAY_URL: gateway,
     OMNIRUSH_DIR: OMNI_DIR,
-    // pi resolves its config dir from this env var; keep the child pi on
-    // exactly the models.json/extensions bin.js just installed.
+    // The agent resolves its config dir from <APP>_CODING_AGENT_DIR. The
+    // branding patch renames the app to omnirush, so set the omnirush
+    // spelling; the pi spelling stays for unpatched cores.
+    OMNIRUSH_CODING_AGENT_DIR: PI_AGENT_DIR,
     PI_CODING_AGENT_DIR: PI_AGENT_DIR,
+    // The agent core is a fork/rebrand: never phone home to pi.dev.
+    PI_TELEMETRY: "0",
   };
 }
 
@@ -433,7 +476,7 @@ if (cmd === "login") await cmdLogin(argv.slice(1));
 else if (cmd === "logout") await cmdLogout();
 else if (cmd === "whoami") await cmdWhoami();
 else if (cmd === "doctor") await cmdDoctor();
-else if (cmd === "--version" || cmd === "-v") console.log("omnirush 0.2.0 (pi core)");
+else if (cmd === "--version" || cmd === "-v") console.log("omnirush 0.2.0");
 else if (cmd === "collect") await cmdCollect(argv.slice(1));
 else if (cmd === undefined || cmd === "run") await cmdRun();
 else {

package/src/lib.js

@@ -67,7 +67,8 @@ const VALUE_FLAGS = new Set([
 
 /**
  * Model defaults for plain `omnirush` runs. OMNIRUSH_MODEL overrides the
- * default model (e.g. to pin a thinking level like "gpt-6-astra:high").
+ * default model — any catalog id below, optionally with a thinking level
+ * like "gpt-6-astra:high" or "gpt-5.6-sol:xhigh".
  */
 export function resolveModelDefaults(env = process.env) {
   return {
@@ -76,6 +77,35 @@ export function resolveModelDefaults(env = process.env) {
   };
 }
 
+// The product's shipped catalog: gpt-6-astra (default) and gpt-5.6-sol.
+// Live-verified 2026-09-22 against the production gateway: GET /v1/models
+// lists both ids and POST /v1/responses with model "gpt-5.6-sol" is served
+// as gpt-5.6-sol (x-omnirush-model response header + the model named in
+// every SSE frame), so the client may offer the switch honestly.
+export const 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 },
+  },
+  {
+    id: "gpt-5.6-sol",
+    name: "GPT-5.6 Sol",
+    reasoning: true,
+    input: ["text", "image"],
+    // Sol list pricing is not published; pi's cost display therefore shows
+    // zeros for it (documented default when cost is omitted).
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    // Same codex backend family as astra; same context window.
+    contextWindow: 400000,
+    compat: { supportsMaxOutputTokens: false },
+  },
+];
+
 /**
  * Prepend `--provider`/`--model` defaults for agent runs, without
  * duplicating flags the user already specified. Consumption rules mirror
@@ -145,12 +175,13 @@ export function withModelDefaults(args, defaults) {
 
 /**
  * The provider/models.json payload omnirush installs into pi. This is the
- * product's shipped model catalog: SOTA only (charter rule 1). The served
- * model is forced server-side by the gateway; the client SOTA guard stays
- * on as verification.
+ * product's shipped model catalog (MODELS above). The gateway allow-lists
+ * the same ids server-side; the client SOTA guard stays on as verification
+ * (it compares the model named in the response frames against the one
+ * requested).
  *
  * Hard-won compat fact: the codex backend rejects
- * `max_output_tokens`, so the model sets
+ * `max_output_tokens`, so every model sets
  * `compat.supportsMaxOutputTokens: false` and ships no maxTokens — pi would
  * otherwise clamp a default and break every request.
  */
@@ -162,18 +193,22 @@ export function modelsConfig({ gatewayUrl } = {}) {
         baseUrl: gatewayUrl ?? DEFAULT_GATEWAY_URL,
         api: "openai-responses",
         apiKey: "$OMNIRUSH_TOKEN",
-        models: [
-          {
-            id: DEFAULT_MODEL,
-            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 },
-          },
-        ],
+        models: MODELS.map((model) => ({ ...model })),
       },
     },
   };
 }
+
+/**
+ * Pure mapping of the bundled search-tool binaries for the launcher: pi
+ * looks for managed `fd`/`rg` in <agentDir>/bin first and downloads from
+ * GitHub when absent. We ship both binaries and the launcher places them
+ * there, so the agent never attempts (or repeats) a download.
+ */
+export function managedToolTargets({ platform = process.platform, runtimeRoot } = {}) {
+  const ext = platform === "win32" ? ".exe" : "";
+  return [
+    { tool: "fd", source: `${runtimeRoot}/bin/fd${ext}`, dest: `bin/fd${ext}` },
+    { tool: "rg", source: `${runtimeRoot}/bin/rg${ext}`, dest: `bin/rg${ext}` },
+  ];
+}

package/src/tools.js

@@ -0,0 +1,40 @@
+// Managed search-tool install (fd, rg) for the agent core.
+//
+// pi checks <agentDir>/bin for managed fd/rg first and, when absent,
+// downloads them from GitHub at every agent startup — on restricted
+// networks that download fails and the attempt repeats on every launch,
+// breaking the find tool and file autocomplete. We bundle the binaries
+// (.runtime/bin, filled by postinstall or the release package) and the
+// launcher places them exactly where pi looks. Best effort: any failure
+// leaves the agent to its own PATH lookup / downloader.
+
+import fs from "node:fs";
+import path from "node:path";
+
+import { managedToolTargets } from "./lib.js";
+
+export function installManagedTools({
+  agentDir,
+  runtimeRoot,
+  platform = process.platform,
+  fsImpl = fs,
+} = {}) {
+  const installed = [];
+  if (!agentDir || !runtimeRoot) return installed;
+  for (const target of managedToolTargets({ platform, runtimeRoot })) {
+    const dest = path.join(agentDir, target.dest);
+    if (fsImpl.existsSync(dest)) continue;
+    if (!fsImpl.existsSync(target.source)) continue;
+    fsImpl.mkdirSync(path.dirname(dest), { recursive: true });
+    fsImpl.copyFileSync(target.source, dest);
+    if (platform !== "win32") {
+      try {
+        fsImpl.chmodSync(dest, 0o755);
+      } catch {
+        /* best effort */
+      }
+    }
+    installed.push(target.tool);
+  }
+  return installed;
+}