@polderlabs/bizar 6.2.5 → 7.0.0

package/cli/commands/claude-cmd.mjs

@@ -0,0 +1,348 @@
+/**
+ * cli/commands/claude-cmd.mjs
+ *
+ * v6.3.0 — Pass-through wrappers for Claude Code CLI commands that
+ * Bizar wants to expose as `bizar <subcommand>` for consistency.
+ *
+ * Replaces `cli/commands/cline-cmd.mjs` (Cline-era).
+ *
+ * These are NOT reimaginings — they're thin pass-throughs that:
+ *   1. Set sane defaults from Bizar's installed location
+ *      (e.g. CLAUDE_CONFIG_DIR=~/.claude)
+ *   2. Spawn the `claude` binary with the same args
+ *   3. Stream the output through (with our chalk banner)
+ *
+ * Wrapped commands (mapped from the v6.2.x Cline originals):
+ *   - bizar config      → `claude config`
+ *   - bizar history     → reader over ~/.claude/sessions/ (no direct CLI)
+ *   - bizar plugin      → `claude plugin <sub>`
+ *   - bizar team        → `claude --agent <name> "..."` (out-of-session dispatch)
+ *   - bizar subagent    → `claude --agent <agent> "..."`
+ *   - bizar run         → `claude -p "<prompt>"` (one-shot) or `--bg` (background)
+ *
+ * Why: Bizar users already know the `bizar` CLI. Wrapping Claude Code
+ * commands means they don't have to remember which binary owns which
+ * feature.
+ *
+ * Migration from Cline (cline-cmd.mjs):
+ *   - cline config   → claude config       (direct)
+ *   - cline history  → no direct equivalent; we read ~/.claude/sessions/
+ *   - cline hub      → claude plugin       (closest functional equivalent)
+ *   - cline hook     → handled via settings.json hooks (this is config, not
+ *                       a subcommand anymore)
+ *   - cline --team-name → no direct equivalent; documented workaround is
+ *                         `claude --agent <name> "..."`
+ *   - cline subagent → claude --agent <name>
+ *   - cline run      → claude -p <prompt>  (foreground) or claude --bg (background)
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+
+const HOMEDIR = process.env.HOME || process.env.USERPROFILE || '/tmp';
+const CLAUDE_BIN = process.env.CLAUDE_BIN || 'claude';
+
+/**
+ * Resolve the Claude Code config directory.
+ *
+ * Mirrors Claude Code's own resolver. Used so all subcommands
+ * delegate to the same `~/.claude/` directory that the rest of the
+ * Bizar harness writes to via `cli/provision-claude.mjs`.
+ */
+export function resolveClaudeDir() {
+  if (process.env.CLAUDE_CONFIG_DIR && process.env.CLAUDE_CONFIG_DIR.trim()) {
+    return process.env.CLAUDE_CONFIG_DIR.trim();
+  }
+  if (process.platform === 'win32') {
+    return process.env.APPDATA
+      ? join(process.env.APPDATA, 'Claude')
+      : join(HOMEDIR, '.claude');
+  }
+  return join(HOMEDIR, '.claude');
+}
+
+/**
+ * Resolve the claude binary. On most installs, `which claude` returns
+ * the shim; we use that. Allow override via CLAUDE_BIN env var.
+ */
+function findClaudeBin() {
+  if (CLAUDE_BIN && existsSync(CLAUDE_BIN)) return CLAUDE_BIN;
+  // Default to PATH lookup via the spawn shell.
+  return 'claude';
+}
+
+/**
+ * Spawn `claude` with the given args, inheriting stdio.
+ * Returns a promise that resolves with the exit code.
+ */
+export function spawnClaude(args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const bin = findClaudeBin();
+    const child = spawn(bin, args, {
+      stdio: opts.stdio || 'inherit',
+      env: {
+        ...process.env,
+        // Always use the standard Claude Code state dir unless
+        // overridden. Claude Code uses CLAUDE_CONFIG_DIR for its
+        // settings.json + agents/ + skills/ + commands/ + hooks/.
+        ...(process.env.CLAUDE_CONFIG_DIR
+          ? {}
+          : { CLAUDE_CONFIG_DIR: resolveClaudeDir() }),
+      },
+    });
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      // Mirror the exit code so callers can chain commands.
+      if (typeof code === 'number') resolve(code);
+      else if (signal) resolve(128 + (typeof process.exitCode === 'number' ? process.exitCode : 0));
+      else resolve(0);
+    });
+  });
+}
+
+export function showClaudeCmdHelp() {
+  console.log(`
+  bizar <claude-cmd> — Pass-through wrappers for Claude Code CLI commands
+
+  These commands delegate to the \`claude\` binary on your PATH so you
+  don't have to remember which binary owns which feature.
+
+  Available wrappers:
+    bizar config      Show current configuration (mirrors \`claude config\`)
+    bizar history     Read ~/.claude/sessions/ (no direct claude CLI)
+    bizar plugin      Manage Claude Code plugins (mirrors \`claude plugin\`)
+    bizar team <name> Spawn a coordinated agent team (wraps \`claude --agent\`)
+    bizar subagent    Spawn a read-only research subagent (\`claude --agent\`)
+    bizar run [prompt] One-shot Claude Code invocation (\`claude -p <prompt>\`)
+
+  Examples:
+    bizar config --json
+    bizar plugin list
+    bizar team auth-sprint "Plan and implement user auth with tests"
+    bizar subagent mimir "Find all places where the auth token is verified"
+    bizar run "fix the failing test in src/auth.test.ts"
+
+  Related:
+    /team            The matching Claude Code slash command (in session)
+    bizar validate   Health check the Bizar install
+    bizar doctor     Diagnose Claude Code-side issues
+  `);
+}
+
+/**
+ * `bizar config` — show current Claude Code configuration.
+ * Thin wrapper around `claude config [options]`.
+ */
+export async function runClaudeConfig(args = []) {
+  console.log(chalk.dim(`  (delegating to \`claude config\`)\n`));
+  const code = await spawnClaude(['config', ...args]);
+  process.exit(code);
+}
+
+/**
+ * `bizar history` — list session history.
+ *
+ * Claude Code has no direct `history` subcommand (vs. Cline which had
+ * `cline history`). We expose this as a best-effort reader over
+ * `~/.claude/sessions/` — listing files and showing their mtime + size.
+ */
+export async function runClaudeHistory(args = []) {
+  const sessionsDir = join(resolveClaudeDir(), 'sessions');
+  if (!existsSync(sessionsDir)) {
+    console.log(chalk.yellow(`  No sessions directory at ${sessionsDir}`));
+    console.log(chalk.dim('  (Claude Code writes session files there when you exit a session.)'));
+    return;
+  }
+  // Parse --limit N if provided
+  let limit = 20;
+  const limitIdx = args.indexOf('--limit');
+  if (limitIdx >= 0) {
+    const n = parseInt(args[limitIdx + 1], 10);
+    if (Number.isFinite(n) && n > 0) limit = n;
+  }
+  const entries = readdirSync(sessionsDir, { withFileTypes: true })
+    .filter((e) => e.isFile())
+    .map((e) => {
+      const fp = join(sessionsDir, e.name);
+      const st = statSync(fp);
+      return { name: e.name, size: st.size, mtime: st.mtimeMs };
+    })
+    .sort((a, b) => b.mtime - a.mtime)
+    .slice(0, limit);
+  console.log(chalk.cyan(`  ${entries.length} session(s) in ${sessionsDir}:\n`));
+  for (const e of entries) {
+    const t = new Date(e.mtime).toISOString().replace('T', ' ').slice(0, 19);
+    console.log(`    ${t}  ${String(e.size).padStart(8)}B  ${e.name}`);
+  }
+}
+
+/**
+ * `bizar plugin <sub>` — manage the Claude Code plugin.
+ * Thin wrapper around `claude plugin <subcommand>`.
+ *
+ * In Claude Code, plugin management is split across:
+ *   - `claude plugin install <name>`  install from marketplace
+ *   - `claude plugin list`             list installed plugins
+ *   - `claude plugin enable <name>`    enable a plugin
+ *   - `claude plugin disable <name>`   disable a plugin
+ *   - `claude plugin remove <name>`    remove a plugin
+ */
+export async function runClaudePlugin(args = []) {
+  if (args.length === 0) {
+    console.log(chalk.cyan('  bizar plugin — Manage Claude Code plugins\n'));
+    console.log(chalk.dim('  Subcommands (passed through to `claude plugin`):'));
+    console.log('    install <name>   Install a plugin from the marketplace');
+    console.log('    list             List installed plugins');
+    console.log('    enable <name>    Enable a plugin');
+    console.log('    disable <name>   Disable a plugin');
+    console.log('    remove <name>    Remove a plugin');
+    console.log('');
+    console.log(chalk.dim('  Note: For Bizar marketplace plugins, use `claude plugin install .` from the repo root.'));
+    console.log('');
+    return;
+  }
+  console.log(chalk.dim(`  (delegating to \`claude plugin ${args.join(' ')}\`)\n`));
+  const code = await spawnClaude(['plugin', ...args]);
+  process.exit(code);
+}
+
+/**
+ * `bizar team <name> "mission" [...flags]` — spawn a coordinated agent
+ * team from the CLI directly.
+ *
+ * Cline had `--team-name <name>`. Claude Code has no direct equivalent
+ * (teams are coordinated via the Agent tool inside a session), but we
+ * can simulate it by spawning `claude --agent <name>` with a team
+ * prompt. Workaround for batch / scripting use cases.
+ *
+ * For full multi-agent orchestration, run `claude` interactively.
+ *
+ * Example:
+ *   bizar team auth-sprint "Plan and implement user auth with tests" \
+ *     --provider litellm --model minimaxcustom/MiniMax-M3
+ */
+export async function runClaudeTeam(args = []) {
+  if (args.length === 0) {
+    console.log(chalk.cyan('  bizar team — Spawn a coordinated agent team from the CLI\n'));
+    console.log(chalk.dim('  Usage:'));
+    console.log('    bizar team <name> "mission" [--provider X] [--model Y] [more flags]');
+    console.log('');
+    console.log(chalk.dim('  Workaround for batch / scripted use cases. Claude Code'));
+    console.log(chalk.dim('  coordinates teams via the Agent tool INSIDE a session; the'));
+    console.log(chalk.dim('  out-of-session equivalent is `claude --agent <name> "..."`.'));
+    console.log(chalk.dim('  Run `claude` interactively for full multi-agent orchestration.'));
+    console.log('');
+    return;
+  }
+  // First positional arg = team name, second = mission prompt.
+  const [name, mission, ...rest] = args;
+  if (!name) {
+    console.error(chalk.red('  ✗ Team name required'));
+    console.error(chalk.dim('    Usage: bizar team <name> "mission"'));
+    process.exit(2);
+  }
+  if (!mission) {
+    console.error(chalk.red('  ✗ Mission prompt required'));
+    console.error(chalk.dim('    Usage: bizar team <name> "mission"'));
+    process.exit(2);
+  }
+  console.log(chalk.cyan(`\n  🚀 Spawning team '${name}'\n`));
+  console.log(chalk.dim(`     Mission: ${mission}\n`));
+  // `claude -p "<prompt>" --agent <name>` is the closest out-of-session
+  // equivalent. The `--agent` flag picks the named agent (loaded from
+  // `~/.claude/agents/<name>.md`).
+  const code = await spawnClaude([
+    '-p', mission,
+    '--agent', name,
+    ...rest,
+  ]);
+  process.exit(code);
+}
+
+/**
+ * `bizar subagent <agent> "task"` — spawn a quick read-only research
+ * subagent via `claude --agent <name> "..."`.
+ *
+ * Note: Claude Code's in-session subagent dispatch uses the `Agent`
+ * tool (when the model decides to delegate). The `claude --agent
+ * <name>` out-of-session form launches a fresh Claude Code run with
+ * the named agent loaded.
+ */
+export async function runClaudeSubagent(args = []) {
+  if (args.length === 0) {
+    console.log(chalk.cyan('  bizar subagent — Spawn a quick read-only research subagent\n'));
+    console.log(chalk.dim('  Subagents are research agents. They run in parallel, '));
+    console.log(chalk.dim('  keep their own context window, and return a focused report.'));
+    console.log(chalk.dim('  Use them for broad codebase exploration without burning context.\n'));
+    console.log('');
+    console.log(chalk.dim('  Usage:'));
+    console.log('    bizar subagent <agent> "task"');
+    console.log('');
+    console.log(chalk.dim('  Note: for IN-SESSION subagent dispatch, use the Agent tool'));
+    console.log(chalk.dim('  Claude Code provides automatically. This wrapper uses'));
+    console.log(chalk.dim('  `claude --agent <name> "..."` for OUT-OF-SESSION use.'));
+    console.log('');
+    return;
+  }
+  const [agent, ...rest] = args;
+  const task = rest.find((a) => typeof a === 'string' && !a.startsWith('-'));
+  if (!agent || !task) {
+    console.error(chalk.red('  ✗ Usage: bizar subagent <agent> "task"'));
+    process.exit(2);
+  }
+  console.log(chalk.cyan(`\n  🔍 Spawning subagent '${agent}'\n`));
+  console.log(chalk.dim(`     Task: ${task}\n`));
+  // Claude Code CLI's --agent flag dispatches into a named agent
+  // role loaded from ~/.claude/agents/<name>.md.
+  const filteredArgs = rest.filter((a) => a !== task);
+  const code = await spawnClaude([
+    '--agent', agent,
+    '-p', task,
+    ...filteredArgs,
+  ]);
+  process.exit(code);
+}
+
+/**
+ * `bizar run [prompt]` — alias for `claude -p <prompt>` (one-shot run)
+ * or `claude --bg -p <prompt>` (background). Useful for piping work
+ * into Claude Code from a shell script.
+ *
+ * Example:
+ *   bizar run "fix the failing test in src/auth.test.ts"
+ *   bizar run --bg "monitor /var/log/auth.log"
+ */
+export async function runClaudeRun(args = []) {
+  if (args.length === 0) {
+    console.log(chalk.cyan('  bizar run — One-shot Claude Code invocation\n'));
+    console.log(chalk.dim('  Usage:'));
+    console.log('    bizar run "fix the failing test in src/auth.test.ts"');
+    console.log('    bizar run --bg "monitor /var/log/auth.log"   # background');
+    console.log('');
+    console.log(chalk.dim('  Maps to `claude -p "<prompt>"` (foreground) or `claude --bg -p <prompt>` (background).'));
+    return;
+  }
+  const bg = args.includes('--bg');
+  const filtered = args.filter((a) => a !== '--bg');
+  const prompt = filtered.join(' ');
+  const code = await spawnClaude(bg ? ['--bg', '-p', prompt] : ['-p', prompt]);
+  process.exit(code);
+}
+
+// ── run() entry point (used by bin.mjs dispatcher) ─────────────────────────
+
+export async function run(name, args, isHelpRequest) {
+  // Note: bin.mjs dispatcher calls run('team', [], false) etc.
+  // So `name` here is the subcommand itself.
+  if (name === 'config') { await runClaudeConfig(args); return true; }
+  if (name === 'history') { await runClaudeHistory(args); return true; }
+  if (name === 'plugin') { await runClaudePlugin(args); return true; }
+  if (name === 'team') { await runClaudeTeam(args); return true; }
+  if (name === 'subagent') { await runClaudeSubagent(args); return true; }
+  if (name === 'run') { await runClaudeRun(args); return true; }
+  // Fallback: show help.
+  showClaudeCmdHelp();
+  return true;
+}

