omnirush 0.8.5 → 0.9.0

package/src/compat.js

@@ -0,0 +1,272 @@
+// Compatibility with installs made before the 0.9.0 rebrand.
+//
+// Up to 0.8.x the agent core kept its data (settings.json, models.json,
+// provider auth.json, sessions/, installed packages) in its upstream
+// default folder, ~/.pi/agent, and read project settings from <project>/.pi.
+// From 0.9.0 everything the user sees is named omnirush:
+//
+//   agent data      ~/.omnirush/agent   (inside the state dir, so
+//                                        OMNIRUSH_DIR moves it too)
+//   project config  <project>/.omnirush
+//   env variables   OMNIRUSH_*          (the core's PI_* names still work)
+//
+// This module holds the pure pieces the launcher uses to get there
+// without losing anything:
+//
+//   resolveAgentDir      where the agent data lives this run (and the
+//                        legacy folder to migrate from)
+//   migrateAgentDir      one-time COPY of the legacy folder into the new
+//                        one (the old folder is left untouched, so an
+//                        older omnirush keeps working); never overwrites,
+//                        merges the three JSON config files key by key,
+//                        writes a marker so it runs once, resumes after a
+//                        crash, and reports failure so the launcher can
+//                        fall back to the legacy folder for that run
+//   projectConfigDirName the project config folder name for a cwd: a
+//                        project that only has a legacy .pi folder keeps
+//                        using it
+//   engineEnvAliases     OMNIRUSH_* spellings of the core's PI_* settings
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/** Marker written into the new agent dir once the legacy data was copied. */
+export const MIGRATION_MARKER = ".migrated.json";
+
+/** Project config folder (the core's configDir after the branding patch). */
+export const PROJECT_CONFIG_DIR = ".omnirush";
+const LEGACY_PROJECT_CONFIG_DIR = ".pi";
+/** Entries that make a project config folder live (the core's trust-gated resources). */
+const PROJECT_RESOURCES = ["settings.json", "extensions", "skills", "prompts", "themes", "SYSTEM.md", "APPEND_SYSTEM.md"];
+
+/** Top-level JSON files merged key by key when both folders have them (the new folder's keys win). */
+const MERGED_JSON = new Set(["settings.json", "models.json", "auth.json"]);
+
+/**
+ * The core's own PI_* settings a user may set, accepted as OMNIRUSH_<NAME>
+ * (the launcher hands them to the core under the name it reads). The
+ * original PI_<NAME> keeps working unchanged. PI_OFFLINE / PI_TELEMETRY
+ * are always forced by the launcher and are not listed.
+ */
+export const ENGINE_ENV_NAMES = [
+  "CACHE_RETENTION",
+  "CLEAR_ON_SHRINK",
+  "EXPERIMENTAL",
+  "HARDWARE_CURSOR",
+  "HYPERLINKS",
+  "IMAGE_PROTOCOL",
+  "OAUTH_CALLBACK_HOST",
+  "PACKAGE_DIR",
+  "RADIUS_GATEWAY",
+  "SHARE_VIEWER_URL",
+  "SKIP_VERSION_CHECK",
+  "STARTUP_BENCHMARK",
+  "TIMING",
+  "TRUE_COLOR",
+  "TUI_DEBUG",
+  "TUI_DEBUG_REDRAW",
+  "TUI_ESC_TIMEOUT",
+  "TUI_WRITE_LOG",
+];
+
+/**
+ * Where the agent data lives: OMNIRUSH_AGENT_DIR (or its pre-0.9 spelling
+ * OMNIRUSH_PI_AGENT_DIR, or the core's own OMNIRUSH_CODING_AGENT_DIR, which
+ * nested runs inherit) when set — then nothing is migrated — else
+ * <stateDir>/agent, with ~/.pi/agent as the legacy folder to migrate from.
+ */
+export function resolveAgentDir(env = process.env, { stateDir, home = os.homedir() } = {}) {
+  const override = String(env.OMNIRUSH_AGENT_DIR || env.OMNIRUSH_PI_AGENT_DIR || env.OMNIRUSH_CODING_AGENT_DIR || "").trim();
+  if (override) return { dir: path.resolve(override), legacyDir: null };
+  const base = stateDir || path.join(home, ".omnirush");
+  return { dir: path.join(base, "agent"), legacyDir: path.join(home, ".pi", "agent") };
+}
+
+function isInside(parent, child, pathImpl) {
+  const relative = pathImpl.relative(parent, child);
+  return relative === "" || (!!relative && !relative.startsWith("..") && !pathImpl.isAbsolute(relative));
+}
+
+function writeAtomic(fsImpl, dest, data, mode) {
+  const tmp = `${dest}.${process.pid}.migrating`;
+  fsImpl.writeFileSync(tmp, data, mode === undefined ? undefined : { mode });
+  fsImpl.renameSync(tmp, dest);
+}
+
+function readJson(fsImpl, file) {
+  try {
+    const value = JSON.parse(fsImpl.readFileSync(file, "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Old keys fill the gaps of the new file; models.json merges its providers map the same way. */
+function mergeJson(name, older, newer) {
+  const merged = { ...older, ...newer };
+  if (name === "models.json" && older.providers && typeof older.providers === "object") {
+    merged.providers = { ...older.providers, ...(newer.providers || {}) };
+  }
+  return merged;
+}
+
+/**
+ * A session file's header names its parent session by absolute path; a
+ * copied session points at the copied parent instead.
+ */
+export function rebaseSessionHeader(content, from, to, pathImpl = path) {
+  const newline = content.indexOf("\n");
+  const first = newline === -1 ? content : content.slice(0, newline);
+  let header;
+  try {
+    header = JSON.parse(first);
+  } catch {
+    return content;
+  }
+  if (!header || header.type !== "session" || typeof header.parentSession !== "string") return content;
+  if (!isInside(from, header.parentSession, pathImpl)) return content;
+  header.parentSession = pathImpl.join(to, pathImpl.relative(from, header.parentSession));
+  return JSON.stringify(header) + (newline === -1 ? "" : content.slice(newline));
+}
+
+/**
+ * Copy the legacy agent folder into the new one, once. Never overwrites a
+ * file the new folder already has (the three JSON config files are merged
+ * instead), keeps modes and timestamps (the core orders sessions by them),
+ * skips lock files and our own extension folder (reinstalled at every
+ * launch), and writes MIGRATION_MARKER last: an interrupted copy resumes
+ * on the next start, a finished one never runs again.
+ *
+ * Returns { status: "migrated" | "already" | "none" | "failed", copied,
+ * merged, skipped, error? }.
+ */
+export function migrateAgentDir({ from, to, fsImpl = fs, pathImpl = path, now = () => new Date(), onStart } = {}) {
+  const result = { status: "none", copied: 0, merged: 0, skipped: 0 };
+  const marker = pathImpl.join(to, MIGRATION_MARKER);
+  if (fsImpl.existsSync(marker)) return { ...result, status: "already" };
+  try {
+    fsImpl.mkdirSync(to, { recursive: true });
+    let legacy = null;
+    try {
+      legacy = from && pathImpl.resolve(from) !== pathImpl.resolve(to) ? fsImpl.statSync(from) : null;
+    } catch {
+      legacy = null;
+    }
+    if (legacy?.isDirectory()) {
+      onStart?.();
+      copyTree(from, to, "");
+      result.status = "migrated";
+    }
+    const record = { version: 1, from: legacy?.isDirectory() ? from : null, at: now().toISOString(), copied: result.copied, merged: result.merged, skipped: result.skipped };
+    writeAtomic(fsImpl, marker, JSON.stringify(record, null, 2) + "\n");
+    return result;
+  } catch (error) {
+    return { ...result, status: "failed", error };
+  }
+
+  function copyTree(srcDir, destDir, rel) {
+    for (const entry of fsImpl.readdirSync(srcDir, { withFileTypes: true })) {
+      const name = entry.name;
+      const relPath = rel ? `${rel}/${name}` : name;
+      if (name === MIGRATION_MARKER || name.endsWith(".lock") || name.endsWith(".migrating")) continue;
+      if (relPath === "extensions/omnirush") continue;
+      const src = pathImpl.join(srcDir, name);
+      const dest = pathImpl.join(destDir, name);
+      const stat = fsImpl.lstatSync(src);
+      if (stat.isDirectory()) {
+        fsImpl.mkdirSync(dest, { recursive: true });
+        copyTree(src, dest, relPath);
+        continue;
+      }
+      const exists = (() => {
+        try {
+          fsImpl.lstatSync(dest);
+          return true;
+        } catch {
+          return false;
+        }
+      })();
+      if (stat.isSymbolicLink()) {
+        if (exists) {
+          result.skipped++;
+          continue;
+        }
+        try {
+          fsImpl.symlinkSync(fsImpl.readlinkSync(src), dest);
+          result.copied++;
+        } catch {
+          result.skipped++; // e.g. Windows without symlink rights
+        }
+        continue;
+      }
+      if (!stat.isFile()) continue;
+      if (exists) {
+        if (!rel && MERGED_JSON.has(name)) {
+          const older = readJson(fsImpl, src);
+          const newer = readJson(fsImpl, dest);
+          if (older && newer) {
+            const merged = mergeJson(name, older, newer);
+            if (JSON.stringify(merged) !== JSON.stringify(newer)) {
+              writeAtomic(fsImpl, dest, JSON.stringify(merged, null, 2) + "\n", fsImpl.statSync(dest).mode & 0o777);
+              result.merged++;
+              continue;
+            }
+          }
+        }
+        result.skipped++;
+        continue;
+      }
+      const tmp = `${dest}.${process.pid}.migrating`;
+      if (relPath.startsWith("sessions/") && name.endsWith(".jsonl")) {
+        const content = fsImpl.readFileSync(src, "utf8");
+        fsImpl.writeFileSync(tmp, rebaseSessionHeader(content, from, to, pathImpl));
+      } else {
+        fsImpl.copyFileSync(src, tmp);
+      }
+      try {
+        fsImpl.chmodSync(tmp, stat.mode & 0o777);
+      } catch {
+        /* modes are advisory on Windows */
+      }
+      fsImpl.utimesSync(tmp, stat.atime, stat.mtime);
+      fsImpl.renameSync(tmp, dest);
+      result.copied++;
+    }
+  }
+}
+
+/**
+ * The project config folder the core should read in `cwd`: .omnirush, or
+ * the legacy .pi when the project has one with settings or resources and
+ * no .omnirush yet (the launcher passes it as OMNIRUSH_PROJECT_CONFIG_DIR).
+ */
+export function projectConfigDirName(cwd, fsImpl = fs) {
+  try {
+    if (fsImpl.existsSync(path.join(cwd, PROJECT_CONFIG_DIR))) return PROJECT_CONFIG_DIR;
+    const legacy = path.join(cwd, LEGACY_PROJECT_CONFIG_DIR);
+    if (PROJECT_RESOURCES.some((entry) => fsImpl.existsSync(path.join(legacy, entry)))) return LEGACY_PROJECT_CONFIG_DIR;
+  } catch {
+    /* unreadable cwd: the default */
+  }
+  return PROJECT_CONFIG_DIR;
+}
+
+/**
+ * The core-facing variables for the OMNIRUSH_* spellings the user set:
+ * OMNIRUSH_<NAME> -> PI_<NAME> (the OMNIRUSH_ value wins over a PI_ one),
+ * and the pre-0.9 PI_CODING_AGENT_SESSION_DIR -> the OMNIRUSH_ name the
+ * rebranded core reads.
+ */
+export function engineEnvAliases(env = process.env) {
+  const out = {};
+  for (const name of ENGINE_ENV_NAMES) {
+    const value = env[`OMNIRUSH_${name}`];
+    if (value !== undefined && value !== "") out[`PI_${name}`] = value;
+  }
+  if (env.PI_CODING_AGENT_SESSION_DIR && !env.OMNIRUSH_CODING_AGENT_SESSION_DIR) {
+    out.OMNIRUSH_CODING_AGENT_SESSION_DIR = env.PI_CODING_AGENT_SESSION_DIR;
+  }
+  return out;
+}

package/src/lib.js

@@ -403,3 +403,67 @@ export function managedToolTargets({ platform = process.platform, runtimeRoot }
     { tool: "rg", source: `${runtimeRoot}/bin/rg${ext}`, dest: `bin/rg${ext}` },
   ];
 }
+
+// --- yolo mode ---------------------------------------------------------------
+//
+// `--yolo`, `/yolo on` (saved as "yolo": true in <state dir>/settings.json) or
+// OMNIRUSH_YOLO=1: the project folder is trusted for the run (the core's
+// --approve) and nothing asks for confirmation. Precedence: --yolo/--no-yolo,
+// then OMNIRUSH_YOLO, then the saved setting. Default: off.
+
+export const YOLO_BANNER = "yolo mode: no prompts, project trusted";
+
+const TRUE_WORDS = new Set(["1", "true", "on", "yes"]);
+const FALSE_WORDS = new Set(["0", "false", "off", "no"]);
+
+/** OMNIRUSH_YOLO as true/false, or undefined when unset or unrecognised. */
+export function parseYoloEnv(value) {
+  const v = String(value ?? "").trim().toLowerCase();
+  if (TRUE_WORDS.has(v)) return true;
+  if (FALSE_WORDS.has(v)) return false;
+  return undefined;
+}
+
+/**
+ * Resolve yolo mode for one launch. Strips --yolo/--no-yolo from `args`
+ * (never past `--`) and, when yolo is on for an agent run, adds the core's
+ * --approve unless the user already chose -a/--approve/-na/--no-approve.
+ * Returns { yolo, source, trusted, args }: `trusted` is false only when an
+ * explicit --no-approve wins over yolo's project trust.
+ */
+export function resolveYolo(args, { env = process.env, setting } = {}) {
+  let flag;
+  const rest = [];
+  let passthrough = false;
+  for (const arg of args) {
+    if (!passthrough && arg === "--") passthrough = true;
+    if (!passthrough && arg === "--yolo") flag = true;
+    else if (!passthrough && arg === "--no-yolo") flag = false;
+    else rest.push(arg);
+  }
+  let yolo = false;
+  let source = "default";
+  const fromEnv = parseYoloEnv(env.OMNIRUSH_YOLO);
+  if (flag !== undefined) {
+    yolo = flag;
+    source = "flag";
+  } else if (fromEnv !== undefined) {
+    yolo = fromEnv;
+    source = "env";
+  } else if (setting === true) {
+    yolo = true;
+    source = "setting";
+  }
+  const subcommand = rest.length > 0 && PI_SUBCOMMANDS.has(rest[0]);
+  if (!yolo || subcommand) return { yolo: yolo && !subcommand, source, trusted: !subcommand && yolo, args: rest };
+  const end = rest.indexOf("--");
+  const scan = end < 0 ? rest : rest.slice(0, end);
+  if (scan.some((a) => a === "--no-approve" || a === "-na")) return { yolo, source, trusted: false, args: rest };
+  if (scan.some((a) => a === "--approve" || a === "-a")) return { yolo, source, trusted: true, args: rest };
+  return { yolo, source, trusted: true, args: ["--approve", ...rest] };
+}
+
+/** The one-line banner for a resolved yolo launch. */
+export function yoloBanner({ trusted }) {
+  return trusted ? YOLO_BANNER : "yolo mode: no prompts (project not trusted: --no-approve)";
+}

package/scripts/patch-pi-branding.js

@@ -1,251 +0,0 @@
-#!/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)",
-  },
-  // Belt-and-braces against the pi.dev update banner (Foxtran's 0.73.1
-  // report: a stale core showed "Update Available — pi.dev/changelog"
-  // even though PI_OFFLINE should suppress the check). PI_OFFLINE=1 in
-  // the spawn env stops the check; these rewrites make the banner
-  // UNRENDERABLE even where PI_OFFLINE is absent (direct pi spawns,
-  // older cores): showNewVersionNotification returns before its body
-  // (the parameter is renamed so the replacement stays idempotent and
-  // never re-matches), and the pi.dev changelog URL is blanked. The
-  // parameter spelling differs between the standalone dist (readable)
-  // and the minified runtime bundle chunk, hence the two variants; a
-  // future core that renames the parameter just reports "missing"
-  // (fail-soft) and we would re-derive the target.
-  {
-    label: "TUI update banner (standalone dist)",
-    from: "showNewVersionNotification(release) {",
-    to: "showNewVersionNotification(_release) { return;",
-  },
-  {
-    label: "TUI update banner (runtime bundle chunk)",
-    from: "showNewVersionNotification(release2){",
-    to: "showNewVersionNotification(_r){return;",
-  },
-  {
-    label: "pi.dev changelog URL",
-    from: '"https://pi.dev/changelog"',
-    to: '""',
-  },
-];
-
-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);
-  }
-}