pennyrouter 0.2.25 → 0.2.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pennyrouter",
-  "version": "0.2.25",
+  "version": "0.2.26",
   "description": "Install and manage PennyRouter local coding-agent integrations.",
   "homepage": "https://pennyrouter.com",
   "bugs": {

package/src/cli.js

@@ -26,6 +26,7 @@ import {
   APP_URL,
   createCliSession,
   forgetAnthropicToken,
+  forgetUpstreamCredential,
   maskKey,
   pollForKey,
   probeClaudeCodeGateway,
@@ -72,6 +73,7 @@ const CLAUDE_PROVIDER_OPTIONS = [
   { id: "subscription", name: "Claude subscription" },
   { id: "anthropic-api", name: "Anthropic API key" },
   { id: "openrouter", name: "OpenRouter API key" },
+  { id: "anthropic-proxy", name: "Other proxy (custom base URL)" },
 ];
 const CODEX_PROVIDER_OPTIONS = [
   { id: "subscription", name: "ChatGPT subscription" },
@@ -169,6 +171,10 @@ function parseArgs(argv) {
     else if (arg === "--openai-api-key") flags.openaiApiKey = rest[++i] || "";
     else if (arg.startsWith("--openai-api-key=")) flags.openaiApiKey = arg.slice("--openai-api-key=".length);
     else if (arg === "--openrouter-api-key") flags.openrouterApiKey = rest[++i] || "";
+    else if (arg === "--proxy-base-url") flags.proxyBaseUrl = rest[++i] || "";
+    else if (arg.startsWith("--proxy-base-url=")) flags.proxyBaseUrl = arg.slice("--proxy-base-url=".length);
+    else if (arg === "--proxy-api-key") flags.proxyApiKey = rest[++i] || "";
+    else if (arg.startsWith("--proxy-api-key=")) flags.proxyApiKey = arg.slice("--proxy-api-key=".length);
     else if (arg.startsWith("--openrouter-api-key=")) flags.openrouterApiKey = arg.slice("--openrouter-api-key=".length);
     else if (arg === "--harness") flags.harness = rest[++i] || "";
     else if (arg.startsWith("--harness=")) flags.harness = arg.slice("--harness=".length);
@@ -230,6 +236,10 @@ function applyConfigFile(flags) {
   if (codexFunding.has("openai-api") && flags.openaiApiKey === undefined) {
     flags.openaiApiKey = config.openaiApiKey || "";
   }
+  if (claudeFunding.has("anthropic-proxy")) {
+    if (flags.proxyBaseUrl === undefined) flags.proxyBaseUrl = config.proxyBaseUrl || "";
+    if (flags.proxyApiKey === undefined) flags.proxyApiKey = config.proxyApiKey || "";
+  }
 
   flags.yes = true;
   flags.fromConfig = true;
@@ -284,11 +294,21 @@ async function authProvider(flags) {
         "No PennyRouter key found in Claude Code settings. Pass `--penny-key pr-...`.",
       );
     }
-    const gatewayBaseUrl = flags.gatewayBaseUrl || process.env.PENNYROUTER_GATEWAY_BASE_URL || DEFAULT_GATEWAY_BASE_URL;
+    // Resolve against the INSTALLED config before falling back to the prod default.
+    // This is a destructive call against whichever gateway it reaches, so defaulting to
+    // production while the user is working against a local gateway would silently delete
+    // the wrong account's token (and leave the local one in place, looking like a no-op).
+    const globalAuth = await readClaudeCodeGatewayAuth();
+    const gatewayBaseUrl = flags.gatewayBaseUrl
+      || process.env.PENNYROUTER_GATEWAY_BASE_URL
+      || launchConfig.gateway_base_url
+      || globalAuth.gatewayBaseUrl
+      || DEFAULT_GATEWAY_BASE_URL;
     if (flags.dryRun) {
       console.log(`Will delete stored Anthropic token from gateway: ${gatewayBaseUrl}`);
       return;
     }
+    console.log(`Gateway: ${gatewayBaseUrl}`);
     const ok = await forgetAnthropicToken({ gatewayBaseUrl, apiKey: pennyKey });
     if (ok) {
       console.log("Successfully forgot stored Anthropic token on server.");
@@ -579,6 +599,7 @@ export async function install(flags = {}) {
         apiKey: claim.api_key,
         provider: credential.provider,
         token: credential.token,
+        metadata: credential.metadata,
       });
     }
   }
@@ -669,6 +690,11 @@ export async function install(flags = {}) {
         record.user_funded_provider = harnessNeededAuth
           ? (funding.claudeCredentialProvider || existingRecord?.user_funded_provider)
           : existingRecord?.user_funded_provider;
+        // Host only, never the key — the key lives encrypted on the gateway.
+        const proxyBaseUrl = harnessNeededAuth
+          ? (funding.claudeProxyBaseUrl ?? existingRecord?.proxy_base_url ?? null)
+          : (existingRecord?.proxy_base_url ?? null);
+        if (proxyBaseUrl) record.proxy_base_url = proxyBaseUrl;
       }
       if (harness.id === "codex") {
         record.user_funded_provider = harnessNeededAuth
@@ -1055,14 +1081,19 @@ async function selectClaudeFundingProviders(flags, selected) {
       || process.env.ANTHROPIC_AUTH_TOKEN)) supplied.add("subscription");
   if (flags.anthropicApiKey || process.env.ANTHROPIC_API_KEY) supplied.add("anthropic-api");
   if (flags.openrouterApiKey || process.env.OPENROUTER_API_KEY) supplied.add("openrouter");
+  if ((flags.proxyBaseUrl || process.env.PENNYROUTER_PROXY_BASE_URL)
+      && (flags.proxyApiKey || process.env.PENNYROUTER_PROXY_API_KEY)) {
+    supplied.add("anthropic-proxy");
+  }
 
   // Explicit flags are the automation selector. Interactive installs always default to the
   // subscription alone; environment keys are used if the user checks their provider.
   const explicit = flags.anthropicAuth || flags.noAnthropicAuth || flags.token
-    || flags.tokenCommand || flags.anthropicApiKey || flags.openrouterApiKey;
+    || flags.tokenCommand || flags.anthropicApiKey || flags.openrouterApiKey
+    || flags.proxyBaseUrl || flags.proxyApiKey;
   if (explicit || flags.yes || !input.isTTY || !output.isTTY) return supplied;
 
-  console.log("PennyRouter can use your Claude subscription, an Anthropic API key, or an OpenRouter API key to run Claude Code.");
+  console.log("PennyRouter can use your Claude subscription, an Anthropic API key, an OpenRouter API key, or your own Anthropic-compatible proxy to run Claude Code.");
   console.log("Choose one or more providers. PennyRouter will try them in order when available.");
   return promptFundingProviderCheckboxes(
     CLAUDE_PROVIDER_OPTIONS,
@@ -1165,6 +1196,12 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
   let openrouterApiKey = String(
     flags.openrouterApiKey || process.env.OPENROUTER_API_KEY || "",
   ).trim();
+  let proxyBaseUrl = String(
+    flags.proxyBaseUrl || process.env.PENNYROUTER_PROXY_BASE_URL || "",
+  ).trim();
+  let proxyApiKey = String(
+    flags.proxyApiKey || process.env.PENNYROUTER_PROXY_API_KEY || "",
+  ).trim();
   const codexSubscriptionAuth = wantsCodex && codexProviders.has("subscription")
     ? await detectCodexChatgptAuth()
     : false;
@@ -1177,6 +1214,19 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
     if (!interactive) throw new Error("OpenRouter was selected, but no key was provided.");
     openrouterApiKey = (await promptSecretish("OpenRouter API key: ")).trim();
   }
+  if (wantsClaude && claudeProviders.has("anthropic-proxy") && !(proxyBaseUrl && proxyApiKey)) {
+    if (!interactive) {
+      throw new Error(
+        "Other proxy was selected, but --proxy-base-url and --proxy-api-key were not both provided.",
+      );
+    }
+    // The URL is not a secret and is easy to mistype, so it echoes; the key does not.
+    if (!proxyBaseUrl) proxyBaseUrl = await promptText("Proxy base URL (e.g. https://proxy.example.com): ");
+    if (!proxyApiKey) proxyApiKey = (await promptSecretish("Proxy API key: ")).trim();
+    if (!proxyBaseUrl || !proxyApiKey) {
+      throw new Error("Other proxy requires both a base URL and an API key.");
+    }
+  }
   if (wantsCodex && codexProviders.has("subscription") && !codexSubscriptionAuth) {
     throw new Error(
       "ChatGPT subscription was selected, but Codex is not logged in. Run `codex login`, or select an API-key provider.",
@@ -1191,7 +1241,9 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
     openrouterApiKey = (await promptSecretish("OpenRouter API key: ")).trim();
   }
 
-  if (wantsClaude && !claudeAnthropicAuth && !anthropicApiKey && !openrouterApiKey) {
+  const claudeProxyConfigured = Boolean(proxyBaseUrl && proxyApiKey);
+  if (wantsClaude && !claudeAnthropicAuth && !anthropicApiKey && !openrouterApiKey
+      && !claudeProxyConfigured) {
     if (!interactive) {
       throw new Error(
         "Claude Code requires a Claude subscription, --anthropic-api-key (or ANTHROPIC_API_KEY), "
@@ -1244,13 +1296,23 @@ async function configureUserFunding(flags, selected, claudeAnthropicAuth,
   if ((wantsClaude || wantsCodex) && openrouterApiKey) {
     credentials.push({ provider: "openrouter", token: openrouterApiKey });
   }
+  if (wantsClaude && claudeProxyConfigured) {
+    credentials.push({
+      provider: "anthropic_proxy",
+      token: proxyApiKey,
+      metadata: { base_url: proxyBaseUrl },
+    });
+  }
 
   return {
     credentials,
     codexSubscriptionAuth,
     claudeCredentialProvider: claudeAnthropicAuth
       ? "claude-subscription"
-      : anthropicApiKey ? "anthropic-api" : openrouterApiKey ? "openrouter" : null,
+      : anthropicApiKey ? "anthropic-api"
+      : claudeProxyConfigured ? "anthropic-proxy"
+      : openrouterApiKey ? "openrouter" : null,
+    claudeProxyBaseUrl: claudeProxyConfigured ? proxyBaseUrl : null,
     codexCredentialProvider: codexSubscriptionAuth
       ? "chatgpt-subscription"
       : openaiApiKey ? "openai-api" : openrouterApiKey ? "openrouter" : null,
@@ -1423,7 +1485,7 @@ async function uninstall(flags) {
     const ok = await runHarnessJob(failures, record.harness, "uninstall", async () => {
       if (flags.forgetToken) {
         await forgetStoredAnthropicToken(record);
-      } else if (record.anthropic_token_stored) {
+      } else if (record.anthropic_token_stored || record.proxy_base_url) {
         anthropicTokenNotice = true;
       }
       if (record.launch_available) await removePennyHarness(record.harness);
@@ -1443,7 +1505,7 @@ async function uninstall(flags) {
     await runHarnessJob(failures, record.harness, "uninstall", async () => {
       if (flags.forgetToken) {
         await forgetStoredAnthropicToken(record);
-      } else if (record.anthropic_token_stored) {
+      } else if (record.anthropic_token_stored || record.proxy_base_url) {
         anthropicTokenNotice = true;
       }
       if (record.launch_available) await removePennyHarness(record.harness);
@@ -1537,6 +1599,10 @@ 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.proxy_base_url) {
+      const note = record.anthropic_oauth ? " (subscription takes precedence)" : "";
+      console.log(`  Upstream proxy: ${record.proxy_base_url}${note}`);
+    }
     if (record.launch_available) {
       const command = record.harness === "claude-code" ? "penny claude" : "penny codex";
       console.log(`  command: ${command}`);
@@ -1847,14 +1913,24 @@ function formatError(error) {
 // live config BEFORE harness.uninstall strips them. Never throws — a local uninstall
 // must not be blocked by a network hiccup; the record is going away regardless.
 async function forgetStoredAnthropicToken(record) {
-  if (record.harness !== "claude-code" || !record.anthropic_token_stored) return;
+  if (record.harness !== "claude-code") return;
+  if (!record.anthropic_token_stored && !record.proxy_base_url) return;
   try {
     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 });
+    if (record.anthropic_token_stored) {
+      await forgetAnthropicToken({ gatewayBaseUrl, apiKey });
+    }
+    // The proxy key is stored server-side exactly like the subscription token, so the
+    // same "forget my credentials" gesture has to clear it too.
+    if (record.proxy_base_url) {
+      await forgetUpstreamCredential({
+        gatewayBaseUrl, apiKey, provider: "anthropic_proxy",
+      });
+    }
   } catch {
     // swallow — see note above
   }
@@ -1867,6 +1943,15 @@ async function confirm(question) {
   return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
 }
 
+// Visible-echo input, for values that are not secrets. A mistyped proxy URL is a
+// confusing failure much later, so the user gets to see what they typed.
+async function promptText(question) {
+  const rl = createInterface({ input, output });
+  const answer = await rl.question(question);
+  rl.close();
+  return answer.trim();
+}
+
 async function promptSecretish(question) {
   if (!input.isTTY || !output.isTTY) {
     const rl = createInterface({ input, output });
@@ -1986,7 +2071,7 @@ function printHelp() {
   console.log(`PennyRouter CLI
 
 Usage:
-  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--no-mcp] [--anthropic-auth|--no-anthropic-auth] [--anthropic-api-key KEY] [--openai-api-key KEY] [--openrouter-api-key KEY] [--local[=URL]|--prod] [--config PATH] [--allow-running-harnesses]
+  pennyrouter install [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--yes] [--dry-run] [--make-default|--penny-only] [--no-path-update] [--no-mcp] [--anthropic-auth|--no-anthropic-auth] [--anthropic-api-key KEY] [--openai-api-key KEY] [--openrouter-api-key KEY] [--proxy-base-url URL --proxy-api-key KEY] [--local[=URL]|--prod] [--config PATH] [--allow-running-harnesses]
   pennyrouter update [--harness ${SUPPORTED_HARNESS_IDS}] [--all] [--dry-run] [--penny-key pr-...] [--gateway-base-url URL|--local[=URL]|--prod] [--no-mcp] [--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]
@@ -2023,6 +2108,7 @@ Examples:
   npx pennyrouter install --harness claude-code --anthropic-auth --token <token>
   npx pennyrouter install --harness claude-code --anthropic-api-key <key>
   npx pennyrouter install --harness codex --openai-api-key <key>
+  npx pennyrouter install --harness claude-code --proxy-base-url https://proxy.example.com --proxy-api-key <key>
   npx pennyrouter install --openrouter-api-key <key>
   npx pennyrouter auth anthropic
   npx pennyrouter install --all

package/src/cli.test.js

@@ -121,3 +121,76 @@ test("harnessFundingChanged: no requested funding for an existing harness is not
   };
   assert.equal(harnessFundingChanged({}, claudeHarness, manifest), false);
 });
+
+// --- Other proxy (user-supplied Anthropic-compatible base URL) ----------------
+
+test("--proxy-base-url and --proxy-api-key parse in both forms", async () => {
+  for (const args of [
+    ["--proxy-base-url", "https://proxy.example.com", "--proxy-api-key", "k"],
+    ["--proxy-base-url=https://proxy.example.com", "--proxy-api-key=k"],
+  ]) {
+    const lines = await captureLogs(() => main([
+      "install", "--harness", "claude-code", "--dry-run", ...args,
+    ]));
+    assert.ok(lines.length > 0);
+  }
+});
+
+test("--config maps anthropic-proxy funding to the proxy flags", async () => {
+  await withConfigFile(
+    {
+      harnesses: ["claude-code"],
+      claudeFunding: ["anthropic-proxy"],
+      proxyBaseUrl: "https://proxy.example.com",
+      proxyApiKey: "secret-key",
+    },
+    async (path) => {
+      const lines = await captureLogs(() => main(["install", "--config", path, "--dry-run"]));
+      assert.ok(lines.some((line) => line.includes("Claude Code")));
+      // The key must never be echoed to the terminal.
+      assert.ok(!lines.some((line) => line.includes("secret-key")));
+    },
+  );
+});
+
+test("harnessFundingChanged sees a switch to the proxy as a change", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "claude-subscription" }],
+  };
+  const changed = harnessFundingChanged(
+    { configClaudeFunding: new Set(["anthropic-proxy"]) },
+    { id: "claude-code" },
+    manifest,
+  );
+  assert.equal(changed, true);
+});
+
+test("harnessFundingChanged sees an unchanged proxy install as unchanged", () => {
+  const manifest = {
+    installations: [{ harness: "claude-code", user_funded_provider: "anthropic-proxy" }],
+  };
+  const changed = harnessFundingChanged(
+    { configClaudeFunding: new Set(["anthropic-proxy"]) },
+    { id: "claude-code" },
+    manifest,
+  );
+  assert.equal(changed, false);
+});
+
+test("auth anthropic --forget targets the installed gateway, not prod", async () => {
+  // Regression: this defaulted to https://api.pennyrouter.com even when the machine was
+  // installed against a local gateway, silently deleting the wrong account's token.
+  const lines = await captureLogs(() => main([
+    "auth", "anthropic", "--forget", "--dry-run",
+    "--penny-key", "pr-test", "--gateway-base-url", "http://localhost:8400",
+  ]));
+  assert.ok(lines.some((line) => line.includes("http://localhost:8400")));
+  assert.ok(!lines.some((line) => line.includes("api.pennyrouter.com")));
+});
+
+test("auth anthropic --forget honors --local", async () => {
+  const lines = await captureLogs(() => main([
+    "auth", "anthropic", "--forget", "--dry-run", "--local", "--penny-key", "pr-test",
+  ]));
+  assert.ok(lines.some((line) => line.includes("localhost:8400")));
+});

package/src/launch.js

@@ -438,6 +438,11 @@ export function buildPennyInvocation(harness, args, config) {
     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);
+    if (models.custom) {
+      env.ANTHROPIC_CUSTOM_MODEL_OPTION = upgradeClaudeCodeModelValue(models.custom);
+      if (models.custom_name) env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME = models.custom_name;
+      if (models.custom_description) env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION = models.custom_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.

package/src/session.js

@@ -49,7 +49,7 @@ export function sleep(ms) {
 // Encrypt and store a user-owned upstream credential against the account server-side,
 // so the pr- key alone unlocks the selected harness and the provider secret is never
 // written to harness configuration.
-export async function storeUpstreamCredential({ gatewayBaseUrl, apiKey, provider, token }) {
+export async function storeUpstreamCredential({ gatewayBaseUrl, apiKey, provider, token, metadata }) {
   const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials`;
   const response = await fetch(url, {
     method: "POST",
@@ -57,7 +57,7 @@ export async function storeUpstreamCredential({ gatewayBaseUrl, apiKey, provider
       "content-type": "application/json",
       authorization: `Bearer ${apiKey}`,
     },
-    body: JSON.stringify({ provider, token }),
+    body: JSON.stringify({ provider, token, ...(metadata ? { metadata } : {}) }),
   });
   if (!response.ok) {
     let detail = "";
@@ -135,10 +135,10 @@ export async function probeClaudeCodeGateway({ gatewayBaseUrl, apiKey }) {
 
 // Best-effort "forget my Claude token" on uninstall. Never throws — a cleanup that
 // can't reach the network shouldn't block removing the local integration.
-export async function forgetAnthropicToken({ gatewayBaseUrl, apiKey }) {
+export async function forgetUpstreamCredential({ gatewayBaseUrl, apiKey, provider }) {
   if (!gatewayBaseUrl || !apiKey) return false;
   try {
-    const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials/anthropic`;
+    const url = `${gatewayBaseUrl.replace(/\/+$/, "")}/v1/upstream-credentials/${encodeURIComponent(provider)}`;
     const response = await fetch(url, {
       method: "DELETE",
       headers: { authorization: `Bearer ${apiKey}` },
@@ -149,6 +149,10 @@ export async function forgetAnthropicToken({ gatewayBaseUrl, apiKey }) {
   }
 }
 
+export async function forgetAnthropicToken({ gatewayBaseUrl, apiKey }) {
+  return forgetUpstreamCredential({ gatewayBaseUrl, apiKey, provider: "anthropic" });
+}
+
 function platformName() {
   if (process.platform === "darwin") return "Mac";
   if (process.platform === "win32") return "Windows";

package/src/statusline.js

@@ -11,6 +11,10 @@
 // authed with the pr- key already in Claude Code's settings). The gateway keys that
 // endpoint on the CC session uuid it sees in every request's metadata.user_id — the
 // same uuid Claude Code hands the statusline script on stdin.
+//
+// A wrapped user statusline command is cached the same way: it can be slow to spawn
+// (npx especially, and especially on Windows — see WRAP_REFRESH_MS below), so it's never
+// run inline on Claude Code's ~1s render loop.
 
 import { statePath, atomicWrite, readJsonFile, writeJsonFile } from "./state.js";
 
@@ -87,6 +91,14 @@ const stateDir = join(
   "pennyrouter",
 );
 const cacheDir = join(stateDir, "statusline-cache");
+// A wrapped user statusline command can be slow to spawn (npx especially: on Windows
+// it goes through an extra cmd.exe/npx.cmd hop and can take 2-4s per invocation, vs
+// well under 1s on macOS/Linux). Claude Code re-invokes this script every ~1s
+// (refreshInterval), so running the wrap command inline on every render blocked past
+// that interval on Windows, renders piled up, and the statusline never finished in
+// time to display at all. Cache its output and refresh it out-of-band instead, same
+// as the Penny gateway segment below.
+const WRAP_REFRESH_MS = 2000;
 
 function readJson(path) {
   try { return JSON.parse(readFileSync(path, "utf8")); } catch { return null; }
@@ -109,6 +121,8 @@ function claudeEnv() {
   return { base, key };
 }
 
+const config = readJson(join(stateDir, "claude-statusline.json")) || {};
+
 // --refresh <sessionId>: fetch gateway status into the cache file, then exit.
 if (process.argv[2] === "--refresh") {
   const sessionId = process.argv[3];
@@ -131,11 +145,28 @@ if (process.argv[2] === "--refresh") {
   process.exit(0);
 }
 
+// --refresh-wrap <sessionId>: run the (possibly slow) wrapped statusline command out of
+// band and cache its output. Reads the stdin JSON the main render last saw, persisted to
+// a per-session file since a detached child has no stdin of its own to read.
+if (process.argv[2] === "--refresh-wrap") {
+  const sessionId = process.argv[3];
+  if (!sessionId || !config.wrap_command) process.exit(0);
+  let wrapInput = "{}";
+  try { wrapInput = readFileSync(join(cacheDir, sessionId + ".wrap-input.json"), "utf8"); } catch { /* none yet */ }
+  const run = spawnSync(config.wrap_command, {
+    shell: true, input: wrapInput, encoding: "utf8", timeout: 20000, windowsHide: true,
+  });
+  let wrapLines = (run.stdout || "").replace(/\\n$/, "").split("\\n");
+  if (wrapLines.length === 1 && wrapLines[0] === "") wrapLines = [];
+  mkdirSync(cacheDir, { recursive: true });
+  writeFileSync(join(cacheDir, sessionId + ".wrap.json"), JSON.stringify({ lines: wrapLines, at: Date.now() }));
+  process.exit(0);
+}
+
 const raw = readFileSync(0, "utf8");
 let input = {};
 try { input = JSON.parse(raw); } catch { /* keep {} */ }
 const sessionId = input.session_id || "";
-const config = readJson(join(stateDir, "claude-statusline.json")) || {};
 const refreshMs = (config.refresh_seconds ?? 15) * 1000;
 
 const cachePath = join(cacheDir, sessionId + ".json");
@@ -148,7 +179,7 @@ const { base, key } = claudeEnv();
 const pennyInstalled = Boolean(base) && Boolean(key);
 if (sessionId && pennyInstalled && cacheAge > refreshMs) {
   spawn(process.execPath, [process.argv[1], "--refresh", sessionId], {
-    detached: true, stdio: "ignore",
+    detached: true, stdio: "ignore", windowsHide: true,
   }).unref();
 }
 
@@ -193,9 +224,27 @@ if (!pennyInstalled) {
 }
 
 let lines;
-if (config.wrap_command) {
+if (config.wrap_command && sessionId) {
+  const wrapCachePath = join(cacheDir, sessionId + ".wrap.json");
+  const wrapCache = readJson(wrapCachePath);
+  const wrapAge = wrapCache && typeof wrapCache.at === "number" ? Date.now() - wrapCache.at : Infinity;
+  if (wrapAge > WRAP_REFRESH_MS) {
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(join(cacheDir, sessionId + ".wrap-input.json"), raw);
+    // Bump the cache timestamp before spawning: Claude Code polls every ~1s, so
+    // without this every render in the next couple seconds would see a still-stale
+    // cache and fire its own overlapping refresh while the first one is still running.
+    writeFileSync(wrapCachePath, JSON.stringify({ lines: (wrapCache && wrapCache.lines) || [], at: Date.now() }));
+    spawn(process.execPath, [process.argv[1], "--refresh-wrap", sessionId], {
+      detached: true, stdio: "ignore", windowsHide: true,
+    }).unref();
+  }
+  lines = (wrapCache && wrapCache.lines) || [];
+} else if (config.wrap_command) {
+  // No session id (e.g. a manual/interactive invocation outside Claude Code): there's
+  // no cache key to keep state under, so run inline like before caching existed.
   const run = spawnSync(config.wrap_command, {
-    shell: true, input: raw, encoding: "utf8", timeout: 5000,
+    shell: true, input: raw, encoding: "utf8", timeout: 5000, windowsHide: true,
   });
   lines = (run.stdout || "").replace(/\\n$/, "").split("\\n");
   if (lines.length === 1 && lines[0] === "") lines = [];