cc-cream 0.3.4 → 0.4.0

package/CHANGELOG.md

@@ -6,6 +6,35 @@ All notable changes to cc-cream are documented here. Format follows
 
 ## [Unreleased]
 
+## [0.4.0] — 2026-06-04
+
+### Added
+- **`--show` / `--hide` flags on `/cc-cream:setup` and `cc-cream-setup`.** Toggle segments from the command line without editing JSON: `--hide 5h,7d,peak`, `--show all`, `--show effort,thinking`. `--hide` overrides `--show` when both name the same segment. Changes are idempotent and written to `~/.claude/cc-cream.json`.
+- **`--set key=value` flag.** Set any config field via dot-path: `--set percentage=remaining`, `--set ctx.ceiling=100000`, `--set 5h.amber=80`. Multiple `--set` flags are allowed in one call. Invalid keys or out-of-domain values exit non-zero with an error message.
+
+### Changed
+- **All 14 segments are now enabled on first install.** Previously `write`, `effort`, `thinking`, `api_ratio`, and `session_name` defaulted to off; users had to know to turn them on. They are now on by default — use `--hide` to remove any you don't need.
+
+### Fixed
+- **Orphaned renderer removes stale `cc-cream-state.json`.** When `/plugin uninstall cc-cream` is run before `/cc-cream:uninstall` (wrong order, cache kept), the ghost-bar self-defense suppressed the bar but left `cc-cream-state.json` on disk. The orphaned renderer now removes it before exiting.
+
+## [0.3.6] — 2026-06-04
+
+### Changed
+- **Plugin is now distributed via a lean catalogue repo (`bart-turczynski/claude-plugins`) instead of the full dev repo.** Previously the marketplace pointed at `bart-turczynski/cc-cream`, so every user who registered the marketplace got a full clone of the development repository — `features/`, `fixtures/`, `package-lock.json` (114 KB), `CHANGELOG.md` (31 KB), and the full git history — landing in `~/.claude/plugins/marketplaces/`. The marketplace source is now `bart-turczynski/claude-plugins`, a purpose-built catalogue containing only the plugin payload and `marketplace.json`. The marketplaces clone shrinks from ~1 MB to ~260 KB (irreducible floor: `.git/` + `.claude-plugin/`). Existing installs should remove and re-add the marketplace: `claude plugin marketplace remove bart-turczynski && claude plugin marketplace add bart-turczynski/claude-plugins`.
+
+### Infrastructure
+- Added `.github/workflows/sync-catalogue.yml`: on each GitHub Release, syncs `plugin/` contents to `cc-cream/` in the `bart-turczynski/claude-plugins` catalogue repo so the distribution copy stays current without manual maintenance.
+
+## [0.3.5] — 2026-06-04
+
+### Fixed
+- **`/cc-cream:setup --force` now actually replaces an existing statusLine.** The setup slash command shelled out to `install.js --plugin` but never forwarded `$ARGUMENTS`, so `--force` (and any other flag) was silently dropped — `--force` appeared to do nothing when another tool already owned the statusLine. `commands/setup.md` now passes `$ARGUMENTS` through, matching `uninstall.md`. `install.js` already honored `--force`; only the command wiring was broken.
+- **Plugin install no longer balloons the cache to ~114 MB.** Claude Code's plugin installer runs `npm install` whenever it finds a `package.json` in the cached plugin tree, which pulled the entire devDependency tree (Biome, Cucumber, knip, c8, …) into `~/.claude/plugins/cache/cc-cream/`. The plugin payload now lives in a `plugin/` subdirectory and the marketplace `source` points to `"./plugin"`, so only `plugin/`'s contents (`src/`, `commands/`, `hooks/`, `.claude-plugin/plugin.json`) are copied to the cache — with no `package.json` there, the installer has nothing to install. `package.json`, dev configs, and `marketplace.json` stay at the repo root; npm `bin`/`files` now point at `plugin/src/`. No behavior change to the rendered bar.
+
+### Added
+- **The `peak` segment now shows when the window closes and when the next one opens (CREAM-scwwzbxh).** Inside the faster-drain window it reads `peak until HH:MM` — the close time in your **local** timezone, not PT — so you can see how long the elevated drain lasts. In the hour before the window opens it counts down `peak in Nm`. The new `peak.lead` config key sets how many minutes ahead the countdown appears (default `60`). Previously the segment showed only the bare word `peak` while in-window and nothing otherwise.
+
 ## [0.3.4] — 2026-05-31
 
 ### Changed

package/README.md

@@ -19,23 +19,25 @@ With all segments enabled:
 
 ```
 ctx:21% [43k] | cache:99% | write:2% | ttl:60 | effort:high | think:on | ∿ api:74% | ~$0.23
-5h:13% ↺2h57m | ~3h12m | 7d:6% ↺Sat 21:00 | peak
+5h:13% ↺2h57m | ~3h12m | 7d:6% ↺Sat 21:00 | peak until 11:00
 Sonnet 4.6 | My project session
 ```
 
-**Row 1 — this session:** context-window fill, cache hit rate, TTL countdown, session cost. Optional: cache write rate, effort level, thinking mode, API time ratio.
+**Row 1 — this session:** context-window fill, cache hit rate, TTL countdown, session cost, cache write rate, effort level, thinking mode, API time ratio.
 
 **Row 2 — rate-limit budgets:** 5h and 7d window usage with reset countdowns and a burn-rate projection. Hidden for API users.
 
 **Row 3 — identity:** model name and session name.
 