package/cli/commands/cost.mjs

@@ -0,0 +1,279 @@
+/**
+ * cli/commands/cost.mjs
+ *
+ * F-035 (MetaHarness) — `bizar cost` subcommand surface.
+ *
+ * Subcommands:
+ *   bizar cost register <room> <cap>     # registerRoom(roomId, capUsd)
+ *   bizar cost status   <room>           # status(roomId) → JSON
+ *   bizar cost status   [--all]          # listRooms()
+ *   bizar cost reserve  <room> <amount>  # reserve(roomId, callerId, amount)
+ *     --caller <id>                     (default: process.env.USER)
+ *     --expiry <ms>                     (default: 60_000, clamped to [5s, 300s])
+ *   bizar cost commit   <txId> <amount>  # commit(txId, actualUsd)
+ *   bizar cost release  <txId>           # release(txId)
+ *   bizar cost sweep                      # sweepExpired() (manual)
+ *
+ * Wraps cli/cost-gate.mjs (better-sqlite3-backed, atomic).
+ *
+ * --json flag for machine-readable output.
+ */
+
+import chalk from 'chalk';
+import { existsSync } from 'node:fs';
+
+import { CostGate, defaultDbPath } from '../cost-gate.mjs';
+
+const EXIT_OK = 0;
+const EXIT_ERROR = 1;
+const EXIT_USAGE = 2;
+
+function parseFlags(args) {
+  const flags = { _: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--json') flags.json = true;
+    else if (a === '--all') flags.all = true;
+    else if (a === '--caller' && i + 1 < args.length) { flags.caller = args[++i]; }
+    else if (a.startsWith('--caller=')) flags.caller = a.slice('--caller='.length);
+    else if (a === '--expiry' && i + 1 < args.length) { flags.expiry = Number(args[++i]); }
+    else if (a.startsWith('--expiry=')) flags.expiry = Number(a.slice('--expiry='.length));
+    else if (a === '--db' && i + 1 < args.length) { flags.db = args[++i]; }
+    else if (a.startsWith('--db=')) flags.db = a.slice('--db='.length);
+    else if (a === '--help' || a === '-h') flags.help = true;
+    else flags._.push(a);
+  }
+  return flags;
+}
+
+function showHelp() {
+  console.log(`
+  bizar cost — atomic cost gate (SQLite-backed room budget tracker)
+
+  Usage:
+    bizar cost register <room> <cap>            Register a room with a monthly cap (USD)
+    bizar cost status   [room] [--all]          Show one room's status, or list all rooms
+    bizar cost reserve  <room> <amount>         Reserve budget (atomic; returns txId)
+      [--caller <id>]                           Caller id (default: $USER)
+      [--expiry <ms>]                           Reservation window (default 60000, range [5s,300s])
+    bizar cost commit   <txId> <amount>         Commit the actual cost
+    bizar cost release  <txId>                  Release a still-reserved reservation
+    bizar cost sweep                            Sweep expired reservations (--expired)
+    bizar cost list                              List all transactions in a room (requires <room>)
+
+  Flags:
+    --json            Machine-readable JSON output
+    --db <path>       Override DB path (default: ~/.bizar/cost-gate.db)
+    --all             For \`status\`: list every room
+    --caller <id>     Reservation caller id
+    --expiry <ms>     Reservation window before expiry
+    --help, -h        Show this help
+
+  Description:
+    The cost gate prevents overspend on multi-model orchestration by
+    atomically reserving / committing / releasing micro-budget lines
+    per request. Uses better-sqlite3 with WAL + BEGIN IMMEDIATE so
+    concurrent reserves never double-spend.
+
+  Examples:
+    bizar cost register titan-cluster 50
+    bizar cost reserve titan-cluster 1.50 --caller sonnet --expiry 30000
+    bizar cost commit   tx-7a4b... 0.42
+`);
+}
+
+function withGate(flags, fn) {
+  const gate = new CostGate({ dbPath: flags.db || defaultDbPath() });
+  try {
+    return fn(gate);
+  } finally {
+    gate.close();
+  }
+}
+
+function out(result, flags, formatter) {
+  if (flags.json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  } else if (formatter) {
+    formatter(result);
+  } else if (typeof result === 'string') {
+    console.log(result);
+  } else {
+    console.log(JSON.stringify(result, null, 2));
+  }
+}
+
+export async function run(name, args, isHelpRequest) {
+  if (name !== 'cost') return false;
+  const flags = parseFlags(args);
+  if (flags.help || isHelpRequest) {
+    showHelp();
+    return true;
+  }
+
+  const [sub, ...rest] = flags._;
+  if (!sub) {
+    showHelp();
+    return true;
+  }
+
+  try {
+    if (sub === 'register') {
+      const [room, capStr] = rest;
+      if (!room || capStr == null) {
+        console.error(chalk.red('  ✗ Usage: bizar cost register <room> <cap>'));
+        return false;
+      }
+      const cap = Number(capStr);
+      if (!Number.isFinite(cap) || cap < 0) {
+        console.error(chalk.red('  ✗ cap must be a non-negative number'));
+        return false;
+      }
+      const result = withGate(flags, (gate) => gate.registerRoom(room, cap));
+      out(result, flags, (r) =>
+        console.log(chalk.green(`  ✓ Registered room '${r.roomId}' with cap $${r.capUsd.toFixed(2)}`)),
+      );
+      return true;
+    }
+
+    if (sub === 'status') {
+      const [room] = rest;
+      const result = withGate(flags, (gate) => {
+        if (flags.all || !room) return { rooms: gate.listRooms() };
+        return gate.status(room);
+      });
+      out(result, flags, (r) => {
+        if (r.rooms) {
+          console.log(chalk.bold(`  Rooms (${r.rooms.length}):`));
+          for (const rm of r.rooms) {
+            console.log(`    ${chalk.cyan(rm.roomId)} cap=$${rm.capUsd.toFixed(2)} spent=$${rm.spentUsd.toFixed(2)} reserved=$${rm.reservedUsd.toFixed(2)} remaining=$${rm.remainingUsd.toFixed(2)}`);
+          }
+          return;
+        }
+        if (r === null) {
+          console.log(chalk.yellow(`  ! Room '${room}' not found`));
+          return;
+        }
+        console.log(chalk.bold(`  Room ${chalk.cyan(r.roomId)}:`));
+        console.log(`    cap      = $${r.capUsd.toFixed(2)}`);
+        console.log(`    spent    = $${r.spentUsd.toFixed(2)}`);
+        console.log(`    reserved = $${r.reservedUsd.toFixed(2)}`);
+        console.log(`    remaining= $${r.remainingUsd.toFixed(2)}`);
+        console.log(`    txCount  = ${r.txCount}`);
+      });
+      return true;
+    }
+
+    if (sub === 'reserve') {
+      const [room, amountStr] = rest;
+      if (!room || amountStr == null) {
+        console.error(chalk.red('  ✗ Usage: bizar cost reserve <room> <amount> [--caller <id>] [--expiry <ms>]'));
+        return false;
+      }
+      const amount = Number(amountStr);
+      if (!Number.isFinite(amount) || amount < 0) {
+        console.error(chalk.red('  ✗ amount must be a non-negative number'));
+        return false;
+      }
+      const caller = flags.caller || process.env.USER || 'unknown';
+      const opts = {};
+      if (flags.expiry != null) opts.expiryMs = flags.expiry;
+      const result = withGate(flags, (gate) => gate.reserve(room, caller, amount, opts));
+      if (!result.ok) {
+        if (flags.json) {
+          process.stdout.write(JSON.stringify(result) + '\n');
+        } else {
+          console.log(chalk.red(`  ✗ Reserve failed: ${result.error}`));
+          if (result.error === 'BUDGET_EXCEEDED') {
+            console.log(chalk.dim(`     cap=$${result.capUsd.toFixed(2)} committed=$${result.committed.toFixed(2)} reserved=$${result.reserved.toFixed(2)}`));
+          }
+        }
+        return true; // graceful failure with status to caller
+      }
+      out(result, flags, (r) =>
+        console.log(
+          chalk.green(`  ✓ Reserved $${amount.toFixed(2)} in '${room}' → ${chalk.bold(r.txId)} (expires in ${Math.round((r.expiresAt - Date.now()) / 1000)}s, remaining=$${r.remainingAfterReserve.toFixed(2)})`),
+        ),
+      );
+      return true;
+    }
+
+    if (sub === 'commit') {
+      const [txId, amountStr] = rest;
+      if (!txId || amountStr == null) {
+        console.error(chalk.red('  ✗ Usage: bizar cost commit <txId> <amount>'));
+        return false;
+      }
+      const amount = Number(amountStr);
+      if (!Number.isFinite(amount) || amount < 0) {
+        console.error(chalk.red('  ✗ amount must be a non-negative number'));
+        return false;
+      }
+      const result = withGate(flags, (gate) => gate.commit(txId, amount));
+      out(result, flags, (r) => {
+        if (!r.ok) {
+          console.log(chalk.red(`  ✗ Commit failed: ${r.error}`));
+          return;
+        }
+        if (r.warned === 'COMMIT_AFTER_EXPIRY') {
+          console.log(chalk.yellow(`  ⚠ Committed ${txId} after expiry ($${amount.toFixed(2)}); remaining=$${r.finalRemaining.toFixed(2)}`));
+        } else {
+          console.log(chalk.green(`  ✓ Committed ${txId} ($${amount.toFixed(2)}); remaining=$${r.finalRemaining.toFixed(2)}`));
+        }
+      });
+      return true;
+    }
+
+    if (sub === 'release') {
+      const [txId] = rest;
+      if (!txId) {
+        console.error(chalk.red('  ✗ Usage: bizar cost release <txId>'));
+        return false;
+      }
+      const result = withGate(flags, (gate) => gate.release(txId));
+      out(result, flags, (r) => {
+        if (!r.ok) {
+          console.log(chalk.red(`  ✗ Release failed: ${r.error}`));
+          return;
+        }
+        console.log(chalk.green(`  ✓ Released ${txId}`));
+      });
+      return true;
+    }
+
+    if (sub === 'sweep') {
+      const result = withGate(flags, (gate) => ({ swept: gate.sweepExpired() }));
+      out(result, flags, (r) =>
+        console.log(chalk.green(`  ✓ Swept ${r.swept} expired reservation(s)`)),
+      );
+      return true;
+    }
+
+    if (sub === 'list') {
+      const [room] = rest;
+      if (!room) {
+        console.error(chalk.red('  ✗ Usage: bizar cost list <room>'));
+        return false;
+      }
+      const result = withGate(flags, (gate) => ({ room, txs: gate.listTransactions(room) }));
+      out(result, flags, (r) => {
+        if (r.txs.length === 0) {
+          console.log(chalk.dim(`  (no transactions in ${r.room})`));
+          return;
+        }
+        console.log(chalk.bold(`  Transactions in ${r.room}:`));
+        for (const t of r.txs) {
+          console.log(`    ${chalk.cyan(t.tx_id.slice(0, 12))}…  kind=${t.kind} amount=$${t.amount_usd.toFixed(4)} ts=${new Date(t.ts).toISOString()}`);
+        }
+      });
+      return true;
+    }
+
+    console.error(chalk.red(`  ✗ Unknown subcommand: ${sub}`));
+    showHelp();
+    return false;
+  } catch (err) {
+    console.error(chalk.red(`  ✗ ${err && err.message ? err.message : String(err)}`));
+    return false;
+  }
+}

