@askviraj/ai-plugins 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Viraj Patel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/installer.js

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * @askviraj/ai-plugins — installs the powerline statusline into Claude Code.
+ *
+ * Single-command oclif CLI, plain JS (no build step). Run via:
+ *   npx @askviraj/ai-plugins --statusline --subagentstatusline [--yes]
+ */
+
+const { Command, Flags, execute, settings } = require("@oclif/core");
+const { existsSync } = require("node:fs");
+const { spawnSync } = require("node:child_process");
+
+// This is a plain-JS CLI (no TypeScript / ts-node). Tell oclif so it never tries
+// to auto-transpile, which otherwise warns "Could not find typescript".
+settings.enableAutoTranspile = false;
+const { chmod, copyFile, mkdir, readFile, writeFile } = require(
+  "node:fs/promises",
+);
+const { homedir } = require("node:os");
+const { delimiter, dirname, join } = require("node:path");
+const readline = require("node:readline/promises");
+
+const SCRIPTS_DIR = join(homedir(), ".claude", "scripts");
+const SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+const INSTALLED_SCRIPT = join(SCRIPTS_DIR, "statusline");
+const USER_CONFIG_PATH = join(homedir(), ".config", "statusline.json");
+const ASSETS_DIR = join(__dirname, "..", "tools", "statusline");
+
+// Written verbatim per docs/statusline.md. ${HOME} is expanded by the shell when
+// Claude Code runs the statusLine command.
+const COMMAND = "${HOME}/.claude/scripts/statusline";
+
+const STATUS_LINE = {
+  type: "command",
+  command: COMMAND,
+  padding: 0,
+  refreshInterval: 4,
+};
+
+const SUBAGENT_STATUS_LINE = {
+  type: "command",
+  command: COMMAND,
+};
+
+// GitHub shorthand passed to `claude plugin marketplace add`, and the marketplace
+// name it resolves to (used as `<plugin>@<name>` when installing).
+const MARKETPLACE_REF = "virajp/ai-plugins";
+const MARKETPLACE_NAME = "virajp-plugins";
+
+// All plugins published by the virajp-plugins marketplace.
+const PLUGINS = ["vwf", "typescript-lsp", "dart-lsp", "context7", "mempalace"];
+
+// Plugins that install at project scope by default; everything else is
+// user-scoped. The marketplace itself is always user-scoped.
+const PROJECT_SCOPED = new Set(["dart-lsp"]);
+const scopeFor = name => (PROJECT_SCOPED.has(name) ? "project" : "user");
+
+// How to install each external tool we depend on (matches this toolchain:
+// brew + mise drive the rest; rtk ships as a brew formula).
+const DEP_HINTS = {
+  brew:
+    "/bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"",
+  mise: "brew install mise",
+  claude: "mise use -g claude-code@latest",
+  rtk: "brew install --formulae rtk",
+  pnpm: "mise use -g pnpm@latest",
+  node: "mise use -g node@latest",
+  graphify: "mise use -g pipx:graphifyy@latest",
+};
+
+// Tools required whenever any plugin/marketplace install runs.
+const CORE_DEPS = ["brew", "mise", "claude"];
+
+// Extra tools specific plugins need: vwf ships an `rtk hook claude` Bash hook,
+// uses graphify, and pulls in context7, which runs its MCP server via pnpx (pnpm).
+const PLUGIN_EXTRA_DEPS = {
+  vwf: ["rtk", "pnpm", "graphify"],
+  context7: ["pnpm"],
+};
+
+class Installer extends Command {
+  async run() {
+    const { flags } = await this.parse(Installer);
+    const plan = this.resolvePlan(flags);
+
+    if (!plan.plugins.length && !plan.statusLine && !plan.subagentStatusLine) {
+      this.error(
+        "Nothing to do. Pass --all, --plugins, --plugin <name>, --statusline, and/or --subagentstatusline.",
+      );
+    }
+
+    this.checkDeps(plan);
+
+    if (plan.plugins.length) {
+      this.installPlugins(plan.plugins);
+    }
+
+    if (plan.statusLine || plan.subagentStatusLine) {
+      await this.installStatusline(plan, flags.yes);
+    }
+  }
+
+  // Turn the parsed flags into a concrete plan: which plugins to install and
+  // which statusline keys to set. --all is the superset of everything.
+  resolvePlan(flags) {
+    const all = flags.all;
+    let plugins;
+    if (all || flags.plugins) {
+      plugins = [...PLUGINS];
+    }
+    else if (flags.plugin?.length) {
+      const invalid = flags.plugin.filter(n => !PLUGINS.includes(n));
+      if (invalid.length) {
+        this.error(
+          `Unknown plugin(s): ${invalid.join(", ")}. Valid: ${
+            PLUGINS.join(", ")
+          }`,
+        );
+      }
+      plugins = [...new Set(flags.plugin)];
+    }
+    else {
+      plugins = [];
+    }
+    return {
+      all,
+      plugins,
+      statusLine: all || flags.statusline,
+      subagentStatusLine: all || flags.subagentstatusline,
+    };
+  }
+
+  // Verify every tool the plan needs is on PATH. If any are missing, print the
+  // install command for each and exit so the user installs them and re-runs.
+  checkDeps(plan) {
+    const missing = requiredTools(plan).filter(t => !hasBin(t));
+    if (!missing.length) {
+      return;
+    }
+    this.log("\nMissing required dependencies — install these, then re-run:\n");
+    for (const t of missing) {
+      this.log(`  ${t}`);
+      this.log(`    ${DEP_HINTS[t] || "see project docs"}`);
+    }
+    this.exit(1);
+  }
+
+  // Add the marketplace (user scope), then install each plugin at its scope.
+  installPlugins(plugins) {
+    this.log(`\nAdding marketplace ${MARKETPLACE_NAME} (user scope)…`);
+    if (
+      !this.runClaude([
+        "plugin",
+        "marketplace",
+        "add",
+        "--scope",
+        "user",
+        MARKETPLACE_REF,
+      ])
+    ) {
+      this.log(
+        "Marketplace add returned non-zero (may already exist) — continuing.",
+      );
+    }
+    for (const name of plugins) {
+      const scope = scopeFor(name);
+      this.log(`\nInstalling ${name} (${scope} scope)…`);
+      if (
+        !this.runClaude([
+          "plugin",
+          "install",
+          "--scope",
+          scope,
+          `${name}@${MARKETPLACE_NAME}`,
+        ])
+      ) {
+        this.log(`Failed to install ${name}.`);
+      }
+    }
+  }
+
+  // Run a `claude` subcommand, streaming its output. Returns true on exit 0.
+  runClaude(args) {
+    this.log(`$ claude ${args.join(" ")}`);
+    const res = spawnSync("claude", args, { stdio: "inherit" });
+    if (res.error) {
+      this.error(`Failed to run claude: ${res.error.message}`);
+    }
+    return res.status === 0;
+  }
+
+  // Copy the script, seed the user config, and set the requested statusline keys.
+  async installStatusline(plan, yes) {
+    await this.installScript();
+    await this.seedUserConfig();
+
+    const settings = await this.readSettings();
+    if (plan.statusLine) {
+      await this.applyKey(settings, "statusLine", STATUS_LINE, yes);
+    }
+    if (plan.subagentStatusLine) {
+      await this.applyKey(
+        settings,
+        "subagentStatusLine",
+        SUBAGENT_STATUS_LINE,
+        yes,
+      );
+    }
+    await this.writeSettings(settings);
+  }
+
+  // Copy the statusline script into ~/.claude/scripts/ and make it executable.
+  async installScript() {
+    await mkdir(SCRIPTS_DIR, { recursive: true });
+    await copyFile(join(ASSETS_DIR, "statusline"), INSTALLED_SCRIPT);
+    await chmod(INSTALLED_SCRIPT, 0o755);
+    this.log(`Installed script → ${INSTALLED_SCRIPT}`);
+  }
+
+  // Seed ~/.config/statusline.json with the bundled defaults, or deep-merge any
+  // missing settings into an existing file (existing user values are preserved).
+  async seedUserConfig() {
+    const defaults = JSON.parse(
+      await readFile(join(ASSETS_DIR, "statusline.json"), "utf8"),
+    );
+    await mkdir(dirname(USER_CONFIG_PATH), { recursive: true });
+
+    if (existsSync(USER_CONFIG_PATH)) {
+      const raw = await readFile(USER_CONFIG_PATH, "utf8");
+      if (raw.trim()) {
+        let existing;
+        try {
+          existing = JSON.parse(raw);
+        }
+        catch {
+          this.error(
+            `${USER_CONFIG_PATH} is not valid JSON. Fix or remove it, then retry.`,
+          );
+        }
+        await writeFile(
+          USER_CONFIG_PATH,
+          `${JSON.stringify(deepMerge(defaults, existing), null, 2)}\n`,
+        );
+        this.log(`Filled missing settings → ${USER_CONFIG_PATH}`);
+        return;
+      }
+    }
+    await writeFile(USER_CONFIG_PATH, `${JSON.stringify(defaults, null, 2)}\n`);
+    this.log(`Seeded defaults → ${USER_CONFIG_PATH}`);
+  }
+
+  async readSettings() {
+    if (!existsSync(SETTINGS_PATH)) {
+      return {};
+    }
+    const raw = await readFile(SETTINGS_PATH, "utf8");
+    if (!raw.trim()) {
+      return {};
+    }
+    try {
+      return JSON.parse(raw);
+    }
+    catch {
+      this.error(
+        `${SETTINGS_PATH} is not valid JSON. Fix or remove it, then retry.`,
+      );
+    }
+  }
+
+  // Set `key`, prompting before overwriting an existing value unless `yes`.
+  async applyKey(settings, key, value, yes) {
+    if (!yes && settings[key] !== undefined) {
+      this.log(`\nExisting ${key} in ${SETTINGS_PATH}:`);
+      this.log(JSON.stringify(settings[key], null, 2));
+      if (!(await confirm(`Overwrite ${key}?`))) {
+        this.log(`Skipped ${key}.`);
+        return;
+      }
+    }
+    settings[key] = value;
+    this.log(`Set ${key}.`);
+  }
+
+  async writeSettings(settings) {
+    await mkdir(dirname(SETTINGS_PATH), { recursive: true });
+    await writeFile(SETTINGS_PATH, `${JSON.stringify(settings, null, 2)}\n`);
+    this.log(`Updated ${SETTINGS_PATH}`);
+  }
+}
+
+Installer.description =
+  "Install Viraj Patel's Claude Code toolkit: marketplace plugins (via the `claude` CLI) and the powerline statusline. Checks required tools (brew/mise/claude/rtk/pnpm/…) first and prints install hints for any that are missing.";
+
+Installer.examples = [
+  "<%= config.bin %> --all",
+  "<%= config.bin %> --plugins",
+  "<%= config.bin %> --plugin vwf --plugin dart-lsp",
+  "<%= config.bin %> --statusline --subagentstatusline --yes",
+];
+
+Installer.flags = {
+  all: Flags.boolean({
+    description:
+      "Install everything: every marketplace plugin plus both statusline keys",
+  }),
+  plugins: Flags.boolean({
+    description: `Install all marketplace plugins (${PLUGINS.join(", ")})`,
+  }),
+  plugin: Flags.string({
+    multiple: true,
+    description: `Install a specific plugin by name (repeatable). One of: ${
+      PLUGINS.join(", ")
+    }`,
+  }),
+  statusline: Flags.boolean({
+    description:
+      "Install `statusLine` (the main status bar) in ~/.claude/settings.json",
+  }),
+  subagentstatusline: Flags.boolean({
+    description:
+      "Install `subagentStatusLine` (the subagent panel) in ~/.claude/settings.json",
+  }),
+  yes: Flags.boolean({
+    char: "y",
+    description: "Overwrite existing config without prompting",
+  }),
+};
+
+// True if `bin` is an executable found on PATH.
+function hasBin(bin) {
+  return (process.env.PATH || "")
+    .split(delimiter)
+    .some(dir => dir && existsSync(join(dir, bin)));
+}
+
+// The tools that must be present for the resolved install plan.
+function requiredTools({ plugins, statusLine, subagentStatusLine }) {
+  const tools = new Set();
+  if (plugins.length) {
+    for (const d of CORE_DEPS) {
+      tools.add(d);
+    }
+  }
+  for (const p of plugins) {
+    for (const d of PLUGIN_EXTRA_DEPS[p] || []) {
+      tools.add(d);
+    }
+  }
+  if (statusLine || subagentStatusLine) {
+    tools.add("node");
+  }
+  return [...tools];
+}
+
+const isObject = v => v != null && typeof v === "object" && !Array.isArray(v);
+
+// Deep-merge: objects merge key-by-key; arrays and scalars from `override` win.
+// Called as deepMerge(defaults, existing) so existing user values are preserved
+// and only missing keys are filled from the defaults.
+function deepMerge(base, override) {
+  if (!isObject(base) || !isObject(override)) {
+    return override === undefined ? base : override;
+  }
+  const out = { ...base };
+  for (const key of Object.keys(override)) {
+    out[key] = isObject(base[key]) && isObject(override[key])
+      ? deepMerge(base[key], override[key])
+      : override[key];
+  }
+  return out;
+}
+
+async function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    const answer = (await rl.question(`${message} [y/N] `))
+      .trim()
+      .toLowerCase();
+    return answer === "y" || answer === "yes";
+  }
+  finally {
+    rl.close();
+  }
+}
+
+module.exports = Installer;
+
+// oclif loads this file as the single command (see `oclif.commands` in
+// package.json); when invoked directly it also bootstraps the CLI.
+if (require.main === module) {
+  execute({ dir: __dirname });
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "author": "Viraj Patel",
+  "bin": {
+    "ai-plugins": "./bin/installer.js"
+  },
+  "dependencies": {
+    "@oclif/core": "latest"
+  },
+  "description": "CLI to install Viraj Patel's Claude Code toolkit: marketplace plugins (via the claude CLI) and the powerline statusline",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "tools"
+  ],
+  "license": "MIT",
+  "name": "@askviraj/ai-plugins",
+  "oclif": {
+    "bin": "ai-plugins",
+    "commands": {
+      "strategy": "single",
+      "target": "./bin/installer.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "github:virajp/ai-plugins"
+  },
+  "type": "commonjs",
+  "version": "1.0.0"
+}