+Use `--hide` to remove any segments you don't need: `/cc-cream:setup --hide write,api_ratio,thinking`.
+
 ## Features
 
 **Cache health.** `cache` shows your hit rate each turn and turns red when it drops sharply — the only signal you'll get that a compaction, a far-back edit, or a large tool result just invalidated your cache prefix. `ttl` counts down to when the cache goes cold, turning amber then red as the window closes. Supports both 5-minute (API) and 60-minute (subscriber) TTLs, auto-detected.
 
 **Rate-limit budgets.** `5h` and `7d` show how much of your rolling usage is gone and when each window resets. `burn` adds a live projection based on your current pace — useful before committing to a long agent run.
 
-**Peak hours.** Anthropic's rate-limit drain accelerates Mon–Fri during Pacific business hours. The `peak` segment lights up when you're in that window so you can pace yourself accordingly. No other Claude Code status tool surfaces this.
+**Peak hours.** Anthropic's rate-limit drain accelerates Mon–Fri during Pacific business hours. The `peak` segment tells you when the current window closes (`peak until 11:00`, in your local time) while you're in it, and counts down to the next one (`peak in 47m`) in the hour before it opens — so you can pace yourself or wait it out. No other Claude Code status tool surfaces this.
 
 **Context window.** `ctx` shows occupancy and input-token magnitude. On large-context models where "50% of window" still means 500k tokens, you can set a fixed-token ceiling instead — warnings fire at the same absolute count regardless of window size.
 
@@ -60,7 +62,7 @@ macOS and Linux. Windows is a planned fast-follow.
 ### Option 1 — Claude Code plugin (recommended)
 
 ```bash
-/plugin marketplace add bart-turczynski/cc-cream
+/plugin marketplace add bart-turczynski/claude-plugins
 /plugin install cc-cream
 ```
 
@@ -91,7 +93,7 @@ Download or clone the repository, then run the consent installer:
 
 ```bash
 git clone https://github.com/bart-turczynski/cc-cream.git
-node cc-cream/src/install.js
+node cc-cream/plugin/src/install.js
 ```
 
 The installer detects an existing `statusLine` and asks before replacing it, preserves any `padding` you have set, and is idempotent.
@@ -117,9 +119,50 @@ Add `--purge` to either to also remove your `~/.claude/cc-cream.json` config. Se
 
 ## Configuration
 
-Every display decision is driven by `~/.claude/cc-cream.json`. You don't have to edit it by hand — just ask Claude to toggle segments, flip how percentages are counted, or adjust thresholds. The defaults are based on what the data and community experience suggest are reasonable starting points.
+### Toggle segments
+
+**Plugin users** — pass flags directly to `/cc-cream:setup`:
+```
+/cc-cream:setup --hide 5h,7d,peak
+/cc-cream:setup --show all --hide peak
+/cc-cream:setup --show effort,thinking
+```
+
+**npm / manual users** — same flags via `cc-cream-setup`:
+```bash
+cc-cream-setup --hide 5h,7d,peak
+cc-cream-setup --show all
+```
+
+`--show all` re-enables everything. `--hide` overrides `--show` when both name the same segment. Valid segment names: `ctx` `cache` `write` `ttl` `effort` `thinking` `api_ratio` `cost` `5h` `7d` `burn` `peak` `model` `session_name`.
+
+### Set config values
+
+`--set key=value` sets any config field. Multiple `--set` flags are allowed in one call.
+
+```
+# flip percentage direction
+/cc-cream:setup --set percentage=remaining
+
+# set a fixed-token ceiling for ctx warnings (useful on large-context models)
+/cc-cream:setup --set ctx.basis=ceiling --set ctx.ceiling=100000
+
+# tighten color thresholds
+/cc-cream:setup --set ctx.amber=20 --set ctx.orange=30 --set ctx.red=40
+
+# adjust rate-limit warning bands
+/cc-cream:setup --set 5h.amber=80 --set 5h.red=95
+```
+
+npm / manual users replace `/cc-cream:setup` with `cc-cream-setup`.
+
+Top-level keys: `percentage` (`consumed`|`remaining`), `numbers` (`compact`|`exact`), `ttl` (`auto`|`60`|`5`). Per-segment dot-paths: `segment.field` — e.g. `ctx.ceiling`, `ctx.basis`, `5h.amber`. Full field reference in [CONFIGURATION.md](CONFIGURATION.md).
+
+The flags write to `~/.claude/cc-cream.json`; the bar reflects the change on the next render.
+
+### Fine-tuning
 
-If you do edit by hand, run the doctor afterward to catch typos:
+Every display decision is also configurable by hand in `~/.claude/cc-cream.json` — thresholds, row assignments, color bands, TTL mode, and more. Run the doctor after editing to catch typos:
 ```bash
 cc-cream-setup --check-config
 ```

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "cc-cream",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "See cache health, context fill, token burn, rate limits, and peak hours in Claude Code CLI. The status line for tokenminning - cache rules everything around me - dolla, dolla bill, y'all.",
   "directories": {
     "doc": "docs"
   },
   "scripts": {
-    "lint": "biome lint src/ hooks/",
+    "lint": "biome lint plugin/src/ plugin/hooks/",
     "knip": "knip",
-    "validate": "command -v claude >/dev/null 2>&1 && claude plugin validate . || echo 'cc-cream: claude CLI not found — skipping plugin validation'",
-    "pretest": "npm run lint && npm run knip && npm run validate",
+    "validate": "command -v claude >/dev/null 2>&1 && claude plugin validate plugin || echo 'cc-cream: claude CLI not found — skipping plugin validation'",
+    "pretest": "pnpm run lint && pnpm run knip && pnpm run validate",
     "test": "cucumber-js",
     "test:manual": "cucumber-js --profile manual",
     "test:cli": "cucumber-js --profile cli",
-    "coverage": "c8 cucumber-js",
+    "coverage": "c8 --check-coverage --lines 90 cucumber-js",
     "watch": "cucumber-js --watch",
     "hooks": "simple-git-hooks",
     "release": "node scripts/release.mjs",
-    "prepublishOnly": "npm test"
+    "prepublishOnly": "pnpm test"
   },
   "simple-git-hooks": {
-    "pre-push": "npm run coverage"
+    "pre-push": "pnpm run coverage"
   },
   "bin": {
-    "cc-cream": "src/cc-cream.js",
-    "cc-cream-setup": "src/install.js"
+    "cc-cream": "plugin/src/cc-cream.js",
+    "cc-cream-setup": "plugin/src/install.js"
   },
   "files": [
-    "src/",
+    "plugin/src/",
     "LICENSE",
     "README.md",
     "CHANGELOG.md"
@@ -47,8 +47,9 @@
   "author": "Bart Turczynski <support@spoonkeyworks.com>",
   "license": "MIT",
   "type": "module",
+  "packageManager": "pnpm@11.3.0",
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "repository": {
     "type": "git",
@@ -64,8 +65,5 @@
     "c8": "^11.0.0",
     "knip": "^6.14.2",
     "simple-git-hooks": "^2.13.1"
-  },
-  "overrides": {
-    "yargs": "^18.0.0"
   }
 }

