claude-code-runrate 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -0,0 +1,114 @@
+# Changelog
+
+Every release also has a [GitHub release](https://github.com/bingh0/ccr/releases)
+and a release commit, and those carry the full notes — what was measured, what
+was rejected, and why. This file is the index: enough to decide whether a
+version is worth upgrading to, and where to read the rest.
+
+Dates are npm publish dates, because that is when a version reached anyone.
+
+## 0.5.0 — 2026-08-22
+
+The Windows release. The things that could not be reasoned about were measured
+on a real Windows 11 machine, because none of them are reachable from CI: every
+Windows test injects the launcher, so the suite proves the argv `ccr` builds and
+nothing about what Windows Terminal does when handed it.
+
+- **The panes open where `ccr` was run.** `wt.exe` does not inherit the working
+  directory the way `tmux new-session` does, so every pane opened in
+  `%USERPROFILE%` while the launch record claimed otherwise — and the sidecar
+  prefers that record, so the git pane described the project in full confidence
+  for a terminal that was not in it. One source now feeds both.
+- **Measured limits, and they are real.** Past 256 characters `wt` opens *no
+  tab at all*; a UNC path opens a tab and silently lands in `%SystemRoot%`; a
+  semicolon costs the whole tab; a backtick does not, so refusing it was wrong
+  and no longer happens. Each unusable path degrades — the panes open in the
+  default directory and stderr names which of the four reasons applied.
+- **The sidecar pane has a cycle key** on Windows Terminal. F3 or Space. F3 has
+  three encodings and on Windows which one arrives depends on the *Node*
+  version, so `ccr` answers all three rather than pinning a Node floor for a
+  keystroke.
+- **A pane config that says what is wrong.** A UTF-8 BOM is stripped; UTF-16 —
+  what PowerShell 5.1 writes for `>` and `Out-File` — is named as an encoding
+  problem instead of reported as bad JSON; `~\` expands as well as `~/`; and a
+  broken config says so on the panel and in `ccr doctor`, which reports pane
+  paths as *resolved*.
+- **`ccr sidecar` resolves the instance from the working directory**, which the
+  feature files and the README had both described for a while.
+- **The economy screen earns a decimal** where the next tenth is a decision: at
+  or past 95% used, one truncated digit, so `floor(shown)` still matches
+  `/usage`. A snapshot that stopped refreshing dims rather than blanks.
+
+## 0.4.0 — 2026-08-07
+
+[The instance layer and the git pane.](https://github.com/bingh0/ccr/releases/tag/v0.4.0)
+
+- **Instances.** Every launch is a named, slotted instance under one container
+  home; the name is derived from the project or given with `-i`, and travels
+  into the window title, status line and sidebar.
+- **A git pane** on F3: which repository the tab is in, the working tree, and
+  recent history in lanes. Read-only — it never writes to the repository.
+- The three launchers (tmux, Windows Terminal, VS Code) take naming, titles and
+  retention from one shared path rather than the tmux path owning them.
+
+## 0.3.0 — 2026-08-04
+
+[External tool panes in the sidebar.](https://github.com/bingh0/ccr/releases/tag/v0.3.0)
+
+- **Panes from other tools.** The sidebar hosts full-height read-only panes
+  rendered from small JSON blobs another tool writes beside its own artifacts.
+  You list the path in `~/.config/ccr/config.json`; F3 cycles.
+- A rate-limit correctness fix, and `strict` type checking across the codebase.
+
+## 0.2.4 — 2026-07-12
+
+[VS Code sidecars stop piling up; profile state-dir fix.](https://github.com/bingh0/ccr/releases/tag/v0.2.4)
+
+- One live sidecar per session: relaunching inside VS Code no longer
+  accumulates identical panes.
+- Profile sessions write their snapshots to the right state dir.
+
+## 0.2.3 — 2026-07-03
+
+[Sidecars agree on 5h/weekly across profiles.](https://github.com/bingh0/ccr/releases/tag/v0.2.3)
+
+- The 5h and weekly walls are one account-wide resource, but each profile only
+  captures its own; two sidecars on the same account could disagree. They
+  reconcile now.
+
+## 0.2.2 — 2026-07-02
+
+[Aligned meter bars + a staleness marker.](https://github.com/bingh0/ccr/releases/tag/v0.2.2)
+
+- A barely-used window projects an enormous time-to-exhaust, which overflowed
+  the fixed time column and shoved that row's bar out of line. Long horizons
+  are capped, so the bars stay aligned and the figure reads more honestly.
+- A stale snapshot is annotated (`· updated Nm ago`) rather than silently
+  frozen. Never a wipe — Claude Code legitimately stops ticking during a long
+  operation.
+
+## 0.2.1 — 2026-06-26
+
+[Windows Terminal teardown and sidecar width fixes.](https://github.com/bingh0/ccr/releases/tag/v0.2.1)
+
+- ConPTY makes a split pane's reported width unreliable, so the panel
+  soft-wrapped. The launcher injects the computed width and the sidecar clamps
+  to the smaller of the two.
+- On exit the sidecar pane collapses first and the border sweeps left to right,
+  fixing an ordering bug where Claude's pane could close first.
+
+## 0.2.0 — 2026-06-26
+
+[Native Windows and VS Code live sidecars.](https://github.com/bingh0/ccr/releases/tag/v0.2.0)
+
+- **Native Windows** — the live sidecar hosted in Windows Terminal split panes,
+  no tmux, bash or WSL, with a graceful fallback when `wt.exe` is absent.
+- **VS Code integrated terminal on any OS** — split-pane sidecar via a
+  clipboard one-liner.
+- `statusLine` injected per launch through a temp settings file, so `~/.claude`
+  is never mutated.
+
+## 0.1.0 — 2026-06-24
+
+First publish: the CLI and status line — `economy`, `resume`, `statusline` —
+with the live sidebar on tmux. Native Windows arrived in 0.2.0.

package/README.md

@@ -173,11 +173,11 @@ small JSON blob beside its own artifacts; you list that file's path in ccr's
 config; the sidebar cycles between the economy panel, the built-in git pane, and
 each configured pane.
 
-**Cycling views.** Under tmux the launcher binds **F3**. VS Code and its forks
-(Cursor, Positron, Antigravity) bind no key and leave both split panes running a
-foreground process, so the pasted sidecar one-liner carries `--keys`: click that
-pane and press **Space** (or **F3**). The renderer still reads no input — the key
-lives in a separate parent process that runs the panel as a child, the same
+**Cycling views.** Under tmux the launcher binds **F3** at the host. **Windows
+Terminal** binds no key of its own, and neither do VS Code and its forks (Cursor,
+Positron, Antigravity) — so on those the sidecar pane carries its own key: click
+the pane and press **Space** or **F3**. The renderer still reads no input — the
+key lives in a separate parent process that runs the panel as a child, the same
 separation tmux enforces. Anywhere else, `ccr cycle-view -i <name>` (or
 `--state-dir <dir>`); a bare `ccr cycle-view` resolves the instance from your
 working directory, like `ccr economy` does.
@@ -191,6 +191,19 @@ read from a repository:
 { "panes": [ { "path": "/home/you/project/.your-tool/sidecar.json" } ] }
 ```
 
+A leading `~` expands, with either separator (`~/tools/blob.json`,
+`~\tools\blob.json`), and a relative path resolves against the config file's own
+directory. **On Windows, save the file as UTF-8** — `>` and `Out-File` in Windows
+PowerShell 5.1 write UTF-16, which is not JSON as far as any parser is concerned:
+
+```powershell
+Set-Content -Encoding utf8 $env:USERPROFILE\.config\ccr\config.json $json
+```
+
+`ccr doctor` reports what it read out of the config — the paths as **resolved**,
+not as written — and names the problem when there is one, so a pane that never
+appears is a question you can answer rather than a silence.
+
 A pane is a full-height view carrying the producing tool's own rows — here
 `gherkin-trace`, whose blob ships as the golden example:
 
@@ -253,10 +266,16 @@ method has followed since, and is honest about which point on that line this
 repository represents.
 
 ```bash
-npm test            # node --test — harness self-tests + feature scenarios
-npm run typecheck   # tsc --noEmit over @ts-check'd JS (needs: npm i first)
+npm test              # node --test — harness self-tests + feature scenarios
+npm run typecheck     # tsc --noEmit over @ts-check'd JS (needs: npm i first)
+npm run install-hooks # copy .githooks/ into this clone (run once)
 ```
 
+`install-hooks` installs a fail-closed `pre-push` guard for the public remote:
+only `main`, fast-forward only, and a scan of the commits the push would make
+public. It is worth running in any clone you push from — a push is the moment
+history stops being private, and it is the last moment the check can help.
+
 - **No runtime dependencies**, ever — it's what lets `npx claude-code-runrate` install
   instantly on every OS, including native Windows.
 - **Dev-only** tooling (`typescript`, `@types/node`) exists solely for

package/bin/ccr.js

@@ -323,8 +323,18 @@ function cmdResume(arg) {
  * @returns {number | undefined}
  */
 function cmdSidecar(stateDir, showHint, exitOnEnd, useKeys, view, target = null) {
-  if (!stateDir && target != null) {
-    // -i: attach to a live instance by name, through the resolution chain.
+  // Resolve whether or not -i was typed, which is what `ccr cycle-view` has
+  // always done. Consulting the chain ONLY for -i meant a bare `ccr sidecar`
+  // skipped every other link in it — including the one that matters most here,
+  // "the live instance whose launch directory contains the cwd" — and landed on
+  // the CONTAINER (~/.ccr) instead. The container holds no session, so the pane
+  // sat empty next to a running instance, and the fix looked like naming the
+  // instance exactly right when the whole point of the chain is not having to.
+  //
+  // --hint is left out: it prints the VS Code split instructions, which are
+  // worth printing before any instance exists, so requiring a live one to
+  // explain how to start one would be backwards.
+  if (!stateDir && !showHint) {
     const res = require('../src/instance-resolve').resolveInstance({ target, command: 'sidecar' });
     if (!res.ok) { process.stderr.write(res.error + '\n'); return 1; }
     stateDir = res.stateDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-runrate",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Claude Code run-rate — subscription burn-rate & economy for your Claude Code sessions.",
   "license": "MIT",
   "author": "Bing Ho <reps-attic-riot@duck.com>",
@@ -25,6 +25,7 @@
     "scripts/launch.sh",
     "sidecar",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "scripts": {
@@ -32,7 +33,10 @@
     "typecheck": "tsc --noEmit -p jsconfig.json",
     "lint": "oxlint",
     "release-gate": "node scripts/release-gate.js",
-    "prepublishOnly": "npm run release-gate && npm run lint && npm run typecheck && npm test"
+    "install-hooks": "node scripts/install-hooks.js",
+    "probe:wt": "node scripts/probe-wt.js",
+    "scan-package": "node scripts/scan-package.js",
+    "prepublishOnly": "npm run release-gate && npm run scan-package && npm run lint && npm run typecheck && npm test"
   },
   "keywords": [
     "claude-code",

package/src/doctor.js

@@ -9,6 +9,7 @@ const path = require('node:path');
 const os = require('node:os');
 const { spawnSync } = require('node:child_process');
 const { stripControl } = require('./sanitize');
+const { loadPaneConfig } = require('./pane-config');
 
 const ok = (/** @type {string} */ s) => `\x1b[32m✓\x1b[0m ${s}`;
 const bad = (/** @type {string} */ s) => `\x1b[31m✗\x1b[0m ${s}`;
@@ -36,7 +37,8 @@ function isExec(/** @type {string} */ f) {
 
 /**
  * @param {{ platform?: string, has?: (cmd: string) => (string|null),
- *   homedir?: string, repo?: string, write?: (s: string) => void }} [opts]
+ *   homedir?: string, repo?: string, write?: (s: string) => void,
+ *   env?: Record<string, string|undefined> }} [opts]
  *   side effects are injectable for testing; defaults hit the real environment
  * @returns {number} exit code (0 = healthy)
  */
@@ -91,6 +93,24 @@ function run(opts = {}) {
     out.push(dim('· ccs not installed (optional — only for `ccr <profile>`)'));
   }
 
+  // Pane wiring. This command exists to diagnose "nothing happens", and a pane
+  // config the user wrote and got wrong is exactly that — the sidecar has room
+  // for a one-line marker and no more. Here there is room for the path, the
+  // reason, and what ccr actually read out of the file, which is the question
+  // someone whose pane never appeared is really asking.
+  const cfg = loadPaneConfig({ env: opts.env, home: homedir });
+  if (cfg.error) {
+    out.push(bad(`pane config: ${cfg.error} — ${stripControl(cfg.configPath)}`));
+    problems++;
+  } else if (cfg.panes.length) {
+    out.push(ok(`pane config: ${cfg.panes.length} pane(s) (${stripControl(cfg.configPath)})`));
+    // The path as ccr resolved it, not as written: a tilde that did not expand
+    // is invisible in the source string and obvious in the resolved one.
+    for (const pane of cfg.panes) out.push(dim(`  · ${stripControl(pane.path)}`));
+  } else {
+    out.push(dim(`· no panes configured (optional — ${stripControl(cfg.configPath)})`));
+  }
+
   // newest captured snapshot across the container. Instances live TWO levels
   // down under the 0.4.0 layout (~/.ccr/instances/<n>/last-status.json) — the
   // one-level scan alone would report "no status captured" while instances run