pennyrouter 0.3.33 → 0.3.34

package/README.md

@@ -97,6 +97,7 @@ directory to the user PATH:
 
 ```bash
 penny claude
+penny claude --stats
 penny claude desktop
 penny claude desktop gateway
 penny claude desktop native
@@ -108,6 +109,9 @@ penny codex desktop native
 penny opencode
 ```
 
+`penny claude --stats` launches Claude Code with Penny Compare's live single-session token and
+cost readout. Other arguments still pass through, so `penny claude --stats --resume` works.
+
 Arguments are passed through to the native harness, so commands such as `penny claude --resume`,
 `penny codex resume --last`, and `penny opencode --continue` work normally. By default, bare
 `claude`, `codex`, and `opencode` remain

package/package.json

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

package/src/launch.js

@@ -1240,6 +1240,25 @@ export function extractProfileArgs(args) {
   return { profile, args: rest };
 }
 
+/**
+ * Remove the launcher-only stats flag while preserving every native harness argument.
+ * A bare `--` ends Penny's option parsing, so a later `--stats` still reaches the harness.
+ */
+export function extractStatsArgs(args) {
+  const rest = [];
+  let stats = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--") {
+      rest.push(...args.slice(i));
+      break;
+    }
+    if (arg === "--stats") stats = true;
+    else rest.push(arg);
+  }
+  return { stats, args: rest };
+}
+
 function assertNoConflictingArgs(harness, args) {
   if (harness === "claude" && args.some((arg) => arg === "--settings" || arg.startsWith("--settings="))) {
     throw new Error("penny claude manages --settings; remove that flag or run native claude.");
@@ -1416,23 +1435,63 @@ async function waitForChild(child) {
   });
 }
 
+/** Launch Penny Claude inside Penny Compare's single-session token readout. */
+export async function runPennyClaudeStats(args, profile) {
+  if (!(process.platform === "darwin" || process.platform === "linux")) {
+    throw new Error("penny claude --stats is supported on macOS and Linux.");
+  }
+  const panePath = join(pennyCompareDir(), "pane.py");
+  try {
+    await stat(panePath);
+  } catch {
+    throw new Error(
+      "Penny's stats display is not installed. Run `npx pennyrouter compare` and try again.",
+    );
+  }
+  const child = spawn("python3", [
+    panePath,
+    "penny-claude",
+    "--side",
+    "single",
+    "--cwd",
+    process.cwd(),
+    "--harness-args-json",
+    JSON.stringify(["--penny-profile", profile, ...args]),
+  ], {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: "inherit",
+  });
+  const result = await waitForChild(child);
+  if (result.signal) return 128 + (osConstants.signals[result.signal] || 0);
+  return result.code ?? 1;
+}
+
 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|opencode> [--penny-profile <name>] [native arguments...]");
     console.log("       --private / --cloud select the like-named profile.");
+    console.log("       penny claude --stats adds the live single-session token readout.");
     return 0;
   }
   if (!["claude", "codex", "opencode"].includes(harness)) {
     throw new Error(`Unknown harness "${harness}". Try penny claude, penny codex, or penny opencode.`);
   }