package/{src → plugin/src}/cc-cream.js

@@ -4,11 +4,11 @@
 // <=3-row bar. Hard rule: degrade, never crash.
 
 import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { loadConfig, readConfigFile } from './config.js';
+import { isOrphanedPluginRun } from './orphan.js';
+import { PATHS } from './paths.js';
 import { buildSegments, render } from './render.js';
 import {
   getSessionState,
@@ -82,7 +82,7 @@ const debugEnabled = (env) => {
 };
 
 function writeDebug(env, lines) {
-  const file = env.CC_CREAM_DEBUG_LOG || path.join(os.homedir(), '.claude', 'cc-cream-debug.log');
+  const file = env.CC_CREAM_DEBUG_LOG || PATHS.debugLog();
   try {
     fs.appendFileSync(file, `${lines.join('\n')}\n`);
   } catch {
@@ -107,82 +107,15 @@ function logDebug(env, { data, cfg, now, prevSessionState, sessionId, rawLen, tt
   ]);
 }
 
-// --- Ghost-bar self-defense (CREAM-uchemxln) --------------------------------
-// No Claude Code host removal path deletes our statusLine OR the version cache:
-// `/plugin uninstall` and `/plugin marketplace remove` both leave the cache tree
-// AND the statusLine in settings.json. So a plugin-cache copy of this renderer
-// keeps executing every session after the plugin is gone — a zombie bar the user
-// has no in-product way to stop (`/cc-cream:uninstall` deregisters with the
-// plugin). The shell `[ -f entrypoint ] || exit 0` guard in install.js can't
-// cover this: the cache it checks for is never GC'd, so the file never goes
-// missing. The reliable signal is the host registry, not the filesystem — when we
-// detect we're running FROM the plugin cache, confirm cc-cream is still listed in
-// installed_plugins.json; if it's gone, exit 0 silently.
-
-function realpathOr(p) {
-  try {
-    return fs.realpathSync(p);
-  } catch {
-    return path.resolve(p);
-  }
-}
-
-// If `selfPath` lives under `<root>/plugins/cache/<marketplace>/<plugin>/...`,
-// return { pluginsDir, pluginHome }; otherwise null (a manual/dev install, which
-// is never a cache orphan). Both paths are derived from the running location, so
-// the registry we consult is the one that actually governs THIS install — no
-// os.homedir()/CLAUDE_CONFIG_DIR assumption.
-function pluginCacheLocation(selfPath) {
-  const segs = realpathOr(selfPath).split(path.sep);
-  for (let i = 0; i + 3 < segs.length; i++) {
-    if (segs[i] === 'plugins' && segs[i + 1] === 'cache') {
-      return {
-        pluginsDir: segs.slice(0, i + 1).join(path.sep),
-        pluginHome: segs.slice(0, i + 4).join(path.sep),
-      };
-    }
-  }
-  return null;
-}
-
-function isWithin(parent, child) {
-  const rel = path.relative(parent, child);
-  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
-}
-
-// True when this renderer is a plugin-cache orphan: running from the cache while
-// cc-cream is absent from the host's installed_plugins.json. Cost is one tiny
-// read, and ONLY on the plugin-cache path — manual/dev installs return early
-// before touching the disk. A missing registry (ENOENT) counts as orphaned; any
-// other read/parse failure is treated as not-orphaned, so a transient glitch can
-// never suppress a legitimately wired bar.
-function isOrphanedPluginRun(selfPath) {
-  const loc = pluginCacheLocation(selfPath);
-  if (!loc) return false;
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(path.join(loc.pluginsDir, 'installed_plugins.json'), 'utf8'));
-  } catch (err) {
-    return err?.code === 'ENOENT';
-  }
-  const plugins = parsed && typeof parsed === 'object' ? parsed.plugins : null;
-  if (!plugins || typeof plugins !== 'object') return true;
-  const home = realpathOr(loc.pluginHome);
-  for (const entries of Object.values(plugins)) {
-    if (!Array.isArray(entries)) continue;
-    for (const entry of entries) {
-      if (entry && typeof entry.installPath === 'string' && isWithin(home, realpathOr(entry.installPath))) {
-        return false; // an installed cc-cream entry lives in our cache subtree
-      }
-    }
-  }
-  return true;
-}
-
 async function main() {
   // Self-suppress a zombie bar left behind by an uninstalled plugin (before any
   // stdin read — matching the intent of install.js's now-dead `[ -f ]` guard).
-  if (isOrphanedPluginRun(fileURLToPath(import.meta.url))) process.exit(0);
+  // Also clean up the stale session state so it doesn't linger after a
+  // wrong-order `/plugin uninstall` (cache kept, /cc-cream:uninstall skipped).
+  if (isOrphanedPluginRun(fileURLToPath(import.meta.url))) {
+    try { fs.rmSync(PATHS.stateFile(), { force: true }); } catch { /* ignore */ }
+    process.exit(0);
+  }
 
   const raw = await readStdin();
   const data = parseSession(raw);
@@ -190,7 +123,7 @@ async function main() {
   const now = nowFromEnv(process.env);
 
   const sessionId = typeof data.session_id === 'string' && data.session_id ? data.session_id : null;
-  const stateFile = path.join(os.homedir(), '.claude', 'cc-cream-state.json');
+  const stateFile = PATHS.stateFile();
   const state = sessionId ? readState(stateFile) : {};
   const prevSessionState = getSessionState(state, sessionId);
 

package/{src → plugin/src}/config.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import { DEFAULTS } from './defaults.js';
+import { PATHS } from './paths.js';
 import { clone, isNum, numOr } from './utils.js';
 
 // Each normalizer is `(value, fallback) => value | fallback`: it returns the
@@ -48,6 +47,7 @@ const SEGMENT_FIELDS = {
   display: ctxDisplayOr,
   start: hourOr,
   end: hourOr,
+  lead: posOr,
 };
 
 function mergeConfig(parsed) {
@@ -140,9 +140,50 @@ export function checkConfig(parsed) {
   return problems;
 }
 
+// Coerce a CLI string to the JS value a normalizer expects.
+function coerceValue(str) {
+  if (str === 'true') return true;
+  if (str === 'false') return false;
+  const n = Number(str);
+  return !Number.isNaN(n) && str.trim() !== '' ? n : str;
+}
+
+// Validate and normalize a single dot-path assignment from the CLI.
+// dotPath: "percentage" (top-level) or "ctx.ceiling" (segment.field).
+// rawValue: the string the user passed; coerced before normalization.
+// Returns { ok: true, value } or { ok: false, error }.
+export function normalizeConfigField(dotPath, rawValue) {
+  const INVALID = Symbol('invalid');
+  const coerced = coerceValue(rawValue);
+  const parts = dotPath.split('.');
+
+  if (parts.length === 1) {
+    const [key] = parts;
+    const norm = TOP_LEVEL[key];
+    if (!norm) return { ok: false, error: `unknown config key: "${key}"` };
+    const v = norm(coerced, INVALID);
+    if (v === INVALID) return { ok: false, error: `invalid value for "${key}": ${JSON.stringify(rawValue)}` };
+    return { ok: true, value: v };
+  }
+
+  if (parts.length === 2) {
+    const [segId, field] = parts;
+    if (!DEFAULTS.segments[segId]) return { ok: false, error: `unknown segment: "${segId}"` };
+    const segDef = DEFAULTS.segments[segId];
+    if (!(field in segDef)) return { ok: false, error: `unknown field "${field}" on segment "${segId}"` };
+    const norm = SEGMENT_FIELDS[field];
+    if (!norm) return { ok: false, error: `unsettable field: "${field}"` };
+    const v = norm(coerced, INVALID);
+    if (v === INVALID) return { ok: false, error: `invalid value for "${segId}.${field}": ${JSON.stringify(rawValue)}` };
+    return { ok: true, value: v };
+  }
+
+  return { ok: false, error: `invalid key path "${dotPath}" — use "key" for top-level or "segment.field" for per-segment` };
+}
+
 export function readConfigFile() {
   try {
-    return fs.readFileSync(path.join(os.homedir(), '.claude', 'cc-cream.json'), 'utf8');
+    return fs.readFileSync(PATHS.configFile(), 'utf8');
   } catch {
     return null;
   }

package/{src → plugin/src}/defaults.js

@@ -19,16 +19,18 @@ export const DEFAULTS = {
     cost:     { on: true,  row: 1, order: 5 },
     '5h':     { on: true,  row: 2, order: 1, amber: 75, red: 90 },
     '7d':     { on: true,  row: 2, order: 2, amber: 75, red: 90 },
-    // peak: amber "peak" word during Anthropic's faster-drain window (PRDv2 §2).
-    // start/end are Pacific-time hours (0–23, exclusive end); weekday (Mon–Fri)
-    // and the America/Los_Angeles timezone are hardcoded policy facts, not config.
-    peak:     { on: true,  row: 2, order: 3, start: 5, end: 11 },
+    // peak: amber peak-window indicator (PRDv2 §2). start/end are Pacific-time
+    // hours (0–23, exclusive end); weekday (Mon–Fri) and the America/Los_Angeles
+    // timezone are hardcoded policy facts, not config. Inside the window it reads
+    // "peak until HH:MM" (local close time); the `lead` minutes before it opens it
+    // counts down "peak in Nm".
+    peak:     { on: true,  row: 2, order: 3, start: 5, end: 11, lead: 60 },
     burn:         { on: true,  row: 2, order: 1.5 },
-    effort:       { on: false, row: 1, order: 6 },
-    thinking:     { on: false, row: 1, order: 7 },
-    api_ratio:    { on: false, row: 1, order: 8 },
-    session_name: { on: false, row: 3, order: 1 },
-    write:        { on: false, row: 1, order: 3.5 },
+    effort:       { on: true, row: 1, order: 6 },
+    thinking:     { on: true, row: 1, order: 7 },
+    api_ratio:    { on: true, row: 1, order: 8 },
+    session_name: { on: true, row: 3, order: 1 },
+    write:        { on: true, row: 1, order: 3.5 },
   },
 };
 

package/{src → plugin/src}/install.js

@@ -10,12 +10,13 @@
 
 import { execSync } from 'node:child_process';
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
 import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
-import { checkConfig } from './config.js';
+import { checkConfig, normalizeConfigField } from './config.js';
+import { DEFAULTS } from './defaults.js';
+import { PATHS } from './paths.js';
 import { isSafeToWrite, readSettings as readSettingsFile, writeFileAtomic } from './settings.js';
 import { isEntrypoint } from './utils.js';
 
@@ -50,8 +51,22 @@ const TRUST_NOTE =
 // statusLine outlives the deleted cache. Without it, node would crash with
 // MODULE_NOT_FOUND on every render. "Degrade, never crash" (CLAUDE.md). `exec`
 // replaces the shell so stdin/stdout pass straight through to the renderer.
+
+// Escape a path for safe embedding inside a "double-quoted" POSIX shell word.
+// The paths here aren't third-party-controlled — they're the user's own install
+// location (os.homedir() + the resolved node binary) — but a home dir or node
+// path containing `"`, `$`, a backtick, or `\` would otherwise break the command
+// or let the shell expand/execute part of it. These four are the only characters
+// special inside double quotes; backslash-escaping them neutralizes the lot while
+// leaving every ordinary path byte-for-byte unchanged (so no command churn).
+function shDquote(s) {
+  return String(s).replace(/(["$`\\])/g, '\\$1');
+}
+
 export function statusLineCommand(nodePath, entrypoint) {
-  return `[ -f "${entrypoint}" ] || exit 0; exec "${nodePath}" "${entrypoint}"`;
+  const ep = shDquote(entrypoint);
+  const node = shDquote(nodePath);
+  return `[ -f "${ep}" ] || exit 0; exec "${node}" "${ep}"`;
 }
 
 // `desired` is considered already installed if it matches the planned command
@@ -68,16 +83,23 @@ function isInstalled(existing, command) {
 }
 
 // True if an existing statusLine belongs to cc-cream under ANY install strategy
-// (dev repo, copied home runtime, or the plugin cache-glob) — every command
-// references the cc-cream entrypoint. Used by uninstall so we never touch a
-// statusLine the user wired for something else.
+// (dev repo, copied home runtime, or the plugin cache) — every strategy points
+// the command at an entrypoint whose basename is `cc-cream.js`. We match that
+// filename rather than the bare substring `cc-cream`: the loose match would also
+// claim a FOREIGN statusLine that merely mentions the string (a comment, an
+// unrelated arg, a directory called cc-cream), and the whole consent flow exists
+// precisely so we never touch a line the user wired for something else. Matching
+// the entrypoint filename stays strategy-agnostic (it's invariant across dev /
+// home-copy / plugin-cache) without over-fitting to the `[ -f … ] || exit 0`
+// wrapper, so it still recognizes older command shapes. Used by uninstall and by
+// the consent gate in plan().
 export function isCcCreamStatusLine(existing) {
   return (
     !!existing &&
     typeof existing === 'object' &&
     existing.type === 'command' &&
     typeof existing.command === 'string' &&
-    existing.command.includes('cc-cream')
+    existing.command.includes('cc-cream.js')
   );
 }
 
@@ -146,17 +168,134 @@ export function plan(settings, { entrypoint, consent, nodePath } = {}) {
   return { settings: { ...s, statusLine: desired }, changed: true, messages, needsConsent: hasForeign };
 }
 
-// ---------------------------------------------------------------------------
-// CLI wrapper.
-// ---------------------------------------------------------------------------
-function settingsPath() {
-  return path.join(os.homedir(), '.claude', 'settings.json');
+// Decide what to do for --show / --hide segment config. Pure: no I/O.
+// `show` and `hide` are arrays of segment IDs (or ['all']); hide overrides show.
+// Returns { config, changed, messages, problems }.
+export function planConfigure(currentRaw, { show = [], hide = [] } = {}) {
+  const ALL = Object.keys(DEFAULTS.segments);
+  const messages = [];
+  const problems = [];
+
+  const showIds = show.includes('all') ? ALL : show;
+  const hideIds = hide.includes('all') ? ALL : hide;
+
+  for (const id of new Set([...showIds, ...hideIds])) {
+    if (!DEFAULTS.segments[id]) problems.push(`unknown segment: "${id}"`);
+  }
+  if (problems.length) {
+    for (const p of problems) messages.push(p);
+    return { config: null, changed: false, messages, problems };
+  }
+
+  let parsed = {};
+  if (currentRaw != null) {
+    try { parsed = JSON.parse(currentRaw); } catch { /* start fresh */ }
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) parsed = {};
+
+  const existingSegs =
+    parsed.segments && typeof parsed.segments === 'object' && !Array.isArray(parsed.segments)
+      ? parsed.segments
+      : {};
+  const segs = { ...existingSegs };
+
+  // hide overrides show: last writer wins in target map
+  const target = {};
+  for (const id of showIds) target[id] = true;
+  for (const id of hideIds) target[id] = false;
+
+  let changed = false;
+  for (const [id, on] of Object.entries(target)) {
+    const existing = segs[id];
+    const currentOn =
+      existing && typeof existing === 'object' && 'on' in existing
+        ? existing.on
+        : DEFAULTS.segments[id].on;
+    if (currentOn !== on) {
+      segs[id] = { ...(existing || {}), on };
+      changed = true;
+      messages.push(`${on ? 'Showing' : 'Hiding'} segment "${id}".`);
+    }
+  }
+
+  if (!changed) {
+    messages.push('Already configured — no changes needed.');
+    return { config: parsed, changed: false, messages, problems: [] };
+  }
+  return { config: { ...parsed, segments: segs }, changed: true, messages, problems: [] };
 }
 
-function destinationPath() {
-  return path.join(os.homedir(), '.claude', 'cc-cream', 'cc-cream.js');
+// Apply one or more "key=value" assignments to ~/.claude/cc-cream.json. Pure: no I/O.
+// assignments: array of strings like ["percentage=remaining", "ctx.ceiling=100000"].
+// Supports top-level keys and "segment.field" dot-paths.
+// Returns { config, changed, messages, problems }.
+export function planSet(currentRaw, assignments) {
+  const messages = [];
+  const problems = [];
+
+  const parsed_pairs = [];
+  for (const a of assignments) {
+    const eq = a.indexOf('=');
+    if (eq === -1) {
+      problems.push(`invalid assignment "${a}" — expected key=value`);
+      continue;
+    }
+    const dotPath = a.slice(0, eq).trim();
+    const rawValue = a.slice(eq + 1).trim();
+    const result = normalizeConfigField(dotPath, rawValue);
+    if (!result.ok) {
+      problems.push(result.error);
+    } else {
+      parsed_pairs.push({ dotPath, value: result.value });
+    }
+  }
+
+  if (problems.length) {
+    for (const p of problems) messages.push(p);
+    return { config: null, changed: false, messages, problems };
+  }
+
+  let cfg = {};
+  if (currentRaw != null) {
+    try { cfg = JSON.parse(currentRaw); } catch { /* start fresh */ }
+  }
+  if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) cfg = {};
+
+  let changed = false;
+  for (const { dotPath, value } of parsed_pairs) {
+    const parts = dotPath.split('.');
+    if (parts.length === 1) {
+      const [key] = parts;
+      if (cfg[key] !== value) {
+        cfg = { ...cfg, [key]: value };
+        changed = true;
+        messages.push(`Set ${key} = ${JSON.stringify(value)}.`);
+      }
+    } else {
+      const [segId, field] = parts;
+      const segs = cfg.segments && typeof cfg.segments === 'object' && !Array.isArray(cfg.segments)
+        ? { ...cfg.segments }
+        : {};
+      const seg = segs[segId] && typeof segs[segId] === 'object' ? { ...segs[segId] } : {};
+      if (seg[field] !== value) {
+        seg[field] = value;
+        segs[segId] = seg;
+        cfg = { ...cfg, segments: segs };
+        changed = true;
+        messages.push(`Set ${segId}.${field} = ${JSON.stringify(value)}.`);
+      }
+    }
+  }
+
+  if (!changed) {
+    messages.push('Already configured — no changes needed.');
+  }
+  return { config: cfg, changed, messages, problems: [] };
 }
 
+// ---------------------------------------------------------------------------
+// CLI wrapper.
+// ---------------------------------------------------------------------------
 // Read settings.json safely for the CLI. A MISSING or empty file -> {} (fresh
 // start, nothing to lose); a valid object is returned as-is. Any other state
 // (corrupt JSON, a non-object, or an unreadable file) is REFUSED: we exit rather
@@ -231,7 +370,7 @@ function ask(question) {
 // additionally removes the one file worth keeping by default: the user-authored
 // config (~/.claude/cc-cream.json).
 async function uninstall({ purge }) {
-  const file = settingsPath();
+  const file = PATHS.settingsFile();
   const settings = readSettings(file);
   const result = planUninstall(settings);
   for (const m of result.messages) console.log(m);
@@ -240,11 +379,10 @@ async function uninstall({ purge }) {
     console.log(`Updated ${file}.`);
   }
 
-  const home = path.join(os.homedir(), '.claude');
-  const configFile = path.join(home, 'cc-cream.json');
+  const configFile = PATHS.configFile();
 
   // Auto-clean regenerable scratch (not user data — no prompt).
-  const scratch = [path.join(home, 'cc-cream'), path.join(home, 'cc-cream-state.json')]
+  const scratch = [PATHS.runtimeDir(), PATHS.stateFile()]
     .filter((p) => fs.existsSync(p));
   for (const p of scratch) fs.rmSync(p, { recursive: true, force: true });
   if (scratch.length) console.log('Removed the copied runtime and session state.');
@@ -264,7 +402,7 @@ async function uninstall({ purge }) {
 // Shorten an absolute path under $HOME to a `~/…` form for display. The shell
 // still expands `~`, so the result stays copy-pasteable.
 function tildeify(p) {
-  const home = os.homedir();
+  const home = PATHS.homeDir();
   return p === home || p.startsWith(`${home}/`) ? `~${p.slice(home.length)}` : p;
 }
 
@@ -293,7 +431,7 @@ function printUninstallReceipt() {
 // config schema, reporting unknown keys and out-of-domain values (which the
 // renderer silently ignores). Exits non-zero when problems are found.
 function checkConfigCli() {
-  const file = path.join(os.homedir(), '.claude', 'cc-cream.json');
+  const file = PATHS.configFile();
   if (!fs.existsSync(file)) {
     console.log(`No config at ${file} — cc-cream uses its defaults. Nothing to check.`);
     return;
@@ -345,13 +483,13 @@ function readJsonSafe(file) {
 // can't otherwise tell whether cc-cream fully went away — this command answers
 // "clean slate?" in one shot, and points out what the host left behind.
 function statusCli() {
-  const home = path.join(os.homedir(), '.claude');
+  const home = PATHS.claudeDir();
   const plugins = path.join(home, 'plugins');
   const items = [];
   const add = (label, present, detail) => items.push({ label, present, detail });
 
   // statusLine wiring
-  const { state, value } = readSettingsFile(settingsPath());
+  const { state, value } = readSettingsFile(PATHS.settingsFile());
   if (!isSafeToWrite(state)) {
     add('statusLine wiring', false, `settings.json unreadable (${state}) — not inspected`);
   } else if (isCcCreamStatusLine(value.statusLine)) {
@@ -397,7 +535,7 @@ function statusCli() {
   add('auto-wire marker', !!marker, marker || 'none');
 
   // session state
-  const stateFile = path.join(home, 'cc-cream-state.json');
+  const stateFile = PATHS.stateFile();
   if (fs.existsSync(stateFile)) {
     const obj = readJsonSafe(stateFile);
     const n = obj && typeof obj === 'object' ? Object.keys(obj).length : '?';
@@ -407,11 +545,11 @@ function statusCli() {
   }
 
   // config
-  const configFile = path.join(home, 'cc-cream.json');
+  const configFile = PATHS.configFile();
   add('config', fs.existsSync(configFile), fs.existsSync(configFile) ? configFile : 'none (using defaults)');
 
   // manual runtime copy
-  const runtimeDir = path.join(home, 'cc-cream');
+  const runtimeDir = PATHS.runtimeDir();
   add('manual runtime copy', fs.existsSync(runtimeDir), fs.existsSync(runtimeDir) ? runtimeDir : 'none');
 
   console.log('cc-cream footprint:');
@@ -427,6 +565,62 @@ function statusCli() {
   console.log('  then rm -rf ~/.claude/plugins/cache/cc-cream (the host never removes it).');
 }
 
+function allArgVals(args, flag) {
+  const results = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === flag && i + 1 < args.length) {
+      results.push(args[i + 1]);
+      i++;
+    }
+  }
+  return results;
+}
+
+function argVal(args, flag) {
+  const i = args.indexOf(flag);
+  return i !== -1 && i + 1 < args.length ? args[i + 1] : null;
+}
+
+function splitIds(val) {
+  return val ? val.split(',').map((s) => s.trim()).filter(Boolean) : [];
+}
+
+async function setCli(assignments) {
+  const file = PATHS.configFile();
+  let raw = null;
+  try { raw = fs.readFileSync(file, 'utf8'); } catch { /* not found is fine */ }
+
+  const result = planSet(raw, assignments);
+  for (const m of result.messages) console.log(m);
+  if (result.problems.length) {
+    process.exit(1);
+    return;
+  }
+  if (result.changed) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    writeFileAtomic(file, `${JSON.stringify(result.config, null, 2)}\n`);
+    console.log(`\nWrote ${file}.`);
+  }
+}
+
+async function configureCli({ show, hide }) {
+  const file = PATHS.configFile();
+  let raw = null;
+  try { raw = fs.readFileSync(file, 'utf8'); } catch { /* not found is fine */ }
+
+  const result = planConfigure(raw, { show, hide });
+  for (const m of result.messages) console.log(m);
+  if (result.problems.length) {
+    process.exit(1);
+    return;
+  }
+  if (result.changed) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    writeFileAtomic(file, `${JSON.stringify(result.config, null, 2)}\n`);
+    console.log(`\nWrote ${file}.`);
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
   if (args.includes('--status')) {
@@ -441,12 +635,24 @@ async function main() {
     await uninstall({ purge: args.includes('--purge') });
     return;
   }
+  const showArg = argVal(args, '--show');
+  const hideArg = argVal(args, '--hide');
+  if (showArg !== null || hideArg !== null) {
+    await configureCli({ show: splitIds(showArg), hide: splitIds(hideArg) });
+    return;
+  }
+  const setArgs = allArgVals(args, '--set');
+  if (setArgs.length > 0) {
+    const assignments = setArgs.flatMap((v) => v.split(',').map((s) => s.trim()).filter(Boolean));
+    await setCli(assignments);
+    return;
+  }
   const plugin = args.includes('--plugin');
   const force = args.includes('--force') || args.includes('--yes');
   // First non-flag arg is an optional local source path (manual mode only).
   const positional = args.filter((a) => !a.startsWith('--'));
 
-  const file = settingsPath();
+  const file = PATHS.settingsFile();
   const settings = readSettings(file);
 
   // planOpts holds the entrypoint + node path the command bakes in.
@@ -470,7 +676,7 @@ async function main() {
       process.exit(1);
     }
 
-    const dest = destinationPath();
+    const dest = PATHS.runtimeEntry();
     const destDir = path.dirname(dest);
     if (copyRuntimeFiles(sourceFile, destDir)) {
       console.log(`Copied cc-cream runtime files to ${destDir}`);

package/plugin/src/orphan.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+function realpathOr(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+}
+
+// If `selfPath` lives under `<root>/plugins/cache/<marketplace>/<plugin>/...`,
+// return { pluginsDir, pluginHome }; otherwise null (manual/dev install, never
+// a cache orphan). Both paths derive from the running location so the registry
+// we consult is the one governing THIS install — no os.homedir() assumption.
+function pluginCacheLocation(selfPath) {
+  const segs = realpathOr(selfPath).split(path.sep);
+  for (let i = 0; i + 3 < segs.length; i++) {
+    if (segs[i] === 'plugins' && segs[i + 1] === 'cache') {
+      return {
+        pluginsDir: segs.slice(0, i + 1).join(path.sep),
+        pluginHome: segs.slice(0, i + 4).join(path.sep),
+      };
+    }
+  }
+  return null;
+}
+
+function isWithin(parent, child) {
+  const rel = path.relative(parent, child);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+// True when this renderer is a plugin-cache orphan: running from the cache while
+// cc-cream is absent from the host's installed_plugins.json. Cost is one tiny
+// read, and ONLY on the plugin-cache path — manual/dev installs return early
+// before touching the disk. A missing registry (ENOENT) counts as orphaned; any
+// other read/parse failure is treated as not-orphaned, so a transient glitch can
+// never suppress a legitimately wired bar.
+export function isOrphanedPluginRun(selfPath) {
+  const loc = pluginCacheLocation(selfPath);
+  if (!loc) return false;
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(path.join(loc.pluginsDir, 'installed_plugins.json'), 'utf8'));
+  } catch (err) {
+    return err?.code === 'ENOENT';
+  }
+  const plugins = parsed && typeof parsed === 'object' ? parsed.plugins : null;
+  if (!plugins || typeof plugins !== 'object') return true;
+  const home = realpathOr(loc.pluginHome);
+  for (const entries of Object.values(plugins)) {
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (entry && typeof entry.installPath === 'string' && isWithin(home, realpathOr(entry.installPath))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}

package/plugin/src/paths.js

@@ -0,0 +1,16 @@
+import os from 'node:os';
+import path from 'node:path';
+
+const homeDir = () => os.homedir();
+const claudeDir = () => path.join(homeDir(), '.claude');
+
+export const PATHS = {
+  homeDir,
+  claudeDir,
+  configFile: () => path.join(claudeDir(), 'cc-cream.json'),
+  stateFile: () => path.join(claudeDir(), 'cc-cream-state.json'),
+  debugLog: () => path.join(claudeDir(), 'cc-cream-debug.log'),
+  settingsFile: () => path.join(claudeDir(), 'settings.json'),
+  runtimeDir: () => path.join(claudeDir(), 'cc-cream'),
+  runtimeEntry: () => path.join(claudeDir(), 'cc-cream', 'cc-cream.js'),
+};

package/{src → plugin/src}/segments.js

@@ -1,4 +1,4 @@
-import { band, countdown, flipPct, fmtNum, isNum, isPeak, numOr, pad2 } from './utils.js';
+import { band, countdown, flipPct, fmtNum, isNum, localHM, numOr, pad2, peakStatus } from './utils.js';
 import { hasWindow } from './ttl.js';
 
 function magnitudeTokens(cw) {
@@ -125,8 +125,12 @@ function segCacheWrite(data) {
 function segPeak(data, cfg, now, tz) {
   // peak rides the account-budget row, so it shows only when that row has windows.
   if (!hasWindow(data?.rate_limits)) return null;
-  if (!isPeak(now, cfg, tz)) return null;
-  return { text: 'peak', color: 'amber' };
+  const st = peakStatus(now, cfg, tz);
+  if (!st) return null;
+  const text = st.state === 'approaching'
+    ? `peak in ${st.startsInMin}m`        // counting down to the window opening
+    : `peak until ${localHM(st.endsAtMs)}`; // inside it: local clock time it closes
+  return { text, color: 'amber' };
 }
 
 function segBurn(fiveHour, prev, now) {

package/{src → plugin/src}/utils.js

@@ -75,24 +75,48 @@ export const flipPct = (consumedShown, cfg) => (
   cfg.percentage === 'remaining' ? 100 - consumedShown : consumedShown
 );
 
-// True during Anthropic's faster-drain "peak" window (PRDv2 §2): a weekday
-// (Mon–Fri) within [start, end) Pacific-time hours.
-export function isPeak(now, cfg, tz = 'America/Los_Angeles') {
+// Resolve the "peak" window (PRDv2 §2) relative to `now`. Anthropic drains the
+// 5h budget faster on weekdays (Mon–Fri) within [start, end) Pacific-time hours.
+// Returns one of:
+//   { state: 'in',          endsAtMs }    — inside [start, end); endsAtMs is the
+//                                           window close as an epoch (format local)
+//   { state: 'approaching', startsInMin } — inside [start-lead, start)
+//   null                                  — off-window, weekend, or Intl failure
+// `lead` (minutes, default 60) is how early the approaching countdown appears.
+export function peakStatus(now, cfg, tz = 'America/Los_Angeles') {
   const s = cfg?.segments?.peak ?? {};
   const start = isNum(s.start) ? s.start : 5;
   const end = isNum(s.end) ? s.end : 11;
+  const lead = isNum(s.lead) && s.lead > 0 ? s.lead : 60;
   try {
     const parts = new Intl.DateTimeFormat('en-US', {
-      timeZone: tz, hour: 'numeric', hour12: false, weekday: 'short',
+      timeZone: tz, hour: 'numeric', minute: 'numeric', hour12: false, weekday: 'short',
     }).formatToParts(new Date(now));
     const p = Object.fromEntries(parts.map((x) => [x.type, x.value]));
-    const hour = Number(p.hour) % 24; // some ICU builds emit "24" for midnight
-    return !['Sat', 'Sun'].includes(p.weekday) && hour >= start && hour < end;
+    if (['Sat', 'Sun'].includes(p.weekday)) return null;
+    const ptMin = (Number(p.hour) % 24) * 60 + Number(p.minute); // some ICU builds emit "24" for midnight
+    const startMin = start * 60;
+    const endMin = end * 60;
+    if (ptMin >= startMin && ptMin < endMin) {
+      return { state: 'in', endsAtMs: now + (endMin - ptMin) * 60000 };
+    }
+    if (ptMin >= startMin - lead && ptMin < startMin) {
+      return { state: 'approaching', startsInMin: startMin - ptMin };
+    }
+    return null;
   } catch {
-    return false;
+    return null;
   }
 }
 
+// Back-compat predicate: true only inside the window itself (not while approaching).
+export const isPeak = (now, cfg, tz = 'America/Los_Angeles') => peakStatus(now, cfg, tz)?.state === 'in';
+
+// Wall-clock HH:MM in the host's local timezone (TZ-driven, like countdown's day branch).
+export const localHM = (ms) => new Date(ms).toLocaleTimeString(undefined, {
+  hour: '2-digit', minute: '2-digit', hour12: false,
+});
+
 // resets_at - now, on the §4.4 format ladder: >=1d -> "Fri 23:45", >=1h -> HhMMm, else MMm.
 export function countdown(resetsAt, now) {
   const t = toEpochMs(resetsAt);