pennyrouter 0.1.20 → 0.2.0

package/README.md

@@ -10,7 +10,7 @@ status checks, and uninstall metadata.
 
 ```bash
 npx pennyrouter install
-npx pennyrouter install --existing-account
+npx pennyrouter install --make-default
 npx pennyrouter auth anthropic
 npx pennyrouter install --harness claude-code,cline,opencode,codex,windsurf,zed,codegpt,aider
 npx pennyrouter disable
@@ -19,6 +19,9 @@ npx pennyrouter uninstall
 npx pennyrouter status
 ```
 
+Installation opens a browser and requires login to the PennyRouter account that should own
+the new machine key. CLI installs no longer create anonymous ghost accounts.
+
 With no `--harness` flag, the interactive installer shows a checkbox list. Tools with
 detected configs start checked; press Enter to accept or type tool IDs to toggle them.
 
@@ -26,6 +29,33 @@ When Claude Code is selected, the installer also offers an optional Claude Pro/M
 subscription-auth step. Users can skip it during install and enable it later with
 `@penny auth` or `npx pennyrouter auth anthropic`.
 
+## Explicit Penny Commands
+
+On macOS and Linux, a normal install adds a small `penny` launcher under `~/.local/bin`:
+
+```bash
+penny claude
+penny codex
+```
+
+Arguments are passed through to the native harness, so commands such as `penny claude --resume`
+and `penny codex resume --last` work normally. By default, bare `claude` and `codex` remain
+completely native; their normal configuration files are not redirected. Choose the installer's
+"make PennyRouter the default" option, or pass `--make-default`, to retain the original global
+routing behavior.
+
+Existing PennyRouter installs preserve their current bare-command behavior during upgrade unless
+the user explicitly changes it. Close running Claude Code or Codex sessions only when adding or
+removing global bare-command routing. A Penny-only install does not require closing native sessions.
+
+The launcher uses a private config at `~/.config/pennyrouter/config.json`, a Claude settings overlay,
+and a secret-free Codex profile. The installer adds one marked PATH block to zsh or bash startup
+files when needed; `--no-path-update` skips that edit.
+
+In Claude Code sessions launched with `penny claude`, `/penny help` is an alias for the existing
+`@penny help` syntax. Both forms remain supported. Codex continues to use `@penny` because Codex
+does not currently expose equivalent project-independent custom slash commands.
+
 When Codex is already signed in with ChatGPT, the installer preserves that Codex-managed
 login and configures PennyRouter as an OpenAI-authenticated Responses proxy. Codex continues
 to own and refresh the OpenAI credentials; PennyRouter stores only its existing `pr-` account
@@ -40,6 +70,12 @@ npx pennyrouter@latest install --harness codex --local
 Restart Codex after installation. Without `--local`, browser authorization supplies the normal
 hosted gateway URL.
 
+Before configuring Claude Code, the installer sends a small compatibility request exercising the
+modern beta/context-management request shape. If that check fails, Claude routing is not enabled;
+the gateway must be redeployed or fixed before retrying. This check is about PennyRouter's gateway
+compatibility, not a demand that the user upgrade a Claude Code version that already emits a
+supported request shape.
+
 ## Supported Tools
 
 - Claude Code
@@ -124,8 +160,9 @@ directly.
 
 ## What It Changes
 
-The CLI writes only selected local tool configuration files, saves backups under the local
-PennyRouter state directory, and records an uninstall manifest.
+The CLI installs its managed launcher under `~/.local`, writes only selected local tool
+configuration or per-command overlay files, saves backups under the local PennyRouter state
+directory, and records an uninstall manifest.
 
 `disable` temporarily removes PennyRouter from selected tools while retaining a local
 PennyRouter-managed snapshot for `enable`.

package/bin/penny.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runPenny } from "../src/launch.js";
+
+runPenny().then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  console.error(error?.message || String(error));
+  process.exitCode = 1;
+});

package/claude-plugin/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "pennyrouter",
+  "description": "PennyRouter in-session command alias for Claude Code",
+  "version": "1.0.0",
+  "author": {
+    "name": "PennyRouter"
+  }
+}