package/readme.md

@@ -0,0 +1,163 @@
+# Plugins for Claude Code
+
+A curated collection of opinionated Claude Code plugins by Viraj Patel — LSP
+servers, MCP servers, a full Spec → Plan → Execute workflow plugin (`vwf`), and
+a config-driven powerline `statusline` — for use with the Claude Code CLI.
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) — runs the installer via `pnpx` (or `npx`).
+- [Claude Code CLI](https://claude.ai/code) — the installer drives it to add the
+  marketplace and install plugins.
+- [Mise](https://mise.jdx.dev/) — the LSP plugins and the `vwf` npm→pnpm hook
+  resolve their tools through it.
+
+> The installer **checks every required tool** for what you're installing
+> (including `rtk` and `pnpm` for `vwf`) and prints the exact install command
+> for anything missing — it never installs a dependency for you. Run it first to
+> see what you need.
+
+## Installation
+
+Everything installs through one CLI —
+[`@askviraj/ai-plugins`](https://www.npmjs.com/package/@askviraj/ai-plugins). It
+adds the `virajp-plugins` marketplace (user-scoped) and drives the Claude Code
+CLI for you, installing each plugin at its default scope (`dart-lsp` is
+project-scoped, every other plugin user-scoped).
+
+> The examples below use `pnpx`; if you don't use `pnpm`, swap in `npx` — the
+> commands are otherwise identical.
+
+**Install everything — all plugins + statusline:**
+
+```sh
+pnpx @askviraj/ai-plugins --all
+```
+
+**Install all plugins (no statusline):**
+
+```sh
+pnpx @askviraj/ai-plugins --plugins
+```
+
+**Install specific plugins (`--plugin` is repeatable):**
+
+```sh
+pnpx @askviraj/ai-plugins --plugin vwf --plugin dart-lsp
+```
+
+Available plugin names: `vwf`, `mempalace`, `context7`, `typescript-lsp`,
+`dart-lsp`.
+
+> The **statusline** also installs through this CLI — see
+> [Statusline](#statusline) below.
+
+## Plugins
+
+### vwf
+
+The flagship plugin — a highly opinionated Spec → Plan → Execute workflow for
+solo developers and small teams. Ships slash commands, subagents, skills, and
+two `PreToolUse` / `Bash` hooks: one that transparently rewrites `npm`/`npx`
+commands to `pnpm`, and an `rtk hook claude` hook (requires `rtk` — see
+Prerequisites).
+
+```sh
+pnpx @askviraj/ai-plugins --plugin vwf
+```
+
+**Slash commands** (`/vwf:<name>`):
+
+| Command        | Description                                                                                    |
+| -------------- | ---------------------------------------------------------------------------------------------- |
+| `spec`         | Maintain the always-current, full-product blueprint under `docs/specs/` (one doc per entity)   |
+| `plan`         | Pick one slice of the spec, diff desired vs actual, write a reviewable cycle plan              |
+| `execute`      | Implement an approved plan under TDD, then code review + security review                       |
+| `archive`      | Move completed plans aside (never deletes)                                                     |
+| `architecture` | Bootstrap or correct `docs/specs/architecture.md` — system shape and machine-readable registry |
+| `git-workflow` | Internal — worktree isolation, commits, merges, pushes (used by plan/execute)                  |
+
+**Skills:**
+
+| Skill                 | Description                                                                                                                                                        |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `karpathy-guidelines` | Behavioral guidelines to reduce common LLM coding mistakes: avoid overcomplication, make surgical changes, surface assumptions, define verifiable success criteria |
+| `rest-api-design`     | Technology-agnostic principles and best practices for designing REST APIs                                                                                          |
+
+#### vwf dependencies
+
+All of vwf's dependencies live in the **same `virajp-plugins` marketplace**
+(`mempalace` is re-listed here), so a clean install needs no other marketplace
+registered:
+
+```sh
+pnpx @askviraj/ai-plugins --plugin vwf   # adds the marketplace, installs vwf + deps
+```
+
+> Auto-enable is **event-driven** — it fires when you enable `vwf`, not
+> continuously. If a dependency later gets disabled on its own, re-enable it
+> directly or toggle `vwf` off and on again.
+
+`vwf` depends on two other plugins, which Claude Code **auto-installs and
+auto-enables** when you enable `vwf` (requires Claude Code ≥ 2.1.143):
+
+- `context7@virajp-plugins` — Context7 MCP docs server
+- `mempalace@virajp-plugins` — AI memory system
+
+### statusline
+
+A standalone, powerline-style statusline (main two-line bar + subagent panel),
+fully data-driven from JSON and themeable across three config layers (defaults →
+`~/.config/statusline.json` → `<repo-root>/.config/statusline.json`). It
+installs via a small CLI rather than the plugin marketplace — the installer
+copies the script to `~/.claude/scripts/` and writes the chosen key(s) into
+`~/.claude/settings.json`. Requires a [Nerd Font](https://www.nerdfonts.com/).
+
+```sh
+# install both surfaces (use --statusline / --subagentstatusline individually too)
+pnpx @askviraj/ai-plugins --statusline --subagentstatusline
+
+# overwrite existing config without prompting
+pnpx @askviraj/ai-plugins --statusline --subagentstatusline --yes
+```
+
+See **[docs/statusline.md](./docs/statusline.md)** for setup and the full
+configuration reference.
+
+### mempalace
+
+AI memory system — mine projects and conversations into a searchable palace. 33
+MCP tools, auto-save hooks, and guided setup. Maintained externally
+([MemPalace/mempalace](https://github.com/MemPalace/mempalace)) and re-listed
+here; it is also a `vwf` dependency.
+
+> When you install `vwf`, `mempalace` is pulled in and enabled automatically —
+> you only need these steps to install `mempalace` on its own.
+
+```sh
+pnpx @askviraj/ai-plugins --plugin mempalace
+```
+
+### context7
+
+Context7 MCP server — fetches up-to-date library/framework documentation.
+
+```sh
+pnpx @askviraj/ai-plugins --plugin context7
+```
+
+### typescript-lsp
+
+TypeScript/JavaScript language server (via `typescript-language-server`).
+
+```sh
+pnpx @askviraj/ai-plugins --plugin typescript-lsp
+```
+
+### dart-lsp
+
+Dart language server.
+
+```sh
+pnpx @askviraj/ai-plugins --plugin dart-lsp
+```

package/tools/statusline/statusline

@@ -0,0 +1,515 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Claude Code statusline — powerline style, config-driven, with subagent mode.
+ *
+ * ONE file serves both surfaces. Wire both keys to it in ~/.claude/settings.json:
+ *   {
+ *     "statusLine":         { "type": "command", "command": "node ~/.claude/statusline", "padding": 0 },
+ *     "subagentStatusLine": { "type": "command", "command": "node ~/.claude/statusline" }
+ *   }
+ *
+ * Mode is detected from stdin: a payload with a `tasks` array is the subagent
+ * panel (one NDJSON {id,content} row per subagent); anything else is the main
+ * two-line status bar. Debug goes to stderr so it never corrupts the line.
+ *
+ * Configuration is fully data-driven and layered. Two files are deep-merged,
+ * low → high precedence (a higher layer overrides the same key in a lower one;
+ * objects merge key-by-key, arrays replace wholesale). Either layer may be absent:
+ *   2. ~/.config/statusline.json — the per-USER config, applied to every repo.
+ *      Seeded with the full defaults by the installer (palette, symbols, line
+ *      layout, subagent panel, …).
+ *   1. <repo-root>/.config/statusline.json — per-REPO overrides (highest).
+ * So a repo can set just `projectName` and inherit everything else, or override
+ * any nested value (a single segment's bg, one symbol, the gauge width, a status
+ * colour, …).
+ *
+ * Colours accept three forms anywhere a colour is expected: a palette name
+ * ("blue"), a hex string ("#458588" or "#abc"), or an RGB triple ([69,133,136]).
+ *
+ * A line is a list of segment entries. An entry is either a segment id string
+ * ("model") or an object {name, bg?, fg?, bold?} that overrides that segment's
+ * styling inline — both resolve their defaults from the `segments` map.
+ *
+ * Main test:
+ *   echo '{"model":{"display_name":"Opus 4.8"},"effort":{"level":"high"},"session_name":"users-and-groups","workspace":{"current_dir":"/Users/virajpatel/Projects/github.com/95octane/workspace/.worktrees/users-and-groups/backend"},"cost":{"total_cost_usd":46.51,"total_duration_ms":33540000},"context_window":{"used_percentage":26,"context_window_size":1000000,"total_input_tokens":259000},"rate_limits":{"five_hour":{"used_percentage":7,"resets_at":1774200000},"seven_day":{"used_percentage":1.0,"resets_at":1774600000}}}' | node statusline
+ * Subagent test:
+ *   echo '{"columns":120,"tasks":[{"id":"t1","name":"reviewer","status":"running","description":"Auditing auth flow","tokenCount":18234,"startTime":1774200000000}]}' | node statusline
+ */
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+
+// Config filename, shared across both layers.
+const CONFIG_FILE = "statusline.json";
+// Relative location under a home/repo root for the user & repo layers.
+const CONFIG_REL = [".config", CONFIG_FILE];
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Config — resolved once per invocation, then exposed as module state so the
+// segment builders and renderers can stay terse.
+// ─────────────────────────────────────────────────────────────────────────────
+let CFG = {};          // the fully merged config object
+let PALETTE = {};      // name -> [r,g,b]
+let SYM = {};          // data-type glyphs
+let TYPE_SYM = {};     // subagent type -> glyph
+let GAUGE = {};        // { width, filled, empty }
+let SUB = {};          // subagent panel config
+let SEP, SEP_THIN, CAP, THIN_FG, DEFAULT_FG, WORKTREE_RE;
+
+const isObj = (v) => v != null && typeof v === "object" && !Array.isArray(v);
+
+// Deep-merge `override` onto `base`: objects merge recursively, everything else
+// (scalars AND arrays) is replaced wholesale by the override.
+function deepMerge(base, override) {
+  if (!isObj(base) || !isObj(override)) return override === undefined ? base : override;
+  const out = { ...base };
+  for (const k of Object.keys(override)) {
+    out[k] = isObj(base[k]) && isObj(override[k]) ? deepMerge(base[k], override[k]) : override[k];
+  }
+  return out;
+}
+
+function readJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch (_) { return null; }
+}
+
+// Merge the two config layers, low → high precedence — each present layer is
+// deep-merged onto the accumulator so a higher layer wins:
+//   2. ~/.config/statusline.json (per-user)  ->  1. <root>/.config/statusline.json (per-repo)
+// The per-user file is seeded with the full defaults by the installer.
+function loadConfig(root) {
+  let cfg = readJson(path.join(os.homedir(), ...CONFIG_REL)) || {};
+  const repo = root ? readJson(path.join(root, ...CONFIG_REL)) : null;
+  if (repo) cfg = deepMerge(cfg, repo);
+  return cfg;
+}
+
+// Hoist the hot paths of the merged config into module state.
+function applyConfig(cfg) {
+  CFG = cfg || {};
+  PALETTE = CFG.palette || {};
+  SYM = CFG.symbols || {};
+  TYPE_SYM = CFG.typeSymbols || {};
+  GAUGE = CFG.gauge || {};
+  SUB = CFG.subagent || {};
+  const pl = CFG.powerline || {};
+  SEP = pl.sep ?? "";
+  SEP_THIN = pl.sepThin ?? "";
+  CAP = pl.cap ?? "";
+  THIN_FG = color(pl.thinFg || "grey");
+  DEFAULT_FG = color(CFG.defaultFg || "white");
+  WORKTREE_RE = new RegExp(CFG.worktreePattern || "worktree", "i");
+}
+
+// Resolve a colour spec to an [r,g,b] triple. Accepts a palette name, a hex
+// string ("#rgb" or "#rrggbb"), or a literal triple. Falls back to white.
+function color(v) {
+  if (Array.isArray(v) && v.length === 3) return v;
+  if (typeof v === "string") {
+    if (PALETTE[v]) return PALETTE[v];
+    if (v[0] === "#") {
+      let h = v.slice(1);
+      if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+      if (h.length === 6) {
+        const n = parseInt(h, 16);
+        if (!isNaN(n)) return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+      }
+    }
+  }
+  return PALETTE.white || [251, 241, 199];
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// ANSI + powerline rendering.
+// ─────────────────────────────────────────────────────────────────────────────
+const fg = ([r, g, b]) => `\x1b[38;2;${r};${g};${b}m`;
+const bg = ([r, g, b]) => `\x1b[48;2;${r};${g};${b}m`;
+const sameColor = (a, b) => a && b && a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+
+/**
+ * Render one powerline row from an ordered list of segments {text, bg, fg?, bold?}.
+ * Opens with a rounded CAP colored as the first bg, joins neighbours with the
+ * fill triangle (fg = prev bg, bg = next bg), and when two neighbours share a
+ * background uses a thin divider so the seam stays visible. Closes with a
+ * triangle that dissolves into the terminal's own background.
+ */
+function renderLine(segments) {
+  let out = "";
+  if (!segments.length) return out;
+  out += fg(segments[0].bg) + CAP + RESET;
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    out += bg(seg.bg) + fg(seg.fg || DEFAULT_FG) + (seg.bold ? BOLD : "");
+    out += ` ${seg.text} ` + RESET;
+
+    const next = segments[i + 1];
+    if (next && sameColor(seg.bg, next.bg)) {
+      out += bg(next.bg) + fg(THIN_FG) + SEP_THIN + RESET; // shared bg: thin seam
+    } else if (next) {
+      out += fg(seg.bg) + bg(next.bg) + SEP + RESET;       // colored transition
+    } else {
+      out += fg(seg.bg) + SEP + RESET;                     // closing cap
+    }
+  }
+  return out;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Formatting utilities.
+// ─────────────────────────────────────────────────────────────────────────────
+
+// Normalize a model field (object {display_name|id} or plain string) to a label.
+function modelName(m) {
+  if (!m) return "";
+  const s = m.display_name || m.id || (typeof m === "string" ? m : "");
+  return s.replace(/\s*\([^)]*\)\s*$/, "");
+}
+
+// Normalize an effort field (object {level} or plain string) to a level string.
+function effortLevel(e) {
+  if (!e) return "";
+  return e.level || (typeof e === "string" ? e : "");
+}
+
+// 1234567 -> "1.2M", 259000 -> "259k"
+function humanTokens(n) {
+  if (n == null || isNaN(n)) return "?";
+  if (n >= 1e6) return (n / 1e6).toFixed(1).replace(/\.0$/, "") + "M";
+  if (n >= 1e3) return Math.round(n / 1e3) + "k";
+  return String(n);
+}
+
+// ms -> "9hr 19m" / "4m 12s"
+function humanDuration(ms) {
+  if (ms == null || isNaN(ms)) return "?";
+  let s = Math.floor(ms / 1000);
+  const h = Math.floor(s / 3600); s -= h * 3600;
+  const m = Math.floor(s / 60);   s -= m * 60;
+  if (h > 0) return `${h}hr ${m}m`;
+  if (m > 0) return `${m}m ${s}s`;
+  return `${s}s`;
+}
+
+// Normalize a timestamp to epoch milliseconds. Accepts:
+//   - epoch seconds  (10-digit number, e.g. 1774200000)
+//   - epoch millis   (13-digit number)
+//   - ISO 8601 string ("2026-03-28T15:00:00Z")
+// Returns null if unparseable.
+function toEpochMs(v) {
+  if (v == null) return null;
+  if (typeof v === "number") return v > 1e12 ? v : v * 1000;
+  const t = Date.parse(String(v));
+  return isNaN(t) ? null : t;
+}
+
+// Time remaining until a reset timestamp -> "4h36m" / "5d2h" / "now".
+// Hardened to accept epoch seconds, epoch millis, or an ISO string.
+function humanResetIn(resetsAt) {
+  const ms = toEpochMs(resetsAt);
+  if (ms == null) return null;
+  let s = Math.floor((ms - Date.now()) / 1000);
+  if (s <= 0) return "now";
+  const d = Math.floor(s / 86400); s -= d * 86400;
+  const h = Math.floor(s / 3600);  s -= h * 3600;
+  const m = Math.floor(s / 60);
+  if (d > 0) return `${d}d${h}h`;
+  return h > 0 ? `${h}h${String(m).padStart(2, "0")}m` : `${m}m`;
+}
+
+// Fixed-width gauge: filled vs empty blocks (glyphs + width from config).
+function gauge(pct) {
+  const width = GAUGE.width || 10;
+  const p = Math.max(0, Math.min(100, pct || 0));
+  const filled = Math.round((p / 100) * width);
+  return (GAUGE.filled || "▰").repeat(filled) + (GAUGE.empty || "▱").repeat(width - filled);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Git (filesystem-only branch/root; one bounded git call for dirtiness).
+// ─────────────────────────────────────────────────────────────────────────────
+
+// Walk up from startDir resolving repo root (dir containing .git) and branch
+// from .git/HEAD. Handles worktrees/submodules (.git as a gitdir pointer file).
+function resolveGit(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 40 && dir; i++) {
+    try {
+      const gitPath = path.join(dir, ".git");
+      const st = fs.statSync(gitPath);
+      let headFile;
+      if (st.isDirectory()) {
+        headFile = path.join(gitPath, "HEAD");
+      } else {
+        const ref = fs.readFileSync(gitPath, "utf8").trim();
+        const m = ref.match(/^gitdir:\s*(.+)$/);
+        if (!m) return { root: dir, branch: null };
+        const gd = path.isAbsolute(m[1]) ? m[1] : path.join(dir, m[1]);
+        headFile = path.join(gd, "HEAD");
+      }
+      const head = fs.readFileSync(headFile, "utf8").trim();
+      const rm = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+      return { root: dir, branch: rm ? rm[1] : head.slice(0, 7) };
+    } catch (_) {
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return { root: null, branch: null };
+}
+
+// Path after a "worktree" keyword component, else null.
+function worktreeSubpath(cwd) {
+  const parts = cwd.split("/").filter(Boolean);
+  let idx = -1;
+  for (let i = 0; i < parts.length; i++) if (WORKTREE_RE.test(parts[i])) idx = i;
+  if (idx === -1 || idx === parts.length - 1) return null;
+  return parts.slice(idx + 1).join("/");
+}
+
+// Single dirty marker: "+" net additions, "-" net deletions, "±" both, "" clean.
+// Shells out to git once (twice on a fresh repo), bounded by a 250ms timeout.
+function gitDirtyMark(cwd) {
+  const { execFileSync } = require("child_process");
+  const opts = { cwd, encoding: "utf8", timeout: 250, stdio: ["ignore", "pipe", "ignore"] };
+  const run = (args) => execFileSync("git", args, opts);
+  let added = 0, removed = 0;
+  try {
+    let numstat;
+    try { numstat = run(["diff", "--numstat", "HEAD"]); }
+    catch (_) { numstat = run(["diff", "--numstat", "--cached"]); }
+    for (const line of numstat.split("\n")) {
+      const m = line.match(/^(\d+|-)\t(\d+|-)\t/);
+      if (!m) continue;
+      if (m[1] !== "-") added += parseInt(m[1], 10);
+      if (m[2] !== "-") removed += parseInt(m[2], 10);
+    }
+    if (run(["ls-files", "--others", "--exclude-standard"]).trim()) added += 1;
+  } catch (_) {
+    return "";
+  }
+  if (added && removed) return SYM.dirtyMix;
+  if (added) return SYM.dirtyAdd;
+  if (removed) return SYM.dirtyDel;
+  return "";
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Segment registry — each builder takes the resolved context `c` and returns the
+// segment TEXT (a string), or null to omit (when its data is absent). All styling
+// (bg/fg/bold) is resolved separately from the `segments` config + inline entry
+// overrides, so this map carries only the text logic. Add an entry here plus a
+// `segments.<id>` default style to introduce a new segment.
+// ─────────────────────────────────────────────────────────────────────────────
+const SEGMENTS = {
+  model: (c) => `${SYM.model} ${c.model}${c.effort ? ` [${c.effort}]` : ""}`,
+  context: (c) =>
+    `${SYM.context} ${gauge(c.ctxPct)} ${humanTokens(c.ctxUsed)}/${humanTokens(c.ctxSize)} (${Math.round(c.ctxPct)}%)`,
+  rl5h: (c) => c.sessPct == null ? null
+    : `${SYM.win5h} ${c.sessPct.toFixed(1)}%${c.reset5h ? ` ${SYM.reset} ${c.reset5h}` : ""}`,
+  rl7d: (c) => c.weekPct == null ? null
+    : `${SYM.win7d} ${c.weekPct.toFixed(1)}%${c.reset7d ? ` ${SYM.reset} ${c.reset7d}` : ""}`,
+  session: (c) => c.sessionName ? `${SYM.session} ${c.sessionName}` : null,
+  cost: (c) => `${SYM.cost} ${c.cost.toFixed(2)}`,
+  duration: (c) => c.dur == null ? null : `${SYM.duration} ${humanDuration(c.dur)}`,
+  project: (c) => c.projectName ? `${c.projectSym} ${c.projectName}` : null,
+  worktree: (c) => c.wt ? `${SYM.worktree} ${SYM.folder} ${c.wt}` : null,
+  branch: (c) => {
+    if (!c.branch) return null;
+    let t = c.wt ? `${SYM.worktree} ${SYM.branch} ${c.branch}` : `${SYM.branch} ${c.branch}`;
+    if (c.dirty) t += ` ${c.dirty}`;
+    return t;
+  },
+};
+
+// Build one rendered segment from a line entry (id string or {name,bg,fg,bold}),
+// resolving styling as: inline override → segments.<id> default → hard fallback.
+function buildSegment(entry, c) {
+  const id = typeof entry === "string" ? entry : (entry.name || entry.id);
+  const build = SEGMENTS[id];
+  if (!build) { process.stderr.write(`statusline: unknown segment "${id}"\n`); return null; }
+
+  let text;
+  try { text = build(c); } catch (_) { return null; }
+  if (text == null) return null;
+
+  const base = (CFG.segments && CFG.segments[id]) || {};
+  const inline = typeof entry === "string" ? {} : entry;
+  const bgSpec = inline.bg ?? base.bg ?? "blue";
+  const fgSpec = inline.fg ?? base.fg;
+  const bold = inline.bold ?? base.bold ?? false;
+  return { text, bg: color(bgSpec), fg: fgSpec ? color(fgSpec) : undefined, bold: !!bold };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Main status bar.
+// ─────────────────────────────────────────────────────────────────────────────
+function renderMain(d) {
+  const cwd = d.workspace?.current_dir || d.cwd || process.cwd();
+  const git = resolveGit(cwd);
+  applyConfig(loadConfig(git.root));
+
+  const ctx     = d.context_window || {};
+  const usage   = ctx.current_usage || {};
+  const ctxSize = ctx.context_window_size;
+  const ctxPct  = ctx.used_percentage ?? 0;
+  // Prefer the input-only total (matches used_percentage); fall back gracefully.
+  const ctxUsed =
+    ctx.total_input_tokens ??
+    ([usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens]
+      .reduce((a, v) => a + (v || 0), 0) || null) ??
+    (ctxSize ? Math.round((ctxPct / 100) * ctxSize) : null);
+
+  const rl     = d.rate_limits || {};
+  const weekly = rl.seven_day || rl.weekly || {};
+
+  const c = {
+    model: modelName(d.model) || "Claude",
+    effort: effortLevel(d.effort),
+    cost: d.cost?.total_cost_usd ?? 0,
+    dur: d.cost?.total_duration_ms,
+    ctxPct, ctxUsed, ctxSize,
+    sessPct: rl.five_hour?.used_percentage,
+    weekPct: weekly.used_percentage,
+    reset5h: humanResetIn(rl.five_hour?.resets_at),
+    reset7d: humanResetIn(weekly.resets_at),
+    sessionName: d.session_name,
+    projectName: CFG.projectName,
+    projectSym: SYM.project,
+    wt: worktreeSubpath(cwd),
+    branch: git.branch,
+    dirty: git.branch ? gitDirtyMark(cwd) : "",
+  };
+
+  const lines = Array.isArray(CFG.lines) ? CFG.lines : [];
+  return lines
+    .map((line) => {
+      const segs = (Array.isArray(line) ? line : [])
+        .map((entry) => buildSegment(entry, c))
+        .filter(Boolean);
+      return segs.length ? renderLine(segs) : null;
+    })
+    .filter((l) => l != null)
+    .join("\n");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Subagent panel — one NDJSON {id, content} row per running subagent.
+// Input shape: { columns, tasks: [{ id, name, type, status, description,
+//                label, startTime, tokenCount, cwd }, ...] }.
+// ─────────────────────────────────────────────────────────────────────────────
+
+// Map a status string to its configured glyph + colour. Statuses are tried in
+// config order; the first whose `match` regex hits wins. An entry with an empty
+// `match` is the fallback for anything unmatched (pending / queued / unknown).
+function taskMark(status) {
+  const s = String(status || "").toLowerCase();
+  const statuses = SUB.statuses || {};
+  let fallback = null;
+  for (const def of Object.values(statuses)) {
+    if (!def || !def.match) { if (def) fallback = def; continue; }
+    try { if (new RegExp(def.match, "i").test(s)) return { sym: def.symbol, bg: color(def.bg) }; }
+    catch (_) { /* bad regex in config: skip */ }
+  }
+  if (fallback) return { sym: fallback.symbol, bg: color(fallback.bg) };
+  return { sym: "", bg: color("bg3") };
+}
+
+// Resolve a subagent segment's styling from subagent.segments.<key>.
+function subStyle(key, fallbackBg) {
+  const s = (SUB.segments && SUB.segments[key]) || {};
+  return { bg: color(s.bg || fallbackBg), fg: s.fg ? color(s.fg) : undefined, bold: !!s.bold };
+}
+
+function renderSubagents(d) {
+  const cwd = d.cwd || (Array.isArray(d.tasks) && d.tasks[0] && d.tasks[0].cwd) || process.cwd();
+  applyConfig(loadConfig(resolveGit(cwd).root));
+
+  const tasks = Array.isArray(d.tasks) ? d.tasks : [];
+  const cols = Number(d.columns) || Number(process.env.COLUMNS) || 80;
+  const budgetFraction = SUB.descBudgetFraction ?? 0.45;
+
+  // Panel-wide fallbacks. Per the documented schema neither model nor effort is
+  // a per-task field, so these are usually the only source — and may be absent
+  // entirely. We read them defensively and only render when something exists.
+  const topModel = modelName(d.model);
+  const topEffort = effortLevel(d.effort);
+
+  const headBold = !!(SUB.segments && SUB.segments.head && SUB.segments.head.bold);
+  const headFg = SUB.segments && SUB.segments.head && SUB.segments.head.fg
+    ? color(SUB.segments.head.fg) : undefined;
+
+  const out = [];
+  for (const t of tasks) {
+    if (!t || t.id == null) continue;
+    const mk = taskMark(t.status);
+
+    // Head: status glyph · type glyph (replaces the raw type string).
+    const typeSym = TYPE_SYM[String(t.type || "").toLowerCase()] || TYPE_SYM._default;
+    const segs = [{ text: `${mk.sym} ${typeSym}`, bg: mk.bg, fg: headFg, bold: headBold }];
+
+    // Name: the subagent's identity as its own configurable segment. Only the
+    // explicit name — Claude Code reports `type` as the generic "local_agent"
+    // regardless of subagent_type, and the type glyph already conveys that, so
+    // a fallback to type would just be redundant noise. Omitted when unnamed.
+    const agentName = t.name;
+    if (agentName) {
+      const st = subStyle("name", "orange");
+      segs.push({ text: `${SYM.agent} ${agentName}`, bg: st.bg, fg: st.fg, bold: st.bold });
+    }
+
+    // Model / effort: prefer a per-task value (in case a future build adds one),
+    // fall back to the panel-wide value, omit when neither is present.
+    const model = modelName(t.model) || topModel;
+    const effort = effortLevel(t.effort) || topEffort;
+    if (model || effort) {
+      const label = [model, effort ? `[${effort}]` : ""].filter(Boolean).join(" ");
+      const st = subStyle("model", "blue");
+      segs.push({ text: `${SYM.model} ${label}`, bg: st.bg, fg: st.fg, bold: st.bold });
+    }
+
+    const desc = (t.description || t.label || "").replace(/\s+/g, " ").trim();
+    if (desc) {
+      const budget = Math.max(12, Math.floor(cols * budgetFraction));
+      const st = subStyle("desc", "bg3");
+      segs.push({ text: desc.length > budget ? desc.slice(0, budget - 1) + "…" : desc, bg: st.bg, fg: st.fg, bold: st.bold });
+    }
+    if (t.tokenCount != null) {
+      const st = subStyle("tokens", "aqua");
+      segs.push({ text: `${SYM.tokens} ${humanTokens(t.tokenCount)}`, bg: st.bg, fg: st.fg, bold: st.bold });
+    }
+
+    const startMs = toEpochMs(t.startTime);
+    if (startMs) {
+      const st = subStyle("duration", "purple");
+      segs.push({ text: `${SYM.duration} ${humanDuration(Date.now() - startMs)}`, bg: st.bg, fg: st.fg, bold: st.bold });
+    }
+
+    out.push(JSON.stringify({ id: t.id, content: renderLine(segs) }));
+  }
+  return out.join("\n");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// stdin plumbing — route by payload shape.
+// ─────────────────────────────────────────────────────────────────────────────
+let buf = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (c) => (buf += c));
+process.stdin.on("end", () => {
+  try {
+    let d = {};
+    try { d = JSON.parse(buf); } catch (_) { /* keep defaults */ }
+    const output = Array.isArray(d.tasks) ? renderSubagents(d) : renderMain(d);
+    process.stdout.write(output);
+  } catch (e) {
+    process.stderr.write(`statusline error: ${e && e.stack ? e.stack : e}\n`);
+    process.stdout.write("⚡ Claude"); // never leave the line blank
+  }
+});

package/tools/statusline/statusline.json

@@ -0,0 +1,199 @@
+{
+  "$schema": "https://raw.githubusercontent.com/virajp/ai-plugins/main/schemas/statusline.schema.json",
+  "defaultFg": "white",
+  "gauge": {
+    "empty": "▱",
+    "filled": "▰",
+    "width": 10
+  },
+  "lines": [
+    [
+      "model",
+      "context",
+      "rl5h",
+      "rl7d",
+      "cost"
+    ],
+    [
+      "project",
+      "worktree",
+      "branch"
+    ]
+  ],
+  "palette": {
+    "aqua": [
+      104,
+      157,
+      106
+    ],
+    "bg3": [
+      102,
+      92,
+      84
+    ],
+    "blue": [
+      69,
+      133,
+      136
+    ],
+    "green": [
+      152,
+      151,
+      26
+    ],
+    "grey": [
+      60,
+      56,
+      54
+    ],
+    "orange": [
+      214,
+      93,
+      14
+    ],
+    "purple": [
+      177,
+      98,
+      134
+    ],
+    "red": [
+      204,
+      36,
+      29
+    ],
+    "white": [
+      251,
+      241,
+      199
+    ],
+    "yellow": [
+      215,
+      153,
+      33
+    ]
+  },
+  "powerline": {
+    "cap": "",
+    "sep": "",
+    "sepThin": "",
+    "thinFg": "grey"
+  },
+  "projectName": "Project-Name",
+  "segments": {
+    "branch": {
+      "bg": "aqua"
+    },
+    "context": {
+      "bg": "aqua"
+    },
+    "cost": {
+      "bg": "green",
+      "bold": true,
+      "fg": "white"
+    },
+    "duration": {
+      "bg": "aqua"
+    },
+    "model": {
+      "bg": "blue",
+      "bold": true,
+      "fg": "white"
+    },
+    "project": {
+      "bg": "green",
+      "bold": true,
+      "fg": "white"
+    },
+    "rl5h": {
+      "bg": "blue"
+    },
+    "rl7d": {
+      "bg": "purple"
+    },
+    "session": {
+      "bg": "orange"
+    },
+    "worktree": {
+      "bg": "yellow",
+      "fg": "grey"
+    }
+  },
+  "subagent": {
+    "descBudgetFraction": 0.45,
+    "segments": {
+      "desc": {
+        "bg": "bg3"
+      },
+      "duration": {
+        "bg": "purple"
+      },
+      "head": {
+        "bold": true
+      },
+      "model": {
+        "bg": "blue"
+      },
+      "name": {
+        "bg": "orange",
+        "bold": true
+      },
+      "tokens": {
+        "bg": "aqua"
+      }
+    },
+    "statuses": {
+      "done": {
+        "bg": "green",
+        "match": "done|complete|success|finish|ok",
+        "symbol": ""
+      },
+      "error": {
+        "bg": "red",
+        "match": "error|fail|cancel|abort",
+        "symbol": ""
+      },
+      "pending": {
+        "bg": "bg3",
+        "match": "",
+        "symbol": ""
+      },
+      "running": {
+        "bg": "blue",
+        "match": "run|active|progress|working|busy",
+        "symbol": ""
+      }
+    }
+  },
+  "symbols": {
+    "agent": "",
+    "branch": "",
+    "context": "",
+    "cost": "",
+    "dirtyAdd": "+",
+    "dirtyDel": "-",
+    "dirtyMix": "±",
+    "duration": "",
+    "folder": "",
+    "model": "⚡",
+    "project": "",
+    "repo": "",
+    "reset": "↻",
+    "session": "",
+    "tokens": "",
+    "win5h": "",
+    "win7d": "",
+    "worktree": "🌲"
+  },
+  "typeSymbols": {
+    "_default": "",
+    "background": "",
+    "cloud_agent": "",
+    "local_agent": "",
+    "mcp": "",
+    "remote_agent": "",
+    "review": "",
+    "task": "",
+    "test": ""
+  },
+  "worktreePattern": "worktree"
+}