@polderlabs/bizar 6.3.0 → 7.0.1

package/cli/bin.mjs

@@ -137,6 +137,8 @@ function showHelp() {
     team                   Spawn an agent team from CLI (wraps claude --team-name)
     subagent               Spawn a read-only research subagent from CLI
     rca                    Analyze a GitHub issue (Claude Code CLI sample)
+    cost <subcommand>      Atomic cost gate (SQLite-backed room budget tracker)
+    claim <subcommand>     GitHub-style claim protocol over feature_list.json
 
   Examples:
     bizar install
@@ -597,6 +599,42 @@ async function main() {
       break;
     }
 
+    case 'cost': {
+      // F-035 MetaHarness — atomic SQLite-backed cost gate.
+      // Subcommands: register | status | reserve | commit | release | sweep | list
+      const mod = await importCommand('cost');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load cost command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'cost');
+      const found = await mod.run(cmd, cmdArgs, isHelpRequest);
+      if (found === false) {
+        console.error(chalk.red(`  ✗ Usage: bizar cost <subcommand> — run 'bizar cost --help'`));
+        process.exit(EXIT_USAGE);
+      }
+      break;
+    }
+
+    case 'claim': {
+      // F-035 MetaHarness — GitHub-style claim protocol over feature_list.json.
+      // Subcommands: <featureId> | release | handoff | steal | status | list | transition
+      const mod = await importCommand('claim');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load claim command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'claim');
+      const found = await mod.run(cmd, cmdArgs, isHelpRequest);
+      if (found === false) {
+        console.error(chalk.red(`  ✗ Usage: bizar claim <subcommand> — run 'bizar claim --help'`));
+        process.exit(EXIT_USAGE);
+      }
+      break;
+    }
+
     default: {
       console.error(chalk.red(`  ✗ Unknown command: ${cmd}`));
       showHelp();

package/cli/commands/claim.mjs

@@ -0,0 +1,282 @@
+/**
+ * cli/commands/claim.mjs
+ *
+ * F-035 (MetaHarness) — `bizar claim` subcommand surface.
+ *
+ * Wraps cli/feature-list-bridge.mjs (over feature_list.json).
+ *
+ * Subcommands:
+ *   bizar claim <featureId>                      # claim with --who (or $USER)
+ *     --who <id>                                 (default: $USER)
+ *     --type <human|agent>                       (default: human)
+ *     --reason <text>                            Free-form claim reason
+ *   bizar claim release <featureId>              # release
+ *     --who <id>                                 Optional claimant check
+ *     --reason <text>
+ *   bizar claim handoff <featureId> --to <id>    # handoff
+ *     --from <id>
+ *     --reason <text>
+ *   bizar claim steal <featureId> --by <id>       # steal
+ *     --type <human|agent>
+ *     --reason <steal-reason>                    Must be one of STEAL_REASONS
+ *   bizar claim status <featureId>               # Show current claim + history
+ *   bizar claim list                              # list all features with status
+ *     --status <s>                               One of CLAIM_STATUSES (repeatable)
+ *     --by-claimant <id>                         Filter by claimant id
+ *     --human-only / --agent-only
+ *   bizar claim transition <featureId> <newStatus>     # active|paused|blocked|completed
+ *     --who <id>
+ *     --reason <text>
+ *
+ * --json flag for machine output.
+ */
+
+import chalk from 'chalk';
+
+import { FeatureListBridge, ClaimError, CLAIM_STATUSES, STEAL_REASONS, defaultFeatureListPath } from '../feature-list-bridge.mjs';
+
+function parseFlags(args) {
+  const flags = { _: [], statuses: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--json') flags.json = true;
+    else if (a === '--who' && i + 1 < args.length) { flags.who = args[++i]; }
+    else if (a.startsWith('--who=')) flags.who = a.slice('--who='.length);
+    else if (a === '--type' && i + 1 < args.length) { flags.type = args[++i]; }
+    else if (a.startsWith('--type=')) flags.type = a.slice('--type='.length);
+    else if (a === '--reason' && i + 1 < args.length) { flags.reason = args[++i]; }
+    else if (a.startsWith('--reason=')) flags.reason = a.slice('--reason='.length);
+    else if (a === '--to' && i + 1 < args.length) { flags.to = args[++i]; }
+    else if (a.startsWith('--to=')) flags.to = a.slice('--to='.length);
+    else if (a === '--from' && i + 1 < args.length) { flags.from = args[++i]; }
+    else if (a.startsWith('--from=')) flags.from = a.slice('--from='.length);
+    else if (a === '--by' && i + 1 < args.length) { flags.by = args[++i]; }
+    else if (a.startsWith('--by=')) flags.by = a.slice('--by='.length);
+    else if (a === '--status' && i + 1 < args.length) { flags.statuses.push(args[++i]); }
+    else if (a.startsWith('--status=')) flags.statuses.push(a.slice('--status='.length));
+    else if (a === '--by-claimant' && i + 1 < args.length) { flags.byClaimant = args[++i]; }
+    else if (a.startsWith('--by-claimant=')) flags.byClaimant = a.slice('--by-claimant='.length);
+    else if (a === '--human-only') flags.humanOnly = true;
+    else if (a === '--agent-only') flags.agentOnly = true;
+    else if (a === '--file' && i + 1 < args.length) { flags.file = args[++i]; }
+    else if (a.startsWith('--file=')) flags.file = a.slice('--file='.length);
+    else if (a === '--help' || a === '-h') flags.help = true;
+    else flags._.push(a);
+  }
+  return flags;
+}
+
+function makeClaimant(flags, fallbackId) {
+  const id = flags.who || flags.by || fallbackId;
+  const type = flags.type || 'human';
+  if (!id) return null;
+  return { type, id, name: id };
+}
+
+function bridge(flags) {
+  return new FeatureListBridge({
+    filePath: flags.file || defaultFeatureListPath(),
+  });
+}
+
+function showHelp() {
+  console.log(`
+  bizar claim — GitHub-ish claim protocol over feature_list.json
+
+  Usage:
+    bizar claim <featureId> [--who <id>] [--type human|agent] [--reason <text>]
+    bizar claim release <featureId> [--who <id>] [--reason <text>]
+    bizar claim handoff <featureId> --to <id> [--from <id>] [--reason <text>]
+    bizar claim steal <featureId> --by <id> [--type human|agent] --reason <reason>
+    bizar claim status <featureId>
+    bizar claim list [--status <s>] [--by-claimant <id>] [--human-only|--agent-only]
+    bizar claim transition <featureId> <active|paused|blocked|completed> [--who <id>]
+
+  Steal reasons (must match exactly):
+    ${STEAL_REASONS.join(' | ')}
+
+  Status states (must match exactly):
+    ${CLAIM_STATUSES.join(' | ')}
+
+  Flags:
+    --json                       Machine-readable JSON output
+    --file <path>                Override feature_list.json path
+    --who <id> / --by <id>       Claimant identifier (default: $USER)
+    --type human|agent           Claimant type (default: human)
+    --reason <text>              Free-form reason (mandatory for steal)
+    --to / --from <id>           Recipient / sender for handoff
+    --human-only / --agent-only  Restrict list to human or agent claims
+    --status <s>                 Filter list (repeat for multiple)
+    --by-claimant <id>           Filter list by claimant id
+    --help, -h                   Show this help
+
+  Examples:
+    bizar claim F-035 --who odin --reason "porting MetaHarness from ruflo"
+    bizar claim steal F-014 --by hermod --reason stale
+    bizar claim handoff F-035 --to tyr --from odin
+    bizar claim list --status claimed --agent-only
+`);
+}
+
+function out(result, flags, formatter) {
+  if (flags.json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  } else if (formatter) {
+    formatter(result);
+  } else {
+    console.log(JSON.stringify(result, null, 2));
+  }
+}
+
+export async function run(name, args, isHelpRequest) {
+  if (name !== 'claim') return false;
+  const flags = parseFlags(args);
+  if (flags.help || isHelpRequest) {
+    showHelp();
+    return true;
+  }
+
+  const [sub, ...rest] = flags._;
+  const fallback = process.env.USER || 'unknown';
+  const who = flags.who || fallback;
+
+  try {
+    const br = bridge(flags);
+
+    if (!sub || sub === 'help') {
+      showHelp();
+      return true;
+    }
+
+    if (sub === 'list' || sub === 'ls') {
+      const filters = {};
+      if (flags.statuses.length) filters.status = flags.statuses;
+      if (flags.byClaimant) filters.claimantId = flags.byClaimant;
+      if (flags.humanOnly) filters.claimedByHuman = true;
+      if (flags.agentOnly) filters.claimedByAgent = true;
+      const rows = br.list(filters);
+      out({ count: rows.length, features: rows }, flags, (r) => {
+        console.log(chalk.bold(`  Claims (${r.count}):`));
+        for (const f of r.features) {
+          const who = f.claimant ? `${f.claimant.name || f.claimant.id} (${f.claimant.type})` : '—';
+          console.log(`    ${chalk.cyan(f.id)} [${f.claimStatus || 'unclaimed'}] by ${who}`);
+        }
+      });
+      return true;
+    }
+
+    if (sub === 'status' || sub === 'show' || sub === 'get') {
+      const featureId = rest[0];
+      if (!featureId) {
+        console.error(chalk.red('  ✗ Usage: bizar claim status <featureId>'));
+        return false;
+      }
+      const feature = br.get(featureId);
+      out(feature, flags, (f) => {
+        console.log(chalk.bold(`  ${chalk.cyan(f.id)} — ${f.behavior || ''}`));
+        const who = f.claimant ? `${f.claimant.name || f.claimant.id} (${f.claimant.type})` : 'unclaimed';
+        console.log(`    state        = ${f.state}`);
+        console.log(`    claim        = ${f.claimStatus || 'unclaimed'} (by ${who})`);
+        console.log(`    claimedAt    = ${f.claimedAt || '—'}`);
+        console.log(`    claimReason  = ${f.claimReason || '—'}`);
+        const hist = Array.isArray(f.claimHistory) ? f.claimHistory : [];
+        console.log(`    history      = ${hist.length} event(s)`);
+        for (const e of hist.slice(-8)) {
+          console.log(`      ${e.ts} ${chalk.dim(e.event)}${e.reason ? ' — ' + e.reason : ''}`);
+        }
+      });
+      return true;
+    }
+
+    if (sub === 'release') {
+      const featureId = rest[0];
+      if (!featureId) {
+        console.error(chalk.red('  ✗ Usage: bizar claim release <featureId> [--who <id>] [--reason <text>]'));
+        return false;
+      }
+      const claimant = makeClaimant({ who, type: flags.type }, fallback);
+      const result = br.release(featureId, claimant, flags.reason || '');
+      out(result, flags, (r) =>
+        console.log(chalk.green(`  ✓ Released ${featureId}`) + (r.previousClaimant ? chalk.dim(` (was held by ${r.previousClaimant.name || r.previousClaimant.id})`) : '')),
+      );
+      return true;
+    }
+
+    if (sub === 'handoff') {
+      const featureId = rest[0];
+      if (!featureId || !flags.to) {
+        console.error(chalk.red('  ✗ Usage: bizar claim handoff <featureId> --to <id> [--from <id>] [--reason <text>]'));
+        return false;
+      }
+      const fromClaimant = flags.from ? { type: flags.type || 'human', id: flags.from, name: flags.from } : null;
+      const toClaimant = { type: flags.type || 'human', id: flags.to, name: flags.to };
+      const result = br.handoff(featureId, fromClaimant, toClaimant, flags.reason || '');
+      out(result, flags, (r) =>
+        console.log(chalk.green(`  ✓ Handed off ${featureId} → ${flags.to}`)),
+      );
+      return true;
+    }
+
+    if (sub === 'steal') {
+      const featureId = rest[0];
+      if (!featureId || !flags.by) {
+        console.error(chalk.red('  ✗ Usage: bizar claim steal <featureId> --by <id> --reason <reason>'));
+        return false;
+      }
+      if (!flags.reason) {
+        console.error(chalk.red('  ✗ steal requires --reason (one of: ' + STEAL_REASONS.join(', ') + ')'));
+        return false;
+      }
+      const newClaimant = { type: flags.type || 'human', id: flags.by, name: flags.by };
+      const result = br.steal(featureId, newClaimant, flags.reason);
+      out(result, flags, (r) =>
+        console.log(chalk.green(`  ✓ Stole ${featureId} (reason: ${r.stealReason}); previous owner: ${r.previousClaimant?.name || r.previousClaimant?.id || '—'}`)),
+      );
+      return true;
+    }
+
+    if (sub === 'transition') {
+      const [featureId, newStatus] = rest;
+      if (!featureId || !newStatus) {
+        console.error(chalk.red('  ✗ Usage: bizar claim transition <featureId> <active|paused|blocked|completed> [--who <id>]'));
+        return false;
+      }
+      if (!CLAIM_STATUSES.includes(newStatus)) {
+        console.error(chalk.red(`  ✗ Unknown status '${newStatus}'. Must be one of: ${CLAIM_STATUSES.join(', ')}`));
+        return false;
+      }
+      const claimant = makeClaimant({ who: flags.who, type: flags.type }, fallback);
+      const result = br.transition(featureId, newStatus, claimant, flags.reason || '');
+      out(result, flags, (r) =>
+        console.log(chalk.green(`  ✓ ${featureId} → ${newStatus}` + (r.unchanged ? ' (unchanged)' : ''))),
+      );
+      return true;
+    }
+
+    // Default: `bizar claim <featureId>` — claim it.
+    if (!sub.startsWith('-') && sub) {
+      const featureId = sub;
+      const claimant = makeClaimant({ who: flags.who, type: flags.type }, fallback);
+      if (!claimant) {
+        console.error(chalk.red('  ✗ No claimant id (set $USER or pass --who <id>)'));
+        return false;
+      }
+      const result = br.claim(featureId, claimant, flags.reason || '');
+      out(result, flags, (r) =>
+        console.log(chalk.green(`  ✓ Claimed ${featureId} by ${r.feature.claimant.name || r.feature.claimant.id} (${r.feature.claimStatus})`)),
+      );
+      return true;
+    }
+
+    console.error(chalk.red(`  ✗ Unknown subcommand: ${sub}`));
+    showHelp();
+    return false;
+  } catch (err) {
+    if (err instanceof ClaimError) {
+      console.error(chalk.red(`  ✗ ${err.code}: ${err.message}`));
+    } else {
+      console.error(chalk.red(`  ✗ ${err && err.message ? err.message : String(err)}`));
+    }
+    return false;
+  }
+}

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;
+  }
+}