pennyrouter 0.3.0 → 0.3.2

package/src/launch.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import {
   chmod,
   cp,
@@ -13,6 +13,7 @@ import { fileURLToPath } from "node:url";
 import { basename, dirname, join, resolve } from "node:path";
 
 import { configureClaudeCodeStatusline } from "./statusline.js";
+import { upgradeClaudeCodeModelValue, writeClaudeCodeModelPresentation } from "./harnesses/claude-code.js";
 import { atomicWrite, homeDir, readJsonFile, readText } from "./state.js";
 
 const CONFIG_VERSION = 1;
@@ -20,8 +21,13 @@ const PATH_START = "# >>> pennyrouter PATH >>>";
 const PATH_END = "# <<< pennyrouter PATH <<<";
 const CODEX_PROFILE_MARKER = "# PennyRouter per-command profile (managed; no secrets)";
 const CLAUDE_COMMAND_MARKER = "<!-- PennyRouter managed Claude command -->";
+const TERMINAL_TITLE_REFRESH_MS = 1000;
+const TERMINAL_STATUS_REFRESH_MS = 15000;
 
 export function pennyConfigDir() {
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA || process.env.LOCALAPPDATA || homeDir(), "PennyRouter");
+  }
   return join(process.env.XDG_CONFIG_HOME || join(homeDir(), ".config"), "pennyrouter");
 }
 
@@ -30,6 +36,9 @@ export function pennyConfigPath() {
 }
 
 export function pennyDataDir() {
+  if (process.platform === "win32") {
+    return join(process.env.LOCALAPPDATA || process.env.APPDATA || homeDir(), "PennyRouter");
+  }
   return join(process.env.XDG_DATA_HOME || join(homeDir(), ".local", "share"), "pennyrouter");
 }
 