package/cli/commands/install.mjs

@@ -32,11 +32,12 @@ export function showInstallHelp() {
        python3.12, jq, gh on Linux; brew on macOS) + service registration
        (systemd / launchd / Task Scheduler).
     3. Syncs agent files, slash commands, and bundled skills into
-       ~/.config/cline/.
-    4. Copies plugins/bizar/ from the npm install into
-       ~/.config/cline/plugins/bizar/ (preserves dev symlinks).
-    5. Patches ~/.config/cline/cline.json with the Bizar plugin
-       entry (skipped if already present).
+       ~/.claude/ (or $CLAUDE_CONFIG_DIR).
+    4. Registers the Bizar MCP server in ~/.claude/settings.json
+       (skipped if already present; the plugin shim is now an MCP
+       transport, not a Cline plugin).
+    5. Wires Claude Code lifecycle hooks (SessionStart / PreToolUse /
+       PostToolUse / UserPromptSubmit) under ~/.claude/hooks/.
     6. Runs 'bizar doctor' as a post-install health check.
 
     No API key collection, no interactive prompts.
@@ -45,9 +46,9 @@ export function showInstallHelp() {
 
 export function showUpdateHelp() {
   console.log(`
-  bizar update — Update cline + @polderlabs/bizar (which bundles the
-  plugin and dashboard). Detects what's installed and only touches what's
-  missing or out of date.
+  bizar update — Update @anthropic-ai/claude-code + @polderlabs/bizar
+  (which bundles the SDK, dashboard, and plugin shim). Detects what's
+  installed and only touches what's missing or out of date.
 
   Usage:
     bizar update                       Update EVERYTHING (default; auto-kills + restarts)
@@ -61,8 +62,8 @@ export function showUpdateHelp() {
     bizar update --help                Show this help
 
   Components updated:
-    cline   the cline CLI itself
-    @polderlabs/bizar    this CLI + dashboard + plugin (one package)
+    @anthropic-ai/claude-code   the Claude Code CLI itself
+    @polderlabs/bizar    this CLI + dashboard + SDK (one package)
 
   Behavior (v4.4.7+):
     • Single unified provisioner. 'bizar install' and 'bizar update' are
@@ -79,7 +80,7 @@ export function showUpdateHelp() {
       fresh detached dashboard process with the new code (skipped with
       --no-restart).
     • Runs 'bizar doctor' after a successful update to catch config
-      regressions before cline tries to start.
+      regressions before claude tries to start.
     • With --check: prints the version matrix and release-notes excerpt
       between current and latest, exits non-zero if an update is available.