-  const selection = extractProfileArgs(argv.slice(1));
+  const statsSelection = extractStatsArgs(argv.slice(1));
+  if (statsSelection.stats && harness !== "claude") {
+    throw new Error("--stats is currently supported only by penny claude.");
+  }
+  const selection = extractProfileArgs(statsSelection.args);
   argv = [harness, ...selection.args];
   const config = await loadPennyConfig({
     profile: selection.profile,
     requireExisting: Boolean(selection.profile),
   });
   if (harness === "claude" && argv[1]?.toLowerCase() === "desktop") {
+    if (statsSelection.stats) {
+      throw new Error("--stats applies to Claude Code sessions, not Claude Desktop.");
+    }
     const option = argv[2]?.toLowerCase();
     if (option === "--restore" || option === "restore") {
       if (argv.length > 3) {
@@ -1469,6 +1528,9 @@ export async function runPenny(argv = process.argv.slice(2)) {
     }
     return runClaudeDesktop(config, { logs, mode });
   }
+  if (statsSelection.stats) {
+    return runPennyClaudeStats(argv.slice(1), config.profile);
+  }
   if (harness === "codex" && argv[1]?.toLowerCase() === "desktop") {
     const option = argv[2]?.toLowerCase();
     const mode = option === "native" || option === "--native" ? "native" : "gateway";

package/standalone/pane.py

@@ -51,7 +51,7 @@ NATIVE_PROXY_TOKEN_ENV = "PENNY_COMPARE_NATIVE_AUTH_TOKEN"
 class Readout:
     """Paints the fixed block at the top of the pane."""
 
-    def __init__(self, harness, title, delta_path=None, provider=None, label=None,
+    def __init__(self, harness, title, delta_path=None, label=None,
                  session_id=None, side=None, variant=None, pricing_profile="standard"):
         self.harness = harness
         # The pane's fixed role ("NATIVE"/"PENNY"). It keys the files the two panes use to
@@ -60,8 +60,6 @@ class Readout:
         # What the readout actually shows, which the user may rename.
         self.label = label or title
         self.delta_path = delta_path
-        # For Codex, whether this pane's session should be the PennyRouter-routed one.
-        self.provider = provider
         # Claude accepts a caller-supplied session id, so its transcript can be selected exactly
         # instead of inferred from timing, model names, or Penny's global title handoff files.
         self.session_id = session_id
@@ -142,13 +140,14 @@ class Readout:
     def resolve(self):
         """Pin this pane to the transcript its own harness created.
 
-        Both panes run in the same working directory, so the newest session there is ambiguous
-        between them, and resolving by timing alone can label the two backwards.
+        Claude is launched with an explicit session id, making its transcript path deterministic.
+        Codex and OpenCode are selected from files created after this pane launched, narrowed by
+        cwd, with pane claims preventing two local panes from adopting the same transcript.
 
-        Claude is launched with an explicit session id, making both its native and Penny
-        transcript paths deterministic. Codex has no equivalent launch flag, but records the
-        provider in its session header, so each Codex pane takes the session matching how it was
-        started.
+        Do not filter Codex by provider here. Subscription-backed Penny sessions deliberately
+        record ``model_provider = openai``, and a hosted gateway cannot create a claim file on
+        this machine. That filter rejects the correct local JSONL for both penny-session and the
+        normal compare layout, where cwd/time/claiming already identify it.
         """
         if self.path and os.path.exists(self.path):
             return self.path
@@ -163,8 +162,7 @@ class Readout:
         # session, so require one created afterwards rather than adopting the newest on disk.
         taken = self._peers() | self._preexisting
         candidate = newest_session(self.harness, os.getcwd(),
-                                   since=self.started, exclude=taken,
-                                   provider=self.provider)
+                                   since=self.started, exclude=taken)
         if candidate and not self._claim(candidate):
             return None
         self.path = candidate
@@ -346,6 +344,8 @@ def main():
                         help="start both panes on one model so the comparison is like for like")
     parser.add_argument("--label", default=None,
                         help="name shown on this pane's readout (default: NATIVE or PENNY)")
+    parser.add_argument("--cwd", default=None,
+                        help="working directory selected by the compare launcher")
     parser.add_argument("--side", choices=("left", "right", "single"),
                         help="stable pane position used by the final report")
     parser.add_argument("--pricing-profile", choices=("standard", "govcloud"),
@@ -353,8 +353,26 @@ def main():
     parser.add_argument("--native-proxy", action="store_true",
                         help=f"route the NATIVE pane through {NATIVE_PROXY_URL_ENV} / "
                              f"{NATIVE_PROXY_TOKEN_ENV} instead of going direct")
+    parser.add_argument("--harness-args-json", default="[]",
+                        help=argparse.SUPPRESS)
     args = parser.parse_args()
 
+    try:
+        harness_args = json.loads(args.harness_args_json)
+        if not isinstance(harness_args, list) or not all(
+                isinstance(value, str) for value in harness_args):
+            raise ValueError("expected a JSON array of strings")
+    except (json.JSONDecodeError, ValueError) as error:
+        sys.stderr.write(f"penny-compare: invalid harness arguments: {error}\n")
+        return 2
+
+    if args.cwd:
+        try:
+            os.chdir(os.path.expanduser(args.cwd))
+        except OSError as error:
+            sys.stderr.write(f"penny-compare: cannot enter {args.cwd}: {error}\n")
+            return 1
+
     harness, command, title = VARIANTS[args.variant]
     session_id = None
     if harness == "claude-code":
@@ -364,20 +382,14 @@ def main():
         # Passed to the harness rather than set in the environment, so Penny's own model
         # configuration is not overridden on the penny side.
         command = command + ["--model", args.model]
+    command = command + harness_args
 
     rows = shutil.get_terminal_size().lines
     # Reserve the top rows for the readout and confine scrolling to what is left.
     sys.stdout.write(f"\033[2J\033[{hud.ROWS + 1};{rows}r\033[{hud.ROWS + 1};1H")
     sys.stdout.flush()
 
-    # Codex and OpenCode have no caller-assigned session id, so they identify their transcript by the provider
-    # recorded in the session header instead.
-    is_penny = command[0] == "penny"
     readout = Readout(harness, title, args.delta_file,
-                      # OpenCode owns provider/model selection inside its own TUI. The
-                      # penny-opencode spelling is only a launch convenience, not a reliable
-                      # provider identity like Codex's session header is.
-                      provider=is_penny if harness == "codex" else None,
                       label=args.label,
                       session_id=session_id,
                       side=args.side,

package/standalone/penny-compare

@@ -236,6 +236,8 @@ workdir_left="${dir_left:-$PWD/native}"
 workdir_left="${workdir_left/#\~/$HOME}"
 workdir_right="${dir_right:-$PWD/penny}"
 workdir_right="${workdir_right/#\~/$HOME}"
+workdir_left_arg=" --cwd $(printf '%q' "$workdir_left")"
+workdir_right_arg=" --cwd $(printf '%q' "$workdir_right")"
 
 # --native-proxy only means anything on a NATIVE Claude or Codex pane;
 # a penny-* pane already owns its own proxy routing and ignores the flag either way.
@@ -265,10 +267,10 @@ wire_args="${wire:+ $wire}${wire_both:+ $wire_both}${wire_https:+ $wire_https}"
 
 tmux new-session -d -s "$session" -c "$workdir_left" -x "$(tput cols)" -y "$(tput lines)" \
   -e PENNY_COMPARE_STATE="$state" \
-  "$here/pane.py $left --side left --pricing-profile $pricing_profile${model:+ --model $model}${native_proxy_left:+ $native_proxy_left}${label_left_arg}${wire_args}"
+  "$here/pane.py $left --side left --pricing-profile $pricing_profile${workdir_left_arg}${model:+ --model $model}${native_proxy_left:+ $native_proxy_left}${label_left_arg}${wire_args}"
 tmux split-window -h -t "$session" -c "$workdir_right" \
   -e PENNY_COMPARE_STATE="$state" \
-  "$here/pane.py $right --side right --pricing-profile $pricing_profile --delta-file $delta${model:+ --model $model}${native_proxy_right:+ $native_proxy_right}${label_right_arg}${wire_args}"
+  "$here/pane.py $right --side right --pricing-profile $pricing_profile --delta-file $delta${workdir_right_arg}${model:+ --model $model}${native_proxy_right:+ $native_proxy_right}${label_right_arg}${wire_args}"
 
 # The comparison belongs to neither pane, so a small watcher derives it from both.
 tmux new-window -d -t "$session" -n delta "$here/delta.py '$state' '$delta'"