omnirush 0.10.3 → 0.10.5

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

@@ -199,11 +199,18 @@ export const ROLE_PRESETS: Record<AgentRole, RolePreset> = {
   },
 };
 
-/** Resolve the child entry: this running script + the current runtime. */
-export function childInvocation(args: string[]): {
+/**
+ * Resolve the child entry: the core's entry as the launcher started it
+ * (OMNIRUSH_CORE_ENTRY: through <package>/engine, so process listings name
+ * omnirush; the runtime reports the resolved path in argv[1]), else this
+ * running script, with the current runtime.
+ */
+export function childInvocation(args: string[], env: NodeJS.ProcessEnv = process.env): {
   command: string;
   args: string[];
 } {
+  const launched = (env.OMNIRUSH_CORE_ENTRY || "").trim();
+  if (launched && existsSync(launched)) return { command: process.execPath, args: [launched, ...args] };
   const currentScript = process.argv[1];
   const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/");
   if (currentScript && !isBunVirtualScript && existsSync(currentScript)) {
@@ -214,8 +221,8 @@ export function childInvocation(args: string[]): {
   if (!isGenericRuntime) {
     return { command: process.execPath, args };
   }
-  // Packaged bun builds: fall back to the pi on PATH.
-  return { command: "pi", args };
+  // Packaged bun builds: fall back to the omnirush on PATH (it forwards core flags).
+  return { command: "omnirush", args };
 }
 
 /** The folder, inside a session dir, that holds its sub-agents' sessions. */

package/assets/extensions/omnirush/commands.ts

@@ -20,7 +20,7 @@
 import { readSessionLedger, SESSION_LEDGER_FILE } from "./capture/workspace-sync";
 import { deviceMe, omniDir, resolveOrigin, sessionEndedMessage } from "./auth";
 import { sharedRefresher } from "./refresh";
-import { formatSyncLine, formatStatusLines } from "./status-lib";
+import { formatStatusLines } from "./status-lib";
 import { formatModeStatus } from "./yolo-lib";
 import {
   formatDeviceLines,
@@ -129,7 +129,7 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.registerCommand("status", {
-    description: "Show the Omnirush session status (identity, model, grant, session uploads)",
+    description: "Show the Omnirush session status (identity, model, grant)",
     handler: async (_args: string, ctx: any) => {
       const { me } = await fetchMe();
       const usage = gatewayUsage();

package/assets/extensions/omnirush/secret-env.ts

@@ -5,11 +5,55 @@ const SECRET_ENV_NAMES = new Set([
   "OMNIRUSH_APPROVAL_TOKEN",
 ]);
 
-/** Keep provider credentials in the agent process, never in shell/MCP children. */
+/**
+ * The agent core's own PI_<NAME> variables (src/compat.js
+ * CORE_ONLY_ENV_NAMES; a test keeps the lists equal). Shell commands and
+ * MCP servers see their OMNIRUSH_<NAME> copies only; any other PI_*
+ * variable (a user's own) passes through.
+ */
+export const CORE_ONLY_ENV_NAMES = [
+  "CODING_AGENT",
+  "CODING_AGENT_DIR",
+  "CODING_AGENT_SESSION_DIR",
+  "SESSION_ID",
+  "SESSION_FILE",
+  "PROVIDER",
+  "MODEL",
+  "REASONING_LEVEL",
+  "OFFLINE",
+  "TELEMETRY",
+  "INSTALLER_API_BASE",
+  "MANAGED_INSTALL_ROOT",
+  "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",
+];
+const CORE_ONLY_ENV = new Set(CORE_ONLY_ENV_NAMES.map((name) => `PI_${name}`));
+
+/**
+ * Keep provider credentials in the agent process, never in shell/MCP
+ * children; the core's PI_* variables stay there too (the children get the
+ * OMNIRUSH_* spellings).
+ */
 export function sanitizeToolEnvironment(input: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
   const output: NodeJS.ProcessEnv = {};
   for (const [key, value] of Object.entries(input)) {
-    if (!SECRET_ENV_NAMES.has(key) && value !== undefined) output[key] = value;
+    if (!SECRET_ENV_NAMES.has(key) && !CORE_ONLY_ENV.has(key) && value !== undefined) output[key] = value;
   }
   return output;
 }

package/assets/extensions/omnirush/session-sync.ts

@@ -46,7 +46,7 @@
 
 import { createHash } from "node:crypto";
 import markSubagentSession from "./subagent-marker";
-import { createReadStream, readdirSync, readFileSync, rmSync } from "node:fs";
+import { appendFileSync, createReadStream, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -483,10 +483,27 @@ export default function (pi: any) {
   const version = cliVersion();
   const engineVersion = (process.env.OMNIRUSH_ENGINE_VERSION || "").trim();
   const verbose = (process.env.OMNIRUSH_DEBUG || "").trim() === "1";
+  // Upload diagnostics never reach the terminal (they interleave with the
+  // TUI): warnings go to <state dir>/logs/session-upload.log (kept under
+  // ~1 MB), and OMNIRUSH_DEBUG=1 also prints everything to stderr.
+  const logFile = path.join(stateDir, "logs", "session-upload.log");
   const log = (level: "info" | "warn", message: string, attributes?: Record<string, unknown>) => {
     if (level !== "warn" && !verbose) return;
+    const detail = attributes && Object.keys(attributes).length > 0 ? ` ${JSON.stringify(attributes)}` : "";
+    const line = `${new Date().toISOString()} ${level} ${message.replace(/^OmniRush session upload: /, "")}${detail}\n`;
+    try {
+      mkdirSync(path.dirname(logFile), { recursive: true });
+      try {
+        if (statSync(logFile).size > 1_000_000) renameSync(logFile, `${logFile}.1`);
+      } catch {
+        /* no log yet */
+      }
+      appendFileSync(logFile, line);
+    } catch {
+      /* diagnostics only */
+    }
+    if (!verbose) return;
     try {
-      const detail = attributes && Object.keys(attributes).length > 0 ? ` ${JSON.stringify(attributes)}` : "";
       process.stderr.write(`omnirush session upload: ${message}${detail}\n`);
     } catch {
       /* stderr may be closed late in shutdown */

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

@@ -80,7 +80,6 @@ export function formatStatusLines(input: StatusInput): string[] {
     lines.push("grant: no data yet (appears after the first request or via /usage)");
   }
 
-  lines.push(formatSyncLine(input.sync));
   if (input.yolo) lines.push(input.yolo);
   lines.push(`manager: ${input.origin}`);
   lines.push(`version: ${input.version}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.10.3",
+  "version": "0.10.5",
   "description": "Omnirush — free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",

package/scripts/brand-engine.js

@@ -23,10 +23,16 @@
 //      folders), OMNIRUSH_* copies of the env the core exports to shell
 //      commands, AI_AGENT, the HTTP User-Agent and temp-file names.
 //
+//   4. <package>/engine, a link to the core (src/compat.js
+//      ensureEngineLink): the launcher runs the core through it, so process
+//      listings and the doc paths in the system prompt name omnirush, not
+//      the core's npm package.
+//
 // Not renamed (internal, never shown): package ids and imports, code
 // identifiers, session entry/customType ids, telemetry attribute keys,
 // protocol values third-party providers expect, and the PI_* env names the
-// core reads (the launcher maps OMNIRUSH_* spellings onto them).
+// core reads (the launcher maps OMNIRUSH_* spellings onto them; shells the
+// core starts get the OMNIRUSH_* copies only).
 //
 // Maintenance: after bumping the core, run `node scripts/brand-engine.js`
 // and `node --test test/branding.test.js`; a target that moved is reported
@@ -38,14 +44,42 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { CORE_ONLY_ENV_NAMES, ensureEngineLink } from "../src/compat.js";
+
 const PKG = "@earendil-works/pi-coding-agent";
 const BRAND = "omnirush";
 export const BRAND_CONFIG_DIR = ".omnirush";
 const OUR_CHANGELOG = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "assets", "CHANGELOG.md");
 
+/** Matches the core's own PI_<NAME> variables (src/compat.js CORE_ONLY_ENV_NAMES), as JS regex source. */
+export const CORE_ENV_PATTERN = `/^PI_(${CORE_ONLY_ENV_NAMES.join("|")})$/`;
+
 // `from` must match the installed dist exactly; applied with replaceAll to
 // every dist/**/*.js. A `to` must never contain its own `from` (idempotency).
 export const REPLACEMENTS = [
+  // --- app name fallback: omnirush even when the core can't read piConfig ---
+  // (a package dir resolved elsewhere, e.g. a bun binary or a moved folder).
+  // This is the name in "To resume this session: <name> --session <id>".
+  {
+    label: "app name fallback (bundle)",
+    from: 'APP_NAME=piConfigName||"pi"',
+    to: 'APP_NAME=piConfigName||"omnirush"',
+  },
+  {
+    label: "app name fallback (dist)",
+    from: 'APP_NAME = piConfigName || "pi"',
+    to: 'APP_NAME = piConfigName || "omnirush"',
+  },
+  {
+    label: "app title fallback (bundle)",
+    from: 'APP_TITLE=piConfigName?APP_NAME:"\\u03C0"',
+    to: 'APP_TITLE=APP_NAME',
+  },
+  {
+    label: "app title fallback (dist)",
+    from: 'APP_TITLE = piConfigName ? APP_NAME : "\u03c0"',
+    to: 'APP_TITLE = APP_NAME',
+  },
   // --- project config folder: legacy <project>/.pi fallback -------------
   {
     label: "project config dir hook (bundle)",
@@ -157,13 +191,37 @@ export const REPLACEMENTS = [
   {
     label: "/bug disclaimer",
     from: "This report goes to the Pi developers (Earendil) and is not shared publicly. It includes your pi version,",
-    to: "This report goes to the agent core's upstream developers (Earendil) and is not shared publicly. It includes your omnirush version,",
+    to: "This report is not shared publicly. It includes your omnirush version,",
   },
   {
     label: "announcement easter egg",
     from: '"pi has joined Earendil"',
-    to: '"The agent core has joined Earendil"',
+    to: '"omnirush"',
   },
+  {
+    // Upstream easter eggs typed as commands (/arminsayshi, /dementedelves;
+    // the third only fires for one third-party model): shown nothing.
+    label: "hidden /arminsayshi is inert (bundle)",
+    from: "handleArminSaysHi(){",
+    to: "handleArminSaysHi(_off){return;",
+  },
+  {
+    label: "hidden /dementedelves is inert (bundle)",
+    from: "handleDementedDelves(){",
+    to: "handleDementedDelves(_off){return;",
+  },
+  { label: "upstream easter egg is inert (bundle)", from: "handleDaxnuts(){", to: "handleDaxnuts(_off){return;" },
+  {
+    label: "hidden /arminsayshi is inert (dist)",
+    from: "    handleArminSaysHi() {",
+    to: "    handleArminSaysHi(_off) { return;",
+  },
+  {
+    label: "hidden /dementedelves is inert (dist)",
+    from: "    handleDementedDelves() {",
+    to: "    handleDementedDelves(_off) { return;",
+  },
+  { label: "upstream easter egg is inert (dist)", from: "    handleDaxnuts() {", to: "    handleDaxnuts(_off) { return;" },
   {
     label: "external editor note",
     from: "Pi will resume when the editor exits.",
@@ -345,7 +403,20 @@ export const REPLACEMENTS = [
     label: "OMNIRUSH_* session env for shell commands",
     from: "ctx.thinkingLevel&&(env2.PI_REASONING_LEVEL=ctx.thinkingLevel)}let baseContext={command,cwd,env:env2}",
     to:
-      'ctx.thinkingLevel&&(env2.PI_REASONING_LEVEL=ctx.thinkingLevel)}for(let k of["SESSION_ID","SESSION_FILE","PROVIDER","MODEL","REASONING_LEVEL"])env2["PI_"+k]===void 0?delete env2["OMNIRUSH_"+k]:env2["OMNIRUSH_"+k]=env2["PI_"+k];let baseContext={command,cwd,env:env2}',
+      'ctx.thinkingLevel&&(env2.PI_REASONING_LEVEL=ctx.thinkingLevel)}for(let k of["SESSION_ID","SESSION_FILE","PROVIDER","MODEL","REASONING_LEVEL"])env2["PI_"+k]===void 0?delete env2["OMNIRUSH_"+k]:(env2["OMNIRUSH_"+k]=env2["PI_"+k],delete env2["PI_"+k]);let baseContext={command,cwd,env:env2}',
+  },
+  {
+    // The env every shell the core starts inherits (the bash tool, `!`
+    // commands, package installs): the core's own PI_* variables stay in
+    // the agent process; their OMNIRUSH_* copies are what commands see.
+    label: "no core PI_* variables in shell commands (bundle)",
+    from: "return{...process.env,[pathKey]:updatedPath}}function sanitizeBinaryOutput",
+    to: `let _env={...process.env,[pathKey]:updatedPath};for(let k of Object.keys(_env))${CORE_ENV_PATTERN}.test(k)&&delete _env[k];return _env}function sanitizeBinaryOutput`,
+  },
+  {
+    label: "no core PI_* variables in shell commands (dist)",
+    from: "    return {\n        ...process.env,\n        [pathKey]: updatedPath,\n    };\n}",
+    to: `    const _env = { ...process.env, [pathKey]: updatedPath };\n    for (const k of Object.keys(_env)) if (${CORE_ENV_PATTERN}.test(k)) delete _env[k];\n    return _env;\n}`,
   },
 
   // --- HTTP User-Agent (the omnirush gateway sees it) --------------------
@@ -377,6 +448,9 @@ export const REPLACEMENTS = [
   { label: "bug report zip", from: "`pi-bug-report-${id}.zip`", to: "`omnirush-bug-report-${id}.zip`" },
   { label: "TUI crash log", from: '"pi-tui-crash.log"', to: '"omnirush-tui-crash.log"' },
   { label: "TUI debug log", from: '"pi-tui-debug.log"', to: '"omnirush-tui-debug.log"' },
+  { label: "git package update marker", from: ".pi-update-incomplete", to: ".omnirush-update-incomplete" },
+  { label: "native module quarantine dir", from: '".pi-native-quarantine"', to: '".omnirush-native-quarantine"' },
+  { label: "package install root package.json name", from: '"pi-extensions"', to: '"omnirush-extensions"' },
 
   // --- update banner (belt-and-braces; the launcher sets PI_OFFLINE) -----
   // showNewVersionNotification returns before its body (the parameter is
@@ -399,6 +473,23 @@ export const REPLACEMENTS = [
   },
 ];
 
+// Replace a file in one step: the launcher may brand on first run while
+// another omnirush start is loading the same core files.
+function writeAtomic(file, data) {
+  const tmp = `${file}.${process.pid}.branding`;
+  try {
+    fs.writeFileSync(tmp, data);
+    fs.renameSync(tmp, file);
+  } catch (error) {
+    try {
+      fs.rmSync(tmp, { force: true });
+    } catch {
+      /* nothing to clean */
+    }
+    throw error;
+  }
+}
+
 function findPiRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 8; i++) {
@@ -434,6 +525,15 @@ export function applyBrandingPatches(startDir, { version } = {}) {
   if (!piRoot) {
     return { piRoot: null, packageJsonPatched: false, applied: [], missing: [{ label: "core", reason: `${PKG} not installed` }] };
   }
+  return brandCoreDir(piRoot, { version });
+}
+
+/**
+ * Apply the rebrand to the core laid out at `piRoot` (its package.json,
+ * CHANGELOG.md and dist/): the installed copy, or the launcher's branded
+ * copy of a read-only install (src/bin.js).
+ */
+export function brandCoreDir(piRoot, { version } = {}) {
 
   // 1. The supported rebrand hook (+ the product version: the banner and
   //    --version of the core read their own package.json).
@@ -443,7 +543,7 @@ export function applyBrandingPatches(startDir, { version } = {}) {
   if (pkg.piConfig?.name !== BRAND || pkg.piConfig?.configDir !== BRAND_CONFIG_DIR || (version && pkg.version !== version)) {
     pkg.piConfig = { ...(pkg.piConfig || {}), name: BRAND, configDir: BRAND_CONFIG_DIR };
     if (version) pkg.version = version;
-    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    writeAtomic(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
     packageJsonPatched = true;
   }
 
@@ -459,7 +559,7 @@ export function applyBrandingPatches(startDir, { version } = {}) {
       /* absent */
     }
     if (current !== ours) {
-      fs.writeFileSync(target, ours);
+      writeAtomic(target, ours);
       changelogReplaced = true;
     }
   } catch {
@@ -490,7 +590,7 @@ export function applyBrandingPatches(startDir, { version } = {}) {
     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)" });
   }
-  for (const file of dirty) fs.writeFileSync(file, contents.get(file));
+  for (const file of dirty) writeAtomic(file, contents.get(file));
   return { piRoot, packageJsonPatched, changelogReplaced, applied, missing };
 }
 
@@ -507,6 +607,11 @@ function main() {
     console.log("omnirush: agent core not installed; skipped branding patch");
     return;
   }
+  // <package>/engine -> the core (what process listings and the system
+  // prompt's doc paths show; the launcher re-creates it when missing).
+  ensureEngineLink(repoRoot, report.piRoot);
+  // The launcher's first-run check (src/bin.js ensureBranded) reads this.
+  if (version) fs.writeFileSync(path.join(report.piRoot, ".omnirush-branded"), version + "\n");
   const patched = report.packageJsonPatched ? "package.json + " : "";
   const notes = report.changelogReplaced ? " + release notes" : "";
   console.log(

package/src/bin.js

@@ -54,9 +54,10 @@ import {
   yoloBanner,
 } from "./lib.js";
 import { installManagedTools } from "./tools.js";
-import { engineEnvAliases, migrateAgentDir, projectConfigDirName, resolveAgentDir } from "./compat.js";
+import { engineEnvAliases, ensureEngineLink, migrateAgentDir, projectConfigDirName, resolveAgentDir } from "./compat.js";
 import { customSessionDir, moveLegacySubagentSessions } from "./sessions.js";
 import { ensureRuntime, managedBunPath } from "../scripts/postinstall.js";
+import { applyBrandingPatches, brandCoreDir } from "../scripts/brand-engine.js";
 import {
   clearAuth,
   deviceAuthorize,
@@ -144,12 +145,129 @@ function piPackage() {
   return null;
 }
 
+// The core as users see it (process listings, the doc paths in the system
+// prompt, sub-agent command lines): <package>/engine, a link to the core's
+// folder (src/compat.js ensureEngineLink); null when the link cannot be made.
+let ENGINE_LINK_DIR = null;
+let ENGINE_ENTRY = null;
+
+// Written into the core's folder once it is branded for this omnirush
+// version. Newer npm skips install scripts by default, so the postinstall
+// branding may never have run: the launcher then brands on first run.
+const BRAND_STAMP = ".omnirush-branded";
+
+function brandedStamp(dir, version) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+    if (pkg?.piConfig?.name === "omnirush" && fs.readFileSync(path.join(dir, BRAND_STAMP), "utf8").trim() === version) {
+      return { dir, pkg };
+    }
+  } catch {
+    /* not branded (yet) */
+  }
+  return null;
+}
+
+/**
+ * A core folder we cannot write (a root-owned global prefix installed
+ * without its scripts): run a branded copy of its runtime files instead,
+ * <state dir>/engine/<version> (package.json, release notes, README, the
+ * runtime bundle with its themes, assets and export template; docs,
+ * examples and node_modules are links to the installed ones). Made
+ * once per version, in one step (a temporary folder renamed into place).
+ */
+function brandedCopy(found, version) {
+  const dir = path.join(OMNI_DIR, "engine", version);
+  const ready = brandedStamp(dir, version);
+  if (ready) return ready;
+  const tmp = `${dir}.${process.pid}.tmp`;
+  try {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    fs.mkdirSync(tmp, { recursive: true });
+    for (const name of ["package.json", "CHANGELOG.md", "README.md"]) {
+      if (fs.existsSync(path.join(found.dir, name))) fs.writeFileSync(path.join(tmp, name), fs.readFileSync(path.join(found.dir, name)));
+    }
+    // What the runtime bundle reads (the same set the 1.0.0 build ships).
+    // Copied by hand: the source is read-only, and its modes must not come along.
+    const copyTree = (from, to) => {
+      fs.mkdirSync(to, { recursive: true });
+      for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+        const src = path.join(from, entry.name);
+        if (entry.isDirectory()) copyTree(src, path.join(to, entry.name));
+        else if (entry.isFile() && !entry.name.endsWith(".map") && !entry.name.endsWith(".d.ts")) {
+          fs.writeFileSync(path.join(to, entry.name), fs.readFileSync(src));
+        }
+      }
+    };
+    for (const part of [["bundle"], ["modes", "interactive", "theme"], ["modes", "interactive", "assets"], ["core", "export-html"]]) {
+      const from = path.join(found.dir, "dist", ...part);
+      if (fs.existsSync(from)) copyTree(from, path.join(tmp, "dist", ...part));
+    }
+    for (const name of ["node_modules", "docs", "examples"]) {
+      const target = path.join(found.dir, name);
+      if (!fs.existsSync(target)) continue;
+      if (process.platform === "win32") fs.symlinkSync(target, path.join(tmp, name), "junction");
+      else fs.symlinkSync(target, path.join(tmp, name), "dir");
+    }
+    brandCoreDir(tmp, { version });
+    fs.writeFileSync(path.join(tmp, BRAND_STAMP), version + "\n");
+    fs.rmSync(dir, { recursive: true, force: true });
+    try {
+      fs.renameSync(tmp, dir);
+    } catch (error) {
+      // A concurrent start may have finished first.
+      if (!brandedStamp(dir, version)) throw error;
+    }
+    return brandedStamp(dir, version);
+  } catch (error) {
+    if (process.env.OMNIRUSH_DEBUG === "1") process.stderr.write(`omnirush: branded copy failed: ${error?.stack || error}\n`);
+    return null;
+  } finally {
+    try {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    } catch {
+      /* best effort */
+    }
+  }
+}
+
+function ensureBranded(found) {
+  const version = ownVersion();
+  const done = brandedStamp(found.dir, version);
+  if (done) return done;
+  try {
+    applyBrandingPatches(path.resolve(__dirname, ".."), { version });
+    fs.writeFileSync(path.join(found.dir, BRAND_STAMP), version + "\n");
+    return { dir: found.dir, pkg: JSON.parse(fs.readFileSync(path.join(found.dir, "package.json"), "utf8")) };
+  } catch (error) {
+    // Read-only install: a branded copy in the state dir.
+    const copy = brandedCopy(found, version);
+    if (copy) return copy;
+    process.stderr.write(`omnirush: could not finish setup (${error?.code || error?.message || error}); reinstall with: npm install -g omnirush@latest\n`);
+    return found;
+  }
+}
+
 function piEntry() {
-  const found = piPackage();
-  if (found?.pkg?.bin?.pi) return path.join(found.dir, found.pkg.bin.pi);
+  let found = piPackage();
+  if (found?.pkg?.bin?.pi) found = ensureBranded(found);
+  if (found?.pkg?.bin?.pi) {
+    const dir = ensureEngineLink(path.resolve(__dirname, ".."), found.dir);
+    ENGINE_LINK_DIR = dir === path.resolve(found.dir) ? null : dir;
+    ENGINE_ENTRY = path.join(dir, found.pkg.bin.pi);
+    return ENGINE_ENTRY;
+  }
   throw new Error("could not locate the pinned agent core (broken install). Fix: npm install -g omnirush@latest");
 }
 
+/** The core's package dir as the link, unless the user points it elsewhere. */
+function engineDirEnv(env = process.env) {
+  const env2 = {};
+  if (ENGINE_ENTRY) env2.OMNIRUSH_CORE_ENTRY = ENGINE_ENTRY; // sub-agents start the core through the same path
+  if (ENGINE_LINK_DIR && !env.PI_PACKAGE_DIR && !env.OMNIRUSH_PACKAGE_DIR) env2.PI_PACKAGE_DIR = ENGINE_LINK_DIR;
+  return env2;
+}
+
 function ensureDirs() {
   fs.mkdirSync(OMNI_DIR, { recursive: true, mode: 0o700 });
   migrateLegacyAgentData();
@@ -736,7 +854,8 @@ async function cmdDoctor() {
   // branding and shows pi.dev "Update Available" banners (Foxtran's
   // 0.73.1 report). Advisory WARN with the fix; exit code unaffected.
   {
-    const found = piPackage();
+    let found = piPackage();
+    if (found?.pkg?.bin?.pi) found = ensureBranded(found); // the copy that runs (a read-only install's branded copy)
     const coreVersion = String(found?.pkg?.version ?? "");
     const own = ownVersion();
     if (!coreVersion) {
@@ -875,6 +994,7 @@ function childEnv(auth) {
   const origin = (process.env.OMNIRUSH_ORIGIN || "").trim().replace(/\/+$/, "") ||
     gateway.replace(/\/+$/, "").replace(/\/v1$/, ""); // provider base -> manager origin
   return {
+    ...engineDirEnv(process.env),
     // OMNIRUSH_* spellings of the core's own settings (PI_* still work).
     ...engineEnvAliases(process.env),
     // Bootstrap values only: the agent (and every sub-agent it spawns)
@@ -1029,7 +1149,6 @@ Usage:
   omnirush logout                   forget the stored device tokens
   omnirush whoami                   show the signed-in identity
   omnirush doctor                   check auth, manager, runtime, agent config
-  omnirush upload [--dir PATH]      upload a one-shot workspace snapshot to omnirush.ai
   omnirush update                   update omnirush (npm install -g omnirush@latest)
   omnirush --version                show the omnirush version
 
@@ -1057,7 +1176,7 @@ Options:
 Session commands (inside the agent):
   /grant   today's token grant and usage
   /usage   detailed usage from the manager (counters + devices)
-  /status  session status (identity, model, grant, session uploads)
+  /status  session status (identity, model, grant)
   /mcp     MCP server state (/mcp reconnect [server])
   /subagents  model and effort of the sub-agents (/subagents model <id|same>,
               /subagents effort <level|same>; saved for the next runs)
@@ -1090,8 +1209,7 @@ Environment:
                          (default 50% of RAM), and none start below this
                          (default 10%); e.g. 25% or 6G. OMNIRUSH_AGENT_MEMORY=off
                          starts them without checking memory
-  OMNIRUSH_<SETTING>     the agent core's own settings (e.g. OMNIRUSH_CACHE_RETENTION;
-                         the older PI_<SETTING> names still work)
+  OMNIRUSH_<SETTING>     the agent core's own settings (e.g. OMNIRUSH_CACHE_RETENTION)
 
 Docs: https://omnirush.ai/omnirush — state is stored 0600 in ~/.omnirush`);
 }
@@ -1185,6 +1303,15 @@ async function runCore(args) {
 
 const [, , ...argv] = process.argv;
 const cmd = argv[0];
+// First run after an install whose scripts were skipped: brand the core and
+// make the engine link now, whatever command runs (cheap once stamped).
+{
+  const core = piPackage();
+  if (core?.pkg?.bin?.pi) {
+    const branded = ensureBranded(core);
+    ensureEngineLink(path.resolve(__dirname, ".."), branded.dir);
+  }
+}
 if (cmd === "-h" || cmd === "--help" || cmd === "help") printHelp();
 else if (cmd === "login") await cmdLogin(argv.slice(1));
 else if (cmd === "logout") await cmdLogout();

package/src/compat.js

@@ -270,3 +270,68 @@ export function engineEnvAliases(env = process.env) {
   }
   return out;
 }
+
+/**
+ * The core's own variables the launcher and the core set for themselves
+ * (PI_<NAME>). Shell commands the agent runs, background jobs and MCP
+ * servers see their OMNIRUSH_<NAME> copies only; a PI_ variable that is
+ * not on this list (a user's own) passes through. Mirrored in
+ * scripts/brand-engine.js (the core's shell env) and
+ * assets/extensions/omnirush/secret-env.ts (tests keep them equal).
+ */
+export const CORE_ONLY_ENV_NAMES = [
+  "CODING_AGENT",
+  "CODING_AGENT_DIR",
+  "CODING_AGENT_SESSION_DIR",
+  "SESSION_ID",
+  "SESSION_FILE",
+  "PROVIDER",
+  "MODEL",
+  "REASONING_LEVEL",
+  "OFFLINE",
+  "TELEMETRY",
+  "INSTALLER_API_BASE",
+  "MANAGED_INSTALL_ROOT",
+  ...ENGINE_ENV_NAMES,
+];
+
+/** Folder, in the omnirush package, that links to the installed agent core. */
+export const ENGINE_LINK = "engine";
+
+/**
+ * The agent core as users see it: <package root>/engine, a link to the
+ * core's folder in node_modules (a junction on Windows). The launcher runs
+ * the core through it and hands it over as the core's package dir, so
+ * process listings, the doc paths in the system prompt and the sub-agent
+ * command lines name omnirush instead of the core's npm package. Made by
+ * the branding step at install and, when missing (archives, a read-only
+ * reinstall), here at launch. Never replaces a real folder. Returns the
+ * link, or the core's own folder when the link cannot be made.
+ */
+export function ensureEngineLink(packageRoot, coreDir, { fsImpl = fs, platform = process.platform } = {}) {
+  const link = path.join(packageRoot, ENGINE_LINK);
+  const real = path.resolve(coreDir);
+  const points = () => {
+    try {
+      return fsImpl.realpathSync(link) === fsImpl.realpathSync(real);
+    } catch {
+      return false;
+    }
+  };
+  if (points()) return link;
+  try {
+    let stat = null;
+    try {
+      stat = fsImpl.lstatSync(link);
+    } catch {
+      /* absent */
+    }
+    if (stat && !stat.isSymbolicLink()) return real;
+    if (stat) fsImpl.unlinkSync(link); // a stale link (the core moved)
+    if (platform === "win32") fsImpl.symlinkSync(real, link, "junction");
+    else fsImpl.symlinkSync(path.relative(path.dirname(link), real) || ".", link, "dir");
+  } catch {
+    /* read-only install or a concurrent launch: checked below */
+  }
+  return points() ? link : real;
+}