omnirush 0.1.1 → 0.3.0

package/assets/extensions/omnirush/collector.ts

@@ -14,9 +14,12 @@ import path from "node:path";
 import { gatewayUrlForOrigin, omniDir, resolveOrigin } from "./auth";
 import { WorkspaceCollector } from "./collector-lib";
 import { sharedRefresher } from "./refresh";
-import { recordGatewayUsage } from "./usage";
+import { recordGatewayUsage, storedUsageRecord } from "./usage";
 
-const SHUTDOWN_UPLOAD_BUDGET_MS = 15_000;
+// End snapshots are full-tree (reproducible environment) and chunked, so
+// shutdown can legitimately take minutes on big workspaces. Bounded so a
+// wedged upload still can't wedge exit.
+const SHUTDOWN_UPLOAD_BUDGET_MS = 120_000;
 
 /** pi session ids are UUIDs; still, never let a foreign format stall us. */
 function sanitizeSessionId(raw: string): string {
@@ -81,7 +84,8 @@ export default function (pi: any) {
     const usage = recordGatewayUsage(event?.headers);
     collector.recordTrace(sessionId, "provider.response", {
       status: event?.status,
-      ...(usage ? { omnirush: usage } : {}),
+      // Stored records stay brand-neutral (the traces are the product).
+      ...(usage ? { agent: storedUsageRecord(usage) } : {}),
     });
   });
 

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,113 @@ export function recordGatewayUsage(headers: unknown): Record<string, string> | n
 export function gatewayUsage(): Record<string, string> | null {
   return latest;
 }
+
+/**
+ * Usage record as embedded into STORED trace events: gateway header
+ * names are normalized so the stored artifacts carry no brand strings —
+ * "x-omnirush-model" -> "model", "x-omnirush-effort" -> "effort";
+ * generic headers (x-ratelimit-*) keep their names.
+ */
+export function storedUsageRecord(usage: Record<string, string>): Record<string, string> {
+  const stored: Record<string, string> = {};
+  for (const [name, value] of Object.entries(usage)) {
+    const lower = name.toLowerCase();
+    const key = lower.startsWith("x-omnirush-") ? lower.slice("x-omnirush-".length) : lower;
+    stored[key] = value;
+  }
+  return stored;
+}
+
+/** 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.3.0",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",
@@ -12,7 +12,8 @@
   },
   "scripts": {
     "test": "node --test",
-    "postinstall": "node scripts/postinstall.js"
+    "test:bun": "if [ -x .runtime/bin/bun ]; then .runtime/bin/bun test test/; else bun test test/; fi",
+    "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,224 @@
+#!/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;
+  // Version alignment: pi's self-reported version (banner/help) reads its
+  // own package.json — rewrite it to the omnirush release version so the
+  // product version, not upstream's, is what users and support see.
+  try {
+    const piPkgPath = path.join(report.piRoot, "package.json");
+    const piPkg = JSON.parse(fs.readFileSync(piPkgPath, "utf8"));
+    const ourVersion = JSON.parse(
+      fs.readFileSync(path.join(repoRoot, "package.json"), "utf8"),
+    ).version;
+    if (piPkg.version !== ourVersion) {
+      piPkg.version = ourVersion;
+      fs.writeFileSync(piPkgPath, JSON.stringify(piPkg, null, 2) + "\n");
+      report.versionAligned = ourVersion;
+    }
+  } catch {
+    /* cosmetic — never fail the patch over version alignment */
+  }
+  }
+  // Version alignment: pi's self-reported version (banner/help) reads its
+  // own package.json — rewrite it to the omnirush release version so the
+  // product version, not upstream's, is what users and support see.
+  try {
+    const piPkgPath = path.join(report.piRoot, "package.json");
+    const piPkg = JSON.parse(fs.readFileSync(piPkgPath, "utf8"));
+    const ourVersion = JSON.parse(
+      fs.readFileSync(path.join(repoRoot, "package.json"), "utf8"),
+    ).version;
+    if (piPkg.version !== ourVersion) {
+      piPkg.version = ourVersion;
+      fs.writeFileSync(piPkgPath, JSON.stringify(piPkg, null, 2) + "\n");
+      report.versionAligned = ourVersion;
+    }
+  } catch {
+    /* cosmetic — never fail the patch over version alignment */
+  }
+  const patched = report.packageJsonPatched ? "package.json + " : "";
+  const ver = report.versionAligned ? `; version aligned to ${report.versionAligned}` : "";
+  console.log(
+    `omnirush: branding applied (${patched}${report.applied.length} display strings)${ver}` +
+      (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);
+  }
+}