omnirush 0.3.3 → 0.4.2

package/scripts/patch-pi-branding.js

@@ -93,6 +93,33 @@ export const REPLACEMENTS = [
     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) {

package/scripts/postinstall.js

@@ -145,11 +145,15 @@ function findFile(rootDir, fileName) {
   return null;
 }
 
-async function fetchBun(plat) {
-  const existing = path.join(RUNTIME, exe("bun"));
+export function managedBunPath() {
+  return path.join(RUNTIME, exe("bun"));
+}
+
+async function fetchBun(plat, log = console.log) {
+  const existing = managedBunPath();
   if (fs.existsSync(existing)) return;
   const zipUrl = `https://github.com/oven-sh/bun/releases/download/${BUN_VERSION}/bun-${bunAssetPlat(plat)}.zip`;
-  process.stdout.write(`omnirush: downloading agent runtime (bun for ${plat})...\n`);
+  log(`omnirush: downloading agent runtime (bun for ${plat})...`);
   const buf = await get(zipUrl);
   fs.mkdirSync(RUNTIME, { recursive: true });
   extractZip(buf, ROOT);
@@ -157,7 +161,7 @@ async function fetchBun(plat) {
   fs.copyFileSync(src, existing);
   if (process.platform !== "win32") fs.chmodSync(existing, 0o755);
   fs.rmSync(path.join(ROOT, `bun-${bunAssetPlat(plat)}`), { recursive: true, force: true });
-  console.log("omnirush: runtime ready");
+  log("omnirush: runtime ready");
 }
 
 // fd/rg release archives both nest the binary under a versioned directory
@@ -196,9 +200,14 @@ function rgAsset(plat) {
   return `ripgrep-${RG_VERSION}-${arch}-unknown-linux-musl`;
 }
 
-async function main() {
+/**
+ * Fetch the agent runtime when it is missing (idempotent: existing
+ * binaries are kept). Used by postinstall and by `omnirush doctor`
+ * self-heal. `log` defaults to console.log.
+ */
+export async function ensureRuntime({ log = console.log } = {}) {
   const plat = platform();
-  await fetchBun(plat);
+  await fetchBun(plat, log);
   for (const [name, version, repo, archive] of [
     ["fd", FD_VERSION, "sharkdp/fd", fdAsset(plat)],
     ["rg", RG_VERSION, "BurntSushi/ripgrep", rgAsset(plat)],
@@ -208,9 +217,17 @@ async function main() {
     } 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);
+      log(`omnirush: ${name} download failed (search may be degraded): ${error.message}`);
     }
   }
 }
 
-main().catch((e) => { console.error("omnirush postinstall:", e.message); process.exit(1); });
+async function main() {
+  await ensureRuntime();
+}
+
+// CLI entry (postinstall). Imported as a module by the launcher — never
+// exit there.
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((e) => { console.error("omnirush postinstall:", e.message); process.exit(1); });
+}

package/src/bin.js

@@ -42,9 +42,11 @@ import {
   modelsConfig,
   resolveGatewayUrl,
   withModelDefaults,
+  withDefaultThinkingLevel,
   resolveModelDefaults,
 } from "./lib.js";
 import { installManagedTools } from "./tools.js";
+import { ensureRuntime, managedBunPath } from "../scripts/postinstall.js";
 import {
   clearAuth,
   deviceAuthorize,
@@ -70,6 +72,7 @@ const PI_AGENT_DIR = process.env.OMNIRUSH_PI_AGENT_DIR
   ? path.resolve(process.env.OMNIRUSH_PI_AGENT_DIR)
   : path.join(os.homedir(), ".pi", "agent");
 const PI_MODELS_JSON = path.join(PI_AGENT_DIR, "models.json");
+const PI_SETTINGS_JSON = path.join(PI_AGENT_DIR, "settings.json");
 const PI_EXT_DIR = path.join(PI_AGENT_DIR, "extensions", "omnirush");
 
 function managerOrigin() {
@@ -79,7 +82,7 @@ function managerOrigin() {
   );
 }
 
-function piEntry() {
+function piPackage() {
   // The pi package is Bun-first and its "exports" map blocks plain Node
   // resolution, so locate it by path: walk up from our own package root
   // to the nearest node_modules containing it.
@@ -88,13 +91,22 @@ function piEntry() {
   for (let i = 0; i < 6; i++) {
     const pkgPath = path.join(dir, "node_modules", PKG, "package.json");
     if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-      if (pkg.bin?.pi) return path.join(dir, "node_modules", PKG, pkg.bin.pi);
+      try {
+        return { dir: path.dirname(pkgPath), pkg: JSON.parse(fs.readFileSync(pkgPath, "utf8")) };
+      } catch {
+        return null;
+      }
     }
     const parent = path.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
+  return null;
+}
+
+function piEntry() {
+  const found = piPackage();
+  if (found?.pkg?.bin?.pi) return path.join(found.dir, found.pkg.bin.pi);
   throw new Error("could not locate the pinned pi CLI (@earendil-works/pi-coding-agent)");
 }
 
@@ -107,6 +119,29 @@ function ensureDirs() {
   } catch {
     /* best effort — pi falls back to PATH, then its own downloader */
   }
+  installDefaultThinkingLevel();
+}
+
+// Product default effort (P2): xhigh. Fills an ABSENT
+// defaultThinkingLevel in the agent settings only — an explicit user
+// choice always wins; the models' thinkingLevelMap is untouched.
+function installDefaultThinkingLevel() {
+  let settings = {};
+  try {
+    settings = JSON.parse(fs.readFileSync(PI_SETTINGS_JSON, "utf8"));
+  } catch {
+    /* fresh install or unparsable — start clean rather than clobber */
+    settings = {};
+  }
+  let next;
+  try {
+    next = withDefaultThinkingLevel(settings);
+  } catch {
+    return;
+  }
+  if (next !== settings) {
+    fs.writeFileSync(PI_SETTINGS_JSON, JSON.stringify(next, null, 2) + "\n");
+  }
 }
 
 // Merge our provider into the user's models.json without clobbering
@@ -154,36 +189,44 @@ function isMusl() {
 }
 
 function findBun() {
-  // Vendored per-platform bun first, then PATH, then the standard
-  // single-user install location. Linux packages ship both the glibc and
-  // the musl binary; the launcher picks by the running libc.
+  // MANAGED runtime first — always (issue #7: a system bun on PATH
+  // shadowed ours when .runtime was missing from a dev checkout, and a
+  // mismatched bun breaks the fork's own extensions). Vendored paths are
+  // canonical; PATH and ~/.bun are last-resort fallbacks that only run
+  // after a self-heal download was attempted. Linux packages ship both
+  // the glibc and the musl binary; the launcher picks by the running libc.
   const runtimeRoot = path.resolve(__dirname, "..", ".runtime");
   const plat = process.platform;
   const arch = process.arch === "arm64" ? "aarch64" : "x64";
-  const candidates = [];
+  const managedCandidates = [];
   if (plat === "win32") {
-    candidates.push(
-      path.join(runtimeRoot, "bun-windows-x64", "bin", "bun.exe"),
-    );
-    for (const dir of (process.env.PATH || "").split(path.delimiter)) {
-      if (dir) candidates.push(path.join(dir, "bun.exe"));
-    }
+    managedCandidates.push(managedBunPath());
+    managedCandidates.push(path.join(runtimeRoot, "bun-windows-x64", "bin", "bun.exe"));
   } else {
     if (plat === "linux") {
-      if (isMusl()) candidates.push(path.join(runtimeRoot, "bin", "bun-musl"));
-      else if (arch === "x64") candidates.push(path.join(runtimeRoot, "bin", "bun"));
-      candidates.push(path.join(runtimeRoot, "bin", `bun-${arch}${isMusl() ? "-musl" : ""}`));
+      if (isMusl()) managedCandidates.push(path.join(runtimeRoot, "bin", "bun-musl"));
+      else if (arch === "x64") managedCandidates.push(path.join(runtimeRoot, "bin", "bun"));
+      managedCandidates.push(path.join(runtimeRoot, "bin", `bun-${arch}${isMusl() ? "-musl" : ""}`));
     }
-    candidates.push(path.join(runtimeRoot, `bun-${plat}-${arch}`, "bin", "bun"));
-    for (const dir of (process.env.PATH || "").split(path.delimiter)) {
-      if (dir) candidates.push(path.join(dir, "bun"));
+    managedCandidates.push(path.join(runtimeRoot, `bun-${plat}-${arch}`, "bin", "bun"));
+  }
+  for (const c of managedCandidates) {
+    try {
+      fs.accessSync(c, fs.constants.X_OK);
+      return { path: c, managed: true };
+    } catch {
+      /* next */
     }
-    candidates.push(path.join(os.homedir(), ".bun", "bin", "bun"));
   }
-  for (const c of candidates) {
+  const fallbackCandidates = [];
+  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+    if (dir) fallbackCandidates.push(path.join(dir, plat === "win32" ? "bun.exe" : "bun"));
+  }
+  fallbackCandidates.push(path.join(os.homedir(), ".bun", "bin", plat === "win32" ? "bun.exe" : "bun"));
+  for (const c of fallbackCandidates) {
     try {
       fs.accessSync(c, fs.constants.X_OK);
-      return c;
+      return { path: c, managed: false };
     } catch {
       /* next */
     }
@@ -191,19 +234,57 @@ function findBun() {
   return null;
 }
 
-function runtimeFor(entry) {
+/**
+ * Self-healing managed-runtime resolution: if no MANAGED bun is
+ * installed, run the same fetch the postinstall runs, then re-check. A
+ * PATH bun is only used when the managed download is impossible — and
+ * the caller reports it.
+ */
+async function resolveBun() {
+  let found = findBun();
+  if (found?.managed) return found;
+  // Self-heal: fetch the managed runtime (downloads only what is
+  // missing; a few MB-100MB depending on platform).
+  try {
+    await ensureRuntime();
+  } catch (error) {
+    // fall through: maybe a usable fallback still exists
+    try {
+      fs.accessSync(managedBunPath(), fs.constants.X_OK);
+      found = { path: managedBunPath(), managed: true };
+    } catch {
+      console.error(`omnirush: managed runtime download failed (${error?.message ?? error})`);
+    }
+  }
+  if (!found?.managed) found = findBun();
+  return found;
+}
+
+async function runtimeFor(entry) {
   // pi is Bun-first; its CLI imports node:module#enableCompileCache,
-  // which needs Node >= 22.8. Prefer bun when present, else enforce the
-  // Node floor with a clear message.
-  const bun = findBun();
-  if (bun) return { cmd: bun, args: [entry] };
+  // which needs Node >= 22.8. The MANAGED bun wins unconditionally
+  // (self-heal download first); a PATH bun is a last resort. Plain node
+  // 22.8+ runs the agent without any bun.
+  const found = await resolveBun();
+  if (found) {
+    if (!found.managed) {
+      console.error(
+        "omnirush: using a non-managed bun from PATH " +
+          `(${found.path}) — the managed runtime is missing. Fix: run ` +
+          "`npm install -g omnirush` again (retries the runtime download).",
+      );
+    }
+    return { cmd: found.path, args: [entry] };
+  }
   const [major, minor] = process.versions.node.split(".").map(Number);
   if (major > 22 || (major === 22 && minor >= 8)) {
     return { cmd: process.execPath, args: [entry] };
   }
   console.error(
-    `omnirush: Node ${process.versions.node} is too old for the agent core ` +
-      "(need >= 22.8) and bun was not found. Install Node 22+ or bun.",
+    `omnirush couldn't set up its agent runtime (Node ${process.versions.node} is too ` +
+      "old for the agent core, which needs Node >= 22.8, and the managed runtime " +
+      "download did not succeed — network or install issue). Fix: run " +
+      "`npm install -g omnirush` again (retries the runtime download), or install Node 22.8+.",
   );
   process.exit(1);
 }
@@ -421,6 +502,72 @@ async function cmdDoctor() {
   }
   ok("agent config", true, PI_MODELS_JSON);
   ok("extensions", true, PI_EXT_DIR);
+  // Agent core version: a stale core predates the omnirush provider and
+  // 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();
+    const coreVersion = String(found?.pkg?.version ?? "");
+    const own = ownVersion();
+    if (!coreVersion) {
+      console.log(`WARN agent core — pinned agent package not found (broken install). Fix: omnirush update`);
+    } else if (coreVersion === own) {
+      ok("agent core", true, `v${coreVersion}`);
+    } else {
+      console.log(
+        `WARN agent core — installed core is v${coreVersion}, this omnirush expects v${own} ` +
+          "(stale install: pi.dev update banners, missing omnirush provider). Fix: omnirush update",
+      );
+    }
+  }
+  // Agent runtime: the managed bun must exist and always wins (issue #7:
+  // a PATH bun shadowed the managed runtime for a dev). Self-heal by
+  // downloading it right here when missing; report WHICH runtime is in
+  // use so support can see it.
+  {
+    let found = findBun();
+    let healError = null;
+    if (!found?.managed) {
+      try {
+        await ensureRuntime();
+      } catch (error) {
+        healError = error;
+      }
+      found = findBun();
+    }
+    if (found?.managed) {
+      ok(
+        "runtime",
+        true,
+        `bundled bun ${bunVersionOf(found.path)} (${found.path})`,
+      );
+    } else if (healError) {
+      ok(
+        "runtime",
+        false,
+        `managed runtime missing and the download failed (${healError?.message ?? healError}) — ` +
+          "Fix: run `npm install -g omnirush` again (retries the runtime download), or install Node 22.8+",
+      );
+    } else if (found) {
+      console.log(
+        `WARN runtime — using a NON-managed bun ${bunVersionOf(found.path)} from PATH (${found.path}); ` +
+          "the managed runtime is missing. Fix: run `npm install -g omnirush` again (retries the runtime download)",
+      );
+    } else {
+      const [major, minor] = process.versions.node.split(".").map(Number);
+      if (major > 22 || (major === 22 && minor >= 8)) {
+        ok("runtime", true, "no bun needed — Node " + process.versions.node + " runs the agent");
+      } else {
+        ok(
+          "runtime",
+          false,
+          `Node ${process.versions.node} is too old for the agent core (need >= 22.8) and the managed ` +
+            "runtime is missing — Fix: run `npm install -g omnirush` again (retries the runtime download), " +
+            "or install Node 22.8+",
+        );
+      }
+    }
+  }
   // 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");
@@ -465,6 +612,23 @@ function requireAuth() {
   process.exit(1);
 }
 
+function bunVersionOf(bunPath) {
+  try {
+    const { execFileSync } = require("node:child_process");
+    return String(execFileSync(bunPath, ["--version"], { timeout: 5000 })).trim() || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+function ownVersion() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8")).version;
+  } catch {
+    return "unknown";
+  }
+}
+
 function childEnv(auth) {
   const gateway = agentGatewayUrl(auth);
   const origin = (process.env.OMNIRUSH_ORIGIN || "").trim().replace(/\/+$/, "") ||
@@ -475,34 +639,85 @@ function childEnv(auth) {
     OMNIRUSH_ORIGIN: origin,
     OMNIRUSH_GATEWAY_URL: gateway,
     OMNIRUSH_DIR: OMNI_DIR,
+    // /status shows the CLI version; extensions have no package.json of
+    // their own in ~/.pi, so the launcher hands it over.
+    OMNIRUSH_VERSION: ownVersion(),
     // 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_OFFLINE kills startup update checks (the "Update Available —
+    // pi.dev/changelog" banner), package updates, and install/update
+    // telemetry; PI_TELEMETRY stays for cores that predate PI_OFFLINE.
+    PI_OFFLINE: "1",
     PI_TELEMETRY: "0",
   };
 }
 
+/**
+ * Spawn the agent with launcher signal hygiene (issue #9). The terminal's
+ * Ctrl+C already reaches the whole foreground process group — the child
+ * (bun -> pi) handles it itself (first ^C interrupts the turn, second
+ * exits pi). The launcher therefore IGNORES SIGINT (it used to die
+ * immediately, orphaning the TUI and forcing a third ^C), forwards
+ * process-directed signals, and exits only when the child does, with the
+ * child's exit code or signal.
+ */
+function spawnAgent(cmd, args, opts) {
+  const child = spawn(cmd, args, opts);
+  let childAlive = true;
+  let lastExit = { code: 0, signal: null };
+  child.on("exit", (code, signal) => {
+    childAlive = false;
+    lastExit = { code, signal };
+  });
+  const onInterrupt = () => {
+    if (!childAlive) {
+      process.exit(lastExit.code ?? 0);
+    }
+    // Otherwise let pi handle the interrupt — never double-send, never
+    // exit first.
+  };
+  const forward = (signal) => () => {
+    if (childAlive) {
+      try {
+        child.kill(signal);
+      } catch {
+        /* already gone */
+      }
+    } else {
+      process.exit(lastExit.code ?? 0);
+    }
+  };
+  process.on("SIGINT", onInterrupt);
+  process.on("SIGTERM", forward("SIGTERM"));
+  if (process.platform !== "win32") {
+    process.on("SIGHUP", forward("SIGHUP"));
+    process.on("SIGQUIT", forward("SIGQUIT"));
+  }
+  child.on("exit", (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    else process.exit(code ?? 0);
+  });
+  return child;
+}
+
 async function cmdRun() {
   ensureDirs();
   const auth = requireAuth();
   installModelsJson(agentGatewayUrl(auth));
   installExtensions();
   const entry = piEntry();
-  const { cmd, args } = runtimeFor(entry);
+  const { cmd, args } = await runtimeFor(entry);
   // Plain `omnirush` always runs the SOTA model (charter rule 1); user
   // flags win when present.
   const piArgs = withModelDefaults([], resolveModelDefaults(process.env));
-  const child = spawn(cmd, [...args, ...piArgs], {
+  spawnAgent(cmd, [...args, ...piArgs], {
     stdio: "inherit",
     env: { ...process.env, ...childEnv(auth) },
   });
-  child.on("exit", (code, signal) => {
-    if (signal) process.kill(process.pid, signal);
-    else process.exit(code ?? 0);
-  });
 }
 
 async function cmdCollect(argv) {
@@ -510,24 +725,63 @@ async function cmdCollect(argv) {
   const auth = requireAuth();
   installExtensions();
   const entry = path.join(__dirname, "..", "assets", "collect-once.ts");
-  const { cmd, args } = runtimeFor(entry);
-  const child = spawn(cmd, [...args, ...argv], {
+  const { cmd, args } = await runtimeFor(entry);
+  spawnAgent(cmd, [...args, ...argv], {
     stdio: "inherit",
     env: { ...process.env, ...childEnv(auth) },
   });
-  child.on("exit", (code, signal) => {
-    if (signal) process.kill(process.pid, signal);
-    else process.exit(code ?? 0);
-  });
+}
+
+// Native omnirush help (issue #8): --help/-h must render OUR commands
+// and branding — never forward to the agent core's help.
+function printHelp() {
+  console.log(`omnirush — free daily tokens for the most powerful coding model on earth
+
+Usage:
+  omnirush                          start the agent (default: gpt-6-astra)
+  omnirush -p "<prompt>"            run a one-shot prompt
+  omnirush login                    sign in (device flow via your browser)
+  omnirush logout                   forget the stored device tokens
+  omnirush whoami                   show the signed-in identity
+  omnirush doctor                   check auth, manager, runtime, agent config
+  omnirush collect [--dir PATH]     one-shot workspace snapshot upload
+  omnirush update                   update omnirush (npm install -g omnirush@latest)
+  omnirush --version                show the omnirush version
+
+Options:
+  --model <model[:effort]>          model override (gpt-6-astra, gpt-5.6-sol;
+                                    effort: minimal..max)
+  --thinking <level>                reasoning effort override
+  --strict-sota                     exit non-zero if the served model is not
+                                    the requested SOTA model
+  --session <file> | --continue     session options (forwarded to the agent)
+  -p, --print "<prompt>"            print-mode: answer once and exit
+  -h, --help                        show this help
+
+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, collector)
+  /mcp     MCP server state (/mcp reconnect [server])
+  /verify  model attestation (arrives with the gateway lane)
+
+Environment:
+  OMNIRUSH_ORIGIN        manager origin override
+  OMNIRUSH_MODEL         default model override (e.g. gpt-5.6-sol)
+  OMNIRUSH_DIR           state dir override (default ~/.omnirush)
+  OMNIRUSH_DEBUG=1       verbose diagnostics (raw gateway errors on failure)
+
+Docs: https://omnirush.ai/omnirush — state is stored 0600 in ~/.omnirush`);
 }
 
 const [, , ...argv] = process.argv;
 const cmd = argv[0];
-if (cmd === "login") await cmdLogin(argv.slice(1));
+if (cmd === "-h" || cmd === "--help" || cmd === "help") printHelp();
+else 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.3.3");
+else if (cmd === "--version" || cmd === "-v") console.log(`omnirush ${ownVersion()}`);
 else if (cmd === "collect") await cmdCollect(argv.slice(1));
 else if (cmd === undefined || cmd === "run") await cmdRun();
 else {
@@ -540,11 +794,10 @@ else {
   installModelsJson(agentGatewayUrl(auth));
   installExtensions();
   const entry = piEntry();
-  const { cmd: bin, args } = runtimeFor(entry);
+  const { cmd: bin, args } = await runtimeFor(entry);
   const piArgs = withModelDefaults(argv, resolveModelDefaults(process.env));
-  const child = spawn(bin, [...args, ...piArgs], {
+  spawnAgent(bin, [...args, ...piArgs], {
     stdio: "inherit",
     env: { ...process.env, ...childEnv(auth) },
   });
-  child.on("exit", (code) => process.exit(code ?? 0));
 }

package/src/lib.js

@@ -221,6 +221,19 @@ export function modelsConfig({ gatewayUrl } = {}) {
   };
 }
 
+/**
+ * Product default effort (Dan's call, 2026-09-24): xhigh, not pi's
+ * medium. The `thinkingLevelMap` on each model is unchanged — this only
+ * fills an ABSENT `defaultThinkingLevel` in the agent's settings.json,
+ * so an explicit user choice (saved via Ctrl+S in /thinking, or edited
+ * manually) always wins. Returns the settings object to persist; pure.
+ */
+export function withDefaultThinkingLevel(settings, level = "xhigh") {
+  const base = settings && typeof settings === "object" && !Array.isArray(settings) ? settings : {};
+  if (base.defaultThinkingLevel !== undefined) return base;
+  return { ...base, defaultThinkingLevel: level };
+}
+
 /**
  * Pure mapping of the bundled search-tool binaries for the launcher: pi
  * looks for managed `fd`/`rg` in <agentDir>/bin first and downloads from