@meterbility/cli 0.3.1

package/dist/index.js

@@ -0,0 +1,3018 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import pc23 from "picocolors";
+
+// src/commands/ingest.ts
+import { existsSync } from "fs";
+import pc2 from "picocolors";
+import {
+  discoverSessions,
+  ingestSession
+} from "@meterbility/claude-code-adapter";
+import {
+  discoverCodexSessions,
+  ingestCodexSession
+} from "@meterbility/codex-cli-adapter";
+import {
+  defaultGlobalDbPath,
+  discoverCursorWorkspaces,
+  ingestCursorGlobal
+} from "@meterbility/cursor-adapter";
+
+// src/util.ts
+import pc from "picocolors";
+import { Store } from "@meterbility/collector";
+import { fmtCents, fmtTokens } from "@meterbility/shared";
+function openStore() {
+  return Store.open();
+}
+function statusColor(status) {
+  switch (status) {
+    case "ok":
+      return pc.green;
+    case "error":
+      return pc.red;
+    case "in_progress":
+      return pc.yellow;
+    case "abandoned":
+      return pc.gray;
+    default:
+      return (s) => s;
+  }
+}
+function actionLabel(step) {
+  switch (step.action.kind) {
+    case "tool_call":
+      return `${step.action.tool_name ?? "tool"}`;
+    case "message":
+      return "message";
+    case "thinking_only":
+      return "thinking";
+    case "sub_agent_dispatch":
+      return `sub_agent(${step.action.sub_agent ?? "?"})`;
+    case "none":
+      return "\u2014";
+  }
+}
+function shortId(id, len = 12) {
+  return id.length > len ? id.slice(0, len) : id;
+}
+function runSummaryLine(r) {
+  const status = statusColor(r.status)(r.status.padEnd(11));
+  const cost = fmtCents(r.cost_cents).padStart(8);
+  return `${pc.dim(shortId(r.run_id))}  ${status}  ${String(r.step_count).padStart(4)} steps  ${cost}  ${pc.cyan(
+    shortId(r.git_branch ?? "", 16).padEnd(16)
+  )}  ${r.title ?? ""}`;
+}
+
+// src/commands/ingest.ts
+function registerIngestCommand(program2) {
+  const ingest = program2.command("ingest").description("Capture agent runs into the local store");
+  ingest.command("claude-code [path]").description(
+    "Import Claude Code sessions. With no path, ingests every session under ~/.claude/projects (only new bytes per file)."
+  ).option("--cwd <dir>", "Restrict to a project by working directory").option("--limit <n>", "Cap number of sessions ingested", (v) => parseInt(v, 10)).action(async (path, opts) => {
+    const store = openStore();
+    try {
+      let paths = [];
+      if (path) {
+        if (!existsSync(path)) throw new Error(`not found: ${path}`);
+        paths = [path];
+      } else {
+        const sessions = await discoverSessions({ cwd: opts.cwd });
+        paths = sessions.map((s) => s.path);
+        if (opts.limit) paths = paths.slice(0, opts.limit);
+      }
+      if (paths.length === 0) {
+        console.log(pc2.dim("no sessions to ingest"));
+        return;
+      }
+      let totalSteps = 0;
+      let totalBytes = 0;
+      let runs = 0;
+      for (const p of paths) {
+        const r = await ingestSession(store, p);
+        if (r.status === "empty") {
+          console.log(`${pc2.dim("skip")}  ${p} ${pc2.dim("(no new bytes)")}`);
+          continue;
+        }
+        runs += 1;
+        totalSteps += r.steps_added;
+        totalBytes += r.bytes_read;
+        console.log(
+          `${pc2.green("ingested")}  ${p}  ${pc2.dim(
+            `run=${r.run_id.slice(0, 12)} steps=${r.steps_added} bytes=${r.bytes_read}`
+          )}`
+        );
+      }
+      console.log(
+        pc2.bold(
+          `
+${runs} run(s) updated \xB7 ${totalSteps} step(s) \xB7 ${(totalBytes / 1024).toFixed(1)}KB read`
+        )
+      );
+    } finally {
+      store.close();
+    }
+  });
+  ingest.command("codex-cli [path]").description(
+    "Import Codex / Codex Desktop sessions. With no path, ingests every rollout under ~/.codex/sessions."
+  ).option("--limit <n>", "Cap number of sessions ingested", (v) => parseInt(v, 10)).action(async (path, opts) => {
+    const store = openStore();
+    try {
+      let paths = [];
+      if (path) {
+        if (!existsSync(path)) throw new Error(`not found: ${path}`);
+        paths = [path];
+      } else {
+        const sessions = await discoverCodexSessions();
+        paths = sessions.map((s) => s.path);
+        if (opts.limit) paths = paths.slice(0, opts.limit);
+      }
+      if (paths.length === 0) {
+        console.log(pc2.dim("no Codex sessions to ingest"));
+        return;
+      }
+      let runs = 0;
+      let totalSteps = 0;
+      let totalBytes = 0;
+      for (const p of paths) {
+        const r = await ingestCodexSession(store, p);
+        if (r.status === "empty") {
+          console.log(`${pc2.dim("skip")}  ${p} ${pc2.dim("(no new bytes)")}`);
+          continue;
+        }
+        runs += 1;
+        totalSteps += r.steps_added;
+        totalBytes += r.bytes_read;
+        console.log(
+          `${pc2.green("ingested")}  ${p}  ${pc2.dim(
+            `run=${r.run_id.slice(0, 12)} steps=${r.steps_added} bytes=${r.bytes_read}`
+          )}`
+        );
+      }
+      console.log(
+        pc2.bold(
+          `
+${runs} run(s) updated \xB7 ${totalSteps} step(s) \xB7 ${(totalBytes / 1024).toFixed(1)}KB read`
+        )
+      );
+    } finally {
+      store.close();
+    }
+  });
+  ingest.command("cursor").description(
+    "Import Cursor composer (Agents/Composer window) conversations from the global state.vscdb."
+  ).option("--db <path>", "Override path to Cursor's state.vscdb").option("--composer <id>", "Restrict to one composer id").option(
+    "--limit <n>",
+    "Cap composers ingested (newest-first)",
+    (v) => parseInt(v, 10)
+  ).option(
+    "--since <iso>",
+    "Skip composers older than this ISO timestamp"
+  ).option(
+    "--cwd <dir>",
+    "Project cwd to attribute the runs to (defaults to '(cursor)')"
+  ).option(
+    "--list-workspaces",
+    "Just print discovered Cursor workspaces and exit"
+  ).action(async (opts) => {
+    if (opts.listWorkspaces) {
+      const ws = await discoverCursorWorkspaces();
+      if (ws.length === 0) {
+        console.log(pc2.dim("no Cursor workspace storage found"));
+        return;
+      }
+      console.log(pc2.bold("Cursor workspaces (newest first):"));
+      for (const w of ws.slice(0, 20)) {
+        console.log(
+          `  ${pc2.cyan(w.workspace_id.slice(0, 12))}  ${w.mtime.toISOString()}  ${pc2.dim(w.path)}`
+        );
+      }
+      return;
+    }
+    const store = openStore();
+    try {
+      const sinceMs = opts.since ? Date.parse(opts.since) : void 0;
+      const dbPath2 = opts.db ?? defaultGlobalDbPath();
+      const r = await ingestCursorGlobal(store, {
+        dbPath: dbPath2,
+        composerId: opts.composer,
+        limit: opts.limit,
+        sinceMs: Number.isFinite(sinceMs) ? sinceMs : void 0,
+        cwd: opts.cwd
+      });
+      if (r.status !== "ok") {
+        console.log(`${pc2.yellow(r.status)}  ${r.reason ?? ""}`);
+        return;
+      }
+      console.log(
+        pc2.bold(
+          `${r.composers_ingested}/${r.composers_seen} composer(s) \xB7 ${r.steps_added} step(s)`
+        )
+      );
+    } finally {
+      store.close();
+    }
+  });
+  ingest.command("discover").description("List Claude Code sessions visible to Meterbility, newest first").option("--cwd <dir>", "Restrict to one project").action(async (opts) => {
+    const sessions = await discoverSessions({ cwd: opts.cwd });
+    if (sessions.length === 0) {
+      console.log(pc2.dim("no sessions found"));
+      return;
+    }
+    console.log(pc2.bold("Sessions:"));
+    for (const s of sessions.slice(0, 50)) {
+      console.log(
+        `  ${pc2.cyan(s.session_id.slice(0, 8))}  ${s.mtime.toISOString()}  ${(s.size_bytes / 1024).toFixed(1).padStart(8)}KB  ${pc2.dim(s.project_dir)}`
+      );
+    }
+    if (sessions.length > 50) {
+      console.log(pc2.dim(`  \u2026 ${sessions.length - 50} more`));
+    }
+  });
+}
+
+// src/commands/list.ts
+import pc3 from "picocolors";
+import { listRuns } from "@meterbility/collector";
+function registerListCommand(program2) {
+  program2.command("list").alias("ls").description("List recent runs").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10), 30).option("--status <s>", "filter by status (ok|error|in_progress|abandoned)").option("--tool <name>", "filter to runs containing a tool call by name").action(async (opts) => {
+    const store = openStore();
+    try {
+      const runs = listRuns(store, {
+        limit: opts.limit,
+        status: opts.status,
+        containsTool: opts.tool
+      });
+      if (runs.length === 0) {
+        console.log(
+          pc3.dim(
+            "no runs found. Try: meter ingest claude-code --limit 1"
+          )
+        );
+        return;
+      }
+      console.log(
+        pc3.bold(
+          "RUN".padEnd(12) + "  STATUS       STEPS  COST       BRANCH            TITLE"
+        )
+      );
+      for (const r of runs) console.log(runSummaryLine(r));
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/commands/inspect.ts
+import pc4 from "picocolors";
+import {
+  getRun,
+  getStep,
+  getStepBySequence,
+  listAnnotations,
+  listFileChanges,
+  listForks,
+  listSteps,
+  resolveSnapshotBlobRef
+} from "@meterbility/collector";
+import { reformatJsonString, prettyTab } from "@meterbility/server";
+function registerInspectCommand(program2) {
+  program2.command("inspect <run-id>").description("Terminal-rendered timeline + step inspector").option("--at <seq-or-step-id>", "Open a specific step").option(
+    "--show <tab>",
+    "Tab to print (context|decision|action|outcome|cost|files|all)",
+    "all"
+  ).option(
+    "--diff",
+    "When `--show files`, print the unified diff for each captured file"
+  ).option(
+    "--pretty-print",
+    "Render decision/action/outcome/cost tabs in a human-readable layout. Default is raw JSON. The context and files tabs are unchanged."
+  ).action(async (runId, opts) => {
+    const store = openStore();
+    try {
+      const run = getRun(store, runId);
+      if (!run) throw new Error(`run not found: ${runId}`);
+      printRunHeader(run);
+      const steps = listSteps(store, run.run_id);
+      printTimeline(steps);
+      const annotations = listAnnotations(store, "run", run.run_id);
+      if (annotations.length) {
+        console.log(pc4.bold("\nRun annotations"));
+        for (const a of annotations) {
+          console.log(
+            `  ${pc4.cyan(a.author)}  ${pc4.dim(a.verdict ?? "note")}  ${a.note ?? ""}`
+          );
+        }
+      }
+      const forks = listForks(store, run.run_id);
+      if (forks.length) {
+        console.log(pc4.bold("\nForks of this run"));
+        for (const f of forks) {
+          console.log(
+            `  ${pc4.magenta(f.edit_type)}  from step ${pc4.dim(f.origin_step_id.slice(0, 12))}  \u2192  ${pc4.cyan(f.fork_run_id.slice(0, 12))}`
+          );
+        }
+      }
+      if (opts.at !== void 0) {
+        const seq = Number(opts.at);
+        const step = Number.isFinite(seq) ? getStepBySequence(store, run.run_id, seq) : getStep(store, opts.at);
+        if (!step) throw new Error(`step not found: ${opts.at}`);
+        await printStep(store, step, opts.show, opts.diff === true, opts.prettyPrint === true);
+      } else {
+        console.log("");
+        for (const s of steps) await printStepSummary(s);
+        console.log(
+          pc4.dim(
+            `
+open one with:  meter inspect ${run.run_id.slice(0, 12)} --at 0`
+          )
+        );
+      }
+    } finally {
+      store.close();
+    }
+  });
+}
+function printRunHeader(run) {
+  if (!run) return;
+  const status = statusColor(run.status)(run.status);
+  console.log(pc4.bold(run.title ?? run.run_id));
+  console.log(
+    `  ${pc4.dim("run")}    ${run.run_id}
+  ${pc4.dim("status")} ${status}
+  ${pc4.dim("branch")} ${run.git_branch ?? "\u2014"}
+  ${pc4.dim("cwd")}    ${run.cwd ?? "\u2014"}
+  ${pc4.dim("steps")}  ${run.step_count}
+  ${pc4.dim("cost")}   ${fmtCents(run.cost_cents)}  ${pc4.dim(`(input ${fmtTokens(run.tokens_total_input)} \xB7 output ${fmtTokens(run.tokens_total_output)} \xB7 cached ${fmtTokens(run.tokens_total_cached)})`)}
+  ${pc4.dim("started")} ${run.started_at}`
+  );
+}
+function printTimeline(steps) {
+  if (steps.length === 0) return;
+  console.log(pc4.bold("\nTimeline"));
+  const cells = [];
+  for (const s of steps) {
+    const color = s.status === "error" ? pc4.red : s.status === "ok" ? pc4.green : s.status === "in_progress" ? pc4.yellow : pc4.dim;
+    const label = `${s.sequence}.${actionLabel(s).slice(0, 6)}`;
+    cells.push(color(label));
+  }
+  let line = "  ";
+  for (const cell of cells) {
+    if (line.length + cell.length > 130) {
+      console.log(line);
+      line = "  ";
+    }
+    line += cell + " ";
+  }
+  if (line.trim().length) console.log(line);
+}
+async function printStepSummary(s) {
+  const color = statusColor(s.status);
+  console.log(
+    `  ${pc4.dim(String(s.sequence).padStart(3))}  ${color(s.status.padEnd(11))}  ${actionLabel(s).padEnd(18)}  ${pc4.dim("tok " + fmtTokens(s.tokens.input) + "/" + fmtTokens(s.tokens.output))}  ${pc4.dim(fmtCents(s.cost_cents).padStart(7))}  ${pc4.dim(s.step_id.slice(0, 12))}`
+  );
+}
+async function printStep(store, step, show, withDiff = false, pretty = false) {
+  console.log(pc4.bold(`
+Step #${step.sequence}  ${pc4.dim(step.step_id)}`));
+  console.log(`  ${pc4.dim("model")} ${step.model}`);
+  console.log(`  ${pc4.dim("status")} ${statusColor(step.status)(step.status)}`);
+  console.log(`  ${pc4.dim("action")} ${actionLabel(step)}`);
+  const showAll = show === "all";
+  const pmode = "ansi";
+  if (showAll || show === "action") {
+    if (pretty) {
+      console.log("\n" + indent(prettyTab("action", step.action, { mode: pmode }), "  "));
+    } else {
+      console.log(pc4.bold("\n  action"));
+      console.log(indent(JSON.stringify(step.action, null, 2)));
+    }
+  }
+  if (showAll || show === "outcome") {
+    if (pretty) {
+      const toolResultText = step.outcome.tool_result_ref ? await store.blobs.tryGetString(step.outcome.tool_result_ref) ?? void 0 : void 0;
+      console.log(
+        "\n" + indent(
+          prettyTab("outcome", step.outcome, { mode: pmode, toolResultText }),
+          "  "
+        )
+      );
+    } else {
+      console.log(pc4.bold("\n  outcome"));
+      console.log(indent(JSON.stringify(step.outcome, null, 2)));
+      if (step.outcome.tool_result_ref) {
+        const text = await store.blobs.tryGetString(step.outcome.tool_result_ref);
+        if (text) {
+          console.log(pc4.bold("\n  tool result (truncated)"));
+          console.log(indent(truncate(reformatJsonString(text), 2e3)));
+        }
+      }
+    }
+  }
+  if (showAll || show === "decision") {
+    const text = await store.blobs.tryGetString(step.decision_ref);
+    if (text) {
+      if (pretty) {
+        console.log("\n" + indent(prettyTab("decision", text, { mode: pmode }), "  "));
+      } else {
+        console.log(pc4.bold("\n  decision"));
+        console.log(indent(truncate(reformatJsonString(text), 4e3)));
+      }
+    }
+  }
+  if (showAll || show === "context") {
+    await printResolvedContext(store, step);
+  }
+  if (showAll || show === "cost") {
+    if (pretty) {
+      console.log(
+        "\n" + indent(
+          prettyTab(
+            "cost",
+            {
+              tokens: step.tokens,
+              latency_ms: step.latency_ms,
+              cost_cents: step.cost_cents,
+              tags: step.tags
+            },
+            { mode: pmode }
+          ),
+          "  "
+        )
+      );
+    } else {
+      console.log(pc4.bold("\n  cost"));
+      console.log(
+        indent(
+          JSON.stringify(
+            {
+              tokens: step.tokens,
+              latency_ms: step.latency_ms,
+              cost_cents: step.cost_cents,
+              tags: step.tags
+            },
+            null,
+            2
+          )
+        )
+      );
+    }
+  }
+  if (showAll || show === "files") {
+    await printStepFiles(store, step, withDiff);
+  }
+}
+async function printStepFiles(store, step, withDiff) {
+  const fcs = listFileChanges(store, { stepId: step.step_id });
+  if (fcs.length === 0) {
+    if (withDiff) {
+      console.log(pc4.bold("\n  files"));
+      console.log(indent(pc4.dim("(no file changes captured for this step)")));
+    }
+    return;
+  }
+  console.log(
+    pc4.bold("\n  files") + pc4.dim(`  \xB7 ${fcs.length} change${fcs.length === 1 ? "" : "s"}`)
+  );
+  for (const fc of fcs) {
+    const renderedPath = fc.op === "rename" && fc.old_path ? `${fc.old_path} \u2192 ${fc.path}` : fc.path;
+    const flags = [];
+    if (fc.partial_diff) flags.push(pc4.yellow("partial"));
+    if (fc.patch_format === "binary") flags.push(pc4.dim("binary"));
+    const stats = `${fc.lines_added === 0 ? "+0" : pc4.green(`+${fc.lines_added}`)} ${fc.lines_removed === 0 ? "\u22120" : pc4.red(`\u2212${fc.lines_removed}`)}`;
+    console.log(
+      `    ${opTagInline(fc.op)}  ${renderedPath.padEnd(30)}  ${stats}${flags.length ? "  " + flags.join(" ") : ""}`
+    );
+    if (withDiff && fc.patch_text) {
+      for (const line of fc.patch_text.split("\n")) {
+        if (line.startsWith("@@")) console.log(indent(pc4.cyan(line), "      "));
+        else if (line.startsWith("+") && !line.startsWith("+++"))
+          console.log(indent(pc4.green(line), "      "));
+        else if (line.startsWith("-") && !line.startsWith("---"))
+          console.log(indent(pc4.red(line), "      "));
+        else console.log(indent(line, "      "));
+      }
+    } else if (withDiff && fc.partial_diff) {
+      console.log(
+        indent(
+          pc4.yellow(
+            "(partial \u2014 ran outside captured tools; enable `meter watch --files` in v0.4 for full fidelity)"
+          ),
+          "      "
+        )
+      );
+    }
+  }
+}
+function opTagInline(op) {
+  switch (op) {
+    case "create":
+      return pc4.green("A");
+    case "modify":
+      return pc4.yellow("M");
+    case "delete":
+      return pc4.red("D");
+    case "rename":
+      return pc4.magenta("R");
+    case "chmod":
+      return pc4.dim("X");
+  }
+}
+async function printResolvedContext(store, step) {
+  const ref = resolveSnapshotBlobRef(store, step.context_snapshot_id);
+  const raw = await store.blobs.tryGetString(ref);
+  if (!raw) {
+    console.log(pc4.bold("\n  context"));
+    console.log(indent(pc4.dim("(no snapshot blob found)")));
+    return;
+  }
+  let snapshot;
+  try {
+    snapshot = JSON.parse(raw);
+  } catch {
+    console.log(pc4.bold("\n  context (raw)"));
+    console.log(indent(truncate(raw, 4e3)));
+    return;
+  }
+  let totalChars = 0;
+  const fetchText = async (r) => {
+    const text = await store.blobs.tryGetString(r) ?? "(missing blob)";
+    totalChars += text.length;
+    return text;
+  };
+  const resolved = [];
+  for (const c of snapshot.components) {
+    if (c.type === "system_prompt") {
+      resolved.push({
+        type: "system_prompt",
+        ref: c.content_ref,
+        text: await fetchText(c.content_ref)
+      });
+    } else if (c.type === "tool_definitions") {
+      resolved.push({
+        type: "tool_definitions",
+        ref: c.content_ref,
+        text: await fetchText(c.content_ref)
+      });
+    } else if (c.type === "conversation_history") {
+      const messages = [];
+      for (const m of c.messages ?? []) {
+        messages.push({
+          role: m.role,
+          ref: m.content_ref,
+          text: await fetchText(m.content_ref),
+          step_ref: m.step_ref
+        });
+      }
+      resolved.push({ type: "conversation_history", messages });
+    } else if (c.type === "retrieved_documents") {
+      const docs = [];
+      for (const d of c.docs ?? []) {
+        docs.push({
+          source: d.source,
+          ref: d.content_ref,
+          text: await fetchText(d.content_ref)
+        });
+      }
+      resolved.push({ type: "retrieved_documents", docs });
+    } else if (c.type === "compaction_summary") {
+      resolved.push({
+        type: "compaction_summary",
+        ref: c.content_ref,
+        text: await fetchText(c.content_ref),
+        replaces_steps: c.replaces_steps
+      });
+    }
+  }
+  console.log(
+    pc4.bold(
+      `
+  context (snapshot \xB7 ${resolved.length} component${resolved.length === 1 ? "" : "s"} \xB7 ${totalChars.toLocaleString()} chars)`
+    )
+  );
+  for (const c of resolved) {
+    if (c.type === "system_prompt") {
+      console.log(
+        pc4.bold(`
+  system_prompt`) + pc4.dim(` \xB7 ${c.text.length.toLocaleString()} chars \xB7 ${c.ref.slice(0, 12)}`)
+      );
+      console.log(indent(truncate(c.text, 2e3)));
+    } else if (c.type === "tool_definitions") {
+      console.log(
+        pc4.bold(`
+  tool_definitions`) + pc4.dim(` \xB7 ${c.text.length.toLocaleString()} chars \xB7 ${c.ref.slice(0, 12)}`)
+      );
+      console.log(indent(truncate(reformatJsonString(c.text), 2e3)));
+    } else if (c.type === "conversation_history") {
+      console.log(
+        pc4.bold(`
+  conversation_history`) + pc4.dim(
+          ` \xB7 ${c.messages.length} turn${c.messages.length === 1 ? "" : "s"}`
+        )
+      );
+      for (const m of c.messages) {
+        const roleColor = m.role === "user" ? pc4.cyan : m.role === "assistant" ? pc4.green : pc4.yellow;
+        const tag = roleColor(`[${m.role.toUpperCase()}]`);
+        const meta = pc4.dim(
+          ` \xB7 ${m.text.length.toLocaleString()} chars \xB7 ${m.ref.slice(0, 12)}${m.step_ref ? ` \xB7 step ${m.step_ref.slice(0, 12)}` : ""}`
+        );
+        console.log(`    ${tag}${meta}`);
+        console.log(indent(truncate(m.text, 1200), "      "));
+      }
+    } else if (c.type === "retrieved_documents") {
+      console.log(
+        pc4.bold(`
+  retrieved_documents`) + pc4.dim(` \xB7 ${c.docs.length} doc${c.docs.length === 1 ? "" : "s"}`)
+      );
+      for (const d of c.docs) {
+        console.log(
+          `    ${pc4.magenta(d.source)}${pc4.dim(` \xB7 ${d.text.length.toLocaleString()} chars \xB7 ${d.ref.slice(0, 12)}`)}`
+        );
+        console.log(indent(truncate(d.text, 1e3), "      "));
+      }
+    } else if (c.type === "compaction_summary") {
+      console.log(
+        pc4.bold(`
+  compaction_summary`) + pc4.dim(
+          ` \xB7 replaces ${c.replaces_steps.length} step${c.replaces_steps.length === 1 ? "" : "s"} \xB7 ${c.ref.slice(0, 12)}`
+        )
+      );
+      console.log(indent(truncate(c.text, 2e3)));
+      if (c.replaces_steps.length) {
+        console.log(
+          indent(
+            pc4.dim(
+              "replaced: " + c.replaces_steps.map((s) => s.slice(0, 12)).join(", ")
+            )
+          )
+        );
+      }
+    }
+  }
+}
+function indent(s, prefix = "    ") {
+  return s.split("\n").map((l) => prefix + l).join("\n");
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max) + pc4.dim(`
+\u2026 (${s.length - max} more chars)`) : s;
+}
+
+// src/commands/fork.ts
+import { readFile } from "fs/promises";
+import pc5 from "picocolors";
+import {
+  forkRun,
+  anthropicResponder,
+  continueFork,
+  fakeResponder
+} from "@meterbility/server";
+import { getSetting } from "@meterbility/collector";
+var EDIT_TYPES = [
+  "replace_system_prompt",
+  "add_context",
+  "remove_tool",
+  "modify_tool_description",
+  "replace_user_message",
+  "inject_message",
+  "change_model"
+];
+function registerForkCommand(program2) {
+  program2.command("fork <run-id>").description("Replay a run with an edit applied at a chosen step").requiredOption(
+    "--at <seq-or-step-id>",
+    "Sequence index or step id to fork from"
+  ).requiredOption(
+    "--edit <type>",
+    `Edit type (${EDIT_TYPES.join("|")})`
+  ).option(
+    "--payload <json>",
+    "Edit payload as JSON (string or object)"
+  ).option("--payload-file <path>", "Read payload from a file (treated as text)").option("--text <string>", "Shortcut: set payload to { text: <string> }").option(
+    "--live",
+    "Run a live model call for the suffix step (requires ANTHROPIC_API_KEY)"
+  ).option("--live-model <model>", "Model for live suffix", "claude-opus-4-7").option("--fake <text>", "Use a fake responder that emits the given text").option(
+    "--continue <mode>",
+    "After the first suffix step, continue the agent loop. Values: simulate (use original tool results) | live (caller-provided executor; CLI supports bash-only safe mode)"
+  ).option(
+    "--max-iterations <n>",
+    "Cap continuation loop iterations",
+    (v) => parseInt(v, 10),
+    25
+  ).option(
+    "--allow-tool <name>",
+    "(live continuation) Tools the executor will run. Repeatable.",
+    (v, prev = []) => [...prev, v],
+    []
+  ).action(async (runId, opts) => {
+    if (!EDIT_TYPES.includes(opts.edit)) {
+      throw new Error(
+        `unsupported edit type: ${opts.edit}
+allowed: ${EDIT_TYPES.join(", ")}`
+      );
+    }
+    const edit = {
+      type: opts.edit,
+      payload: await resolvePayload(opts)
+    };
+    const store = openStore();
+    const flagModel = opts.liveModel && opts.liveModel !== "claude-opus-4-7" ? opts.liveModel : void 0;
+    const liveModelEffective = flagModel ?? getSetting(store, "fork.default_model") ?? "claude-opus-4-7";
+    const maxIterFromSetting = getSetting(
+      store,
+      "fork.default_max_iterations"
+    );
+    const maxIterationsEffective = opts.maxIterations !== 25 ? opts.maxIterations : maxIterFromSetting ? parseInt(maxIterFromSetting, 10) || opts.maxIterations : opts.maxIterations;
+    const responder = opts.fake ? fakeResponder(opts.fake) : opts.live ? buildAnthropicResponder(liveModelEffective) : void 0;
+    try {
+      const at = Number.isFinite(Number(opts.at)) ? Number(opts.at) : opts.at;
+      const result = await forkRun(
+        store,
+        {
+          origin_run_id: runId,
+          at,
+          edit
+        },
+        responder
+      );
+      console.log(pc5.bold("\nfork created"));
+      console.log(`  ${pc5.dim("fork_id")}      ${result.fork_id}`);
+      console.log(`  ${pc5.dim("fork_run_id")}  ${result.fork_run_id}`);
+      console.log(`  ${pc5.dim("prefix")}       ${result.prefix_steps} steps`);
+      console.log(
+        `  ${pc5.dim("suffix")}       ${result.live ? pc5.green("live step appended") : pc5.yellow("none \u2014 use --live or --fake to extend")}`
+      );
+      if (opts.continue) {
+        if (opts.continue !== "simulate" && opts.continue !== "live") {
+          throw new Error(
+            `unknown --continue mode: ${opts.continue}
+allowed: simulate, live`
+          );
+        }
+        if (opts.continue === "live" && !process.env.ANTHROPIC_API_KEY) {
+          throw new Error(
+            "--continue=live requires ANTHROPIC_API_KEY for the model loop"
+          );
+        }
+        const modelCaller = buildContinuationCaller(liveModelEffective);
+        const cont = await continueFork(store, result.fork_run_id, {
+          mode: opts.continue,
+          modelCaller,
+          toolExecutor: opts.continue === "live" ? buildBashOnlyExecutor(opts.allowTool) : void 0,
+          maxIterations: maxIterationsEffective,
+          originRunId: runId
+        });
+        console.log(pc5.bold("\ncontinuation"));
+        console.log(`  ${pc5.dim("mode")}         ${opts.continue}`);
+        console.log(`  ${pc5.dim("iterations")}   ${cont.iterations_run}`);
+        console.log(`  ${pc5.dim("steps added")}  ${cont.steps_added}`);
+        console.log(
+          `  ${pc5.dim("terminal")}     ${terminalColor(cont.terminal_reason)}`
+        );
+      }
+      console.log(
+        pc5.dim(
+          `
+open with:  meter inspect ${result.fork_run_id.slice(0, 12)}
+diff vs origin:  meter diff ${runId.slice(0, 12)} ${result.fork_run_id.slice(0, 12)}`
+        )
+      );
+    } finally {
+      store.close();
+    }
+  });
+}
+function terminalColor(reason) {
+  switch (reason) {
+    case "model_completed":
+      return pc5.green(reason);
+    case "max_iterations":
+      return pc5.yellow(reason);
+    case "simulate_miss":
+      return pc5.yellow(reason);
+    case "tool_error":
+    case "model_error":
+      return pc5.red(reason);
+    default:
+      return reason;
+  }
+}
+function buildContinuationCaller(model) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  return async (args) => {
+    if (!apiKey) {
+      return {
+        model: "dry-run",
+        decision_content: [
+          { type: "text", text: "(dry run \u2014 set ANTHROPIC_API_KEY for live continuation)" }
+        ],
+        action: { kind: "message", text: "(dry run)" },
+        tokens: { input: 0, output: 0, cached_read: 0, cache_creation: 0 },
+        latency_ms: 0
+      };
+    }
+    const { default: Anthropic } = await import("@anthropic-ai/sdk");
+    const { Store: Store2 } = await import("@meterbility/collector");
+    const store = Store2.open();
+    try {
+      const client = new Anthropic({ apiKey });
+      const messages = [];
+      for (const m of args.history) {
+        if (m.role === "tool") continue;
+        const text2 = await store.blobs.tryGetString(m.content_ref);
+        if (text2) messages.push({ role: m.role, content: text2 });
+      }
+      const t0 = Date.now();
+      const resp = await client.messages.create({
+        model,
+        max_tokens: 4096,
+        system: args.system_prompt,
+        messages: messages.length ? messages : [{ role: "user", content: "(no history)" }]
+      });
+      const t1 = Date.now();
+      const blocks = resp.content ?? [];
+      const toolUse = blocks.find(
+        (b) => b.type === "tool_use"
+      );
+      const text = blocks.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+      const cc = resp.usage?.cache_creation;
+      const tokens5m = cc ? cc.ephemeral_5m_input_tokens ?? 0 : resp.usage?.cache_creation_input_tokens ?? 0;
+      const tokens1h = cc?.ephemeral_1h_input_tokens ?? 0;
+      return {
+        model: resp.model,
+        decision_content: resp.content,
+        action: toolUse ? {
+          kind: "tool_call",
+          tool_name: toolUse.name,
+          tool_use_id: toolUse.id,
+          tool_input: toolUse.input
+        } : { kind: "message", text },
+        tokens: {
+          input: resp.usage?.input_tokens ?? 0,
+          output: resp.usage?.output_tokens ?? 0,
+          cached_read: resp.usage?.cache_read_input_tokens ?? 0,
+          cache_creation: tokens5m,
+          cache_creation_1h: tokens1h
+        },
+        latency_ms: t1 - t0
+      };
+    } finally {
+      store.close();
+    }
+  };
+}
+function buildBashOnlyExecutor(allowList) {
+  const allowSet = new Set(allowList);
+  return async (call) => {
+    if (!allowSet.has(call.tool_name)) {
+      return {
+        output: {
+          meter_note: `tool '${call.tool_name}' not in --allow-tool set; skipped`
+        },
+        is_error: false,
+        summary: `skipped (not allowed): ${call.tool_name}`
+      };
+    }
+    if (call.tool_name === "Bash") {
+      const input = call.tool_input;
+      const cmd = input?.command;
+      if (!cmd || typeof cmd !== "string") {
+        return {
+          output: { error: "missing command" },
+          is_error: true,
+          summary: "missing command"
+        };
+      }
+      if (/\brm\s+-[rRfF]|sudo\b|mkfs|dd\s+if=|--no-verify|>\s*\/dev\/sd/.test(cmd)) {
+        return {
+          output: { error: "command rejected as destructive" },
+          is_error: true,
+          summary: "destructive command rejected"
+        };
+      }
+      const { spawnSync } = await import("child_process");
+      const r = spawnSync("bash", ["-lc", cmd], {
+        encoding: "utf-8",
+        timeout: 3e4
+      });
+      return {
+        output: {
+          stdout: r.stdout?.slice(0, 8e3) ?? "",
+          stderr: r.stderr?.slice(0, 2e3) ?? "",
+          exit_code: r.status
+        },
+        is_error: (r.status ?? 0) !== 0,
+        summary: (r.stdout?.split("\n")[0] ?? "").slice(0, 200)
+      };
+    }
+    return {
+      output: { meter_note: `tool '${call.tool_name}' has no live executor; no-op` },
+      is_error: false,
+      summary: `no-op: ${call.tool_name}`
+    };
+  };
+}
+async function resolvePayload(opts) {
+  if (opts.text !== void 0) return { text: opts.text };
+  if (opts.payloadFile) {
+    const buf = await readFile(opts.payloadFile, "utf-8");
+    try {
+      return JSON.parse(buf);
+    } catch {
+      return { text: buf };
+    }
+  }
+  if (opts.payload) {
+    try {
+      return JSON.parse(opts.payload);
+    } catch {
+      return { text: opts.payload };
+    }
+  }
+  return null;
+}
+function buildAnthropicResponder(model) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "--live requires ANTHROPIC_API_KEY in the environment"
+    );
+  }
+  return /* @__PURE__ */ (() => {
+    return async (args) => {
+      const { Store: Store2 } = await import("@meterbility/collector");
+      const store = Store2.open();
+      try {
+        const fn = anthropicResponder(store, { apiKey, model });
+        return fn(args);
+      } finally {
+        store.close();
+      }
+    };
+  })();
+}
+
+// src/commands/diff.ts
+import pc6 from "picocolors";
+import { getRun as getRun2 } from "@meterbility/collector";
+import { diffRuns } from "@meterbility/server";
+function registerDiffCommand(program2) {
+  program2.command("diff <run-a> <run-b>").description("Side-by-side trajectory diff of two runs").option("--json", "Emit machine-readable JSON").option("--all", "Include shared rows (default: only diff rows)").action((runA, runB, opts) => {
+    const store = openStore();
+    try {
+      const a = getRun2(store, runA);
+      const b = getRun2(store, runB);
+      if (!a) throw new Error(`run not found: ${runA}`);
+      if (!b) throw new Error(`run not found: ${runB}`);
+      const result = diffRuns(store, a.run_id, b.run_id);
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      printDiff(result, opts.all ?? false);
+    } finally {
+      store.close();
+    }
+  });
+}
+function printDiff(d, includeShared) {
+  console.log(pc6.bold(`Diff: ${d.run_a_id.slice(0, 12)} vs ${d.run_b_id.slice(0, 12)}`));
+  console.log(
+    `  ${pc6.dim("shared prefix")}   ${d.shared_prefix_length} step(s)
+  ${pc6.dim("divergence at")}   ${d.first_divergence_sequence ?? "\u2014"}
+  ${pc6.dim("total A / B")}    ${d.total_steps_a} / ${d.total_steps_b}`
+  );
+  console.log("");
+  for (const row of d.rows) {
+    if (!includeShared && row.kind === "shared") continue;
+    const color = pickColor(row.kind);
+    const a = row.a ? `${row.a.action_kind}${row.a.tool_name ? `(${row.a.tool_name})` : ""} \xB7 ${row.a.outcome_status}` : "\u2014";
+    const b = row.b ? `${row.b.action_kind}${row.b.tool_name ? `(${row.b.tool_name})` : ""} \xB7 ${row.b.outcome_status}` : "\u2014";
+    console.log(
+      `  ${String(row.sequence).padStart(4)}  ${color(row.kind.padEnd(14))}  ${a.padEnd(34)}  ${pc6.dim("\u2502")}  ${b}`
+    );
+  }
+}
+function pickColor(kind) {
+  switch (kind) {
+    case "shared":
+      return pc6.dim;
+    case "context_diff":
+      return pc6.yellow;
+    case "decision_diff":
+      return pc6.cyan;
+    case "action_diff":
+      return pc6.red;
+    case "outcome_diff":
+      return pc6.magenta;
+    case "only_a":
+      return pc6.red;
+    case "only_b":
+      return pc6.green;
+    case "diverged":
+      return pc6.magenta;
+    default:
+      return (s) => s;
+  }
+}
+
+// src/commands/annotate.ts
+import pc7 from "picocolors";
+import { getRun as getRun3, getStep as getStep2, insertAnnotation } from "@meterbility/collector";
+var VERDICTS = [
+  "correct",
+  "incorrect",
+  "unclear",
+  "good_decision",
+  "bad_decision"
+];
+function registerAnnotateCommand(program2) {
+  program2.command("annotate <target>").description("Attach a verdict + note to a step or run").option("--verdict <v>", `One of: ${VERDICTS.join(", ")}`).option("--note <text>", "Free-form note").option("--author <name>", "Author name", process.env.USER ?? "anonymous").action(async (target, opts) => {
+    const store = openStore();
+    try {
+      let kind;
+      let resolvedId;
+      if (target.startsWith("stp_")) {
+        const step = getStep2(store, target);
+        if (!step) throw new Error(`step not found: ${target}`);
+        kind = "step";
+        resolvedId = step.step_id;
+      } else if (target.startsWith("run_")) {
+        const run = getRun3(store, target);
+        if (!run) throw new Error(`run not found: ${target}`);
+        kind = "run";
+        resolvedId = run.run_id;
+      } else {
+        throw new Error(
+          "target must be a step id (stp_\u2026) or run id (run_\u2026)"
+        );
+      }
+      if (opts.verdict && !VERDICTS.includes(opts.verdict)) {
+        throw new Error(
+          `invalid verdict: ${opts.verdict}
+allowed: ${VERDICTS.join(", ")}`
+        );
+      }
+      const ann = insertAnnotation(store, {
+        targetKind: kind,
+        targetId: resolvedId,
+        author: opts.author,
+        verdict: opts.verdict,
+        note: opts.note
+      });
+      console.log(
+        `${pc7.green("annotated")}  ${kind}=${target.slice(0, 12)}  ${pc7.dim(ann.annotation_id)}`
+      );
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/commands/web.ts
+import pc8 from "picocolors";
+import { serveApp, SlackNotifier } from "@meterbility/server";
+import { resolveSetting, getSetting as getSetting2 } from "@meterbility/collector";
+function registerWebCommand(program2) {
+  program2.command("web").description("Serve the Meterbility web UI on a local port").option("-p, --port <n>", "Port", (v) => parseInt(v, 10), 4317).option("-h, --host <addr>", "Host", "127.0.0.1").option("--no-open", "Do not auto-open the browser").option(
+    "--live",
+    "Watch ~/.claude/projects for live agent activity (fleet view + SSE)"
+  ).option(
+    "--watch-tool <name>",
+    "Fire an alert when this tool is invoked (repeatable)",
+    (val, prev = []) => [...prev, val],
+    []
+  ).option(
+    "--stall-seconds <n>",
+    "Stall alert threshold in seconds",
+    (v) => parseInt(v, 10),
+    120
+  ).option(
+    "--slack-webhook <url>",
+    "Slack incoming-webhook URL (or set METERBILITY_SLACK_WEBHOOK)"
+  ).option(
+    "--slack-event <kind>",
+    "Slack event type to forward (repeatable). Default: alert. Other values: run:created, run:completed",
+    (v, prev = []) => [...prev, v],
+    []
+  ).option(
+    "--allow-unauth-bind",
+    "Allow binding to a non-loopback host without web.bind_token set. Per SPEC-V0_3 \xA711 this requires explicit opt-in \u2014 the default behavior is to refuse, since anyone on the network can read all runs and step blobs through the unauthenticated /api/* surface."
+  ).action(async (opts) => {
+    const store = openStore();
+    const isLoopback = opts.host === "127.0.0.1" || opts.host === "::1" || opts.host === "localhost" || opts.host.startsWith("127.");
+    if (!isLoopback) {
+      const bindToken = getSetting2(store, "web.bind_token");
+      if (!bindToken && !opts.allowUnauthBind) {
+        console.error(
+          pc8.red("refusing to bind: ") + `--host=${opts.host} is non-loopback and web.bind_token is not set.
+` + pc8.dim(
+            "  Anyone on this network would be able to read every run and step blob via /api/*.\n  Fix either:\n    \u2022 meter config set web.bind_token <random-string>\n    \u2022 or re-run with --allow-unauth-bind to opt into the insecure config.\n  See SPEC-V0_3 \xA711."
+          )
+        );
+        store.close();
+        process.exit(1);
+      }
+      console.warn(
+        pc8.yellow("\u26A0  binding to ") + pc8.yellow(`${opts.host}:${opts.port}`) + pc8.yellow(" \u2014 non-loopback exposure")
+      );
+      if (!bindToken) {
+        console.warn(
+          pc8.yellow(
+            "   /api/* is UNAUTHENTICATED. Anyone on this network can read all runs and step blobs."
+          )
+        );
+      } else {
+        console.warn(
+          pc8.dim(
+            "   /api/* is gated by web.bind_token. Pass it as `Authorization: Bearer <token>` from clients."
+          )
+        );
+      }
+    }
+    const watchToolsEffective = opts.watchTool.length > 0 ? opts.watchTool : (getSetting2(store, "live.watch_tools") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    const stallFromSetting = getSetting2(store, "live.stall_seconds");
+    const stallSecondsEffective = opts.stallSeconds !== 120 ? opts.stallSeconds : stallFromSetting ? parseInt(stallFromSetting, 10) || opts.stallSeconds : opts.stallSeconds;
+    const { url, live } = serveApp(store, {
+      port: opts.port,
+      host: opts.host,
+      live: opts.live === true,
+      liveOptions: {
+        watchTools: watchToolsEffective,
+        stallSeconds: stallSecondsEffective
+      }
+    });
+    console.log(pc8.green("Meterbility running at ") + pc8.cyan(url));
+    if (live) {
+      console.log(
+        pc8.dim(
+          `live mode on \u2014 watching Claude Code sessions every ${1500}ms. Watching tools: ${watchToolsEffective.join(", ") || "(none)"}.`
+        )
+      );
+      const webhook = opts.slackWebhook ?? resolveSetting(store, "slack.webhook", "METERBILITY_SLACK_WEBHOOK") ?? "";
+      const slackEventsFromSetting = getSetting2(
+        store,
+        "slack.default_events"
+      );
+      if (webhook) {
+        try {
+          const fallbackEvents = slackEventsFromSetting ? slackEventsFromSetting.split(",").map((s) => s.trim()).filter(Boolean) : ["alert"];
+          const events = opts.slackEvent.length > 0 ? opts.slackEvent : fallbackEvents;
+          const slack = new SlackNotifier({
+            webhookUrl: webhook,
+            serverUrl: url,
+            events
+          });
+          slack.attach(live);
+          console.log(
+            pc8.dim(
+              `slack notifications enabled \xB7 forwarding: ${events.join(", ")}`
+            )
+          );
+        } catch (err) {
+          console.error(
+            pc8.red("slack disabled: ") + err.message
+          );
+        }
+      }
+      live.on("data", (e) => {
+        if (e.type === "alert") {
+          console.log(
+            pc8.yellow(`alert[${e.kind}]`) + ` ${e.run_id.slice(0, 12)} \xB7 ${e.message}`
+          );
+        } else if (e.type === "run:created") {
+          console.log(
+            pc8.blue("run:created") + ` ${e.run.run_id.slice(0, 12)} \xB7 ${e.run.title ?? ""}`
+          );
+        } else if (e.type === "run:completed") {
+          console.log(
+            pc8.green("run:completed") + ` ${e.run.run_id.slice(0, 12)} \xB7 status=${e.run.status}`
+          );
+        }
+      });
+    }
+    console.log(pc8.dim("press ctrl-c to stop"));
+    if (opts.open !== false) {
+      await openBrowser(url);
+    }
+  });
+}
+async function openBrowser(url) {
+  const { spawn: spawn3 } = await import("child_process");
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  spawn3(cmd, args, { detached: true, stdio: "ignore" }).unref();
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync2 } from "fs";
+import { stat } from "fs/promises";
+import pc9 from "picocolors";
+import { claudeHome, claudeProjectsRoot, dbPath, meterHome } from "@meterbility/shared";
+import { discoverSessions as discoverSessions2 } from "@meterbility/claude-code-adapter";
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Verify Meterbility can capture and store agent runs (Gate 2 check)").option("--json", "Emit results as a single JSON object instead of pretty output").action(async (opts) => {
+    const checks = [];
+    const record = (status, label, detail = "") => {
+      checks.push({ status, label, detail });
+    };
+    const node = process.versions.node;
+    const [major, minor] = node.split(".").map(Number);
+    if (major > 20 || major === 20 && minor >= 6 || major >= 22) {
+      record("ok", "Node", `v${node}`);
+    } else if (major >= 20) {
+      record(
+        "warn",
+        "Node",
+        `v${node} \u2014 upgrade to 20.6+ for full --import support`
+      );
+    } else {
+      record("fail", "Node version >= 20.6", `found v${node}`);
+    }
+    record("ok", "METERBILITY_HOME", meterHome());
+    if (existsSync2(claudeHome())) {
+      record("ok", "CLAUDE_HOME", claudeHome());
+    } else {
+      record(
+        "fail",
+        "CLAUDE_HOME",
+        `not found at ${claudeHome()} \u2014 set CLAUDE_HOME or install Claude Code`
+      );
+    }
+    if (existsSync2(claudeProjectsRoot())) {
+      record("ok", "Claude projects dir", claudeProjectsRoot());
+    } else {
+      record(
+        "warn",
+        "Claude projects dir",
+        `no ${claudeProjectsRoot()} \u2014 nothing to ingest yet`
+      );
+    }
+    try {
+      const sessions = await discoverSessions2();
+      if (sessions.length === 0) {
+        record("warn", "Session discovery", "no .jsonl session files found");
+      } else {
+        const newest = sessions[0];
+        record(
+          "ok",
+          "Session discovery",
+          `${sessions.length} session(s) \u2014 newest ${newest.session_id.slice(0, 8)} (${(newest.size_bytes / 1024).toFixed(0)}KB)`
+        );
+      }
+    } catch (err) {
+      record("fail", "Session discovery", err.message);
+    }
+    try {
+      const { Store: Store2 } = await import("@meterbility/collector");
+      const store = Store2.open();
+      store.close();
+      const s = await stat(dbPath());
+      record("ok", "SQLite store", `${dbPath()} (${s.size} bytes)`);
+    } catch (err) {
+      record("fail", "SQLite store", err.message);
+    }
+    const summary = checks.reduce(
+      (acc, c) => {
+        acc[c.status] += 1;
+        return acc;
+      },
+      { ok: 0, warn: 0, fail: 0 }
+    );
+    if (opts.json) {
+      const payload = {
+        meter_home: meterHome(),
+        claude_home: claudeHome(),
+        claude_projects_root: claudeProjectsRoot(),
+        db_path: dbPath(),
+        node: process.versions.node,
+        checks,
+        summary,
+        ok: summary.fail === 0
+      };
+      process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+      if (summary.fail > 0) process.exit(1);
+      return;
+    }
+    for (const c of checks) {
+      const icon = c.status === "ok" ? pc9.green("\u2714") : c.status === "warn" ? pc9.yellow("\u26A0") : pc9.red("\u2716");
+      const tag = c.status === "ok" ? pc9.green("PASS") : c.status === "warn" ? pc9.yellow("WARN") : pc9.red("FAIL");
+      console.log(`${icon} [${tag}] ${pc9.bold(c.label)} ${pc9.dim(c.detail)}`);
+    }
+    console.log("");
+    console.log(
+      pc9.bold(
+        `${pc9.green(String(summary.ok))} pass \xB7 ${pc9.yellow(String(summary.warn))} warn \xB7 ${pc9.red(String(summary.fail))} fail`
+      )
+    );
+    if (summary.fail > 0) process.exit(1);
+  });
+}
+
+// src/commands/export.ts
+import { writeFile } from "fs/promises";
+import pc10 from "picocolors";
+import {
+  getBaselineTree,
+  getRun as getRun4,
+  getSetting as getSetting3,
+  listFileChanges as listFileChanges2,
+  listSteps as listSteps2,
+  resolveSnapshotBlobRef as resolveSnapshotBlobRef2
+} from "@meterbility/collector";
+import { TRACE_FORMAT_VERSION } from "@meterbility/spec";
+function registerExportCommand(program2) {
+  program2.command("export <run-id>").description("Export a run to the open Meterbility Trace Format (0.3.0)").option("-o, --output <path>", "Output file (default: stdout)").option(
+    "--no-blobs",
+    "Skip inlining blob contents (refs only \u2014 much smaller)"
+  ).option(
+    "--include-file-blobs",
+    "Inline file-content blobs in the export (default: omit \u2014 bug reports get shared)"
+  ).action(async (runId, opts) => {
+    const store = openStore();
+    try {
+      const run = getRun4(store, runId);
+      if (!run) throw new Error(`run not found: ${runId}`);
+      const steps = listSteps2(store, run.run_id);
+      const file_changes = listFileChanges2(store, { runId: run.run_id });
+      const baseline_trees = run.baseline_tree_id ? [getBaselineTree(store, run.baseline_tree_id)].filter(
+        (bt) => !!bt
+      ) : [];
+      const trace = {
+        meter_trace_version: TRACE_FORMAT_VERSION,
+        run,
+        steps,
+        file_changes,
+        baseline_trees
+      };
+      if (opts.blobs !== false) {
+        const includeFileBlobs = opts.includeFileBlobs ?? getSetting3(store, "export.include_file_blobs") === "true";
+        const blobs = {};
+        const fileBlobRefs = /* @__PURE__ */ new Set();
+        for (const fc of file_changes) {
+          if (fc.before_blob_ref) fileBlobRefs.add(fc.before_blob_ref);
+          if (fc.after_blob_ref) fileBlobRefs.add(fc.after_blob_ref);
+        }
+        const structuralRefs = /* @__PURE__ */ new Set();
+        for (const s of steps) {
+          structuralRefs.add(
+            resolveSnapshotBlobRef2(store, s.context_snapshot_id)
+          );
+          structuralRefs.add(s.decision_ref);
+          if (s.outcome.tool_result_ref) {
+            structuralRefs.add(s.outcome.tool_result_ref);
+          }
+        }
+        for (const bt of baseline_trees) {
+          if (bt.manifest_blob_ref) {
+            structuralRefs.add(bt.manifest_blob_ref);
+          }
+        }
+        const refsToInline = new Set(structuralRefs);
+        if (includeFileBlobs) {
+          for (const r of fileBlobRefs) refsToInline.add(r);
+        }
+        for (const r of refsToInline) {
+          const text = await store.blobs.tryGetString(r);
+          if (text !== void 0) {
+            blobs[r] = Buffer.from(text, "utf-8").toString("base64");
+          }
+        }
+        trace.blobs = blobs;
+      }
+      const json = JSON.stringify(trace, null, 2);
+      if (opts.output) {
+        await writeFile(opts.output, json);
+        console.log(
+          `${pc10.green("exported")}  ${runId.slice(0, 12)} \u2192 ${opts.output}  ${pc10.dim(`(${(json.length / 1024).toFixed(1)}KB \xB7 ${file_changes.length} file changes)`)}`
+        );
+      } else {
+        process.stdout.write(json + "\n");
+      }
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/commands/test.ts
+import { writeFile as writeFile2, readFile as readFile2 } from "fs/promises";
+import pc11 from "picocolors";
+import { getRun as getRun5, listSteps as listSteps3, listRuns as listRuns2 } from "@meterbility/collector";
+import {
+  addAssertion,
+  createTest,
+  deleteTest,
+  deriveAssertionsFromRun,
+  getTestByName,
+  listResults,
+  listTests,
+  runTest
+} from "@meterbility/server";
+var KINDS = [
+  "includes_tool_call",
+  "excludes_tool_call",
+  "tool_call_count",
+  "output_contains",
+  "output_does_not_contain",
+  "min_steps",
+  "max_steps",
+  "final_status",
+  "max_cost_cents",
+  "no_error_step",
+  "step_status_at"
+];
+function registerTestCommand(program2) {
+  const test = program2.command("test").description("Regression tests \u2014 assertions over captured runs");
+  test.command("list").description("List defined regression tests").action(() => {
+    const store = openStore();
+    try {
+      const tests = listTests(store);
+      if (tests.length === 0) {
+        console.log(pc11.dim("no tests defined. Try: meter test create <name> --from <run-id>"));
+        return;
+      }
+      for (const t of tests) {
+        console.log(
+          `  ${pc11.cyan(t.name.padEnd(28))}  ${pc11.dim(t.assertions.length + " assertions")}  ${pc11.dim(t.canonical_run_id?.slice(0, 12) ?? "")}  ${t.description ?? ""}`
+        );
+      }
+    } finally {
+      store.close();
+    }
+  });
+  test.command("create <name>").description("Create a regression test, optionally derived from a canonical run").option("--from <run-id>", "Derive assertions from this run").option("--description <text>", "Free-form description").option("--from-file <path>", "Load assertions from a JSON file").action(async (name, opts) => {
+    const store = openStore();
+    try {
+      let assertions = [];
+      let canonicalRunId;
+      if (opts.from) {
+        const run = getRun5(store, opts.from);
+        if (!run) throw new Error(`run not found: ${opts.from}`);
+        const steps = listSteps3(store, run.run_id);
+        assertions = deriveAssertionsFromRun(run, steps);
+        canonicalRunId = run.run_id;
+      }
+      if (opts.fromFile) {
+        const buf = await readFile2(opts.fromFile, "utf-8");
+        assertions = JSON.parse(buf);
+      }
+      const t = createTest(store, {
+        name,
+        description: opts.description,
+        assertions,
+        canonical_run_id: canonicalRunId
+      });
+      console.log(
+        `${pc11.green("created")}  ${t.name}  ${pc11.dim(t.assertions.length + " assertions")}`
+      );
+      for (const a of t.assertions) {
+        console.log(
+          `    ${pc11.dim("\xB7")} ${a.kind} ${pc11.cyan(String(a.value))}${a.label ? pc11.dim(`  (${a.label})`) : ""}`
+        );
+      }
+    } finally {
+      store.close();
+    }
+  });
+  test.command("add-assertion <test-name> <kind> <value>").description(
+    `Append an assertion to a test. Kinds: ${KINDS.join(", ")}.`
+  ).option("--at <seq>", "Step sequence (for step_status_at)", (v) => parseInt(v, 10)).option("--label <text>", "Friendly label").action((name, kind, value, opts) => {
+    if (!KINDS.includes(kind)) {
+      throw new Error(`unknown kind: ${kind}
+allowed: ${KINDS.join(", ")}`);
+    }
+    const store = openStore();
+    try {
+      const numericValue = /^[\d.]+$/.test(value) && !["final_status"].includes(kind) ? Number(value) : value;
+      const t = addAssertion(store, name, {
+        kind,
+        value: numericValue,
+        at: opts.at,
+        label: opts.label
+      });
+      console.log(
+        `${pc11.green("added")}  ${t.assertions.length} assertions on ${t.name}`
+      );
+    } finally {
+      store.close();
+    }
+  });
+  test.command("rm <name>").description("Delete a regression test").action((name) => {
+    const store = openStore();
+    try {
+      if (!deleteTest(store, name)) throw new Error(`test not found: ${name}`);
+      console.log(`${pc11.yellow("deleted")}  ${name}`);
+    } finally {
+      store.close();
+    }
+  });
+  test.command("run <test-name> [run-id]").description(
+    "Run a test against a specific run, or against every captured run if no id is given"
+  ).option("--limit <n>", "Cap runs scanned", (v) => parseInt(v, 10), 100).option("--json", "Emit machine-readable JSON").action((testName, runId, opts) => {
+    const store = openStore();
+    try {
+      const t = getTestByName(store, testName);
+      if (!t) throw new Error(`test not found: ${testName}`);
+      let runs;
+      if (runId) {
+        const r = getRun5(store, runId);
+        if (!r) throw new Error(`run not found: ${runId}`);
+        runs = [r];
+      } else {
+        runs = listRuns2(store, { limit: opts.limit });
+      }
+      const results = runs.map((r) => runTest(store, t, r.run_id));
+      if (opts.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+      }
+      let pass = 0;
+      let fail = 0;
+      for (const r of results) {
+        const tag = r.passed ? pc11.green("PASS") : pc11.red("FAIL");
+        console.log(
+          `${tag}  ${r.run_id.slice(0, 12)}  ${pc11.dim(`${r.assertions.filter((a) => a.passed).length}/${r.assertions.length} assertions`)}`
+        );
+        if (!r.passed) {
+          for (const a of r.assertions.filter((x) => !x.passed)) {
+            console.log(
+              `      ${pc11.red("\u2716")} ${pc11.dim(a.assertion.kind)} ${a.reason}`
+            );
+          }
+        }
+        if (r.passed) pass += 1;
+        else fail += 1;
+      }
+      console.log(
+        pc11.bold(
+          `
+${results.length} run(s) checked \xB7 ${pc11.green(`${pass} pass`)} \xB7 ${pc11.red(`${fail} fail`)}`
+        )
+      );
+      if (fail > 0) process.exit(1);
+    } finally {
+      store.close();
+    }
+  });
+  test.command("show <name>").description("Show a test's assertions").action((name) => {
+    const store = openStore();
+    try {
+      const t = getTestByName(store, name);
+      if (!t) throw new Error(`test not found: ${name}`);
+      console.log(pc11.bold(t.name));
+      if (t.description) console.log(`  ${pc11.dim(t.description)}`);
+      if (t.canonical_run_id)
+        console.log(`  ${pc11.dim("canonical run:")} ${t.canonical_run_id}`);
+      console.log(`  ${pc11.dim("created:")} ${t.created_at}`);
+      for (const a of t.assertions) {
+        console.log(
+          `  \xB7 ${pc11.cyan(a.kind)} ${pc11.bold(String(a.value))}${a.at !== void 0 ? pc11.dim(`  at=${a.at}`) : ""}${a.label ? pc11.dim(`  (${a.label})`) : ""}`
+        );
+      }
+    } finally {
+      store.close();
+    }
+  });
+  test.command("results [test-name]").description("Show recent regression results").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10), 25).action((name, opts) => {
+    const store = openStore();
+    try {
+      const testId = name ? getTestByName(store, name)?.test_id : void 0;
+      if (name && !testId) throw new Error(`test not found: ${name}`);
+      const results = listResults(store, testId, opts.limit);
+      if (results.length === 0) {
+        console.log(pc11.dim("no results yet"));
+        return;
+      }
+      for (const r of results) {
+        console.log(
+          `  ${r.passed ? pc11.green("PASS") : pc11.red("FAIL")}  ${pc11.dim(r.created_at)}  ${pc11.cyan(r.test_name.padEnd(20))}  ${r.run_id.slice(0, 12)}`
+        );
+      }
+    } finally {
+      store.close();
+    }
+  });
+  test.command("export <name>").description("Export a test as a JSON file (round-trip via --from-file)").option("-o, --output <path>", "Output file (default: stdout)").action(async (name, opts) => {
+    const store = openStore();
+    try {
+      const t = getTestByName(store, name);
+      if (!t) throw new Error(`test not found: ${name}`);
+      const json = JSON.stringify(t.assertions, null, 2);
+      if (opts.output) {
+        await writeFile2(opts.output, json);
+        console.log(`${pc11.green("exported")}  ${name} \u2192 ${opts.output}`);
+      } else {
+        process.stdout.write(json + "\n");
+      }
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/commands/db.ts
+import pc12 from "picocolors";
+import { resolveSetting as resolveSetting2 } from "@meterbility/collector";
+function resolvePostgresUrl(store, flag) {
+  if (flag) return flag;
+  return resolveSetting2(store, "postgres.url", "METERBILITY_DB_URL");
+}
+function registerDbCommand(program2) {
+  const db = program2.command("db").description("Hosted backend management (Postgres, optional)");
+  db.command("postgres-init").description(
+    "Connect to a Postgres URL and ensure Meterbility's schema is present."
+  ).option(
+    "--url <conn>",
+    "Postgres connection URL (defaults to METERBILITY_DB_URL or postgres.url setting)"
+  ).action(async (opts) => {
+    const { PostgresStore } = await import("@meterbility/store-postgres");
+    const sqlite = openStore();
+    let store;
+    try {
+      store = await PostgresStore.open({
+        url: resolvePostgresUrl(sqlite, opts.url)
+      });
+    } finally {
+      sqlite.close();
+    }
+    try {
+      const r = await store.client.query(
+        "SELECT value FROM meta WHERE key='schema_version'"
+      );
+      console.log(
+        `${pc12.green("connected")}  schema_version=${r.rows[0]?.value ?? "?"}`
+      );
+    } finally {
+      await store.close();
+    }
+  });
+  db.command("postgres-sync").description(
+    "Copy local SQLite runs / steps / blobs into Postgres. Idempotent."
+  ).option(
+    "--url <conn>",
+    "Postgres URL (defaults to METERBILITY_DB_URL or postgres.url setting)"
+  ).option(
+    "--limit <n>",
+    "Cap runs synced (default 1000)",
+    (v) => parseInt(v, 10)
+  ).action(async (opts) => {
+    const { PostgresStore, syncSqliteToPostgres } = await import("@meterbility/store-postgres");
+    const sqlite = openStore();
+    const postgres = await PostgresStore.open({
+      url: resolvePostgresUrl(sqlite, opts.url)
+    });
+    try {
+      const t0 = Date.now();
+      const r = await syncSqliteToPostgres(sqlite, postgres, {
+        limitRuns: opts.limit
+      });
+      const dt = Date.now() - t0;
+      console.log(
+        pc12.bold(
+          `synced ${r.runs} runs \xB7 ${r.steps} steps \xB7 ${r.blobs} blobs (${(r.bytes / 1024).toFixed(1)}KB) in ${dt}ms`
+        )
+      );
+    } finally {
+      sqlite.close();
+      await postgres.close();
+    }
+  });
+}
+
+// src/commands/slack.ts
+import pc13 from "picocolors";
+import { SlackNotifier as SlackNotifier2 } from "@meterbility/server";
+function registerSlackCommand(program2) {
+  const slack = program2.command("slack").description("Slack integration utilities");
+  slack.command("test").description("Send a one-off Slack message to verify the webhook").option(
+    "--webhook <url>",
+    "Webhook URL (or set METERBILITY_SLACK_WEBHOOK)"
+  ).action(async (opts) => {
+    const url = opts.webhook ?? process.env.METERBILITY_SLACK_WEBHOOK;
+    if (!url) {
+      throw new Error(
+        "missing --webhook or METERBILITY_SLACK_WEBHOOK environment variable"
+      );
+    }
+    const n = new SlackNotifier2({ webhookUrl: url });
+    await n.sendTest();
+    console.log(`${pc13.green("ok")}  test message sent`);
+  });
+}
+
+// src/commands/config.ts
+import pc14 from "picocolors";
+import {
+  deleteSetting,
+  getSetting as getSetting4,
+  isSecret,
+  listSettings,
+  maskSecret,
+  setSetting
+} from "@meterbility/collector";
+var KNOWN_KEYS = [
+  "slack.webhook",
+  "slack.default_events",
+  "live.watch_tools",
+  "live.stall_seconds",
+  "fork.default_model",
+  "fork.default_max_iterations",
+  "anthropic.api_key",
+  "postgres.url"
+];
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description(
+    "Get/set persisted Meterbility settings (mirrors the web UI's Settings page)"
+  );
+  config.command("list").alias("ls").description("List all configured settings (secrets masked)").option("--reveal", "Show secret values in plaintext").option("--json", "Emit JSON for scripting").action((opts) => {
+    const store = openStore();
+    try {
+      const rows = listSettings(store);
+      if (opts.json) {
+        const payload = rows.map((r) => ({
+          key: r.key,
+          value: opts.reveal || !isSecret(r.key) ? r.value : maskSecret(r.value),
+          updated_at: r.updated_at,
+          secret: isSecret(r.key)
+        }));
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+      }
+      if (rows.length === 0) {
+        console.log(pc14.dim("(no settings configured)"));
+        console.log(
+          pc14.dim(
+            "  set one with:  meter config set <key> <value>\n  known keys:   " + KNOWN_KEYS.join(", ")
+          )
+        );
+        return;
+      }
+      for (const r of rows) {
+        const displayed = opts.reveal || !isSecret(r.key) ? r.value : maskSecret(r.value);
+        const tag = isSecret(r.key) ? pc14.yellow(" [secret]") : "";
+        console.log(
+          `  ${pc14.cyan(r.key.padEnd(28))} ${displayed}${tag}  ${pc14.dim(r.updated_at)}`
+        );
+      }
+    } finally {
+      store.close();
+    }
+  });
+  config.command("get <key>").description("Print a single setting value (raw, no masking)").action((key) => {
+    const store = openStore();
+    try {
+      const v = getSetting4(store, key);
+      if (v === void 0) {
+        console.error(pc14.red(`not set: ${key}`));
+        process.exit(1);
+      }
+      process.stdout.write(v + "\n");
+    } finally {
+      store.close();
+    }
+  });
+  config.command("set <key> <value>").description(
+    `Persist a setting. Known keys: ${KNOWN_KEYS.join(", ")}`
+  ).action((key, value) => {
+    const store = openStore();
+    try {
+      setSetting(store, key, value);
+      const display = isSecret(key) ? maskSecret(value) : value;
+      console.log(
+        `${pc14.green("set")}  ${pc14.cyan(key)} = ${display}${isSecret(key) ? pc14.yellow(" [secret]") : ""}`
+      );
+      if (!KNOWN_KEYS.includes(key)) {
+        console.log(
+          pc14.dim(
+            `  note: '${key}' is not a known SettingKey \u2014 saved anyway. Known keys: ${KNOWN_KEYS.join(", ")}`
+          )
+        );
+      }
+    } finally {
+      store.close();
+    }
+  });
+  config.command("rm <key>").alias("unset").description("Delete a setting").action((key) => {
+    const store = openStore();
+    try {
+      const existing = getSetting4(store, key);
+      if (existing === void 0) {
+        console.error(pc14.red(`not set: ${key}`));
+        process.exit(1);
+      }
+      deleteSetting(store, key);
+      console.log(`${pc14.green("removed")}  ${pc14.cyan(key)}`);
+    } finally {
+      store.close();
+    }
+  });
+}
+
+// src/commands/watch.ts
+import pc15 from "picocolors";
+import {
+  LiveInspector
+} from "@meterbility/server";
+import { getSetting as getSetting5 } from "@meterbility/collector";
+function registerWatchCommand(program2) {
+  program2.command("watch").description(
+    "Stream live agent activity from ~/.claude/projects to the terminal"
+  ).option(
+    "--watch-tool <name>",
+    "Fire an alert when this tool is invoked (repeatable)",
+    (val, prev = []) => [...prev, val],
+    []
+  ).option(
+    "--stall-seconds <n>",
+    "Stall alert threshold in seconds",
+    (v) => parseInt(v, 10),
+    120
+  ).option(
+    "--filter <kinds>",
+    "Comma-separated event kinds to keep (alert,run:created,run:updated,run:completed,fleet:snapshot)"
+  ).option("--run <id>", "Filter to a single run id (or its 12-char prefix)").option(
+    "--no-snapshot",
+    "Suppress the periodic fleet:snapshot events (they're noisy)"
+  ).option("--json", "Emit each event as one JSON line (newline-delimited)").action(
+    async (opts) => {
+      const store = openStore();
+      const watchToolsEffective = opts.watchTool.length > 0 ? opts.watchTool : (getSetting5(store, "live.watch_tools") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+      const stallFromSetting = getSetting5(store, "live.stall_seconds");
+      const stallSecondsEffective = opts.stallSeconds !== 120 ? opts.stallSeconds : stallFromSetting ? parseInt(stallFromSetting, 10) || opts.stallSeconds : opts.stallSeconds;
+      const allowedKinds = opts.filter ? new Set(
+        opts.filter.split(",").map((s) => s.trim()).filter(Boolean)
+      ) : null;
+      const runFilter = opts.run;
+      const matchesRun = (id) => {
+        if (!runFilter) return true;
+        return id === runFilter || id.startsWith(runFilter);
+      };
+      const live = new LiveInspector(store, {
+        watchTools: watchToolsEffective,
+        stallSeconds: stallSecondsEffective
+      });
+      if (!opts.json) {
+        console.log(
+          pc15.dim(
+            `watching ~/.claude/projects \xB7 tools=${watchToolsEffective.join(",") || "(none)"} \xB7 stall=${stallSecondsEffective}s` + (runFilter ? ` \xB7 run=${runFilter}` : "") + (allowedKinds ? ` \xB7 filter=${[...allowedKinds].join(",")}` : "") + "\npress ctrl-c to stop"
+          )
+        );
+      }
+      live.on("data", (e) => {
+        if (allowedKinds && !allowedKinds.has(e.type)) return;
+        if (e.type === "fleet:snapshot" && opts.snapshot === false) return;
+        if (runFilter && (e.type === "run:created" || e.type === "run:updated" || e.type === "run:completed") && !matchesRun(e.run.run_id)) {
+          return;
+        }
+        if (runFilter && e.type === "alert" && !matchesRun(e.run_id)) {
+          return;
+        }
+        if (opts.json) {
+          process.stdout.write(JSON.stringify(e) + "\n");
+          return;
+        }
+        printPretty(e);
+      });
+      await live.start();
+      const stop = () => {
+        live.stop();
+        store.close();
+        process.exit(0);
+      };
+      process.on("SIGINT", stop);
+      process.on("SIGTERM", stop);
+    }
+  );
+}
+function printPretty(e) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+  const head = pc15.dim(ts) + "  ";
+  switch (e.type) {
+    case "run:created":
+      console.log(
+        head + pc15.blue("run:created  ") + pc15.cyan(e.run.run_id.slice(0, 12)) + (e.run.title ? "  " + e.run.title : "")
+      );
+      return;
+    case "run:updated":
+      console.log(
+        head + pc15.dim("run:updated  ") + pc15.cyan(e.run.run_id.slice(0, 12)) + pc15.dim(`  +${e.new_steps.length} step${e.new_steps.length === 1 ? "" : "s"}`)
+      );
+      return;
+    case "run:completed":
+      console.log(
+        head + pc15.green("run:completed") + "  " + pc15.cyan(e.run.run_id.slice(0, 12)) + pc15.dim(`  status=${e.run.status}`)
+      );
+      return;
+    case "alert":
+      console.log(
+        head + pc15.yellow(`alert[${e.kind}] `) + pc15.cyan(e.run_id.slice(0, 12)) + "  " + e.message
+      );
+      return;
+    case "fleet:snapshot": {
+      const counts = e.entries.reduce((acc, x) => {
+        acc[x.status] = (acc[x.status] ?? 0) + 1;
+        return acc;
+      }, {});
+      const summary = Object.entries(counts).map(([k, v]) => `${k}=${v}`).join(" ");
+      console.log(
+        head + pc15.dim(`fleet:snapshot ${e.entries.length} runs \xB7 ${summary}`)
+      );
+      return;
+    }
+  }
+}
+
+// src/commands/open.ts
+import { spawn } from "child_process";
+import http from "http";
+import pc16 from "picocolors";
+import { getRun as getRun6, getStep as getStep3, getStepBySequence as getStepBySequence2 } from "@meterbility/collector";
+function registerOpenCommand(program2) {
+  program2.command("open <run-id>").description("Open a run in the local Meterbility web UI (auto-starts the server if needed)").option("--at <seq-or-step-id>", "Deep-link to a specific step").option(
+    "--context",
+    "When --at is set, link into the resolved-context page"
+  ).option("-p, --port <n>", "Web UI port", (v) => parseInt(v, 10), 4317).option("-h, --host <addr>", "Web UI host", "127.0.0.1").option("--no-launch", "Print the URL but do not open a browser or start the server").option(
+    "--print",
+    "Print the URL and exit without opening (useful for piping to pbcopy)"
+  ).action(
+    async (runId, opts) => {
+      const store = openStore();
+      let url;
+      try {
+        const run = getRun6(store, runId);
+        if (!run) throw new Error(`run not found: ${runId}`);
+        const fullRunId = run.run_id;
+        let path = `/runs/${fullRunId}`;
+        if (opts.at !== void 0) {
+          const seq = Number(opts.at);
+          const step = Number.isFinite(seq) ? getStepBySequence2(store, fullRunId, seq) : getStep3(store, opts.at);
+          if (!step) throw new Error(`step not found: ${opts.at}`);
+          if (opts.context) {
+            path = `/contexts/${step.context_snapshot_id}`;
+          } else {
+            path = `/runs/${fullRunId}#step-${step.step_id}`;
+          }
+        }
+        url = `http://${opts.host}:${opts.port}${path}`;
+      } finally {
+        store.close();
+      }
+      if (opts.print) {
+        process.stdout.write(url + "\n");
+        return;
+      }
+      if (opts.launch === false) {
+        console.log(pc16.cyan(url));
+        return;
+      }
+      const alive = await isServerUp(opts.host, opts.port);
+      if (!alive) {
+        console.log(
+          pc16.dim(
+            `no server on ${opts.host}:${opts.port} \u2014 starting \`meter web\` in the background\u2026`
+          )
+        );
+        await launchDetachedWeb(opts.host, opts.port);
+        const ready = await waitForServer(opts.host, opts.port, 3e3);
+        if (!ready) {
+          console.error(
+            pc16.red("server didn't become reachable in time. ") + pc16.dim(
+              `try \`meter web --port ${opts.port}\` in another terminal, then re-run.`
+            )
+          );
+          process.exit(1);
+        }
+      }
+      console.log(pc16.green("opening ") + pc16.cyan(url));
+      await openBrowser2(url);
+    }
+  );
+}
+function isServerUp(host, port) {
+  return new Promise((resolve2) => {
+    const req = http.request(
+      { host, port, path: "/api/runs", method: "GET", timeout: 500 },
+      (res) => {
+        res.resume();
+        resolve2((res.statusCode ?? 0) < 500);
+      }
+    );
+    req.on("error", () => resolve2(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve2(false);
+    });
+    req.end();
+  });
+}
+async function waitForServer(host, port, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isServerUp(host, port)) return true;
+    await new Promise((r) => setTimeout(r, 150));
+  }
+  return false;
+}
+async function launchDetachedWeb(host, port) {
+  const proc = spawn(
+    process.execPath,
+    [process.argv[1], "web", "--no-open", "--host", host, "--port", String(port)],
+    {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    }
+  );
+  proc.unref();
+}
+async function openBrowser2(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  spawn(cmd, args, { detached: true, stdio: "ignore" }).unref();
+}
+
+// src/commands/proxy.ts
+import pc17 from "picocolors";
+import { startProxy } from "@meterbility/proxy";
+function registerProxyCommand(program2) {
+  program2.command("proxy").description("Run a local LLM-API forward proxy that captures every call as a Meterbility Step").option("-p, --port <n>", "Port to listen on", (v) => parseInt(v, 10), 8765).option("-h, --host <addr>", "Host to bind", "127.0.0.1").option(
+    "--project <name>",
+    "Project label written to captured runs (defaults to cwd)"
+  ).option(
+    "--agent <name>",
+    "Agent label written to captured runs (defaults to 'proxy')"
+  ).option(
+    "--anthropic-target <url>",
+    "Override the Anthropic upstream (default: https://api.anthropic.com)"
+  ).option(
+    "--openai-target <url>",
+    "Override the OpenAI upstream (default: https://api.openai.com)"
+  ).option("--quiet", "Suppress per-request log lines").action(async (opts) => {
+    const proxyOpts = {
+      port: opts.port,
+      host: opts.host,
+      spec: {
+        project: opts.project ?? process.cwd(),
+        agent: opts.agent ?? "proxy"
+      },
+      upstreams: {
+        ...opts.anthropicTarget ? { anthropic: opts.anthropicTarget } : {},
+        ...opts.openaiTarget ? { openai: opts.openaiTarget } : {}
+      },
+      logger: opts.quiet ? () => {
+      } : (line) => console.log(pc17.dim(line))
+    };
+    const handle = await startProxy(proxyOpts);
+    console.log(pc17.green("meter proxy ready ") + pc17.cyan(handle.url));
+    console.log(
+      pc17.dim(
+        `  set in your shell:
+    export ANTHROPIC_BASE_URL=${handle.url}
+    export OPENAI_BASE_URL=${handle.url}/v1
+  or wrap a command with:
+    meter run -- python myagent.py`
+      )
+    );
+    console.log(pc17.dim("press ctrl-c to stop"));
+    const stop = async () => {
+      await handle.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+}
+
+// src/commands/run.ts
+import { spawn as spawn2 } from "child_process";
+import net from "net";
+import pc18 from "picocolors";
+import { startProxy as startProxy2 } from "@meterbility/proxy";
+function registerRunCommand(program2) {
+  program2.command("run").description("Run a command with the Meterbility proxy auto-wired (zero code change capture)").allowUnknownOption(true).option("--port <n>", "Pin the proxy to a port (default: random free port)", (v) => parseInt(v, 10)).option(
+    "--project <name>",
+    "Project label written to captured runs (defaults to cwd)"
+  ).option(
+    "--agent <name>",
+    "Agent label written to captured runs (defaults to 'proxy')"
+  ).option("--quiet", "Suppress per-request capture log lines").option(
+    "--no-openai",
+    "Don't set OPENAI_BASE_URL (only proxy Anthropic calls)"
+  ).option(
+    "--no-anthropic",
+    "Don't set ANTHROPIC_BASE_URL (only proxy OpenAI calls)"
+  ).option(
+    "--anthropic-target <url>",
+    "Override the Anthropic upstream (default: https://api.anthropic.com)"
+  ).option(
+    "--openai-target <url>",
+    "Override the OpenAI upstream (default: https://api.openai.com)"
+  ).action(async (opts, cmd) => {
+    const userArgs = collectUserArgs(cmd);
+    if (userArgs.length === 0) {
+      console.error(
+        pc18.red("meter run: missing command. Usage: meter run -- <command> [args]")
+      );
+      process.exit(2);
+    }
+    const port = opts.port ?? await pickFreePort();
+    const handle = await startProxy2({
+      port,
+      spec: {
+        project: opts.project ?? process.cwd(),
+        agent: opts.agent ?? "proxy"
+      },
+      upstreams: {
+        ...opts.anthropicTarget ? { anthropic: opts.anthropicTarget } : {},
+        ...opts.openaiTarget ? { openai: opts.openaiTarget } : {}
+      },
+      logger: opts.quiet ? () => {
+      } : (line) => process.stderr.write(pc18.dim(`[meter] ${line}
+`))
+    });
+    const childEnv = { ...process.env };
+    if (opts.anthropic !== false) {
+      childEnv.ANTHROPIC_BASE_URL = handle.url;
+    }
+    if (opts.openai !== false) {
+      childEnv.OPENAI_BASE_URL = handle.url + "/v1";
+    }
+    if (!opts.quiet) {
+      process.stderr.write(
+        pc18.dim(
+          `[meter] proxy ${handle.url} \u2192 spawning: ${userArgs.join(" ")}
+`
+        )
+      );
+    }
+    const [bin, ...rest] = userArgs;
+    const child = spawn2(bin, rest, {
+      env: childEnv,
+      stdio: "inherit"
+    });
+    const shutdown = async (code) => {
+      await handle.close();
+      process.exit(code);
+    };
+    let signaled = false;
+    const onSig = (sig) => {
+      if (signaled) return;
+      signaled = true;
+      try {
+        child.kill(sig);
+      } catch {
+      }
+    };
+    process.on("SIGINT", () => onSig("SIGINT"));
+    process.on("SIGTERM", () => onSig("SIGTERM"));
+    child.on("exit", (code, signal) => {
+      setTimeout(() => {
+        if (!opts.quiet) {
+          process.stderr.write(
+            pc18.dim(
+              `[meter] child exited ${code ?? `(signal ${signal})`} \u2014 proxy stopping
+`
+            )
+          );
+        }
+        void shutdown(code ?? (signal ? 130 : 0));
+      }, 250);
+    });
+    child.on("error", (err) => {
+      process.stderr.write(pc18.red(`meter run: failed to spawn child: ${err.message}
+`));
+      void shutdown(127);
+    });
+  });
+}
+function collectUserArgs(cmd) {
+  if (cmd.args && cmd.args.length > 0) return cmd.args.slice();
+  const dashIdx = process.argv.indexOf("--");
+  if (dashIdx >= 0) return process.argv.slice(dashIdx + 1);
+  return [];
+}
+function pickFreePort() {
+  return new Promise((resolve2, reject) => {
+    const srv = net.createServer();
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      if (typeof addr === "object" && addr) {
+        const port = addr.port;
+        srv.close(() => resolve2(port));
+      } else {
+        srv.close(() => reject(new Error("could not allocate free port")));
+      }
+    });
+    srv.on("error", reject);
+  });
+}
+
+// src/commands/runs.ts
+import pc19 from "picocolors";
+import {
+  getRun as getRun7,
+  listRuns as listRuns3,
+  setRunStatus,
+  updateRunTotals
+} from "@meterbility/collector";
+function registerRunsCommand(program2) {
+  const runs = program2.command("runs").description("Run-management operations");
+  runs.command("close [id]").description("Mark an in-progress run as completed (seals status + ended_at)").option(
+    "--status <kind>",
+    "Final status to set (ok|error|abandoned)",
+    "ok"
+  ).option(
+    "--all",
+    "Close every in_progress run (use --older-than to scope by age)"
+  ).option(
+    "--older-than <minutes>",
+    "Only close runs whose last activity is older than N minutes",
+    (v) => parseInt(v, 10)
+  ).option("--source <runtime>", "Restrict --all to one source_runtime (e.g. proxy)").option("--dry-run", "Print what would close without writing").action(
+    (id, opts) => {
+      if (!id && !opts.all) {
+        console.error(
+          pc19.red(
+            "meter runs close: provide a run id, or pass --all to close every in_progress run."
+          )
+        );
+        process.exit(2);
+      }
+      if (!isValidStatus(opts.status)) {
+        console.error(
+          pc19.red(`invalid --status: ${opts.status}. allowed: ok | error | abandoned`)
+        );
+        process.exit(2);
+      }
+      const finalStatus = opts.status;
+      const store = openStore();
+      try {
+        const targets = id ? singleTarget(store, id) : bulkTargets(store, opts);
+        if (targets.length === 0) {
+          console.log(pc19.dim("no runs to close"));
+          return;
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        for (const run of targets) {
+          if (opts.dryRun) {
+            console.log(
+              `${pc19.yellow("would close")} ${pc19.cyan(run.run_id.slice(0, 12))}  ${pc19.dim(`(${run.status} \u2192 ${finalStatus})`)}  ${pc19.dim(run.title ?? "")}`
+            );
+            continue;
+          }
+          setRunStatus(store, run.run_id, finalStatus, now);
+          updateRunTotals(store, run.run_id);
+          console.log(
+            `${pc19.green("closed")}  ${pc19.cyan(run.run_id.slice(0, 12))}  ${pc19.dim(`${run.status} \u2192 ${finalStatus}`)}  ${pc19.dim(run.title ?? "")}`
+          );
+        }
+        if (!opts.dryRun && targets.length > 1) {
+          console.log(pc19.bold(`
+${targets.length} run(s) closed`));
+        }
+      } finally {
+        store.close();
+      }
+    }
+  );
+}
+function singleTarget(store, id) {
+  const run = getRun7(store, id);
+  if (!run) {
+    console.error(pc19.red(`run not found: ${id}`));
+    process.exit(1);
+  }
+  if (run.status !== "in_progress") {
+    console.log(
+      pc19.dim(
+        `${run.run_id.slice(0, 12)} already ${run.status} \u2014 nothing to close. (Pass any explicit --status to override.)`
+      )
+    );
+    process.exit(0);
+  }
+  return [run];
+}
+function bulkTargets(store, opts) {
+  const all = listRuns3(store, { limit: 1e3 });
+  const cutoffMs = opts.olderThan ? Date.now() - opts.olderThan * 6e4 : void 0;
+  return all.filter((run) => {
+    if (run.status !== "in_progress") return false;
+    if (opts.source && run.source_runtime !== opts.source) return false;
+    if (cutoffMs !== void 0) {
+      const startedMs = Date.parse(run.started_at);
+      if (Number.isFinite(startedMs) && startedMs > cutoffMs) return false;
+    }
+    return true;
+  });
+}
+function isValidStatus(s) {
+  return s === "ok" || s === "error" || s === "abandoned";
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync3, mkdirSync } from "fs";
+import { writeFile as writeFile3 } from "fs/promises";
+import { join, resolve } from "path";
+import pc20 from "picocolors";
+import { DEFAULT_METERBILITYIGNORE } from "@meterbility/shared";
+function registerInitCommand(program2) {
+  program2.command("init [path]").description(
+    "Scaffold .meterbility/config.toml and .meterbilityignore for v0.3 file capture"
+  ).option(
+    "--force",
+    "Overwrite existing files (default: leave existing files untouched)"
+  ).option(
+    "--quiet",
+    "Suppress per-file output (still prints the final summary)"
+  ).action(async (pathArg, opts) => {
+    const root = resolve(pathArg ?? process.cwd());
+    if (!existsSync3(root)) {
+      console.error(pc20.red(`meter init: target path does not exist: ${root}`));
+      process.exit(2);
+    }
+    const ignorePath = join(root, ".meterbilityignore");
+    const configDir = join(root, ".meter");
+    const configPath = join(configDir, "config.toml");
+    mkdirSync(configDir, { recursive: true });
+    const ignoreResult = await writeIfNeeded(
+      ignorePath,
+      renderMeterbilityignore(),
+      opts.force === true
+    );
+    const configResult = await writeIfNeeded(
+      configPath,
+      renderConfigToml(),
+      opts.force === true
+    );
+    if (!opts.quiet) {
+      printFileResult(".meterbilityignore", ignorePath, ignoreResult);
+      printFileResult(".meterbility/config.toml", configPath, configResult);
+    }
+    const allCreated = ignoreResult === "created" && configResult === "created";
+    if (allCreated) {
+      console.log(
+        pc20.bold(pc20.green("\nmeter init: scaffolded")) + pc20.dim(" \u2014 v0.3 file capture is now on for this project.")
+      );
+    } else {
+      console.log(
+        pc20.dim(
+          "\nmeter init: complete. Re-run with --force to regenerate existing files."
+        )
+      );
+    }
+    console.log(
+      pc20.dim(
+        "  edit .meterbilityignore to tune what gets captured\n  see `meter files <run-id>` after your next Claude Code session"
+      )
+    );
+  });
+}
+async function writeIfNeeded(path, contents, force) {
+  const present = existsSync3(path);
+  if (present && !force) return "skipped";
+  await writeFile3(path, contents, "utf-8");
+  return present ? "overwritten" : "created";
+}
+function printFileResult(label, path, result) {
+  const tag = result === "created" ? pc20.green("created") : result === "overwritten" ? pc20.yellow("overwrote") : pc20.dim("kept existing");
+  console.log(`  ${tag}  ${pc20.cyan(label)} ${pc20.dim(`(${path})`)}`);
+}
+function renderMeterbilityignore() {
+  return `# .meterbilityignore \u2014 paths Meterbility excludes from file capture (v0.3+).
+# Same syntax subset as .gitignore. First match wins; no negation in v0.3.
+# Generated by \`meter init\`. Edit freely.
+
+# Build artifacts
+node_modules/
+dist/
+build/
+.next/
+target/
+.cache/
+
+# Language-specific
+.venv/
+__pycache__/
+*.pyc
+
+# Version control internals
+.git/objects/
+.git/logs/
+
+# Editor / OS
+.DS_Store
+.idea/
+.vscode/
+
+# Coverage / tooling
+coverage/
+.nyc_output/
+
+# Sensitive by default \u2014 paired with redaction rules in the collector
+.env
+.env.*
+*.pem
+*.key
+id_rsa*
+id_ed25519*
+credentials.json
+.aws/
+.kube/config
+`;
+}
+function renderConfigToml() {
+  return `# .meterbility/config.toml \u2014 per-project Meterbility configuration.
+# v0.3 reads [capture.files] only; later milestones add more sections.
+
+[capture.files]
+# When false, FileChange rows still record the *fact* of an edit but
+# leave before/after blob refs unset (partial_diff = true). Set true to
+# capture the bytes Claude Code / Codex / the SDK / the proxy actually
+# wrote. Off-by-default because capturing code from a random \`cd\`
+# deserves deliberation.
+enabled = true
+
+# Glob patterns. Empty include = "everything not ignored."
+include = []
+exclude = []
+
+# Files larger than this are excluded from the baseline manifest and
+# from full-snapshot FileChange capture. Defaults to 5 MB; the
+# patch_text on the row still records the edit when applicable. Raise
+# this for repos with large generated assets you actually want
+# captured.
+max_file_size_bytes = 5_242_880
+
+# Binary detection strategy. "null-byte-heuristic" matches PR 1's
+# isProbablyText (NUL in first 8 KB \u21D2 binary). "magic-bytes" is
+# scheduled for v0.4 \u2014 it parses file magic for higher precision.
+binary_detection = "null-byte-heuristic"
+`;
+}
+
+// src/commands/files.ts
+import pc21 from "picocolors";
+import {
+  getBaselineTree as getBaselineTree2,
+  getRun as getRun8,
+  getStep as getStep4,
+  getStepBySequence as getStepBySequence3,
+  listFileChanges as listFileChanges3,
+  listSteps as listSteps4
+} from "@meterbility/collector";
+function registerFilesCommand(program2) {
+  program2.command("files <run-id>").description("Show file changes captured for a run (v0.3+)").option(
+    "--at <seq-or-step-id>",
+    "Restrict to changes from a specific step (sequence number or step id)"
+  ).option(
+    "--diff <path>",
+    "Print the unified diff for one path. Combine with --from/--to to scope."
+  ).option(
+    "--from <seq-or-step-id>",
+    "Lower step bound for --diff (inclusive). Defaults to start of run."
+  ).option(
+    "--to <seq-or-step-id>",
+    "Upper step bound for --diff (inclusive). Defaults to end of run."
+  ).option("--json", "Emit JSON instead of human-readable output").action(
+    async (runId, opts) => {
+      const store = openStore();
+      try {
+        const run = getRun8(store, runId);
+        if (!run) {
+          console.error(pc21.red(`run not found: ${runId}`));
+          process.exit(1);
+        }
+        if (opts.diff) {
+          await runDiffMode(store, run, opts);
+          return;
+        }
+        if (opts.at !== void 0) {
+          await runAtMode(store, run, opts);
+          return;
+        }
+        await runSummaryMode(store, run, opts);
+      } finally {
+        store.close();
+      }
+    }
+  );
+}
+async function runSummaryMode(store, run, opts) {
+  const steps = listSteps4(store, run.run_id);
+  const fcs = listFileChanges3(store, { runId: run.run_id });
+  const collapsed = collapseByPath(fcs);
+  const stats = totalStats(collapsed);
+  const baseline = run.baseline_tree_id ? getBaselineTree2(store, run.baseline_tree_id) : void 0;
+  if (opts.json) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          run_id: run.run_id,
+          source_runtime: run.source_runtime,
+          step_count: steps.length,
+          files_touched: collapsed.length,
+          lines_added_total: stats.added,
+          lines_removed_total: stats.removed,
+          baseline: baseline ? {
+            baseline_tree_id: baseline.baseline_tree_id,
+            git_head: baseline.git_head,
+            git_dirty: baseline.git_dirty
+          } : void 0,
+          files: collapsed.map(rowToJson)
+        },
+        null,
+        2
+      ) + "\n"
+    );
+    return;
+  }
+  const sourceLabel = run.source_runtime === "fork" ? "Fork" : run.source_runtime;
+  console.log(
+    pc21.bold(`RUN  ${run.run_id.slice(0, 12)}`) + pc21.dim(
+      `  (${sourceLabel} \xB7 ${steps.length} step${steps.length === 1 ? "" : "s"} \xB7 ${collapsed.length} file${collapsed.length === 1 ? "" : "s"} touched)`
+    )
+  );
+  if (collapsed.length === 0) {
+    console.log(pc21.dim("\n  no file changes captured for this run"));
+    if (!run.baseline_tree_id) {
+      console.log(
+        pc21.dim(
+          "  v0.3 file capture is opt-in per project \u2014 run `meter init` in the project's cwd to enable"
+        )
+      );
+    }
+    return;
+  }
+  console.log("");
+  for (const row of collapsed) {
+    printRow(row);
+  }
+  console.log(
+    pc21.bold(
+      `
+Final ${signedAdd(stats.added)} ${signedRemove(stats.removed)}`
+    ) + pc21.dim(`  across ${collapsed.length} file${collapsed.length === 1 ? "" : "s"}`)
+  );
+  if (baseline) {
+    const head = baseline.git_head ? baseline.git_head.slice(0, 7) : "(no git)";
+    const dirty = baseline.git_dirty ? pc21.yellow("dirty") : pc21.dim("clean");
+    console.log(
+      pc21.dim(`Baseline:  git HEAD ${head}  (${dirty})`)
+    );
+  } else {
+    console.log(
+      pc21.dim(
+        "Baseline:  (none captured \u2014 proxy / non-coding runs or pre-v0.3 ingest)"
+      )
+    );
+  }
+}
+async function runAtMode(store, run, opts) {
+  const step = resolveStep(store, run, opts.at);
+  const fcs = listFileChanges3(store, { stepId: step.step_id });
+  if (opts.json) {
+    process.stdout.write(
+      JSON.stringify(
+        {
+          run_id: run.run_id,
+          step_id: step.step_id,
+          sequence: step.sequence,
+          files: fcs.map(rowToJson)
+        },
+        null,
+        2
+      ) + "\n"
+    );
+    return;
+  }
+  console.log(
+    pc21.bold(`STEP #${step.sequence}`) + pc21.dim(`  ${step.step_id.slice(0, 12)} \xB7 ${fcs.length} file change${fcs.length === 1 ? "" : "s"}`)
+  );
+  if (fcs.length === 0) {
+    console.log(pc21.dim("\n  step did not modify any files"));
+    return;
+  }
+  console.log("");
+  for (const fc of fcs) {
+    printRow(toCollapsedRow(fc));
+  }
+}
+async function runDiffMode(store, run, opts) {
+  const path = opts.diff;
+  const fromSeq = opts.from ? resolveStepSeqLoose(store, run, opts.from) : 0;
+  const toSeq = opts.to ? resolveStepSeqLoose(store, run, opts.to) : Number.MAX_SAFE_INTEGER;
+  if (fromSeq > toSeq) {
+    console.error(pc21.red(`--from (${fromSeq}) must be <= --to (${toSeq})`));
+    process.exit(2);
+  }
+  const all = listFileChanges3(store, { runId: run.run_id, path });
+  const inWindow = filterByStepSeq(store, all, fromSeq, toSeq);
+  if (opts.json) {
+    const blocks = await Promise.all(
+      inWindow.map(async (fc) => ({
+        step_id: fc.step_id,
+        op: fc.op,
+        partial_diff: fc.partial_diff,
+        patch_text: fc.patch_text,
+        lines_added: fc.lines_added,
+        lines_removed: fc.lines_removed,
+        before_blob_ref: fc.before_blob_ref,
+        after_blob_ref: fc.after_blob_ref
+      }))
+    );
+    process.stdout.write(
+      JSON.stringify(
+        { run_id: run.run_id, path, from: fromSeq, to: toSeq, blocks },
+        null,
+        2
+      ) + "\n"
+    );
+    return;
+  }
+  console.log(
+    pc21.bold(`DIFF  ${path}`) + pc21.dim(`  (run ${run.run_id.slice(0, 12)} \xB7 ${inWindow.length} change${inWindow.length === 1 ? "" : "s"} in window)`)
+  );
+  if (inWindow.length === 0) {
+    console.log(pc21.dim("\n  no captured changes for this path in the chosen step window"));
+    return;
+  }
+  const steps = listSteps4(store, run.run_id);
+  const seqByStepId = /* @__PURE__ */ new Map();
+  for (const s of steps) seqByStepId.set(s.step_id, s.sequence);
+  for (const fc of inWindow) {
+    const parentSeq = seqByStepId.get(fc.step_id);
+    const seqLabel = parentSeq !== void 0 ? `step #${parentSeq}` : "step ?";
+    console.log(
+      "\n" + pc21.bold(`@@ ${seqLabel}`) + pc21.dim(`  ${fc.step_id.slice(0, 12)} \xB7 ${fc.op}`)
+    );
+    if (fc.partial_diff) {
+      console.log(
+        pc21.yellow(
+          "  partial: this change ran outside captured tools (e.g. Bash). Enable `meter watch --files` in v0.4 for full fidelity."
+        )
+      );
+      continue;
+    }
+    if (!fc.patch_text) {
+      console.log(pc21.dim("  (binary or no-op \u2014 no patch text)"));
+      continue;
+    }
+    printColorizedPatch(fc.patch_text);
+  }
+}
+function collapseByPath(fcs) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const fc of fcs) {
+    const key = fc.path;
+    const existing = byPath.get(key);
+    if (existing) {
+      existing.lines_added += fc.lines_added;
+      existing.lines_removed += fc.lines_removed;
+      existing.terminalOp = fc.op;
+      existing.any_partial = existing.any_partial || fc.partial_diff;
+      existing.any_binary = existing.any_binary || fc.patch_format === "binary";
+      existing.change_count += 1;
+      if (fc.op === "rename" && fc.old_path) {
+        existing.rename_from = fc.old_path;
+      }
+    } else {
+      byPath.set(key, toCollapsedRow(fc));
+    }
+  }
+  return [...byPath.values()].sort(
+    (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+  );
+}
+function toCollapsedRow(fc) {
+  return {
+    path: fc.path,
+    terminalOp: fc.op,
+    lines_added: fc.lines_added,
+    lines_removed: fc.lines_removed,
+    rename_from: fc.op === "rename" ? fc.old_path : void 0,
+    any_partial: fc.partial_diff,
+    any_binary: fc.patch_format === "binary",
+    change_count: 1
+  };
+}
+function totalStats(rows) {
+  let added = 0;
+  let removed = 0;
+  for (const r of rows) {
+    added += r.lines_added;
+    removed += r.lines_removed;
+  }
+  return { added, removed };
+}
+function printRow(row) {
+  const tag = opTag(row.terminalOp);
+  const renderedPath = row.terminalOp === "rename" && row.rename_from ? `${row.rename_from} \u2192 ${row.path}` : row.path;
+  const pathCell = renderedPath.padEnd(32);
+  const stats = `${signedAdd(row.lines_added).padStart(6)} ${signedRemove(row.lines_removed).padStart(6)}`;
+  const flags = [];
+  if (row.any_partial) flags.push(pc21.yellow("partial"));
+  if (row.any_binary) flags.push(pc21.dim("binary"));
+  if (row.change_count > 1) flags.push(pc21.dim(`${row.change_count} changes`));
+  console.log(
+    `  ${tag}  ${pathCell}  ${stats}${flags.length ? "  " + flags.join(" ") : ""}`
+  );
+}
+function opTag(op) {
+  switch (op) {
+    case "create":
+      return pc21.green("A");
+    case "modify":
+      return pc21.yellow("M");
+    case "delete":
+      return pc21.red("D");
+    case "rename":
+      return pc21.magenta("R");
+    case "chmod":
+      return pc21.dim("X");
+  }
+}
+function signedAdd(n) {
+  return n === 0 ? "+0" : pc21.green(`+${n}`);
+}
+function signedRemove(n) {
+  return n === 0 ? "\u22120" : pc21.red(`\u2212${n}`);
+}
+function printColorizedPatch(patch) {
+  for (const line of patch.split("\n")) {
+    if (line.startsWith("@@")) {
+      console.log(pc21.cyan(line));
+    } else if (line.startsWith("+") && !line.startsWith("+++")) {
+      console.log(pc21.green(line));
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      console.log(pc21.red(line));
+    } else {
+      console.log(line);
+    }
+  }
+}
+function rowToJson(arg) {
+  if ("change_count" in arg) {
+    const r = arg;
+    return {
+      path: r.path,
+      op: r.terminalOp,
+      rename_from: r.rename_from,
+      lines_added: r.lines_added,
+      lines_removed: r.lines_removed,
+      change_count: r.change_count,
+      partial: r.any_partial,
+      binary: r.any_binary
+    };
+  }
+  const fc = arg;
+  return {
+    file_change_id: fc.file_change_id,
+    step_id: fc.step_id,
+    sequence: fc.sequence,
+    path: fc.path,
+    old_path: fc.old_path,
+    op: fc.op,
+    before_blob_ref: fc.before_blob_ref,
+    after_blob_ref: fc.after_blob_ref,
+    partial_diff: fc.partial_diff,
+    patch_format: fc.patch_format,
+    lines_added: fc.lines_added,
+    lines_removed: fc.lines_removed,
+    source_tool_name: fc.source_tool_name
+  };
+}
+function resolveStep(store, run, needle) {
+  const seq = Number(needle);
+  const step = Number.isFinite(seq) ? getStepBySequence3(store, run.run_id, seq) : getStep4(store, needle);
+  if (!step) {
+    console.error(pc21.red(`step not found: ${needle}`));
+    process.exit(1);
+  }
+  return step;
+}
+function resolveStepSeqLoose(store, run, needle) {
+  const seq = Number(needle);
+  if (Number.isFinite(seq)) return seq;
+  const step = getStep4(store, needle);
+  if (!step) {
+    console.error(pc21.red(`step not found: ${needle}`));
+    process.exit(1);
+  }
+  return step.sequence;
+}
+function filterByStepSeq(store, fcs, fromSeq, toSeq) {
+  if (fcs.length === 0) return fcs;
+  const steps = listSteps4(store, fcs[0].run_id);
+  const seqByStepId = /* @__PURE__ */ new Map();
+  for (const s of steps) seqByStepId.set(s.step_id, s.sequence);
+  return fcs.filter((fc) => {
+    const seq = seqByStepId.get(fc.step_id);
+    if (seq === void 0) return false;
+    return seq >= fromSeq && seq <= toSeq;
+  });
+}
+
+// src/commands/probe.ts
+import { readFileSync } from "fs";
+import pc22 from "picocolors";
+import {
+  clearProbe,
+  readState,
+  requestPause,
+  requestResume,
+  setInject
+} from "@meterbility/shared";
+import { getRun as getRun9 } from "@meterbility/collector";
+function registerProbeCommand(program2) {
+  const probe = program2.command("probe").description(
+    "Pause, inject a message, or resume a running agent (Live Probe)"
+  );
+  probe.command("status <run-id>").description("Show current probe state for a run").option("--json", "Emit the full ProbeRecord as one JSON line").action(async (runIdArg, opts) => {
+    const runId = await resolveRunId(runIdArg);
+    const state = readState(runId);
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(state) + "\n");
+      return;
+    }
+    printStatus(runId, state);
+  });
+  probe.command("pause <run-id>").description(
+    "Request a graceful pause \u2014 SDK finishes current call before yielding"
+  ).option("--json", "Emit the resulting ProbeRecord as JSON").action(async (runIdArg, opts) => {
+    const runId = await resolveRunId(runIdArg);
+    const prev = readState(runId);
+    const next = requestPause(runId);
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(next) + "\n");
+      return;
+    }
+    if (prev.state === "pause_requested" || prev.state === "paused") {
+      console.log(
+        pc22.dim(
+          `already ${prev.state} (since ${fmtAgoFromMs(prev.requested_at_ms)})`
+        )
+      );
+    } else {
+      console.log(
+        pc22.yellow("pause requested  ") + pc22.cyan(runId.slice(0, 12)) + pc22.dim("  (will take effect after the current model call)")
+      );
+    }
+  });
+  probe.command("inject <run-id>").description(
+    "Queue a message to be appended to the next user turn (pause + inject + resume is the natural flow)"
+  ).option(
+    "-m, --message <text>",
+    "Message text. Use --stdin for multi-line or to avoid shell-quoting"
+  ).option("--stdin", "Read the message from stdin").option(
+    "--force",
+    "Overwrite a pending inject without warning"
+  ).option("--json", "Emit the resulting ProbeRecord as JSON").action(
+    async (runIdArg, opts) => {
+      const runId = await resolveRunId(runIdArg);
+      const message = readInjectMessage(opts);
+      const prev = readState(runId);
+      if (prev.inject !== null && prev.inject !== void 0 && !opts.force) {
+        throw new Error(
+          `a pending inject is already queued for this run (use --force to overwrite). current: ${JSON.stringify(prev.inject)}`
+        );
+      }
+      const next = setInject(runId, message);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(next) + "\n");
+        return;
+      }
+      console.log(
+        pc22.green("inject queued  ") + pc22.cyan(runId.slice(0, 12)) + pc22.dim(
+          `  (${message.length} chars, will land on next model call)`
+        )
+      );
+    }
+  );
+  probe.command("resume <run-id>").description(
+    "Resume a paused run. Preserves any pending inject \u2014 operator can resume-with-message"
+  ).option("--json", "Emit the resulting ProbeRecord as JSON").action(async (runIdArg, opts) => {
+    const runId = await resolveRunId(runIdArg);
+    const prev = readState(runId);
+    const next = requestResume(runId);
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(next) + "\n");
+      return;
+    }
+    if (prev.state === "running") {
+      console.log(pc22.dim("already running \u2014 nothing to do"));
+    } else {
+      const carried = next.inject !== null ? pc22.dim(`  (carrying pending inject \u2014 will land on next call)`) : "";
+      console.log(
+        pc22.green("resumed  ") + pc22.cyan(runId.slice(0, 12)) + carried
+      );
+    }
+  });
+  probe.command("clear <run-id>").description(
+    "Remove the probe file. For stale recovery when the SDK crashed before tracer.end() ran"
+  ).action(async (runIdArg) => {
+    clearProbe(runIdArg);
+    console.log(pc22.dim(`cleared probe file for ${runIdArg}`));
+  });
+}
+async function resolveRunId(input) {
+  const store = openStore();
+  try {
+    const run = getRun9(store, input);
+    if (!run) {
+      throw new Error(
+        `run not found: ${input} (provide the full id or a unique 6+-char prefix)`
+      );
+    }
+    return run.run_id;
+  } finally {
+    store.close();
+  }
+}
+function readInjectMessage(opts) {
+  if (opts.stdin) {
+    const buf = readFileSync(0, "utf-8");
+    if (buf.length === 0) {
+      throw new Error("--stdin specified but no input received on stdin");
+    }
+    return buf.endsWith("\n") ? buf.slice(0, -1) : buf;
+  }
+  if (opts.message !== void 0) {
+    if (opts.message === "") {
+      throw new Error("--message cannot be empty");
+    }
+    return opts.message;
+  }
+  throw new Error("provide a message via -m <text> or --stdin");
+}
+function printStatus(runId, r) {
+  const stateColor = r.state === "running" ? pc22.green : r.state === "pause_requested" ? pc22.yellow : pc22.red;
+  console.log(pc22.bold(runId));
+  console.log(`  ${pc22.dim("state")}        ${stateColor(r.state)}`);
+  console.log(
+    `  ${pc22.dim("requested at")} ${fmtIsoFromMs(r.requested_at_ms)}`
+  );
+  console.log(
+    `  ${pc22.dim("paused at")}    ${fmtIsoFromMs(r.paused_at_ms)}`
+  );
+  console.log(
+    `  ${pc22.dim("resumed at")}   ${fmtIsoFromMs(r.resumed_at_ms)}`
+  );
+  if (r.inject !== null) {
+    console.log(
+      `  ${pc22.dim("inject")}       ${pc22.cyan("queued")} (${r.inject.length} chars)`
+    );
+    const firstLine = r.inject.split("\n")[0] ?? "";
+    const preview = firstLine.length > 80 ? firstLine.slice(0, 77) + "..." : firstLine;
+    console.log(`               ${pc22.dim("\u203A")} ${preview}`);
+  } else {
+    console.log(`  ${pc22.dim("inject")}       ${pc22.dim("none")}`);
+  }
+}
+function fmtIsoFromMs(ms) {
+  if (ms === null) return pc22.dim("\u2014");
+  return new Date(ms).toISOString();
+}
+function fmtAgoFromMs(ms) {
+  if (ms === null) return "earlier";
+  const delta = Date.now() - ms;
+  if (delta < 1e3) return "just now";
+  const s = Math.floor(delta / 1e3);
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  return `${h}h ago`;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("meter").description(pc23.bold("Meterbility ") + pc23.dim("\u2014 the debugger for AI agents")).version("0.3.1");
+registerDoctorCommand(program);
+registerIngestCommand(program);
+registerListCommand(program);
+registerInspectCommand(program);
+registerForkCommand(program);
+registerDiffCommand(program);
+registerAnnotateCommand(program);
+registerWebCommand(program);
+registerExportCommand(program);
+registerTestCommand(program);
+registerDbCommand(program);
+registerSlackCommand(program);
+registerConfigCommand(program);
+registerWatchCommand(program);
+registerOpenCommand(program);
+registerProxyCommand(program);
+registerRunCommand(program);
+registerRunsCommand(program);
+registerInitCommand(program);
+registerFilesCommand(program);
+registerProbeCommand(program);
+program.parseAsync(process.argv).catch((err) => {
+  console.error(pc23.red("error: ") + err.message);
+  if (process.env.METERBILITY_DEBUG) console.error(err);
+  process.exit(1);
+});