package/claude-plugin/skills/penny/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: penny
+description: Forward a PennyRouter command to the gateway. Use when the user invokes /penny.
+argument-hint: <command and arguments>
+disable-model-invocation: true
+---
+
+@penny $ARGUMENTS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pennyrouter",
-  "version": "0.1.20",
+  "version": "0.2.0",
   "description": "Install and manage PennyRouter local coding-agent integrations.",
   "homepage": "https://pennyrouter.com",
   "bugs": {
@@ -20,11 +20,12 @@
   "files": [
     "bin",
     "src",
+    "claude-plugin",
     "README.md"
   ],
   "scripts": {
     "start": "node ./bin/pennyrouter.js",
-    "check": "node --check ./bin/pennyrouter.js && find src -name '*.js' -print0 | xargs -0 -n1 node --check && node src/statusline.test.js && node src/harnesses/claude-code.test.js && node src/harnesses/codex.test.js"
+    "check": "node --check ./bin/pennyrouter.js && node --check ./bin/penny.js && find src -name '*.js' -print0 | xargs -0 -n1 node --check && node src/session.test.js && node src/statusline.test.js && node src/harnesses/claude-code.test.js && node src/harnesses/codex.test.js && node src/launch.test.js"
   },
   "license": "MIT"
 }

package/src/cli.js

@@ -4,13 +4,14 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { aiderHarness } from "./harnesses/aider.js";
 import {
+  CLAUDE_CODE_MODELS,
   claudeCodeHarness,
   readClaudeCodeGatewayAuth,
   readClaudeCodePennyRouterKey,
 } from "./harnesses/claude-code.js";
 import { clineHarness } from "./harnesses/cline.js";
 import { codeGptHarness } from "./harnesses/codegpt.js";
-import { codexHarness } from "./harnesses/codex.js";
+import { codexHarness, detectCodexChatgptAuth } from "./harnesses/codex.js";
 import { opencodeHarness } from "./harnesses/opencode.js";
 import { windsurfHarness } from "./harnesses/windsurf.js";
 import { zedHarness } from "./harnesses/zed.js";
@@ -20,6 +21,7 @@ import {
   forgetAnthropicToken,
   maskKey,
   pollForKey,
+  probeClaudeCodeGateway,
   sleep,
   storeAnthropicToken,
 } from "./session.js";
@@ -31,6 +33,19 @@ import {
   saveManifest,
   statePath,
 } from "./state.js";