@@ -38,11 +47,12 @@ export function pennyRuntimeDir() {
 }
 
 export function pennyBinDir() {
+  if (process.platform === "win32") return join(pennyDataDir(), "bin");
   return join(homeDir(), ".local", "bin");
 }
 
 export function pennyShimPath() {
-  return join(pennyBinDir(), "penny");
+  return join(pennyBinDir(), process.platform === "win32" ? "penny.cmd" : "penny");
 }
 
 export function claudeLaunchSettingsPath() {
@@ -107,49 +117,131 @@ async function copyRuntime() {
 
 async function writeShim() {
   await mkdir(pennyBinDir(), { recursive: true, mode: 0o755 });
-  const entry = join(pennyRuntimeDir(), "bin", "penny.js").replaceAll('"', '\\"');
-  await writeFile(pennyShimPath(), `#!/bin/sh\nexec node "${entry}" "$@"\n`, {
+  const entry = join(pennyRuntimeDir(), "bin", "penny.js");
+  const body = process.platform === "win32"
+    // `node` and the native harnesses are normally npm .cmd shims on Windows. cmd.exe
+    // resolves those through PATHEXT, while Node's direct spawn does not.
+    ? `@echo off\r\nnode "${entry.replaceAll('"', '""')}" %*\r\n`
+    : `#!/bin/sh\nexec node "${entry.replaceAll('"', '\\"')}" "$@"\n`;
+  await writeFile(pennyShimPath(), body, {
     encoding: "utf8",
     mode: 0o755,
   });
-  await chmod(pennyShimPath(), 0o755);
+  if (process.platform !== "win32") await chmod(pennyShimPath(), 0o755);
 }
 
 function pathContains(dir) {
-  return String(process.env.PATH || "").split(":").some((candidate) => resolve(candidate) === resolve(dir));
+  const delimiter = process.platform === "win32" ? ";" : ":";
+  const normalized = process.platform === "win32" ? String(dir).toLowerCase() : resolve(dir);
+  return String(process.env.PATH || "").split(delimiter).some((candidate) => {
+    const value = candidate.trim().replace(/^"|"$/g, "");
+    return process.platform === "win32"
+      ? value.toLowerCase() === normalized
+      : resolve(value) === normalized;
+  });
 }
 
-function shellRcPath() {
+function readWindowsUserPath() {
+  const result = spawnSync("reg", ["query", "HKCU\\Environment", "/v", "Path"], {
+    encoding: "utf8", windowsHide: true,
+  });
+  if (result.status !== 0) return "";
+  const line = String(result.stdout || "").split(/\r?\n/).find((item) => /\bPath\s+REG_/i.test(item));
+  return line ? line.replace(/^\s*Path\s+REG_\S+\s*/i, "").trim() : "";
+}
+
+function writeWindowsUserPath(value) {
+  const result = spawnSync("reg", [
+    "add", "HKCU\\Environment", "/v", "Path", "/t", "REG_EXPAND_SZ", "/d", value, "/f",
+  ], { stdio: "ignore", windowsHide: true });
+  if (result.status !== 0) throw new Error("Could not add PennyRouter to the Windows user PATH.");
+  broadcastEnvironmentChange();
+}
+
+// user32.dll,UpdatePerUserSystemParameters refreshes desktop/profile parameters (wallpaper,
+// etc.) — it is NOT the env var broadcast and does nothing for PATH. The actual mechanism
+// (what setx.exe and the System Properties dialog use) is a WM_SETTINGCHANGE broadcast with
+// lParam "Environment", which only Win32 SendMessageTimeout can send. Shell out to a tiny
+// inline PowerShell snippet to make that call. New processes started by an already-running
+// shell host (Explorer, Windows Terminal) still won't see the change until that host itself
+// receives and acts on the broadcast, but this is what makes a freshly-opened terminal work.
+function broadcastEnvironmentChange() {
+  const script = [
+    "$sig = '[DllImport(\"user32.dll\", SetLastError = true, CharSet = CharSet.Auto)]",
+    "public static extern IntPtr SendMessageTimeout(IntPtr hWnd, uint Msg, UIntPtr wParam,",
+    "string lParam, uint fuFlags, uint uTimeout, out UIntPtr lpdwResult);'",
+    "$type = Add-Type -MemberDefinition $sig -Name NativeMethods -Namespace Win32 -PassThru",
+    "$result = [UIntPtr]::Zero",
+    "$HWND_BROADCAST = [IntPtr]0xffff",
+    "$WM_SETTINGCHANGE = 0x1a",
+    "$SMTO_ABORTIFHUNG = 0x2",
+    "$type::SendMessageTimeout($HWND_BROADCAST, $WM_SETTINGCHANGE, [UIntPtr]::Zero, 'Environment', $SMTO_ABORTIFHUNG, 5000, [ref]$result) | Out-Null",
+  ].join("\n");
+  spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+    stdio: "ignore", windowsHide: true,
+  });
+}
+
+function windowsPathContains(pathValue, dir) {
+  const wanted = String(dir).toLowerCase();
+  return String(pathValue || "").split(";").some((item) => item.trim().replace(/^"|"$/g, "").toLowerCase() === wanted);
+}
+
+async function ensurePennyOnWindowsPath({ updatePath }) {
+  if (pathContains(pennyBinDir())) return { available: true, changed: false, path_managed: false };
+  const current = readWindowsUserPath();
+  if (windowsPathContains(current, pennyBinDir())) return { available: true, changed: false, path_managed: false };
+  if (!updatePath) return { available: false, changed: false, path_managed: false };
+  const next = current ? `${current};${pennyBinDir()}` : pennyBinDir();
+  writeWindowsUserPath(next);
+  return { available: true, changed: true, path_managed: true };
+}
+
+function shellRcPaths() {
   const shell = basename(process.env.SHELL || "");
-  if (shell === "zsh") return join(homeDir(), ".zshrc");
-  if (shell === "bash") return join(homeDir(), ".bashrc");
-  return null;
+  if (shell === "zsh") return [join(homeDir(), ".zshrc"), join(homeDir(), ".zprofile")];
+  if (shell === "bash") return [join(homeDir(), ".bashrc"), join(homeDir(), ".bash_profile")];
+  return [];
 }
 
 export async function ensurePennyOnPath({ updatePath = true } = {}) {
+  if (process.platform === "win32") return ensurePennyOnWindowsPath({ updatePath });
   if (pathContains(pennyBinDir())) return { available: true, changed: false, rc_path: null };
   if (!updatePath) return { available: false, changed: false, rc_path: null };
-  const rcPath = shellRcPath();
-  if (!rcPath) return { available: false, changed: false, rc_path: null };
-  const current = await readText(rcPath, "");
-  if (!current.includes(PATH_START)) {
-    const block = `${PATH_START}\nexport PATH="$HOME/.local/bin:$PATH"\n${PATH_END}`;
+  const rcPaths = shellRcPaths();
+  if (rcPaths.length === 0) return { available: false, changed: false, rc_path: null, rc_paths: [] };
+  const block = `${PATH_START}\nexport PATH="$HOME/.local/bin:$PATH"\n${PATH_END}`;
+  const changedPaths = [];
+  for (const rcPath of rcPaths) {
+    const current = await readText(rcPath, "");
+    if (current.includes(PATH_START)) continue;
     const prefix = current && !current.endsWith("\n") ? "\n" : "";
     await atomicWrite(rcPath, `${current}${prefix}${block}\n`);
+    changedPaths.push(rcPath);
   }
-  return { available: true, changed: !current.includes(PATH_START), rc_path: rcPath };
+  return {
+    available: true,
+    changed: changedPaths.length > 0,
+    rc_path: rcPaths[0],
+    rc_paths: rcPaths,
+  };
 }
 
 export async function installPennyRuntime({ updatePath = true } = {}) {
-  if (!(["darwin", "linux"].includes(process.platform))) {
+  if (!(["darwin", "linux", "win32"].includes(process.platform))) {
     return { supported: false, available: false, changed: false, rc_path: null };
   }
   await copyRuntime();
   await writeShim();
   const path = await ensurePennyOnPath({ updatePath });
   const config = await loadPennyConfig();
-  if (path.rc_path) {
+  if (path.rc_paths?.length > 0) {
     config.path_rc = path.rc_path;
+    config.path_rcs = path.rc_paths;
+    await savePennyConfig(config);
+  }
+  if (process.platform === "win32" && path.path_managed) {
+    config.windows_path_managed = true;
     await savePennyConfig(config);
   }
   return { supported: true, ...path, shim_path: pennyShimPath() };
@@ -173,9 +265,93 @@ export function renderCodexLaunchProfile({ gatewayBaseUrl, subscriptionAuth }) {
     "supports_websockets = false",
     ...authLines,
     "",
+    "[tui]",
+    // Penny owns the live terminal title while this profile is running. An empty
+    // list disables Codex's default activity/project title so the two writers do
+    // not race each other.
+    "terminal_title = []",
+    "",
   ].join("\n");
 }
 
+function terminalTitle(text) {
+  // OSC titles are interpreted by the terminal, so remove control characters and
+  // the OSC terminators rather than allowing gateway-provided text into the escape.
+  const safe = String(text).replace(/[\u0000-\u001f\u007f\u001b]/g, " ").slice(0, 240);
+  return `\u001b]0;${safe}\u0007`;
+}
+
+function writeTerminalTitle(title) {
+  if (process.stdout.isTTY) process.stdout.write(terminalTitle(title));
+}
+
+function renderPennyTerminalTitle(status) {
+  const parts = ["PennyRouter"];
+  if (status?.model_display_name) parts.push(status.model_display_name);
+  else if (status?.model) parts.push(status.model);
+  if (status?.auth_mode) parts.push(`(${status.auth_mode})`);
+  parts.push(renderCacheWarmth(status));
+  return parts.join(" · ");
+}
+
+function renderCacheWarmth(status) {
+  const expiresAt = status?.cache_expires_at;
+  if (typeof expiresAt !== "number" || !Number.isFinite(expiresAt) || expiresAt <= 0) {
+    return "❄️ cold";
+  }
+  const remaining = Math.floor(expiresAt - Date.now() / 1000);
+  if (remaining <= 0) return "❄️ cold";
+  const minutes = Math.floor(remaining / 60);
+  const seconds = remaining % 60;
+  return `🔥 ${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+
+/**
+ * Keep the terminal/tab title useful while `penny codex` owns the foreground TTY.
+ * This is deliberately local and best-effort: failure to poll the gateway must never
+ * affect Codex, and non-TTY invocations (CI, pipes) receive no escape sequences.
+ */
+export function startPennyTerminalTitle({ gatewayBaseUrl, apiKey }) {
+  if (!process.stdout.isTTY) return () => {};
+
+  let status = null;
+  let stopped = false;
+  let statusInFlight = false;
+
+  const refreshStatus = async () => {
+    if (stopped || statusInFlight || !gatewayBaseUrl || !apiKey) return;
+    statusInFlight = true;
+    try {
+      const response = await fetch(`${String(gatewayBaseUrl).replace(/\/$/, "")}/v1/penny/statusline`, {
+        headers: { "x-api-key": apiKey },
+        signal: AbortSignal.timeout(4000),
+      });
+      if (response.ok) status = await response.json();
+    } catch {
+      // The title remains useful with its local timer when the gateway is unavailable.
+    } finally {
+      statusInFlight = false;
+    }
+  };
+
+  const tick = () => writeTerminalTitle(renderPennyTerminalTitle(status));
+  const timer = setInterval(tick, TERMINAL_TITLE_REFRESH_MS);
+  const statusTimer = setInterval(refreshStatus, TERMINAL_STATUS_REFRESH_MS);
+  timer.unref?.();
+  statusTimer.unref?.();
+  void refreshStatus();
+  tick();
+
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(timer);
+    clearInterval(statusTimer);
+    // Let the shell or terminal choose its normal title again after Codex exits.
+    writeTerminalTitle("");
+  };
+}
+
 async function writeClaudeLaunchSettings() {
   const native = (await readJsonFile(join(homeDir(), ".claude", "settings.json"), null)) || {};
   const overlay = { disableClaudeAiConnectors: true };
@@ -249,6 +425,11 @@ export async function configurePennyHarness(harness, {
       enabled: true,
       subscription_auth: Boolean(subscriptionAuth),
     };
+  } else if (harness === "opencode") {
+    // OpenCode owns its provider and statusline configuration. The launcher only
+    // records that the Penny command is enabled; its existing OpenCode config is
+    // left untouched.
+    config.harnesses.opencode = { enabled: true };
   } else {
     throw new Error(`The penny command does not support ${harness}.`);
   }
@@ -307,9 +488,23 @@ async function removeManagedPathBlock(rcPath) {
   await atomicWrite(rcPath, next);
 }
 
+function removeWindowsPathEntry() {
+  const current = readWindowsUserPath();
+  if (!current) return;
+  const next = current.split(";")
+    .filter((item) => item.trim().replace(/^"|"$/g, "").toLowerCase() !== pennyBinDir().toLowerCase())
+    .join(";");
+  if (next !== current) writeWindowsUserPath(next);
+}
+
 export async function removePennyRuntime() {
   const config = await loadPennyConfig();
-  await removeManagedPathBlock(config.path_rc);
+  if (process.platform === "win32") {
+    if (config.windows_path_managed) removeWindowsPathEntry();
+  } else {
+    const paths = config.path_rcs || [config.path_rc];
+    for (const rcPath of paths) await removeManagedPathBlock(rcPath);
+  }
   await unlink(pennyShimPath()).catch((error) => {
     if (error.code !== "ENOENT") throw error;
   });
@@ -328,6 +523,22 @@ function assertNoConflictingArgs(harness, args) {
   }
 }
 
+const CLAUDE_AUTH_STARTUP_MODES = new Set(["auto", "proxy", "sub", "api", "openrouter"]);
+
+function rewriteClaudeAuthStartup(args) {
+  // `claude <prompt>` submits the positional argument as the first user turn. Convert the
+  // convenient `penny claude proxy` spelling into the managed in-band command before Claude
+  // starts, so Claude receives a real @penny command rather than the literal word "proxy".
+  if (args.length === 1 && CLAUDE_AUTH_STARTUP_MODES.has(args[0].toLowerCase())) {
+    return [`@penny auth ${args[0].toLowerCase()}`];
+  }
+  if (args.length === 2 && args[0].toLowerCase() === "auth"
+      && CLAUDE_AUTH_STARTUP_MODES.has(args[1].toLowerCase())) {
+    return [`@penny auth ${args[1].toLowerCase()}`];
+  }
+  return args;
+}
+
 export function buildPennyInvocation(harness, args, config) {
   const item = config.harnesses?.[harness];
   if (!item || !item.enabled) {
@@ -339,21 +550,34 @@ export function buildPennyInvocation(harness, args, config) {
     const models = item.models || {};
     env.ANTHROPIC_BASE_URL = config.gateway_base_url;
     env.ANTHROPIC_AUTH_TOKEN = config.api_key;
+    // Ask Claude Code to discover the gateway's model catalog at startup. The gateway
+    // advertises Penny-facing ids in /v1/models; this is separate from inference routing.
+    env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
     delete env.ANTHROPIC_API_KEY;
-    if (models.haiku) env.ANTHROPIC_DEFAULT_HAIKU_MODEL = models.haiku;
-    if (models.sonnet) env.ANTHROPIC_DEFAULT_SONNET_MODEL = models.sonnet;
-    if (models.opus) env.ANTHROPIC_DEFAULT_OPUS_MODEL = models.opus;
-    if (models.fable) env.ANTHROPIC_DEFAULT_FABLE_MODEL = models.fable;
+    if (models.haiku) env.ANTHROPIC_DEFAULT_HAIKU_MODEL = upgradeClaudeCodeModelValue(models.haiku);
+    if (models.sonnet) env.ANTHROPIC_DEFAULT_SONNET_MODEL = upgradeClaudeCodeModelValue(models.sonnet);
+    if (models.opus) env.ANTHROPIC_DEFAULT_OPUS_MODEL = upgradeClaudeCodeModelValue(models.opus);
+    if (models.fable) env.ANTHROPIC_DEFAULT_FABLE_MODEL = upgradeClaudeCodeModelValue(models.fable);
+    delete env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+    delete env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
+    delete env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
+    writeClaudeCodeModelPresentation(env);
+    // Per-model limits must come from Claude Code's recognized native model ids. This
+    // global override would incorrectly give Haiku the 1M window.
+    delete env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
     return {
       command: "claude",
-      args: ["--settings", claudeLaunchSettingsPath(), ...args],
+      args: ["--settings", claudeLaunchSettingsPath(), ...rewriteClaudeAuthStartup(args)],
       env,
     };
   }
   if (harness === "codex") {
     return { command: "codex", args: ["--profile", "pennyrouter", ...args], env };
   }
-  throw new Error(`Unknown Penny harness "${harness}". Try penny claude or penny codex.`);
+  if (harness === "opencode") {
+    return { command: "opencode", args, env };
+  }
+  throw new Error(`Unknown Penny harness "${harness}". Try penny claude, penny codex, or penny opencode.`);
 }
 
 async function waitForChild(child) {
@@ -366,11 +590,11 @@ async function waitForChild(child) {
 export async function runPenny(argv = process.argv.slice(2)) {
   const harness = argv[0];
   if (!harness || harness === "help" || harness === "--help" || harness === "-h") {
-    console.log("Usage: penny <claude|codex> [native arguments...]");
+    console.log("Usage: penny <claude|codex|opencode> [native arguments...]");
     return 0;
   }
-  if (!(["claude", "codex"].includes(harness))) {
-    throw new Error(`Unknown harness "${harness}". Try penny claude or penny codex.`);
+  if (!["claude", "codex", "opencode"].includes(harness)) {
+    throw new Error(`Unknown harness "${harness}". Try penny claude, penny codex, or penny opencode.`);
   }
   const config = await loadPennyConfig();
   const invocation = buildPennyInvocation(harness, argv.slice(1), config);
@@ -378,8 +602,16 @@ export async function runPenny(argv = process.argv.slice(2)) {
     cwd: process.cwd(),
     env: invocation.env,
     stdio: "inherit",
+    shell: process.platform === "win32",
   });
+  const stopTerminalTitle = ["codex", "opencode"].includes(harness)
+    ? startPennyTerminalTitle({
+        gatewayBaseUrl: config.gateway_base_url,
+        apiKey: config.api_key,
+      })
+    : () => {};
   const result = await waitForChild(child);
+  stopTerminalTitle();
   if (result.signal) return 128 + (osConstants.signals[result.signal] || 0);
   return result.code ?? 1;
 }

package/src/launch.test.js

@@ -19,6 +19,7 @@ import {
   removePennyRuntime,
   renderCodexLaunchProfile,
 } from "./launch.js";
+import { claudeCodeHarness } from "./harnesses/claude-code.js";
 
 const ENV_KEYS = [
   "HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "CODEX_HOME", "PATH", "SHELL",
@@ -73,6 +74,8 @@ async function main() {
       apiKey: "pr-super-secret",
       gatewayBaseUrl: "https://gateway.example/",
       subscriptionAuth: true,
+      // Simulate an existing install. `penny claude` must fix this at launch,
+      // without requiring a separate reinstall before its context limits are right.
       models: { haiku: "Haiku 4.5 (PennyRouter)", sonnet: "Sonnet 5 (PennyRouter)", opus: "Opus 5 (PennyRouter)" },
     });
     await configurePennyHarness("codex", {
@@ -80,6 +83,10 @@ async function main() {
       gatewayBaseUrl: "https://gateway.example/",
       subscriptionAuth: true,
     });
+    await configurePennyHarness("opencode", {
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+    });
 
     assert.equal(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"), nativeClaude);
     assert.equal(fs.readFileSync(path.join(home, ".codex", "config.toml"), "utf8"), nativeCodex);
@@ -89,8 +96,10 @@ async function main() {
 
     const config = await loadPennyConfig();
     assert.equal(config.api_key, "pr-super-secret");
+    assert.equal(config.harnesses.opencode.enabled, true);
     const codexProfile = fs.readFileSync(codexLaunchProfilePath(), "utf8");
     assert.ok(codexProfile.includes('env_http_headers = { "x-pennyrouter-key" = "PENNYROUTER_API_KEY" }'));
+    assert.ok(codexProfile.includes("[tui]\nterminal_title = []"));
     assert.ok(!codexProfile.includes("pr-super-secret"));
     assert.ok(!rc.includes("pr-super-secret"));
 
@@ -100,11 +109,33 @@ async function main() {
     assert.ok(!claude.args.includes("--plugin-dir"));
     assert.equal(claude.env.ANTHROPIC_AUTH_TOKEN, "pr-super-secret");
     assert.equal(claude.env.ANTHROPIC_BASE_URL, "https://gateway.example/");
-    assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "Opus 5 (PennyRouter)");
+    assert.equal(claude.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY, "1");
+    // 1M-capable slots carry the `[1m]` suffix; Haiku has no 1M variant and stays bare.
+    // Per-slot suffixes, not the global CLAUDE_CODE_MAX_CONTEXT_TOKENS override, which
+    // would wrongly hand Haiku a 1M window too.
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5[1m]");
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME, "Haiku 4.5");
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION, "Fast, economical Claude model · 200K context");
+    assert.equal(claude.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, undefined);
+
+    const proxyStartup = buildPennyInvocation("claude", ["proxy"], config);
+    assert.deepEqual(proxyStartup.args.slice(-1), ["@penny auth proxy"]);
+    const apiStartup = buildPennyInvocation("claude", ["auth", "api"], config);
+    assert.deepEqual(apiStartup.args.slice(-1), ["@penny auth api"]);
+    const normalPrompt = buildPennyInvocation("claude", ["proxy", "please"], config);
+    assert.deepEqual(normalPrompt.args.slice(-2), ["proxy", "please"]);
 
     const codex = buildPennyInvocation("codex", ["resume", "--last"], config);
     assert.deepEqual(codex.args, ["--profile", "pennyrouter", "resume", "--last"]);
     assert.equal(codex.env.PENNYROUTER_API_KEY, "pr-super-secret");
+    const opencode = buildPennyInvocation("opencode", ["--continue"], config);
+    assert.equal(opencode.env.PENNYROUTER_API_KEY, "pr-super-secret");
+    assert.deepEqual(opencode, {
+      command: "opencode",
+      args: ["--continue"],
+      env: opencode.env,
+    });
     assert.throws(() => buildPennyInvocation("claude", ["--settings=x"], config), /manages --settings/);
     assert.throws(() => buildPennyInvocation("codex", ["-p", "other"], config), /manages --profile/);
 
@@ -112,6 +143,18 @@ async function main() {
     assert.ok(command.includes("@penny $ARGUMENTS"));
     assert.ok(command.includes("name: penny"));
 
+    // Persistent direct-Claude installs use the same native ids and must not
+    // leave the former global 1M override behind.
+    await claudeCodeHarness.install({
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+      plan: { configPath: path.join(home, ".claude", "settings.json") },
+    });
+    const persistedClaude = JSON.parse(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"));
+    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
+    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_SONNET_MODEL, "claude-sonnet-5[1m]");
+    assert.equal("CLAUDE_CODE_MAX_CONTEXT_TOKENS" in persistedClaude.env, false);
+
     await removePennyHarness("claude-code");
     assert.ok(!fs.existsSync(claudeUserSkillPath()));
     fs.mkdirSync(path.dirname(claudeUserSkillPath()), { recursive: true });
@@ -124,12 +167,15 @@ async function main() {
     assert.equal(fs.readFileSync(claudeUserSkillPath(), "utf8"), "user-owned command\n");
     assert.ok(fs.existsSync(codexLaunchProfilePath()));
     assert.ok(fs.existsSync(pennyShimPath()));
+    assert.ok(fs.readFileSync(path.join(home, ".zprofile"), "utf8").includes(">>> pennyrouter PATH >>>"));
     await removePennyHarness("codex");
+    await removePennyHarness("opencode");
     await removePennyRuntime();
     assert.ok(!fs.existsSync(pennyShimPath()));
     assert.ok(!fs.existsSync(pennyRuntimeDir()));
     assert.ok(!fs.existsSync(pennyConfigPath()));
     assert.equal(fs.readFileSync(path.join(home, ".zshrc"), "utf8"), "# user setting\n");
+    assert.equal(fs.readFileSync(path.join(home, ".zprofile"), "utf8"), "");
 
     const paid = renderCodexLaunchProfile({
       gatewayBaseUrl: "https://gateway.example/", subscriptionAuth: false,