+import {
+  claudeLaunchSettingsPath,
+  codexLaunchProfilePath,
+  configurePennyHarness,
+  hasConfiguredPennyHarnesses,
+  installPennyRuntime,
+  loadPennyConfig,
+  pennyConfigPath,
+  removePennyHarness,
+  removePennyRuntime,
+  savePennyConfig,
+  setPennyHarnessEnabled,
+} from "./launch.js";
 
 const HARNESS_BY_ID = {
   "claude-code": claudeCodeHarness,
@@ -98,6 +113,11 @@ function parseArgs(argv) {
     else if (arg === "--yes" || arg === "-y") flags.yes = true;
     else if (arg === "--all") flags.all = true;
     else if (arg === "--dry-run") flags.dryRun = true;
+    else if (arg === "--allow-running-claude") flags.allowRunningClaude = true;
+    else if (arg === "--allow-running-harnesses") flags.allowRunningHarnesses = true;
+    else if (arg === "--make-default") flags.makeDefault = true;
+    else if (arg === "--penny-only") flags.pennyOnly = true;
+    else if (arg === "--no-path-update") flags.noPathUpdate = true;
     else if (arg === "--no-browser") flags.noBrowser = true;
     else if (arg === "--existing-account") flags.existingAccount = true;
     else if (arg === "--anthropic-auth") flags.anthropicAuth = true;
@@ -136,7 +156,8 @@ async function authProvider(flags) {
   }
 
   if (flags.forget) {
-    const pennyKey = flags.pennyKey || await readClaudeCodePennyRouterKey();
+    const launchConfig = await loadPennyConfig();
+    const pennyKey = flags.pennyKey || launchConfig.api_key || await readClaudeCodePennyRouterKey();
     if (!pennyKey) {
       throw new Error(
         "No PennyRouter key found in Claude Code settings. Pass `--penny-key pr-...`.",
@@ -165,6 +186,10 @@ async function authProvider(flags) {
     if (updated) {
       await saveManifest(manifest);
     }
+    if (launchConfig.harnesses?.claude) {
+      launchConfig.harnesses.claude.subscription_auth = false;
+      await savePennyConfig(launchConfig);
+    }
     return;
   }
 
@@ -174,7 +199,8 @@ async function authProvider(flags) {
     return;
   }
 
-  const pennyKey = flags.pennyKey || await readClaudeCodePennyRouterKey();
+  const launchConfig = await loadPennyConfig();
+  const pennyKey = flags.pennyKey || launchConfig.api_key || await readClaudeCodePennyRouterKey();
   if (!pennyKey) {
     throw new Error(
       "No PennyRouter key found in Claude Code settings. Run `pennyrouter install --harness claude-code` first, or pass `--penny-key pr-...`.",
@@ -190,29 +216,58 @@ async function authProvider(flags) {
   }
 
   const gatewayBaseUrl = flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL || "https://api.pennyrouter.com";
-  // Store the token encrypted server-side, then write a pr-key-only config.
-  await storeAnthropicToken({ gatewayBaseUrl, apiKey: pennyKey, token });
   const manifest = await loadManifest();
   const existingRecord = (manifest.installations || []).find(
     (candidate) => candidate.harness === "claude-code",
   );
-  const plan = await claudeCodeHarness.planInstall();
-  const record = await claudeCodeHarness.installStoredToken({
-    apiKey: pennyKey, gatewayBaseUrl, plan, existingRecord,
+  const ownsGlobalRouting = existingRecord
+    ? existingRecord.default_routing !== false
+    : Boolean(await readClaudeCodePennyRouterKey());
+  if (ownsGlobalRouting) assertNoRunningHarness("claude-code", flags);
+  await storeAnthropicToken({ gatewayBaseUrl, apiKey: pennyKey, token });
+  await probeClaudeCodeGateway({ gatewayBaseUrl, apiKey: pennyKey });
+  if (process.platform !== "win32") {
+    await installPennyRuntime({ updatePath: !flags.noPathUpdate });
+  }
+  await configurePennyHarness("claude-code", {
+    apiKey: pennyKey,
+    gatewayBaseUrl,
+    subscriptionAuth: true,
+    models: CLAUDE_CODE_MODELS,
   });
+  let record = existingRecord || {
+    harness: "claude-code",
+    config_path: compactHome((await claudeCodeHarness.planInstall()).configPath),
+    installed_at: new Date().toISOString(),
+    launch_available: true,
+    launch_config_path: compactHome(claudeLaunchSettingsPath()),
+    default_routing: ownsGlobalRouting,
+  };
+  if (ownsGlobalRouting) {
+    const plan = await claudeCodeHarness.planInstall();
+    record = {
+      ...record,
+      ...(await claudeCodeHarness.installStoredToken({
+        apiKey: pennyKey, gatewayBaseUrl, plan, existingRecord,
+      })),
+    };
+  }
 
   upsertManifestRecord(manifest, {
     ...record,
+    launch_available: true,
+    launch_config_path: compactHome(claudeLaunchSettingsPath()),
+    default_routing: ownsGlobalRouting,
     anthropic_oauth: true,
     anthropic_token_stored: true,
     token_source: tokenResult.source,
   });
   await saveManifest(manifest);
 
-  console.log("Configured Claude Code for PennyRouter + your Claude subscription.");
+  console.log("Configured `penny claude` for PennyRouter + your Claude subscription.");
   console.log("Your Claude token is stored encrypted; Claude Code holds only your PennyRouter key.");
   console.log("If Claude auth expires, refresh the token source and run `pennyrouter auth anthropic` again.");
-  console.log(`Config: ${record.config_path}`);
+  console.log(`Penny config: ${pennyConfigPath()}`);
 }
 
 function readAnthropicOAuthToken(flags = {}) {
@@ -307,6 +362,9 @@ function normalizeAnthropicToken(value) {
 }
 
 async function install(flags) {
+  if (flags.makeDefault && flags.pennyOnly) {
+    throw new Error("--make-default and --penny-only cannot be used together.");
+  }
   const selected = await selectHarnesses(flags);
   if (selected.length === 0) {
     console.log("No supported harnesses selected.");
@@ -316,9 +374,17 @@ async function install(flags) {
   console.log("PennyRouter install");
   console.log("");
 
+  const manifest = await loadManifest();
+  const defaultRouting = await chooseDefaultRouting(flags, selected, manifest);
+
   if (flags.dryRun) {
     for (const harness of selected) {
-      console.log(`Will install on ${harness.name}${installNoteForHarness(harness.id)}.`);
+      const explicit = ["claude-code", "codex"].includes(harness.id) && process.platform !== "win32";
+      const command = harness.id === "claude-code" ? "penny claude" : "penny codex";
+      console.log(`Will install on ${harness.name}${explicit ? ` via ${command}` : installNoteForHarness(harness.id)}.`);
+      if (defaultRouting.get(harness.id)) {
+        console.log(`Will also route bare ${harness.id === "claude-code" ? "claude" : harness.id} through PennyRouter.`);
+      }
     }
     if (flags.gatewayBaseUrl) console.log(`Serving gateway: ${flags.gatewayBaseUrl}`);
     if (selected.some((harness) => harness.id === "claude-code")) {
@@ -331,14 +397,10 @@ async function install(flags) {
   const session = await createCliSession({
     appUrl: flags.appUrl || APP_URL,
     harnesses: selected.map((harness) => harness.id),
-    accountMode: flags.existingAccount ? "existing" : "seed",
+    accountMode: "existing",
   });
 
-  console.log(
-    flags.existingAccount
-      ? "Opening your browser to authorize this machine with your existing PennyRouter account..."
-      : "Opening your browser to authorize this machine...",
-  );
+  console.log("Opening your browser to log in and authorize this machine with your PennyRouter account...");
   console.log(`If your browser did not open, visit:\n${session.authorize_url}`);
   if (!flags.noBrowser) openBrowser(session.authorize_url);
   console.log("");
@@ -350,7 +412,12 @@ async function install(flags) {
 
   const claudeAnthropicAuth = await maybeConfigureClaudeAnthropicAuth(flags, selected);
 
-  const manifest = await loadManifest();
+  const launchable = selected.filter((harness) => ["claude-code", "codex"].includes(harness.id));
+  let runtimeResult = null;
+  if (launchable.length > 0 && process.platform !== "win32") {
+    runtimeResult = await installPennyRuntime({ updatePath: !flags.noPathUpdate });
+  }
+
   const records = [];
   const failures = [];
   for (const harness of selected) {
@@ -360,32 +427,76 @@ async function install(flags) {
       const existingRecord = (manifest.installations || []).find(
         (candidate) => candidate.harness === harness.id,
       );
-      let record;
+      const supportsPennyCommand = ["claude-code", "codex"].includes(harness.id)
+        && process.platform !== "win32";
+      const makeDefault = defaultRouting.get(harness.id) ?? true;
+      const hadGlobalRouting = Boolean(existingRecord && existingRecord.default_routing !== false);
+      if (["claude-code", "codex"].includes(harness.id) && (makeDefault || hadGlobalRouting)) {
+        assertNoRunningHarness(harness.id, flags);
+      }
+
+      const codexSubscriptionAuth = harness.id === "codex"
+        ? await detectCodexChatgptAuth()
+        : false;
+      const claudeSubscriptionAuth = harness.id === "claude-code"
+        && Boolean(claudeAnthropicAuth || existingRecord?.anthropic_token_stored);
+
       if (harness.id === "claude-code" && claudeAnthropicAuth) {
-        // Store the Claude setup-token encrypted server-side, then write a config
-        // that carries ONLY the pr- key. Nothing Anthropic-flavored on disk, and no
-        // dual-credential warnings from Claude Code.
         await storeAnthropicToken({
           gatewayBaseUrl,
           apiKey: claim.api_key,
           token: claudeAnthropicAuth.token,
         });
-        record = await harness.installStoredToken({
-          apiKey: claim.api_key, gatewayBaseUrl, plan, existingRecord,
-        });
-        record.anthropic_oauth = true;
-        record.anthropic_token_stored = true;
-        record.token_source = claudeAnthropicAuth.source;
-      } else {
-        record = await harness.install({
+      }
+      if (harness.id === "claude-code") {
+        console.log("Verifying modern Claude Code compatibility before changing local settings...");
+        await probeClaudeCodeGateway({ gatewayBaseUrl, apiKey: claim.api_key });
+      }
+
+      if (supportsPennyCommand) {
+        await configurePennyHarness(harness.id, {
           apiKey: claim.api_key,
-          // An explicit --local / --gateway-base-url overrides the URL the server hands back
-          // (which points at prod) — so a --local install serves through the local gateway.
           gatewayBaseUrl,
-          plan,
-          existingRecord,
+          subscriptionAuth: harness.id === "claude-code"
+            ? claudeSubscriptionAuth
+            : codexSubscriptionAuth,
+          models: harness.id === "claude-code" ? CLAUDE_CODE_MODELS : null,
         });
       }
+
+      let record;
+      if (!supportsPennyCommand || makeDefault) {
+        record = harness.id === "claude-code" && claudeSubscriptionAuth
+          ? await harness.installStoredToken({
+              apiKey: claim.api_key, gatewayBaseUrl, plan, existingRecord,
+            })
+          : await harness.install({
+              apiKey: claim.api_key, gatewayBaseUrl, plan, existingRecord,
+            });
+      } else {
+        if (hadGlobalRouting) {
+          await harness.uninstall(existingRecord);
+        }
+        record = {
+          harness: harness.id,
+          config_path: compactHome(plan.configPath),
+          backup_path: existingRecord?.backup_path || null,
+          installed_at: new Date().toISOString(),
+        };
+      }
+      if (supportsPennyCommand) {
+        record.launch_available = true;
+        record.launch_config_path = compactHome(
+          harness.id === "claude-code" ? claudeLaunchSettingsPath() : codexLaunchProfilePath(),
+        );
+        record.default_routing = Boolean(makeDefault);
+      }
+      if (harness.id === "claude-code" && claudeSubscriptionAuth) {
+        record.anthropic_oauth = true;
+        record.anthropic_token_stored = true;
+        record.token_source = claudeAnthropicAuth?.source || existingRecord?.token_source || "stored";
+      }
+      if (harness.id === "codex") record.openai_subscription_auth = codexSubscriptionAuth;
       records.push(record);
       upsertManifestRecord(manifest, record);
       await saveManifest(manifest);
@@ -397,12 +508,65 @@ async function install(flags) {
   console.log("Installed PennyRouter.");
   for (const record of records) {
     const harness = HARNESS_BY_ID[record.harness];
-    console.log(`Installed on ${harness?.name || record.harness}${installNoteForRecord(record)}.`);
+    if (record.launch_available) {
+      const command = record.harness === "claude-code" ? "penny claude" : "penny codex";
+      const native = record.harness === "claude-code" ? "claude" : "codex";
+      console.log(`Installed on ${harness?.name || record.harness}: use \`${command}\`.`);
+      console.log(`  Bare \`${native}\`: ${record.default_routing ? "PennyRouter" : "native"}`);
+    } else {
+      console.log(`Installed on ${harness?.name || record.harness}${installNoteForRecord(record)}.`);
+    }
+  }
+  if (runtimeResult && !runtimeResult.available) {
+    console.log("Add ~/.local/bin to PATH before using the `penny` command.");
+  } else if (runtimeResult?.changed) {
+    console.log("Open a new terminal (or reload your shell) before using the `penny` command.");
   }
   console.log(`Manifest: ${statePath("installations.json")}`);
   reportFailures(failures);
 }
 
+async function chooseDefaultRouting(flags, selected, manifest) {
+  const out = new Map();
+  const launchable = selected.filter((harness) => ["claude-code", "codex"].includes(harness.id));
+  if (process.platform === "win32") {
+    for (const harness of launchable) out.set(harness.id, true);
+    return out;
+  }
+  let newInstallChoice = null;
+  for (const harness of launchable) {
+    if (flags.makeDefault) {
+      out.set(harness.id, true);
+      continue;
+    }
+    if (flags.pennyOnly) {
+      out.set(harness.id, false);
+      continue;
+    }
+    const existing = (manifest.installations || []).find((item) => item.harness === harness.id);
+    if (existing) {
+      const currentlyDefault = existing.default_routing !== false;
+      if (flags.dryRun || !currentlyDefault || flags.yes || !input.isTTY || !output.isTTY) {
+        out.set(harness.id, currentlyDefault);
+        continue;
+      }
+      const native = harness.id === "claude-code" ? "claude" : "codex";
+      const change = await confirm(
+        `PennyRouter currently runs when you type \`${native}\`. Change it to run only with \`penny ${native}\`?`,
+      );
+      out.set(harness.id, !change);
+      continue;
+    }
+    if (newInstallChoice === null) {
+      newInstallChoice = flags.dryRun || flags.yes || !input.isTTY || !output.isTTY
+        ? false
+        : await confirm("Use PennyRouter by default when you type `claude` or `codex`?");
+    }
+    out.set(harness.id, newInstallChoice);
+  }
+  return out;
+}
+
 async function maybeConfigureClaudeAnthropicAuth(flags, selected) {
   if (!selected.some((harness) => harness.id === "claude-code")) return null;
   if (flags.noAnthropicAuth) return null;
@@ -501,13 +665,17 @@ async function disable(flags) {
     }
 
     await runHarnessJob(failures, record.harness, "disable", async () => {
-      if (record.config_path) {
+      const ownsGlobalRouting = !record.launch_available || record.default_routing;
+      if (record.config_path && ownsGlobalRouting) {
         const snapshotPath = await backupFile(record.config_path, `${record.harness}-disabled`);
         record.disabled_snapshot_path = snapshotPath;
       }
 
-      if (typeof harness.disable === "function") await harness.disable(record);
-      else await harness.uninstall(record);
+      if (record.launch_available) await setPennyHarnessEnabled(record.harness, false);
+      if (ownsGlobalRouting) {
+        if (typeof harness.disable === "function") await harness.disable(record);
+        else await harness.uninstall(record);
+      }
 
       record.disabled = true;
       record.disabled_at = new Date().toISOString();
@@ -559,13 +727,17 @@ async function enable(flags) {
     }
 
     await runHarnessJob(failures, record.harness, "enable", async () => {
-      if (typeof harness.enable === "function") await harness.enable(record);
-      else if (record.config_path && record.disabled_snapshot_path) {
-        await restoreFile(record.disabled_snapshot_path, record.config_path);
-      } else if (record.manual_required) {
-        console.log(`${record.harness}: re-enable manually in the tool UI using the status details.`);
-      } else {
-        throw new Error("no disabled snapshot found; run install again");
+      const ownsGlobalRouting = !record.launch_available || record.default_routing;
+      if (record.launch_available) await setPennyHarnessEnabled(record.harness, true);
+      if (ownsGlobalRouting) {
+        if (typeof harness.enable === "function") await harness.enable(record);
+        else if (record.config_path && record.disabled_snapshot_path) {
+          await restoreFile(record.disabled_snapshot_path, record.config_path);
+        } else if (record.manual_required) {
+          console.log(`${record.harness}: re-enable manually in the tool UI using the status details.`);
+        } else {
+          throw new Error("no disabled snapshot found; run install again");
+        }
       }
 
       delete record.disabled;
@@ -625,7 +797,8 @@ async function uninstall(flags) {
       } else if (record.anthropic_token_stored) {
         anthropicTokenNotice = true;
       }
-      await harness.uninstall(record);
+      if (record.launch_available) await removePennyHarness(record.harness);
+      if (!record.launch_available || record.default_routing) await harness.uninstall(record);
       console.log(`Removed ${record.harness}.`);
     });
     if (!ok) kept.push(record);
@@ -644,7 +817,8 @@ async function uninstall(flags) {
       } else if (record.anthropic_token_stored) {
         anthropicTokenNotice = true;
       }
-      await harness.uninstall(record);
+      if (record.launch_available) await removePennyHarness(record.harness);
+      if (!record.launch_available || record.default_routing) await harness.uninstall(record);
       console.log(`Removed ${record.harness}.`);
     });
   }
@@ -657,6 +831,7 @@ async function uninstall(flags) {
 
   manifest.installations = kept;
   await saveManifest(manifest);
+  if (!(await hasConfiguredPennyHarnesses())) await removePennyRuntime();
   reportFailures(failures);
 }
 
@@ -729,6 +904,11 @@ async function status() {
     if (record.disabled_at) console.log(`  disabled: ${record.disabled_at}`);
     if (record.anthropic_oauth) console.log(`  Claude subscription auth: enabled (${record.token_source || "unknown"} token)`);
     if (record.openai_subscription_auth) console.log("  OpenAI subscription auth: enabled (Codex-managed login)");
+    if (record.launch_available) {
+      const command = record.harness === "claude-code" ? "penny claude" : "penny codex";
+      console.log(`  command: ${command}`);
+      console.log(`  bare command: ${record.default_routing ? "PennyRouter" : "native"}`);
+    }
     if (record.manual_required) console.log("  note: finish or remove this integration in the tool UI");
   }
 }
@@ -969,7 +1149,10 @@ function formatError(error) {
 async function forgetStoredAnthropicToken(record) {
   if (record.harness !== "claude-code" || !record.anthropic_token_stored) return;
   try {
-    const { gatewayBaseUrl, apiKey } = await readClaudeCodeGatewayAuth();
+    const launchConfig = await loadPennyConfig();
+    const globalAuth = await readClaudeCodeGatewayAuth();
+    const gatewayBaseUrl = launchConfig.gateway_base_url || globalAuth.gatewayBaseUrl;
+    const apiKey = launchConfig.api_key || globalAuth.apiKey;
     if (!gatewayBaseUrl || !apiKey) return;
     await forgetAnthropicToken({ gatewayBaseUrl, apiKey });
   } catch {
@@ -1058,11 +1241,52 @@ function openBrowser(url) {
   spawnSync(command, args, { stdio: "ignore", detached: true });
 }
 
+function runningClaudeCodeProcesses() {
+  if (process.platform === "win32") {
+    const result = spawnSync("tasklist", ["/FO", "CSV", "/NH"], { encoding: "utf8" });
+    if (result.status !== 0) return [];
+    return String(result.stdout || "").split(/\r?\n/)
+      .filter((line) => /^"claude(?:\.exe)?"/i.test(line.trim()));
+  }
+  const result = spawnSync("ps", ["-ax", "-o", "pid=,command="], { encoding: "utf8" });
+  if (result.status !== 0) return [];
+  return String(result.stdout || "").split(/\r?\n/)
+    .map((line) => line.trim())
+    // Case-sensitive on purpose: match the Claude Code executable, not Claude.app.
+    .filter((line) => /(^|[\/\s])claude(?:\s|$)/.test(line));
+}
+
+function runningCodexProcesses() {
+  if (process.platform === "win32") return [];
+  const result = spawnSync("ps", ["-ax", "-o", "pid=,command="], { encoding: "utf8" });
+  if (result.status !== 0) return [];
+  return String(result.stdout || "").split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => /(^|[\/\s])codex(?:\s|$)/.test(line));
+}
+
+function assertNoRunningHarness(harnessId, flags) {
+  if (flags.allowRunningHarnesses || (harnessId === "claude-code" && flags.allowRunningClaude)) {
+    return;
+  }
+  const running = harnessId === "claude-code"
+    ? runningClaudeCodeProcesses()
+    : runningCodexProcesses();
+  if (running.length === 0) return;
+  const name = harnessId === "claude-code" ? "Claude Code" : "Codex";
+  throw new Error(
+    `${name} is currently running. Close all ${name} sessions before changing its global routing. `
+    + "Installing only the explicit `penny` command does not require this. If you intentionally "
+    + "accept the risk, pass --allow-running-harnesses.\nDetected:\n  "
+    + running.slice(0, 5).join("\n  "),
+  );
+}
+
 function printHelp() {
   console.log(`PennyRouter CLI
 
 Usage:
-  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--existing-account] [--anthropic-auth|--no-anthropic-auth] [--local[=URL]]
+  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--anthropic-auth|--no-anthropic-auth] [--local[=URL]] [--allow-running-harnesses]
   pennyrouter auth anthropic [--penny-key pr-...] [--token oauth-token] [--token-command CMD] [--gateway-base-url URL] [--forget]
   pennyrouter disable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
   pennyrouter enable [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes]
@@ -1071,7 +1295,8 @@ Usage:
 
 Examples:
   npx pennyrouter install
-  npx pennyrouter install --existing-account
+  npx pennyrouter install --make-default
+  npx pennyrouter install --penny-only
   npx pennyrouter install --harness claude-code --anthropic-auth --token <token>
   npx pennyrouter auth anthropic
   npx pennyrouter install --all

package/src/harnesses/claude-code.js

@@ -13,7 +13,7 @@ const CONNECTOR_SETTING = "disableClaudeAiConnectors";
 // pinned to Fable; the DYNAMIC "Penny Custom" option lets PennyRouter cost-route. Legacy
 // "Penny Speed/Core/Power"
 // installs (dynamic bundles) are still recognized for uninstall (see isPennyRouterModelValue).
-const CLAUDE_CODE_MODELS = {
+export const CLAUDE_CODE_MODELS = {
   haiku: "Penny Haiku",     // -> pinned anthropic/claude-haiku-4-5-20251001
   sonnet: "Penny Sonnet",   // -> pinned anthropic/claude-sonnet-4-6
   opus: "Penny Opus",       // -> pinned anthropic/claude-opus-4-8