@meterbility/server 0.3.1

package/dist/index.js

@@ -0,0 +1,3886 @@
+import {
+  DECISION_PREVIEW_LIMIT,
+  prettyMultilineString,
+  prettyTab,
+  prettyValue,
+  reformatJsonString,
+  renderContext,
+  renderDiff,
+  renderFleet,
+  renderProbePanel,
+  renderRun,
+  renderRunList,
+  renderShell,
+  renderStepCardFragment,
+  renderTests
+} from "./chunk-VULWJFYO.js";
+
+// src/replay.ts
+import { randomUUID } from "crypto";
+import { hashJson } from "@meterbility/shared";
+import { costCents } from "@meterbility/spec";
+import {
+  getRun,
+  getStep,
+  insertRun,
+  insertStep,
+  listSteps,
+  recordContextSnapshot,
+  resolveSnapshotBlobRef,
+  setRunStatus,
+  updateRunTotals,
+  upsertAgent,
+  upsertProjectByCwd
+} from "@meterbility/collector";
+async function materializePrefix(store, originRunId, forkStepId, edit) {
+  const origin = getRun(store, originRunId);
+  if (!origin) throw new Error(`unknown run: ${originRunId}`);
+  const forkStep = getStep(store, forkStepId);
+  if (!forkStep || forkStep.run_id !== originRunId) {
+    throw new Error(
+      `step ${forkStepId} does not belong to run ${originRunId}`
+    );
+  }
+  const allSteps = listSteps(store, originRunId);
+  const prefix = allSteps.filter((s) => s.sequence <= forkStep.sequence);
+  const newRunId = `run_${randomUUID()}`;
+  const project = upsertProjectByCwd(store, origin.cwd ?? "(unknown)");
+  const agent = upsertAgent(store, project.project_id, "fork");
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const newRun = {
+    run_id: newRunId,
+    agent_id: agent.agent_id,
+    project_id: project.project_id,
+    source_session_id: void 0,
+    source_runtime: "fork",
+    title: forkTitle(origin, edit),
+    status: "in_progress",
+    started_at: startedAt,
+    git_branch: origin.git_branch,
+    cwd: origin.cwd,
+    fork_origin_run_id: originRunId,
+    fork_origin_step_id: forkStepId,
+    tokens_total_input: 0,
+    tokens_total_output: 0,
+    tokens_total_cached: 0,
+    cost_cents: 0,
+    step_count: 0,
+    tags: ["fork", `fork-edit:${edit.type}`]
+  };
+  insertRun(store, newRun);
+  let prevId;
+  for (const orig of prefix) {
+    const isForkPoint = orig.step_id === forkStepId;
+    const { step, snapshot } = isForkPoint ? await applyEditToStep(store, orig, edit) : copyStep(orig);
+    step.run_id = newRunId;
+    step.step_id = `stp_${randomUUID()}`;
+    step.parent_step_id = prevId;
+    step.fork_origin_id = isForkPoint ? orig.step_id : void 0;
+    if (snapshot) {
+      const ref = await store.blobs.putJson(snapshot);
+      recordContextSnapshot(
+        store,
+        snapshot.id,
+        ref,
+        snapshot.components.length
+      );
+      step.context_snapshot_id = snapshot.id;
+    }
+    if (isForkPoint) {
+      step.outcome = { status: "pending" };
+      step.status = "in_progress";
+    }
+    insertStep(store, step);
+    prevId = step.step_id;
+  }
+  updateRunTotals(store, newRunId);
+  setRunStatus(store, newRunId, "in_progress");
+  return { run_id: newRunId, prefix_steps: prefix.length };
+}
+function forkTitle(origin, edit) {
+  const base = origin.title ?? origin.run_id;
+  return `Fork[${edit.type}] of ${base}`.slice(0, 120);
+}
+function copyStep(orig) {
+  return {
+    step: {
+      ...orig,
+      tokens: { ...orig.tokens },
+      tags: [...orig.tags]
+    }
+  };
+}
+async function applyEditToStep(store, step, edit) {
+  const snapshot = await rewriteSnapshot(store, step.context_snapshot_id, edit);
+  return { step: { ...step, tokens: { ...step.tokens }, tags: [...step.tags] }, snapshot };
+}
+async function rewriteSnapshot(store, snapshotId, edit) {
+  const ref = resolveSnapshotBlobRef(store, snapshotId);
+  const base = await store.blobs.getJson(ref);
+  const components = [];
+  let injected = false;
+  for (const c of base.components) {
+    if (edit.type === "replace_system_prompt" && c.type === "system_prompt") {
+      const text = String(
+        edit.payload?.text ?? ""
+      );
+      const ref2 = await store.blobs.putString(text);
+      components.push({ type: "system_prompt", content_ref: ref2 });
+      injected = true;
+    } else if (edit.type === "replace_user_message" && c.type === "conversation_history") {
+      const stepRef = edit.payload?.step_ref;
+      const text = String(
+        edit.payload?.text ?? ""
+      );
+      const ref2 = await store.blobs.putString(text);
+      const newHistory = c.messages.map((m) => {
+        if (stepRef && m.step_ref === stepRef && m.role === "user") {
+          return { ...m, content_ref: ref2 };
+        }
+        return m;
+      });
+      if (!stepRef && newHistory.length > 0) {
+        for (let i = newHistory.length - 1; i >= 0; i--) {
+          if (newHistory[i].role === "user") {
+            newHistory[i] = { ...newHistory[i], content_ref: ref2 };
+            break;
+          }
+        }
+      }
+      components.push({ type: "conversation_history", messages: newHistory });
+    } else if (edit.type === "inject_message" && c.type === "conversation_history") {
+      const text = String(
+        edit.payload?.text ?? ""
+      );
+      const role = (edit.payload?.role ?? "user") === "assistant" ? "assistant" : "user";
+      const ref2 = await store.blobs.putString(text);
+      components.push({
+        type: "conversation_history",
+        messages: [...c.messages, { role, content_ref: ref2 }]
+      });
+    } else {
+      components.push(c);
+    }
+  }
+  if (edit.type === "replace_system_prompt" && !injected) {
+    const text = String(edit.payload?.text ?? "");
+    const ref2 = await store.blobs.putString(text);
+    components.unshift({ type: "system_prompt", content_ref: ref2 });
+  }
+  if (edit.type === "inject_message" && !components.some((c) => c.type === "conversation_history")) {
+    const text = String(edit.payload?.text ?? "");
+    const role = (edit.payload?.role ?? "user") === "assistant" ? "assistant" : "user";
+    const ref2 = await store.blobs.putString(text);
+    components.push({
+      type: "conversation_history",
+      messages: [{ role, content_ref: ref2 }]
+    });
+  }
+  return { id: hashJson(components), components };
+}
+async function appendLiveStep(store, runId, args) {
+  const run = getRun(store, runId);
+  if (!run) throw new Error(`unknown run: ${runId}`);
+  const prior = listSteps(store, run.run_id);
+  const sequence = prior.length;
+  const decisionRef = await store.blobs.putJson(args.decisionContent);
+  const snapshotRef = await store.blobs.putJson(args.snapshot);
+  recordContextSnapshot(
+    store,
+    args.snapshot.id,
+    snapshotRef,
+    args.snapshot.components.length
+  );
+  const { cost_cents, approx } = costCents(args.model, {
+    input: args.tokens.input,
+    output: args.tokens.output,
+    cached_read: args.tokens.cached_read,
+    cache_creation: args.tokens.cache_creation,
+    cache_creation_1h: args.tokens.cache_creation_1h
+  });
+  const tags = ["live-suffix"];
+  if (approx) tags.push("cost:approx");
+  const step = {
+    step_id: `stp_${randomUUID()}`,
+    run_id: runId,
+    parent_step_id: args.parent_step_id ?? prior[prior.length - 1]?.step_id,
+    sequence,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    model: args.model,
+    context_snapshot_id: args.snapshot.id,
+    decision_ref: decisionRef,
+    action: args.action,
+    outcome: args.outcome,
+    tokens: args.tokens,
+    latency_ms: args.latency_ms,
+    cost_cents,
+    tags,
+    status: args.outcome.status === "error" ? "error" : args.outcome.status === "pending" ? "in_progress" : "ok"
+  };
+  insertStep(store, step);
+  updateRunTotals(store, runId);
+  return step;
+}
+
+// src/fork.ts
+import {
+  getRun as getRun2,
+  getStep as getStep2,
+  getStepBySequence,
+  insertFork,
+  listSteps as listSteps2
+} from "@meterbility/collector";
+async function forkRun(store, args, liveSuffix) {
+  const origin = getRun2(store, args.origin_run_id);
+  if (!origin) throw new Error(`unknown origin run: ${args.origin_run_id}`);
+  const targetStep = typeof args.at === "number" ? getStepBySequence(store, origin.run_id, args.at) : getStep2(store, args.at);
+  if (!targetStep || targetStep.run_id !== origin.run_id) {
+    throw new Error(`fork target step not found in run ${origin.run_id}`);
+  }
+  validateEdit(args.edit);
+  const { run_id: fork_run_id, prefix_steps } = await materializePrefix(
+    store,
+    origin.run_id,
+    targetStep.step_id,
+    args.edit
+  );
+  const fork_id = insertFork(store, {
+    originRunId: origin.run_id,
+    originStepId: targetStep.step_id,
+    forkRunId: fork_run_id,
+    edit: args.edit
+  });
+  let live = false;
+  if (liveSuffix) {
+    const forkSteps = listSteps2(store, fork_run_id);
+    const lastForkStep = forkSteps[forkSteps.length - 1];
+    const history = lastForkStep.context_snapshot_id;
+    const result = await liveSuffix({
+      origin_step: targetStep,
+      context_snapshot_id: history,
+      edit: args.edit
+    });
+    await appendLiveStep(store, fork_run_id, {
+      model: result.model,
+      action: result.action,
+      outcome: result.outcome ?? { status: "ok" },
+      tokens: result.tokens,
+      latency_ms: result.latency_ms ?? 0,
+      parent_step_id: lastForkStep.step_id,
+      snapshot: {
+        id: lastForkStep.context_snapshot_id,
+        components: []
+      },
+      decisionContent: result.decision_content
+    });
+    live = true;
+  }
+  return { fork_id, fork_run_id, prefix_steps, live };
+}
+function validateEdit(edit) {
+  const allowed = [
+    "replace_system_prompt",
+    "add_context",
+    "remove_tool",
+    "modify_tool_description",
+    "replace_user_message",
+    "inject_message",
+    "change_model"
+  ];
+  if (!allowed.includes(edit.type)) {
+    throw new Error(`unsupported edit type: ${edit.type}`);
+  }
+}
+function fakeResponder(text) {
+  return async () => ({
+    model: "fake",
+    action: { kind: "message", text },
+    outcome: { status: "ok" },
+    tokens: { input: 0, output: 0, cached_read: 0, cache_creation: 0 },
+    latency_ms: 1,
+    decision_content: [{ type: "text", text }]
+  });
+}
+function anthropicResponder(store, opts) {
+  return async (args) => {
+    const { default: Anthropic } = await import("@anthropic-ai/sdk");
+    const client = new Anthropic({ apiKey: opts.apiKey });
+    const snapshot = await store.blobs.getJson(args.context_snapshot_id);
+    const history = snapshot.components.find(
+      (c) => c.type === "conversation_history"
+    );
+    const messages = [];
+    if (history?.messages) {
+      for (const m of history.messages) {
+        if (m.role === "tool") continue;
+        const text2 = await store.blobs.tryGetString(m.content_ref);
+        messages.push({ role: m.role, content: text2 ?? "" });
+      }
+    }
+    let systemPrompt = opts.systemPrompt;
+    const sys = snapshot.components.find((c) => c.type === "system_prompt");
+    if (sys?.content_ref && !systemPrompt) {
+      systemPrompt = await store.blobs.tryGetString(sys.content_ref);
+    }
+    const t0 = Date.now();
+    const resp = await client.messages.create({
+      model: opts.model,
+      max_tokens: opts.maxTokens ?? 4096,
+      system: systemPrompt,
+      messages: messages.length ? messages : [{ role: "user", content: "(no history)" }]
+    });
+    const t1 = Date.now();
+    const text = (resp.content ?? []).filter((b) => b.type === "text").map((b) => b.text).join("\n");
+    const usage = resp.usage;
+    const cc = usage?.cache_creation;
+    const tokens5m = cc ? cc.ephemeral_5m_input_tokens ?? 0 : usage?.cache_creation_input_tokens ?? 0;
+    const tokens1h = cc?.ephemeral_1h_input_tokens ?? 0;
+    return {
+      model: resp.model,
+      action: { kind: "message", text },
+      outcome: { status: "ok" },
+      tokens: {
+        input: resp.usage?.input_tokens ?? 0,
+        output: resp.usage?.output_tokens ?? 0,
+        cached_read: usage?.cache_read_input_tokens ?? 0,
+        cache_creation: tokens5m,
+        cache_creation_1h: tokens1h
+      },
+      latency_ms: t1 - t0,
+      decision_content: resp.content
+    };
+  };
+}
+
+// src/diff.ts
+import { listSteps as listSteps3 } from "@meterbility/collector";
+function digest(s) {
+  return {
+    step_id: s.step_id,
+    model: s.model,
+    context_snapshot_id: s.context_snapshot_id,
+    decision_ref: s.decision_ref,
+    action_kind: s.action.kind,
+    tool_name: s.action.tool_name,
+    outcome_status: s.outcome.status,
+    outcome_summary: s.outcome.summary,
+    cost_cents: s.cost_cents,
+    tokens_total: s.tokens.input + s.tokens.output,
+    status: s.status
+  };
+}
+function diffRuns(store, runA, runB) {
+  const stepsA = listSteps3(store, runA);
+  const stepsB = listSteps3(store, runB);
+  const rows = [];
+  const max = Math.max(stepsA.length, stepsB.length);
+  let sharedPrefixLength = 0;
+  let firstDivergence;
+  let diverged = false;
+  for (let i = 0; i < max; i++) {
+    const a = stepsA[i];
+    const b = stepsB[i];
+    if (!a && b) {
+      rows.push({ sequence: i, kind: "only_b", b: digest(b) });
+      if (firstDivergence === void 0) firstDivergence = i;
+      diverged = true;
+      continue;
+    }
+    if (a && !b) {
+      rows.push({ sequence: i, kind: "only_a", a: digest(a) });
+      if (firstDivergence === void 0) firstDivergence = i;
+      diverged = true;
+      continue;
+    }
+    if (!a || !b) continue;
+    if (diverged) {
+      rows.push({ sequence: i, kind: "diverged", a: digest(a), b: digest(b) });
+      continue;
+    }
+    const kind = classify(a, b);
+    rows.push({ sequence: i, kind, a: digest(a), b: digest(b) });
+    if (kind === "shared") {
+      sharedPrefixLength = i + 1;
+    } else {
+      if (firstDivergence === void 0) firstDivergence = i;
+      diverged = true;
+    }
+  }
+  return {
+    run_a_id: runA,
+    run_b_id: runB,
+    total_steps_a: stepsA.length,
+    total_steps_b: stepsB.length,
+    shared_prefix_length: sharedPrefixLength,
+    first_divergence_sequence: firstDivergence,
+    rows
+  };
+}
+function classify(a, b) {
+  if (a.context_snapshot_id !== b.context_snapshot_id) {
+    return "context_diff";
+  }
+  if (a.decision_ref !== b.decision_ref) {
+    return "decision_diff";
+  }
+  if (a.action.kind !== b.action.kind || a.action.tool_name !== b.action.tool_name) {
+    return "action_diff";
+  }
+  if (a.outcome.status !== b.outcome.status || a.outcome.is_error !== b.outcome.is_error) {
+    return "outcome_diff";
+  }
+  return "shared";
+}
+
+// src/web.ts
+import { Hono } from "hono";
+import { stream } from "hono/streaming";
+import { serve } from "@hono/node-server";
+import {
+  clearProbe,
+  consumeInject as consumeProbeInject,
+  readState as readProbeState2,
+  requestPause as probeRequestPause,
+  requestResume as probeRequestResume,
+  setInject as probeSetInject
+} from "@meterbility/shared";
+import {
+  getBaselineTree,
+  getFileChange,
+  getRun as getRun6,
+  getStep as getStep3,
+  getStepBySequence as getStepBySequence2,
+  listAnnotations,
+  listFileChanges as listFileChanges2,
+  listForks,
+  listRuns as listRuns3,
+  listSteps as listSteps7,
+  insertAnnotation as insertAnnotation2,
+  resolveSnapshotBlobRef as resolveSnapshotBlobRef3,
+  setRunStatus as setRunStatus3,
+  updateRunTotals as updateRunTotals3,
+  getSetting,
+  setSetting,
+  deleteSetting,
+  resolveSetting
+} from "@meterbility/collector";
+import { TRACE_FORMAT_VERSION } from "@meterbility/spec";
+
+// src/probe_annotations.ts
+import { insertAnnotation } from "@meterbility/collector";
+var probeAnnotationFailedCount = 0;
+function recordProbeIntervention(store, runId, kind, payload) {
+  try {
+    insertAnnotation(store, {
+      targetKind: "run",
+      targetId: runId,
+      author: "system:probe",
+      kind,
+      note: buildProbeNote(kind, payload)
+    });
+  } catch (err) {
+    probeAnnotationFailedCount += 1;
+    console.error(
+      `[probe_annotation] failed to record ${kind} for ${runId}: ${err.message} (total failures: ${probeAnnotationFailedCount})`
+    );
+  }
+}
+function buildProbeNote(kind, payload) {
+  if (kind === "probe_pause") {
+    const ts2 = String(payload.paused_at ?? (/* @__PURE__ */ new Date()).toISOString());
+    return `paused at ${ts2}`;
+  }
+  const bytes = Number(payload.inject_bytes ?? 0);
+  const ts = String(payload.resumed_at ?? (/* @__PURE__ */ new Date()).toISOString());
+  return `inject staged (${bytes} bytes) \u2014 resumed at ${ts}`;
+}
+
+// src/blob_render.ts
+import { createHash } from "crypto";
+var RENDER_VERSION = "v1";
+var SHIKI_THEME = "github-dark-dimmed";
+function sniffMimeAndLang(buf, pathHint) {
+  if (buf.length >= 8) {
+    if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) {
+      return { mime: "image/png", binary: true };
+    }
+    if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) {
+      return { mime: "image/jpeg", binary: true };
+    }
+    if (buf[0] === 71 && buf[1] === 73 && buf[2] === 70 && buf[3] === 56 && (buf[4] === 55 || buf[4] === 57) && buf[5] === 97) {
+      return { mime: "image/gif", binary: true };
+    }
+    if (buf.length >= 12 && buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 87 && buf[9] === 69 && buf[10] === 66 && buf[11] === 80) {
+      return { mime: "image/webp", binary: true };
+    }
+  }
+  const window = Math.min(buf.length, 8192);
+  for (let i = 0; i < window; i++) {
+    if (buf[i] === 0) {
+      return { mime: "application/octet-stream", binary: true };
+    }
+  }
+  const lang = pathHint ? langFromPath(pathHint) : void 0;
+  return { mime: "text/plain", lang, binary: false };
+}
+function langFromPath(path) {
+  const lower = path.toLowerCase();
+  const basename = lower.includes("/") ? lower.slice(lower.lastIndexOf("/") + 1) : lower;
+  if (basename === "dockerfile" || basename.startsWith("dockerfile."))
+    return "dockerfile";
+  if (basename === "makefile" || basename === "gnumakefile") return "makefile";
+  if (basename === "rakefile" || basename === "gemfile") return "ruby";
+  if (basename === "podfile") return "ruby";
+  if (basename === "vagrantfile") return "ruby";
+  if (basename === "jenkinsfile") return "groovy";
+  if (basename === "cmakelists.txt") return "cmake";
+  if (basename === "license" || basename === "license.txt") return void 0;
+  if (basename === "readme" || basename === "authors") return void 0;
+  const ext = basename.includes(".") ? basename.slice(basename.lastIndexOf(".") + 1) : "";
+  return EXT_TO_LANG[ext];
+}
+var EXT_TO_LANG = {
+  ts: "typescript",
+  tsx: "tsx",
+  js: "javascript",
+  jsx: "jsx",
+  mjs: "javascript",
+  cjs: "javascript",
+  py: "python",
+  rb: "ruby",
+  go: "go",
+  rs: "rust",
+  java: "java",
+  kt: "kotlin",
+  swift: "swift",
+  c: "c",
+  h: "c",
+  cpp: "cpp",
+  cc: "cpp",
+  hpp: "cpp",
+  cs: "csharp",
+  php: "php",
+  sh: "bash",
+  bash: "bash",
+  zsh: "bash",
+  fish: "fish",
+  ps1: "powershell",
+  sql: "sql",
+  json: "json",
+  jsonc: "jsonc",
+  yaml: "yaml",
+  yml: "yaml",
+  toml: "toml",
+  xml: "xml",
+  html: "html",
+  htm: "html",
+  css: "css",
+  scss: "scss",
+  sass: "sass",
+  less: "less",
+  md: "markdown",
+  mdx: "mdx",
+  rst: "rst",
+  tex: "latex",
+  vue: "vue",
+  svelte: "svelte",
+  dart: "dart",
+  ex: "elixir",
+  exs: "elixir",
+  erl: "erlang",
+  hs: "haskell",
+  lua: "lua",
+  pl: "perl",
+  r: "r",
+  scala: "scala",
+  zig: "zig",
+  proto: "proto",
+  graphql: "graphql",
+  gql: "graphql",
+  env: "bash",
+  ini: "ini",
+  conf: "ini",
+  diff: "diff",
+  patch: "diff"
+};
+function stripBom(buf) {
+  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
+    return buf.subarray(3);
+  }
+  return buf;
+}
+function renderCacheKey(blobHash, lang) {
+  return "render_" + createHash("sha256").update(`${blobHash}|${lang}|${RENDER_VERSION}`).digest("hex");
+}
+var shikiHighlighterPromise;
+function getShikiHighlighter() {
+  if (!shikiHighlighterPromise) {
+    shikiHighlighterPromise = (async () => {
+      const shiki = await import("shiki");
+      const highlighter = await shiki.createHighlighter({
+        themes: [SHIKI_THEME],
+        langs: [
+          "typescript",
+          "tsx",
+          "javascript",
+          "jsx",
+          "python",
+          "json",
+          "yaml",
+          "markdown",
+          "bash",
+          "go",
+          "rust",
+          "html",
+          "css",
+          "sql",
+          "diff"
+        ]
+      });
+      return highlighter;
+    })();
+  }
+  return shikiHighlighterPromise;
+}
+async function renderHighlighted(buf, lang) {
+  const cleaned = stripBom(buf);
+  const code = cleaned.toString("utf-8");
+  const effLang = lang ?? "plaintext";
+  try {
+    const highlighter = await getShikiHighlighter();
+    if (effLang !== "plaintext" && typeof highlighter.getLoadedLanguages === "function" && !highlighter.getLoadedLanguages().includes(effLang)) {
+      try {
+        await highlighter.loadLanguage(effLang);
+      } catch {
+        return renderPlaintext(code);
+      }
+    }
+    return highlighter.codeToHtml(code, {
+      lang: effLang,
+      theme: SHIKI_THEME
+    });
+  } catch {
+    return renderPlaintext(code);
+  }
+}
+function renderPlaintext(code) {
+  const escaped = code.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return `<pre class="shiki"><code>${escaped}</code></pre>`;
+}
+
+// src/file_view.ts
+var OP_RANK = {
+  delete: 0,
+  rename: 1,
+  modify: 2,
+  create: 3,
+  chmod: 4
+};
+function compareOpsByRisk(a, b) {
+  const ra = a !== void 0 ? OP_RANK[a] : 99;
+  const rb = b !== void 0 ? OP_RANK[b] : 99;
+  return ra - rb;
+}
+function worstOpAmong(fcs) {
+  if (fcs.length === 0) return void 0;
+  let best = fcs[0].op;
+  for (let i = 1; i < fcs.length; i++) {
+    if (compareOpsByRisk(fcs[i].op, best) < 0) best = fcs[i].op;
+  }
+  return best;
+}
+function buildFileTree(fcs) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const fc of fcs) {
+    const list = byPath.get(fc.path);
+    if (list) list.push(fc);
+    else byPath.set(fc.path, [fc]);
+  }
+  for (const list of byPath.values()) {
+    list.sort((a, b) => a.sequence - b.sequence);
+  }
+  const root = {
+    name: "",
+    path: "",
+    isDir: true,
+    dirs: /* @__PURE__ */ new Map(),
+    files: []
+  };
+  for (const [path, touches] of byPath) {
+    const segments = path.split("/").filter(Boolean);
+    let cursor = root;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const seg = segments[i];
+      let next = cursor.dirs.get(seg);
+      if (!next) {
+        const dirPath = cursor.path ? `${cursor.path}/${seg}` : seg;
+        next = {
+          name: seg,
+          path: dirPath,
+          isDir: true,
+          dirs: /* @__PURE__ */ new Map(),
+          files: []
+        };
+        cursor.dirs.set(seg, next);
+      }
+      cursor = next;
+    }
+    const fileName = segments[segments.length - 1] ?? path;
+    const leaf = {
+      name: fileName,
+      path,
+      isDir: false,
+      worstOp: worstOpAmong(touches),
+      anyPartial: touches.some((t) => t.partial_diff),
+      anyRedacted: touches.some((t) => t.redacted),
+      anyBinary: touches.some(
+        (t) => !t.partial_diff && !t.redacted && t.patch_format === "binary"
+      ),
+      children: [],
+      changes: touches
+    };
+    cursor.files.push(leaf);
+  }
+  function materialize(dir) {
+    const childDirs = [];
+    for (const [, sub] of dir.dirs) {
+      const subChildren = materialize(sub);
+      const allLeaves = collectLeaves(subChildren);
+      childDirs.push({
+        name: sub.name,
+        path: sub.path,
+        isDir: true,
+        worstOp: worstOpAmong(allLeaves.flatMap((l) => l.changes)),
+        anyPartial: allLeaves.some((l) => l.anyPartial),
+        anyRedacted: allLeaves.some((l) => l.anyRedacted),
+        anyBinary: allLeaves.some((l) => l.anyBinary),
+        children: subChildren,
+        changes: []
+      });
+    }
+    childDirs.sort(
+      (a, b) => compareOpsByRisk(a.worstOp, b.worstOp) || a.name.localeCompare(b.name)
+    );
+    const childFiles = [...dir.files].sort(
+      (a, b) => compareOpsByRisk(a.worstOp, b.worstOp) || a.name.localeCompare(b.name)
+    );
+    return [...childDirs, ...childFiles];
+  }
+  return materialize(root);
+}
+function collectLeaves(nodes) {
+  const out = [];
+  for (const n of nodes) {
+    if (n.isDir) out.push(...collectLeaves(n.children));
+    else out.push(n);
+  }
+  return out;
+}
+function flattenForDefaultSelection(tree) {
+  const out = [];
+  function walk(nodes) {
+    for (const n of nodes) {
+      if (n.isDir) walk(n.children);
+      else out.push(n);
+    }
+  }
+  walk(tree);
+  return out;
+}
+function pickEmptyReason(args) {
+  if (!args.captureEnabled) return "capture_disabled";
+  if (args.totalFileChanges === 0) return "no_writes";
+  if (args.redactedStubs > 0 && args.redactedStubs === args.totalFileChanges) {
+    return "all_skipped";
+  }
+  return "unknown";
+}
+function renderEmptyState(reason) {
+  switch (reason) {
+    case "capture_disabled":
+      return `<div class="files-empty">
+        <p class="files-empty-headline">File capture is disabled for this run.</p>
+        <p class="files-empty-sub">
+          Re-enable via <code>capture.files.enabled</code> in
+          <a href="/settings">Settings \u2192</a>
+        </p>
+      </div>`;
+    case "no_writes":
+      return `<div class="files-empty">
+        <p class="files-empty-headline">
+          This run didn't modify any files.
+        </p>
+        <p class="files-empty-sub">All tool calls were read-only.</p>
+      </div>`;
+    case "all_skipped":
+      return `<div class="files-empty">
+        <p class="files-empty-headline">
+          All files in this run exceeded the 50MB capture cap.
+        </p>
+        <p class="files-empty-sub">
+          Adjust <code>capture.files.max_skip_bytes</code> in
+          <a href="/settings">Settings \u2192</a>
+        </p>
+      </div>`;
+    case "unknown":
+    default:
+      return `<div class="files-empty">
+        <p class="files-empty-headline">No files captured for this run.</p>
+      </div>`;
+  }
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var OP_BADGE = {
+  create: { letter: "A", cls: "file-op-create", label: "Created" },
+  modify: { letter: "M", cls: "file-op-modify", label: "Modified" },
+  delete: { letter: "D", cls: "file-op-delete", label: "Deleted" },
+  rename: { letter: "R", cls: "file-op-rename", label: "Renamed" },
+  chmod: { letter: "P", cls: "file-op-chmod", label: "Permissions" }
+};
+function renderRunHeaderStrip(args) {
+  const totals = args.fileChanges.reduce(
+    (acc, fc) => ({
+      added: acc.added + (fc.lines_added ?? 0),
+      removed: acc.removed + (fc.lines_removed ?? 0),
+      partial: acc.partial + (fc.partial_diff ? 1 : 0),
+      redacted: acc.redacted + (fc.redacted ? 1 : 0),
+      uniquePaths: acc.uniquePaths
+    }),
+    { added: 0, removed: 0, partial: 0, redacted: 0, uniquePaths: 0 }
+  );
+  totals.uniquePaths = new Set(args.fileChanges.map((fc) => fc.path)).size;
+  const runShort = args.run.run_id.slice(0, 12);
+  const flagChips = [];
+  if (totals.partial > 0) {
+    flagChips.push(
+      `<span class="file-flag flag-partial">${totals.partial} partial</span>`
+    );
+  }
+  if (totals.redacted > 0) {
+    flagChips.push(
+      `<span class="file-flag flag-redacted">${totals.redacted} redacted</span>`
+    );
+  }
+  return `<div class="files-header-strip" role="region" aria-label="Run files summary">
+    <a class="files-back-link" href="/runs/${esc(args.run.run_id)}">\u2190 Run ${esc(runShort)}</a>
+    <div class="files-summary">
+      <span class="files-stat-add">+${totals.added}</span>
+      <span class="files-stat-rm">\u2212${totals.removed}</span>
+      <span class="files-stat-count">${totals.uniquePaths} file${totals.uniquePaths === 1 ? "" : "s"}</span>
+      <span class="files-stat-count">${args.stepCount} step${args.stepCount === 1 ? "" : "s"} touched</span>
+      ${flagChips.join(" ")}
+    </div>
+  </div>`;
+}
+function renderTreeNode(node, selectedPath, expanded, depth) {
+  if (node.isDir) {
+    const isOpen = expanded.has(node.path);
+    const children = isOpen ? `<div class="file-tree-children">${node.children.map((c) => renderTreeNode(c, selectedPath, expanded, depth + 1)).join("")}</div>` : "";
+    const badge2 = node.worstOp ? `<span class="file-op-badge ${OP_BADGE[node.worstOp].cls}" aria-label="${OP_BADGE[node.worstOp].label}">${OP_BADGE[node.worstOp].letter}</span>` : "";
+    return `<div class="file-tree-dir" data-dir-path="${esc(node.path)}">
+      <button class="file-tree-row file-tree-row-dir"
+              data-action="toggle-dir"
+              data-path="${esc(node.path)}"
+              aria-expanded="${isOpen}"
+              style="padding-left: ${depth * 12 + 8}px">
+        <span class="file-tree-chevron${isOpen ? " is-open" : ""}" aria-hidden="true">\u25B8</span>
+        ${badge2}
+        <span class="file-tree-name">${esc(node.name)}</span>
+      </button>
+      ${children}
+    </div>`;
+  }
+  const isSelected = node.path === selectedPath;
+  const badge = node.worstOp ? `<span class="file-op-badge ${OP_BADGE[node.worstOp].cls}" aria-label="${OP_BADGE[node.worstOp].label}">${OP_BADGE[node.worstOp].letter}</span>` : "";
+  const chipParts = [];
+  if (node.anyPartial) chipParts.push(`<span class="file-flag flag-partial">partial</span>`);
+  if (node.anyRedacted) chipParts.push(`<span class="file-flag flag-redacted">redacted</span>`);
+  if (node.anyBinary) chipParts.push(`<span class="file-flag flag-binary">binary</span>`);
+  return `<a class="file-tree-row file-tree-row-file${isSelected ? " is-selected" : ""}"
+             href="#path=${encodeURIComponent(node.path)}"
+             data-action="select-file"
+             data-path="${esc(node.path)}"
+             title="${esc(node.path)}"
+             aria-current="${isSelected ? "page" : "false"}"
+             style="padding-left: ${depth * 12 + 24}px">
+    ${badge}
+    <span class="file-tree-name">${esc(node.name)}</span>
+    ${chipParts.join(" ")}
+  </a>`;
+}
+function renderRightPane(args) {
+  const tab = args.tab ?? "final";
+  const touches = args.node.changes;
+  const totals = touches.reduce(
+    (acc, fc) => ({
+      added: acc.added + (fc.lines_added ?? 0),
+      removed: acc.removed + (fc.lines_removed ?? 0)
+    }),
+    { added: 0, removed: 0 }
+  );
+  const op = args.node.worstOp;
+  const opLabel = op ? OP_BADGE[op].label : "";
+  const touchCount = touches.length;
+  const finalActive = tab === "final";
+  const historyActive = tab === "history";
+  const rawActive = tab === "raw";
+  let finalBlobRef;
+  let finalIsPartial = false;
+  let finalIsRedacted = false;
+  let finalSizeBefore;
+  let finalSizeAfter;
+  for (let i = touches.length - 1; i >= 0; i--) {
+    const t = touches[i];
+    if (t.after_blob_ref) {
+      finalBlobRef = t.after_blob_ref;
+      finalIsPartial = t.partial_diff;
+      finalIsRedacted = t.redacted;
+      finalSizeBefore = t.size_before;
+      finalSizeAfter = t.size_after;
+      break;
+    }
+  }
+  if (!finalBlobRef) {
+    const last = touches[touches.length - 1];
+    if (last) {
+      finalIsPartial = last.partial_diff;
+      finalIsRedacted = last.redacted;
+      finalSizeBefore = last.size_before;
+      finalSizeAfter = last.size_after;
+    }
+  }
+  const headerHtml = `<div class="file-pane-header">
+    <span class="file-pane-path">${esc(args.node.path)}</span>
+    <span class="file-pane-stats">
+      <span class="files-stat-add">+${totals.added}</span>
+      <span class="files-stat-rm">\u2212${totals.removed}</span>
+    </span>
+    <span class="file-pane-op">${esc(opLabel)} \xB7 ${touchCount} touch${touchCount === 1 ? "" : "es"}</span>
+  </div>`;
+  const tabStrip = `<div class="tab-bar" role="tablist">
+    <button class="tab-btn${finalActive ? " is-active" : ""}"
+            role="tab"
+            aria-selected="${finalActive}"
+            data-action="select-tab"
+            data-tab="final"
+            data-key="1">Final</button>
+    <button class="tab-btn${historyActive ? " is-active" : ""}"
+            role="tab"
+            aria-selected="${historyActive}"
+            data-action="select-tab"
+            data-tab="history"
+            data-key="2">History <span class="tab-count">${touchCount}</span></button>
+    <button class="tab-btn${rawActive ? " is-active" : ""}"
+            role="tab"
+            aria-selected="${rawActive}"
+            data-action="select-tab"
+            data-tab="raw"
+            data-key="3">Raw <span class="tab-count">${touches.length}</span></button>
+  </div>`;
+  let finalBody = "";
+  if (finalActive) {
+    if (finalIsRedacted) {
+      finalBody = `<div class="file-banner banner-redacted" role="status">
+        \u26D4 Content not captured (file exceeded 50MB cap).
+        Original size: ${fmtBytes(finalSizeBefore ?? finalSizeAfter)}.
+        <a href="/settings#capture.files.max_skip_bytes">Why? \u2192</a>
+      </div>`;
+    } else if (!finalBlobRef && op === "delete") {
+      finalBody = `<div class="file-banner banner-deleted" role="status">
+        \u{1F5D1} File deleted in this run. No final content.
+      </div>`;
+    } else if (!finalBlobRef) {
+      finalBody = `<div class="file-banner banner-missing" role="status">
+        \u2139 No final content available for this file.
+      </div>`;
+    } else if (args.node.anyBinary) {
+      finalBody = `<div class="file-binary-placard">
+        <p>Binary file \xB7 ${fmtBytes(finalSizeAfter ?? finalSizeBefore)}</p>
+        <a href="/api/blob/${esc(finalBlobRef)}" class="btn-secondary">Download \u2192</a>
+      </div>`;
+    } else {
+      const partialBanner = finalIsPartial ? `<div class="file-banner banner-partial" role="status">
+          \u26A0 First ${fmtBytes(finalSizeAfter)} of ${fmtBytes(finalSizeBefore ?? finalSizeAfter)} shown
+          \u2014 file exceeded capture policy.
+          <a href="/api/blob/${esc(finalBlobRef)}">Download full blob \u2192</a>
+        </div>` : "";
+      const langQS = args.langHint ? `?lang=${encodeURIComponent(args.langHint)}&path=${encodeURIComponent(args.node.path)}` : `?path=${encodeURIComponent(args.node.path)}`;
+      finalBody = `${partialBanner}
+        <div class="file-final-render"
+             data-blob-ref="${esc(finalBlobRef)}"
+             data-render-url="/api/blob/${esc(finalBlobRef)}/render${langQS}">
+          <iframe class="file-final-frame"
+                  src="/api/blob/${esc(finalBlobRef)}/render${langQS}"
+                  sandbox="allow-same-origin"
+                  loading="lazy"
+                  title="Rendered ${esc(args.node.path)}"></iframe>
+        </div>`;
+    }
+  }
+  let historyBody = "";
+  if (historyActive) {
+    if (touches.length === 0) {
+      historyBody = `<p class="file-pane-empty">No touches recorded.</p>`;
+    } else {
+      historyBody = touches.map((t) => renderTouchSummary(t)).join("\n");
+    }
+  }
+  let rawBody = "";
+  if (rawActive) {
+    rawBody = renderRawTab(touches);
+  }
+  return `<section class="file-pane" data-selected-path="${esc(args.node.path)}">
+    ${headerHtml}
+    ${tabStrip}
+    <div class="file-pane-body" role="tabpanel">
+      ${finalBody}${historyBody}${rawBody}
+    </div>
+  </section>`;
+}
+function renderTouchSummary(t) {
+  const badge = OP_BADGE[t.op];
+  return `<div class="file-history-touch">
+    <span class="file-op-badge ${badge.cls}" aria-label="${badge.label}">${badge.letter}</span>
+    <span class="file-history-meta">
+      seq <code>${t.sequence}</code> \xB7
+      step <code>${esc(t.step_id.slice(0, 12))}</code> \xB7
+      <span class="files-stat-add">+${t.lines_added ?? 0}</span>
+      <span class="files-stat-rm">\u2212${t.lines_removed ?? 0}</span>
+      ${t.partial_diff ? `<span class="file-flag flag-partial">partial</span>` : ""}
+      ${t.redacted ? `<span class="file-flag flag-redacted">redacted</span>` : ""}
+    </span>
+    ${t.patch_text ? `<pre class="file-history-diff">${esc(t.patch_text)}</pre>` : ""}
+  </div>`;
+}
+function renderRawTab(touches) {
+  if (touches.length === 0) {
+    return `<p class="file-pane-empty">No blob refs recorded.</p>`;
+  }
+  const rows = touches.map((t) => {
+    const badge = OP_BADGE[t.op];
+    const beforeCell = t.before_blob_ref ? `<a href="/api/blob/${esc(t.before_blob_ref)}" class="raw-blob-link" title="${esc(t.before_blob_ref)}">${esc(shortHash(t.before_blob_ref))}</a>` : `<span class="raw-blob-none">\u2014</span>`;
+    const afterCell = t.after_blob_ref ? `<a href="/api/blob/${esc(t.after_blob_ref)}" class="raw-blob-link" title="${esc(t.after_blob_ref)}">${esc(shortHash(t.after_blob_ref))}</a>` : `<span class="raw-blob-none">\u2014</span>`;
+    return `<tr>
+        <td>${t.sequence}</td>
+        <td><span class="file-op-badge ${badge.cls}">${badge.letter}</span></td>
+        <td>${beforeCell}</td>
+        <td>${afterCell}</td>
+        <td>${fmtBytes(t.size_before)}</td>
+        <td>${fmtBytes(t.size_after)}</td>
+        <td>${esc(t.patch_format ?? "")}</td>
+      </tr>`;
+  }).join("\n");
+  return `<table class="raw-tab-table">
+    <thead>
+      <tr>
+        <th>seq</th>
+        <th>op</th>
+        <th>before</th>
+        <th>after</th>
+        <th>size before</th>
+        <th>size after</th>
+        <th>format</th>
+      </tr>
+    </thead>
+    <tbody>${rows}</tbody>
+  </table>`;
+}
+function shortHash(hash) {
+  if (hash.length <= 12) return hash;
+  return hash.slice(0, 8) + "\u2026" + hash.slice(-4);
+}
+function fmtBytes(n) {
+  if (n === void 0 || n === null) return "\u2014";
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`;
+  return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+function renderFilesPage(args) {
+  const headerStrip = renderRunHeaderStrip({
+    run: args.run,
+    fileChanges: args.fileChanges,
+    stepCount: args.steps.length
+  });
+  if (args.fileChanges.length === 0 || !args.captureEnabled) {
+    const stubsRedacted = args.fileChanges.filter((fc) => fc.redacted).length;
+    const reason = pickEmptyReason({
+      captureEnabled: args.captureEnabled,
+      totalFileChanges: args.fileChanges.length,
+      redactedStubs: stubsRedacted
+    });
+    return {
+      bodyHtml: `${headerStrip}${renderEmptyState(reason)}`,
+      stylesHtml: FILES_PAGE_STYLES,
+      scriptsHtml: ""
+    };
+  }
+  const tree = buildFileTree(args.fileChanges);
+  const flat = flattenForDefaultSelection(tree);
+  const selected = args.selectedPath && flat.find((n) => n.path === args.selectedPath) ? flat.find((n) => n.path === args.selectedPath) : flat[0];
+  const expanded = new Set(args.expandedPaths ?? []);
+  if (selected) {
+    const segs = selected.path.split("/").filter(Boolean);
+    let acc = "";
+    for (let i = 0; i < segs.length - 1; i++) {
+      acc = acc ? `${acc}/${segs[i]}` : segs[i];
+      expanded.add(acc);
+    }
+  }
+  const treeHtml = `<nav class="file-tree" role="tree" aria-label="Files changed in run">
+    ${tree.map((n) => renderTreeNode(n, selected?.path ?? "", expanded, 0)).join("\n")}
+  </nav>`;
+  const paneHtml = selected ? renderRightPane({
+    runId: args.run.run_id,
+    node: selected,
+    tab: args.tab
+  }) : `<section class="file-pane"><p>Select a file on the left.</p></section>`;
+  const mobileDropdown = `<select class="file-tree-mobile-select"
+      aria-label="Pick a file"
+      data-action="mobile-select-file">
+    ${flat.map(
+    (n) => `<option value="${esc(n.path)}"${n.path === selected?.path ? " selected" : ""}>${esc(n.path)}</option>`
+  ).join("")}
+  </select>`;
+  return {
+    bodyHtml: `${headerStrip}
+      ${mobileDropdown}
+      <div class="files-two-pane">
+        <aside class="files-tree-pane">${treeHtml}</aside>
+        <main class="files-content-pane">${paneHtml}</main>
+      </div>`,
+    stylesHtml: FILES_PAGE_STYLES,
+    scriptsHtml: FILES_PAGE_SCRIPTS
+  };
+}
+var FILES_PAGE_STYLES = `<style>
+  .files-header-strip {
+    display: flex; align-items: center; gap: 16px;
+    padding: 14px 20px;
+    border-bottom: 1px solid var(--border);
+    background: var(--surface-1);
+  }
+  .files-back-link {
+    font-size: 12.5px; color: var(--text-secondary);
+    text-decoration: none;
+  }
+  .files-back-link:hover { color: var(--cerulean-400); }
+  .files-empty {
+    padding: 80px 20px; text-align: center;
+    color: var(--text-secondary);
+  }
+  .files-empty-headline {
+    font-size: 15px; color: var(--text-primary); margin: 0 0 8px;
+  }
+  .files-empty-sub {
+    font-size: 13px; color: var(--text-tertiary); margin: 0;
+  }
+  .files-empty code {
+    font-family: var(--font-mono); font-size: 12px;
+    background: var(--surface-2); padding: 1px 6px; border-radius: 3px;
+  }
+  .files-two-pane {
+    display: grid;
+    grid-template-columns: 280px 1fr;
+    gap: 0;
+    min-height: calc(100vh - 120px);
+  }
+  .files-tree-pane {
+    border-right: 1px solid var(--border);
+    background: var(--surface-1);
+    overflow-y: auto;
+    max-height: calc(100vh - 120px);
+  }
+  .files-content-pane {
+    background: var(--surface-0);
+    overflow: hidden;
+  }
+  .file-tree {
+    padding: 4px 0;
+    font-size: 13px;
+  }
+  .file-tree-row {
+    display: flex; align-items: center; gap: 8px;
+    width: 100%; min-height: 28px;
+    padding: 4px 12px 4px 8px;
+    border: none; background: none; color: var(--text-primary);
+    text-align: left; cursor: pointer;
+    font-family: inherit; font-size: 13px;
+    text-decoration: none;
+    border-left: 2px solid transparent;
+  }
+  .file-tree-row:hover { background: var(--surface-2); }
+  .file-tree-row:focus-visible {
+    outline: var(--focus-ring); outline-offset: -2px;
+  }
+  .file-tree-row.is-selected {
+    background: rgba(56,189,248,0.08);
+    border-left-color: var(--cerulean-400);
+  }
+  .file-tree-chevron {
+    display: inline-block;
+    color: var(--text-tertiary);
+    transition: transform 120ms ease;
+    width: 12px; text-align: center;
+  }
+  .file-tree-chevron.is-open { transform: rotate(90deg); }
+  .file-tree-name {
+    flex: 1; min-width: 0;
+    overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  }
+  .file-op-badge {
+    display: inline-flex; align-items: center; justify-content: center;
+    width: 20px; height: 20px;
+    font-family: var(--font-mono); font-size: 11px; font-weight: 600;
+    border-radius: 3px;
+    flex-shrink: 0;
+  }
+  .file-tree-mobile-select { display: none; }
+
+  .file-pane {
+    padding: 20px 24px;
+    height: 100%;
+    overflow-y: auto;
+  }
+  .file-pane-header {
+    display: flex; align-items: baseline; gap: 12px;
+    padding-bottom: 12px;
+    border-bottom: 1px solid var(--border);
+    margin-bottom: 12px;
+  }
+  .file-pane-path {
+    font-family: var(--font-mono); font-size: 12.5px;
+    color: var(--text-primary);
+    flex: 1; overflow-wrap: anywhere;
+  }
+  .file-pane-stats { display: inline-flex; gap: 6px; font-size: 12px; }
+  .file-pane-op {
+    font-size: 11.5px; color: var(--text-tertiary);
+    text-transform: uppercase; letter-spacing: 0.04em;
+  }
+  .file-banner {
+    padding: 10px 14px; margin-bottom: 12px;
+    border-radius: 4px; font-size: 12.5px;
+    border-left: 3px solid;
+  }
+  .banner-partial {
+    background: var(--amber-bg); border-left-color: var(--amber-400);
+    color: var(--text-primary);
+  }
+  .banner-redacted {
+    background: rgba(248,113,113,0.08); border-left-color: var(--coral-400);
+    color: var(--text-primary);
+  }
+  .banner-deleted, .banner-missing {
+    background: var(--surface-2); border-left-color: var(--text-tertiary);
+    color: var(--text-secondary);
+  }
+  .file-banner a { color: var(--cerulean-400); }
+  .file-final-render { background: var(--surface-0); border-radius: 4px; }
+  .file-final-frame {
+    width: 100%; min-height: 60vh; border: none;
+    background: var(--surface-0);
+  }
+  .file-binary-placard {
+    padding: 32px 20px; text-align: center;
+    background: var(--surface-2); border-radius: 4px;
+    color: var(--text-secondary);
+  }
+  .btn-secondary {
+    display: inline-block; margin-top: 8px;
+    padding: 6px 14px; border-radius: 4px;
+    background: var(--surface-3); color: var(--text-primary);
+    text-decoration: none; font-size: 12.5px;
+  }
+  .file-history-touch {
+    padding: 10px 0; border-bottom: 1px solid var(--border);
+  }
+  .file-history-touch:last-child { border-bottom: none; }
+  .file-history-meta {
+    font-size: 12px; color: var(--text-tertiary);
+    margin-left: 8px;
+  }
+  .file-history-diff {
+    margin-top: 8px;
+    font-family: var(--font-mono); font-size: 12px;
+    background: var(--surface-1); padding: 10px 12px;
+    border-radius: 4px; overflow-x: auto;
+  }
+  .raw-tab-table {
+    width: 100%; border-collapse: collapse;
+    font-size: 12.5px;
+  }
+  .raw-tab-table th {
+    text-align: left; padding: 8px 12px;
+    border-bottom: 1px solid var(--border);
+    color: var(--text-tertiary);
+    font-weight: 500; text-transform: uppercase;
+    font-size: 10.5px; letter-spacing: 0.04em;
+  }
+  .raw-tab-table td {
+    padding: 8px 12px;
+    border-bottom: 1px solid var(--border);
+    font-family: var(--font-mono);
+    color: var(--text-primary);
+  }
+  .raw-blob-link {
+    color: var(--cerulean-400); text-decoration: none;
+    font-family: var(--font-mono);
+  }
+  .raw-blob-none { color: var(--text-tertiary); }
+  .file-pane-empty {
+    color: var(--text-tertiary); padding: 24px 0;
+  }
+
+  /* D12 \u2014 responsive breakpoints. */
+  @media (max-width: 1100px) {
+    .files-two-pane {
+      grid-template-columns: 1fr;
+    }
+    .files-tree-pane {
+      max-height: 40vh;
+      border-right: none;
+      border-bottom: 1px solid var(--border);
+    }
+  }
+  @media (max-width: 600px) {
+    .files-tree-pane { display: none; }
+    .file-tree-mobile-select {
+      display: block; width: calc(100% - 40px);
+      margin: 12px 20px;
+      padding: 8px 12px;
+      background: var(--surface-2); color: var(--text-primary);
+      border: 1px solid var(--border); border-radius: 4px;
+      font-family: var(--font-mono); font-size: 12.5px;
+    }
+  }
+</style>`;
+var FILES_NAV_CLIENT_JS = String.raw`
+(function() {
+  function parseFragment() {
+    var hash = window.location.hash.replace(/^#/, '');
+    var out = { path: '', open: [] };
+    hash.split('&').forEach(function(part) {
+      var eq = part.indexOf('=');
+      if (eq < 0) return;
+      var k = decodeURIComponent(part.slice(0, eq));
+      var v = decodeURIComponent(part.slice(eq + 1));
+      if (k === 'path') out.path = v;
+      else if (k === 'open') out.open = v ? v.split(',') : [];
+    });
+    return out;
+  }
+  function writeFragment(state) {
+    var parts = [];
+    if (state.path) parts.push('path=' + encodeURIComponent(state.path));
+    if (state.open.length)
+      parts.push('open=' + state.open.map(encodeURIComponent).join(','));
+    window.history.replaceState(null, '', '#' + parts.join('&'));
+  }
+  function getState() {
+    var frag = parseFragment();
+    var selected = document.querySelector('.file-tree-row.is-selected');
+    var openDirs = [];
+    document.querySelectorAll('.file-tree-row-dir[aria-expanded="true"]').forEach(
+      function(el) { openDirs.push(el.dataset.path); }
+    );
+    return {
+      path: selected ? selected.dataset.path : frag.path,
+      open: openDirs.length ? openDirs : frag.open,
+    };
+  }
+  function syncFragmentFromDom() { writeFragment(getState()); }
+
+  function focusableRows() {
+    return Array.prototype.slice.call(
+      document.querySelectorAll('.file-tree-row-file:not([hidden])')
+    );
+  }
+  function currentIndex(rows) {
+    var sel = document.querySelector('.file-tree-row-file.is-selected');
+    if (!sel) return -1;
+    return rows.indexOf(sel);
+  }
+  function selectByIndex(rows, idx) {
+    if (idx < 0 || idx >= rows.length) return;
+    rows.forEach(function(r) {
+      r.classList.remove('is-selected');
+      r.setAttribute('aria-current', 'false');
+    });
+    rows[idx].classList.add('is-selected');
+    rows[idx].setAttribute('aria-current', 'page');
+    rows[idx].focus();
+    // Fragment fetch + swap right pane.
+    var path = rows[idx].dataset.path;
+    loadFragment(path);
+    syncFragmentFromDom();
+  }
+  function loadFragment(path) {
+    var runMatch = window.location.pathname.match(/\\/runs\\/([^/]+)\\/files/);
+    if (!runMatch) return;
+    var runId = runMatch[1];
+    fetch('/runs/' + encodeURIComponent(runId) + '/files/' +
+          encodeURIComponent(path) + window.location.search)
+      .then(function(r) { return r.ok ? r.text() : ''; })
+      .then(function(html) {
+        if (!html) return;
+        var pane = document.querySelector('.files-content-pane');
+        if (pane) pane.innerHTML = html;
+      })
+      .catch(function() {});
+  }
+
+  // Initial state restoration from URL fragment.
+  var initialFrag = parseFragment();
+  if (initialFrag.path) {
+    var initial = document.querySelector(
+      '.file-tree-row-file[data-path="' + cssEsc(initialFrag.path) + '"]'
+    );
+    if (initial) {
+      document.querySelectorAll('.file-tree-row.is-selected').forEach(
+        function(el) { el.classList.remove('is-selected'); }
+      );
+      initial.classList.add('is-selected');
+      initial.setAttribute('aria-current', 'page');
+    }
+  }
+  initialFrag.open.forEach(function(p) {
+    var dir = document.querySelector(
+      '.file-tree-row-dir[data-path="' + cssEsc(p) + '"]'
+    );
+    if (dir) dir.setAttribute('aria-expanded', 'true');
+  });
+
+  function cssEsc(s) {
+    return s.replace(/[\\\\"]/g, function(c) { return '\\\\' + c; });
+  }
+
+  // Click handler — D9 (whole row toggles dir; file row swaps pane).
+  document.addEventListener('click', function(e) {
+    var btn = e.target.closest('[data-action]');
+    if (!btn) return;
+    var action = btn.dataset.action;
+    if (action === 'toggle-dir') {
+      var open = btn.getAttribute('aria-expanded') === 'true';
+      btn.setAttribute('aria-expanded', open ? 'false' : 'true');
+      var chev = btn.querySelector('.file-tree-chevron');
+      if (chev) chev.classList.toggle('is-open');
+      // toggle children visibility.
+      var children = btn.nextElementSibling;
+      if (children) children.style.display = open ? 'none' : '';
+      syncFragmentFromDom();
+      e.preventDefault();
+    } else if (action === 'select-file') {
+      e.preventDefault();
+      var rows = focusableRows();
+      var idx = rows.indexOf(btn);
+      selectByIndex(rows, idx);
+    } else if (action === 'select-tab') {
+      e.preventDefault();
+      selectTab(btn.dataset.tab);
+    } else if (action === 'mobile-select-file') {
+      // Handled by 'change' below.
+    }
+  });
+
+  // Mobile <select> dropdown (D12).
+  document.addEventListener('change', function(e) {
+    var el = e.target;
+    if (el.dataset && el.dataset.action === 'mobile-select-file') {
+      loadFragment(el.value);
+      writeFragment({ path: el.value, open: parseFragment().open });
+    }
+  });
+
+  function selectTab(tab) {
+    document.querySelectorAll('.tab-btn').forEach(function(b) {
+      var isActive = b.dataset.tab === tab;
+      b.classList.toggle('is-active', isActive);
+      b.setAttribute('aria-selected', isActive ? 'true' : 'false');
+    });
+    var sel = document.querySelector('.file-tree-row-file.is-selected');
+    if (!sel) return;
+    var path = sel.dataset.path;
+    var runMatch = window.location.pathname.match(/\\/runs\\/([^/]+)\\/files/);
+    if (!runMatch) return;
+    var runId = runMatch[1];
+    fetch('/runs/' + encodeURIComponent(runId) + '/files/' +
+          encodeURIComponent(path) + '?tab=' + encodeURIComponent(tab))
+      .then(function(r) { return r.ok ? r.text() : ''; })
+      .then(function(html) {
+        if (!html) return;
+        var pane = document.querySelector('.files-content-pane');
+        if (pane) pane.innerHTML = html;
+      })
+      .catch(function() {});
+  }
+
+  // Keyboard nav — D13.
+  document.addEventListener('keydown', function(e) {
+    if (e.target.matches('input, textarea, select')) return;
+    var rows = focusableRows();
+    var idx = currentIndex(rows);
+    if (e.key === 'j' || e.key === 'ArrowDown') {
+      e.preventDefault();
+      selectByIndex(rows, Math.min(rows.length - 1, idx + 1));
+    } else if (e.key === 'k' || e.key === 'ArrowUp') {
+      e.preventDefault();
+      selectByIndex(rows, Math.max(0, idx - 1));
+    } else if (e.key === '1') {
+      selectTab('final');
+    } else if (e.key === '2') {
+      selectTab('history');
+    } else if (e.key === '3') {
+      selectTab('raw');
+    }
+  });
+})();
+`;
+var FILES_PAGE_SCRIPTS = `<script>
+${FILES_NAV_CLIENT_JS}
+</script>`;
+
+// src/live.ts
+import { EventEmitter } from "events";
+import { existsSync } from "fs";
+import {
+  claudeProjectsRoot,
+  probeFilePath,
+  readState as readProbeState
+} from "@meterbility/shared";
+import {
+  ingestSession,
+  discoverSessions,
+  readSession,
+  probeRecords,
+  formatWarning
+} from "@meterbility/claude-code-adapter";
+import {
+  getRun as getRun3,
+  listFileChanges,
+  listRuns,
+  listSteps as listSteps4
+} from "@meterbility/collector";
+
+// src/live-heuristics.ts
+function contextUtilization(step) {
+  if (!step) return 0;
+  const window = inferWindowSize(step.model);
+  const total = step.tokens.input + step.tokens.cached_read + step.tokens.cache_creation;
+  if (window === 0) return 0;
+  return Math.min(100, Math.round(total / window * 100));
+}
+function inferWindowSize(model) {
+  if (/\[1m\]|-1m\b|1m-context/i.test(model)) return 1e6;
+  if (/opus|sonnet|haiku/i.test(model)) return 2e5;
+  return 128e3;
+}
+function classifyRunStatus(run, steps, stallSeconds) {
+  if (run.status === "ok") return "completed";
+  if (run.status === "error") return "errored";
+  if (steps.length === 0) return "progressing";
+  const last = steps[steps.length - 1];
+  const ageS = (Date.now() - new Date(last.timestamp).getTime()) / 1e3;
+  if (last.outcome.status === "pending") {
+    return ageS > stallSeconds ? "stalled" : "awaiting_input";
+  }
+  if (ageS > stallSeconds) return "stalled";
+  if (detectLoop(steps, 4)) return "looping";
+  return "progressing";
+}
+function detectLoop(steps, window = 4) {
+  if (steps.length < window) return void 0;
+  const tail = steps.slice(-window);
+  const first = tail[0];
+  if (first.action.kind !== "tool_call" || !first.action.tool_name) {
+    return void 0;
+  }
+  const sig = JSON.stringify(first.action.tool_input ?? null);
+  for (let i = 1; i < tail.length; i++) {
+    const s = tail[i];
+    if (s.action.kind !== "tool_call" || s.action.tool_name !== first.action.tool_name || JSON.stringify(s.action.tool_input ?? null) !== sig) {
+      return void 0;
+    }
+  }
+  return {
+    tool: first.action.tool_name,
+    signature: sig.slice(0, 64),
+    repeats: window
+  };
+}
+
+// src/live.ts
+var DEFAULT_OPTS = {
+  projectsRoot: claudeProjectsRoot(),
+  scanIntervalMs: 1500,
+  stallSeconds: 120,
+  contextThresholds: [50, 70, 90],
+  watchTools: [],
+  loopWindow: 4
+};
+function buildFleetEntries(store, opts = {}) {
+  const limit = opts.limit ?? 50;
+  const stallSeconds = opts.stallSeconds ?? 120;
+  const firedAlerts = opts.firedAlerts;
+  const runs = listRuns(store, { limit });
+  return runs.map((run) => {
+    const steps = listSteps4(store, run.run_id);
+    const lastStep = steps[steps.length - 1];
+    const status = classifyRunStatus(run, steps, stallSeconds);
+    const ctxPct = contextUtilization(lastStep);
+    const recentTools = steps.slice(-5).map((s) => s.action.tool_name).filter((x) => !!x);
+    const alerts = firedAlerts ? Array.from(
+      firedAlerts.get(run.run_id)?.values() ?? []
+    ).map((a) => ({ kind: a.kind, message: a.message })) : [];
+    return {
+      run,
+      status,
+      context_pct: ctxPct,
+      recent_tools: recentTools,
+      last_step_at: lastStep?.timestamp,
+      alerts
+    };
+  });
+}
+var LiveInspector = class extends EventEmitter {
+  store;
+  opts;
+  knownPaths = /* @__PURE__ */ new Set();
+  // run_id → (dedup key → display info). The key prevents re-fires; the
+  // value is what fleet entries render, so it must be human-readable.
+  firedAlerts = /* @__PURE__ */ new Map();
+  lastSizes = /* @__PURE__ */ new Map();
+  // path → size at last poll
+  lastStepCounts = /* @__PURE__ */ new Map();
+  // run_id → step count
+  lastStatus = /* @__PURE__ */ new Map();
+  // run_id → last seen status
+  probeTracks = /* @__PURE__ */ new Map();
+  // run_id → probe poll state
+  timer;
+  stopped = false;
+  /** Set on the first scan so we can backfill state silently — historical
+   *  sessions on disk are not "new runs" the user just kicked off. */
+  booted = false;
+  constructor(store, opts = {}) {
+    super();
+    this.store = store;
+    this.opts = { ...DEFAULT_OPTS, ...opts };
+  }
+  async start() {
+    for (const run of listRuns(this.store, { limit: 1e5 })) {
+      this.lastStepCounts.set(run.run_id, run.step_count);
+      this.lastStatus.set(run.run_id, run.status);
+    }
+    await this.tick({ silent: true });
+    this.booted = true;
+    void this.runShapeProbe().catch((err) => {
+      console.warn("[meter/shape-probe] probe failed (non-fatal):", err);
+    });
+    this.timer = setInterval(() => {
+      void this.tick().catch((err) => {
+        console.error("[meter/live] tick error:", err);
+      });
+    }, this.opts.scanIntervalMs);
+  }
+  /**
+   * Sample the newest few sessions and validate their records against
+   * the shapes `types.ts` claims. One warning per unique drift hash
+   * (so a single schema change doesn't spam thousands of lines).
+   * Disabled when `METERBILITY_DISABLE_SHAPE_PROBE` is set — useful for
+   * tests with intentionally minimal fixtures.
+   */
+  async runShapeProbe() {
+    if (process.env.METERBILITY_DISABLE_SHAPE_PROBE) return;
+    const sessions = await discoverSessions();
+    const sample = sessions.sort((a, b) => b.mtime.getTime() - a.mtime.getTime()).slice(0, 5);
+    if (sample.length === 0) return;
+    const allRecords = [];
+    for (const s of sample) {
+      try {
+        const parsed = await readSession(s.path);
+        for (const p of parsed) allRecords.push(p.record);
+      } catch {
+      }
+    }
+    const warnings = probeRecords(allRecords);
+    for (const w of warnings) {
+      console.warn(formatWarning(w));
+    }
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+  }
+  /**
+   * One scan: discover sessions, re-ingest any whose file has grown,
+   * compute the current fleet snapshot, fire alerts where appropriate.
+   *
+   * `silent: true` runs the same ingest pipeline but suppresses event
+   * emission — used for the first-tick backfill at startup so historical
+   * runs don't masquerade as freshly-created ones.
+   */
+  async tick(opts = {}) {
+    if (this.stopped) return;
+    const silent = opts.silent === true;
+    const sessions = await discoverSessions();
+    const toProcess = /* @__PURE__ */ new Set();
+    for (const s of sessions) {
+      if (!this.knownPaths.has(s.path)) {
+        this.knownPaths.add(s.path);
+        toProcess.add(s.path);
+      }
+      const lastSize = this.lastSizes.get(s.path) ?? 0;
+      if (s.size_bytes > lastSize) {
+        toProcess.add(s.path);
+        this.lastSizes.set(s.path, s.size_bytes);
+      }
+    }
+    for (const path of toProcess) {
+      try {
+        const result = await ingestSession(this.store, path);
+        if (result.status === "empty") continue;
+        const run = getRun3(this.store, result.run_id);
+        if (!run) continue;
+        const newSteps = collectNewSteps(this.store, run, this.lastStepCounts);
+        const wasKnown = this.lastStepCounts.has(run.run_id);
+        const prevStatus = this.lastStatus.get(run.run_id);
+        this.lastStepCounts.set(run.run_id, run.step_count);
+        this.lastStatus.set(run.run_id, run.status);
+        if (!silent) {
+          if (!wasKnown) {
+            this.emit("data", { type: "run:created", run });
+          } else if (newSteps.length > 0) {
+            this.emit("data", {
+              type: "run:updated",
+              run,
+              new_steps: newSteps
+            });
+          }
+          for (const s of newSteps) {
+            this.emitFilesChangedIfAny(run, s);
+          }
+        }
+        await this.maybeAlert(run, newSteps, silent);
+        const isTerminal = run.status === "ok" || run.status === "error";
+        const wasTerminal = prevStatus === "ok" || prevStatus === "error";
+        if (!silent && isTerminal && !wasTerminal) {
+          this.emit("data", {
+            type: "run:completed",
+            run
+          });
+        }
+      } catch (err) {
+        console.error(`[meter/live] ingest failed for ${path}:`, err);
+      }
+    }
+    if (!silent) this.pollProbeStates();
+    this.emit("data", {
+      type: "fleet:snapshot",
+      entries: this.fleetEntries()
+    });
+  }
+  /**
+   * Emit `files:changed` if the given step has any file_change rows.
+   * Pulled into its own method so tests can exercise the dedup-paths
+   * shape without going through a full tick.
+   */
+  emitFilesChangedIfAny(run, step) {
+    const fcs = listFileChanges(this.store, { stepId: step.step_id });
+    if (fcs.length === 0) return;
+    const paths = /* @__PURE__ */ new Set();
+    let partial = false;
+    for (const fc of fcs) {
+      paths.add(fc.path);
+      if (fc.old_path) paths.add(fc.old_path);
+      if (fc.partial_diff) partial = true;
+    }
+    this.emit("data", {
+      type: "files:changed",
+      run_id: run.run_id,
+      step_id: step.step_id,
+      paths: Array.from(paths),
+      partial
+    });
+  }
+  /**
+   * Poll probe state for every run with an active probe file. Two-axis
+   * detection: the FSM `state` drives inject-window accounting; the
+   * `paused_at_ms` / `resumed_at_ms` timestamps drive `run:paused` /
+   * `run:resumed` emission. The timestamp axis matters because a full
+   * pause→ack→resume cycle can complete inside one 1500ms tick — a
+   * pure `state → state` comparison would silently swallow those
+   * events (the bug Codex flagged at this site).
+   *
+   * Runs without a probe file are skipped entirely: probe files only
+   * exist while a run is under operator control (created lazily by
+   * `requestPause` / `setInject`, removed by `clearProbe` on terminal
+   * cleanup), so the file's presence is the cleanest natural gate.
+   * Per-run reads are guarded — a single EACCES or corrupt file on
+   * one probe shouldn't degrade `/api/live` for every other run.
+   */
+  pollProbeStates() {
+    for (const runId of this.lastStepCounts.keys()) {
+      if (!existsSync(probeFilePath(runId))) {
+        this.probeTracks.delete(runId);
+        continue;
+      }
+      let record;
+      try {
+        record = readProbeState(runId);
+      } catch (err) {
+        console.error(`[meter/live] probe read failed for ${runId}:`, err);
+        continue;
+      }
+      let tracked = this.probeTracks.get(runId);
+      if (!tracked) {
+        tracked = {
+          state: record.state,
+          edits: 0,
+          lastInject: null,
+          lastPausedAtMs: null,
+          lastResumedAtMs: null,
+          inPauseWindow: false
+        };
+        this.probeTracks.set(runId, tracked);
+      }
+      const nowInWindow = record.state === "pause_requested" || record.state === "paused";
+      if (nowInWindow && !tracked.inPauseWindow) {
+        tracked.edits = record.inject !== null && record.inject !== "" ? 1 : 0;
+      } else if (nowInWindow && record.inject !== null && record.inject !== "" && record.inject !== tracked.lastInject) {
+        tracked.edits += 1;
+      }
+      tracked.lastInject = record.inject;
+      tracked.inPauseWindow = nowInWindow;
+      const newPause = record.paused_at_ms !== null && record.paused_at_ms !== tracked.lastPausedAtMs;
+      if (newPause) {
+        const steps = listSteps4(this.store, runId);
+        const lastStep = steps[steps.length - 1];
+        this.emit("data", {
+          type: "run:paused",
+          run_id: runId,
+          step_id: lastStep?.step_id ?? null,
+          paused_at: new Date(record.paused_at_ms).toISOString()
+        });
+        tracked.lastPausedAtMs = record.paused_at_ms;
+      }
+      const newResume = record.resumed_at_ms !== null && record.resumed_at_ms !== tracked.lastResumedAtMs;
+      if (newResume) {
+        this.emit("data", {
+          type: "run:resumed",
+          run_id: runId,
+          edits: tracked.edits,
+          resumed_at: new Date(record.resumed_at_ms).toISOString()
+        });
+        tracked.edits = 0;
+        tracked.lastResumedAtMs = record.resumed_at_ms;
+      }
+      tracked.state = record.state;
+    }
+  }
+  /** Compute the current fleet view (active + recently-completed runs). */
+  fleetEntries() {
+    return buildFleetEntries(this.store, {
+      stallSeconds: this.opts.stallSeconds,
+      firedAlerts: this.firedAlerts,
+      limit: 50
+    });
+  }
+  async maybeAlert(run, newSteps, silent = false) {
+    const fired = this.firedAlerts.get(run.run_id) ?? /* @__PURE__ */ new Map();
+    const fireOrSeed = (key, event) => {
+      if (fired.has(key)) return;
+      fired.set(key, { kind: event.kind, message: event.message });
+      if (!silent) this.emit("data", event);
+    };
+    for (const s of newSteps) {
+      if (s.action.kind === "tool_call" && s.action.tool_name && this.opts.watchTools.includes(s.action.tool_name)) {
+        fireOrSeed(`tool:${s.action.tool_name}:${s.step_id}`, {
+          type: "alert",
+          run_id: run.run_id,
+          kind: "tool_called",
+          message: `watched tool ${s.action.tool_name} called at step #${s.sequence}${describeToolInput(s.action.tool_input)}`,
+          meta: { step_id: s.step_id, sequence: s.sequence }
+        });
+      }
+    }
+    for (const s of newSteps) {
+      const pct = contextUtilization(s);
+      for (const t of this.opts.contextThresholds) {
+        if (pct >= t) {
+          fireOrSeed(`ctx:${t}`, {
+            type: "alert",
+            run_id: run.run_id,
+            kind: "context_threshold",
+            message: `context window ${pct}% full \u2014 crossed the ${t}% threshold at step #${s.sequence}`,
+            meta: { sequence: s.sequence, percent: pct }
+          });
+        }
+      }
+    }
+    const allSteps = listSteps4(this.store, run.run_id);
+    const loop = detectLoop(allSteps, this.opts.loopWindow);
+    if (loop) {
+      fireOrSeed(`loop:${loop.tool}:${loop.signature}`, {
+        type: "alert",
+        run_id: run.run_id,
+        kind: "loop",
+        message: `possible loop: last ${loop.repeats} steps all called ${loop.tool} with identical input (${loop.signature.slice(0, 48)}\u2026)`,
+        meta: { window: this.opts.loopWindow }
+      });
+    }
+    if (run.status === "in_progress" && allSteps.length > 0) {
+      const lastTs = new Date(allSteps[allSteps.length - 1].timestamp).getTime();
+      const ageS = (Date.now() - lastTs) / 1e3;
+      const HOUR = 3600;
+      if (ageS > this.opts.stallSeconds && ageS < HOUR) {
+        for (const k of fired.keys()) {
+          if (k.startsWith("stall:")) fired.delete(k);
+        }
+        const lastStep = allSteps[allSteps.length - 1];
+        const doing = lastStep.action.kind === "tool_call" && lastStep.action.tool_name ? `after calling ${lastStep.action.tool_name}` : `after a ${lastStep.action.kind} step`;
+        fireOrSeed(`stall:${Math.floor(ageS / 60)}`, {
+          type: "alert",
+          run_id: run.run_id,
+          kind: "stall",
+          message: `stalled at step #${lastStep.sequence} ${doing} \u2014 no activity for ${formatDuration(ageS)}`
+        });
+      }
+    }
+    if (fired.size > 0) this.firedAlerts.set(run.run_id, fired);
+  }
+};
+function collectNewSteps(store, run, lastCounts) {
+  const last = lastCounts.get(run.run_id) ?? 0;
+  const all = listSteps4(store, run.run_id);
+  return all.slice(last);
+}
+function formatDuration(seconds) {
+  const s = Math.round(seconds);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  return rem > 0 ? `${m}m ${rem}s` : `${m}m`;
+}
+function describeToolInput(input) {
+  if (!input || typeof input !== "object") return "";
+  const obj = input;
+  for (const field of ["command", "file_path", "path", "url", "pattern", "query"]) {
+    const v = obj[field];
+    if (typeof v === "string" && v.length > 0) {
+      const preview = v.length > 60 ? `${v.slice(0, 60)}\u2026` : v;
+      return ` \u2014 ${field}: "${preview}"`;
+    }
+  }
+  return "";
+}
+var LiveController = class {
+  store;
+  inspector;
+  subscribers = /* @__PURE__ */ new Set();
+  storeOpts = {};
+  constructor(store) {
+    this.store = store;
+  }
+  /** Spin up an inspector if one isn't already running. Idempotent. */
+  async start(opts) {
+    if (this.inspector) return;
+    if (opts) this.storeOpts = opts;
+    const inspector = new LiveInspector(this.store, this.storeOpts);
+    for (const fn of this.subscribers) inspector.on("data", fn);
+    this.inspector = inspector;
+    await inspector.start();
+  }
+  /** Stop the running inspector if any. Idempotent. */
+  stop() {
+    if (!this.inspector) return;
+    for (const fn of this.subscribers) this.inspector.off("data", fn);
+    this.inspector.stop();
+    this.inspector = void 0;
+  }
+  isLive() {
+    return this.inspector !== void 0;
+  }
+  on(event, fn) {
+    this.subscribers.add(fn);
+    this.inspector?.on(event, fn);
+  }
+  off(event, fn) {
+    this.subscribers.delete(fn);
+    this.inspector?.off(event, fn);
+  }
+  /** Latest fleet snapshot — empty when not running. */
+  fleetEntries() {
+    if (!this.inspector) return [];
+    return this.inspector.fleetEntries();
+  }
+};
+
+// src/continuation.ts
+import { hashJson as hashJson2 } from "@meterbility/shared";
+import { costCents as costCents2 } from "@meterbility/spec";
+import {
+  getRun as getRun4,
+  insertStep as insertStep2,
+  listSteps as listSteps5,
+  recordContextSnapshot as recordContextSnapshot2,
+  resolveSnapshotBlobRef as resolveSnapshotBlobRef2,
+  setRunStatus as setRunStatus2,
+  updateRunTotals as updateRunTotals2
+} from "@meterbility/collector";
+import { randomUUID as randomUUID2 } from "crypto";
+async function continueFork(store, forkRunId, opts) {
+  const fork = getRun4(store, forkRunId);
+  if (!fork) throw new Error(`fork run not found: ${forkRunId}`);
+  const max = opts.maxIterations ?? 25;
+  if (opts.mode === "live" && !opts.toolExecutor) {
+    throw new Error("live mode requires a toolExecutor");
+  }
+  if (opts.mode === "simulate" && !opts.originRunId) {
+    throw new Error("simulate mode requires an originRunId");
+  }
+  const simIndex = opts.mode === "simulate" ? buildToolIndex(store, opts.originRunId) : /* @__PURE__ */ new Map();
+  let stepsAdded = 0;
+  let lastStepId = "";
+  for (let iteration = 0; iteration < max; iteration++) {
+    const steps = listSteps5(store, fork.run_id);
+    const prior = steps[steps.length - 1];
+    if (!prior) {
+      throw new Error(`fork run has no steps: ${forkRunId}`);
+    }
+    lastStepId = prior.step_id;
+    const { history, systemPrompt } = await assembleHistory(store, prior);
+    let modelResult;
+    try {
+      modelResult = await opts.modelCaller({
+        history,
+        prior_step: prior,
+        system_prompt: systemPrompt,
+        iteration
+      });
+    } catch (err) {
+      const errorStep = await persistErrorStep(store, fork.run_id, prior, {
+        kind: "model_error",
+        message: err.message
+      });
+      stepsAdded += 1;
+      lastStepId = errorStep.step_id;
+      return {
+        iterations_run: iteration + 1,
+        steps_added: stepsAdded,
+        terminal_reason: "model_error",
+        final_step_id: lastStepId
+      };
+    }
+    const modelStep = await persistModelStep(store, fork.run_id, prior, modelResult);
+    stepsAdded += 1;
+    lastStepId = modelStep.step_id;
+    if (modelResult.action.kind !== "tool_call" || !modelResult.action.tool_name) {
+      setRunStatus2(store, fork.run_id, "ok", (/* @__PURE__ */ new Date()).toISOString());
+      updateRunTotals2(store, fork.run_id);
+      return {
+        iterations_run: iteration + 1,
+        steps_added: stepsAdded,
+        terminal_reason: "model_completed",
+        final_step_id: lastStepId
+      };
+    }
+    const toolCall = {
+      tool_name: modelResult.action.tool_name,
+      tool_use_id: modelResult.action.tool_use_id,
+      tool_input: modelResult.action.tool_input
+    };
+    let toolResult;
+    if (opts.mode === "simulate") {
+      const sigKey = toolSignature(toolCall);
+      const hit = simIndex.get(sigKey);
+      if (!hit) {
+        await tagStep(store, modelStep.step_id, "simulate_miss");
+        setRunStatus2(store, fork.run_id, "in_progress");
+        updateRunTotals2(store, fork.run_id);
+        return {
+          iterations_run: iteration + 1,
+          steps_added: stepsAdded,
+          terminal_reason: "simulate_miss",
+          final_step_id: lastStepId
+        };
+      }
+      toolResult = {
+        output: hit.result,
+        is_error: hit.is_error,
+        summary: hit.summary
+      };
+    } else if (opts.mode === "live" && opts.toolExecutor) {
+      try {
+        toolResult = await opts.toolExecutor(toolCall);
+      } catch (err) {
+        toolResult = {
+          output: { error: err.message },
+          is_error: true,
+          summary: `tool threw: ${err.message}`.slice(0, 200)
+        };
+      }
+    }
+    if (!toolResult) {
+      throw new Error("internal: missing tool result");
+    }
+    const ref = await store.blobs.putJson(toolResult.output);
+    const updatedOutcome = {
+      status: toolResult.is_error ? "error" : "ok",
+      tool_result_ref: ref,
+      is_error: toolResult.is_error ?? false,
+      summary: toolResult.summary
+    };
+    store.db.prepare("UPDATE steps SET outcome_json = ?, status = ? WHERE step_id = ?").run(
+      JSON.stringify(updatedOutcome),
+      toolResult.is_error ? "error" : "ok",
+      modelStep.step_id
+    );
+    if (toolResult.is_error && opts.mode === "live") {
+      setRunStatus2(store, fork.run_id, "error");
+      updateRunTotals2(store, fork.run_id);
+      return {
+        iterations_run: iteration + 1,
+        steps_added: stepsAdded,
+        terminal_reason: "tool_error",
+        final_step_id: lastStepId
+      };
+    }
+  }
+  setRunStatus2(store, fork.run_id, "in_progress");
+  updateRunTotals2(store, fork.run_id);
+  return {
+    iterations_run: max,
+    steps_added: stepsAdded,
+    terminal_reason: "max_iterations",
+    final_step_id: lastStepId
+  };
+}
+async function assembleHistory(store, priorStep) {
+  const ref = resolveSnapshotBlobRef2(store, priorStep.context_snapshot_id);
+  const snap = await store.blobs.tryGetString(ref);
+  if (!snap) return { history: [] };
+  let parsed;
+  try {
+    parsed = JSON.parse(snap);
+  } catch {
+    return { history: [] };
+  }
+  const history = [];
+  let systemPrompt;
+  for (const c of parsed.components) {
+    if (c.type === "system_prompt") {
+      systemPrompt = await store.blobs.tryGetString(c.content_ref);
+    } else if (c.type === "conversation_history") {
+      for (const m of c.messages) history.push(m);
+    }
+  }
+  const priorAction = priorStep.action;
+  let assistantText = "";
+  if (priorAction.kind === "message" && priorAction.text) {
+    assistantText = priorAction.text;
+  } else if (priorAction.kind === "tool_call") {
+    assistantText = `[tool_call: ${priorAction.tool_name ?? "?"}]`;
+  }
+  if (assistantText) {
+    const aref = await store.blobs.putString(assistantText);
+    history.push({ role: "assistant", content_ref: aref });
+  }
+  if (priorAction.kind === "tool_call" && priorStep.outcome.tool_result_ref) {
+    history.push({
+      role: "tool",
+      content_ref: priorStep.outcome.tool_result_ref
+    });
+  }
+  return { history, systemPrompt };
+}
+async function persistModelStep(store, runId, prior, result) {
+  const { history, systemPrompt } = await assembleHistory(store, prior);
+  const components = [];
+  if (systemPrompt) {
+    components.push({
+      type: "system_prompt",
+      content_ref: await store.blobs.putString(systemPrompt)
+    });
+  }
+  if (history.length > 0) {
+    components.push({ type: "conversation_history", messages: history });
+  }
+  const snapshot = { id: hashJson2(components), components };
+  const blobRef = await store.blobs.putJson(snapshot);
+  recordContextSnapshot2(store, snapshot.id, blobRef, snapshot.components.length);
+  const decisionRef = await store.blobs.putJson(result.decision_content);
+  const { cost_cents, approx } = costCents2(result.model, {
+    input: result.tokens.input,
+    output: result.tokens.output,
+    cached_read: result.tokens.cached_read,
+    cache_creation: result.tokens.cache_creation,
+    cache_creation_1h: result.tokens.cache_creation_1h
+  });
+  const tags = ["continuation"];
+  if (approx) tags.push("cost:approx");
+  const step = {
+    step_id: `stp_${randomUUID2()}`,
+    run_id: runId,
+    parent_step_id: prior.step_id,
+    sequence: prior.sequence + 1,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    model: result.model,
+    context_snapshot_id: snapshot.id,
+    decision_ref: decisionRef,
+    action: result.action,
+    outcome: { status: "pending" },
+    tokens: result.tokens,
+    latency_ms: result.latency_ms,
+    cost_cents,
+    tags,
+    status: "in_progress"
+  };
+  insertStep2(store, step);
+  return step;
+}
+async function persistErrorStep(store, runId, prior, err) {
+  const components = [];
+  const snapshot = { id: hashJson2(components), components };
+  const blobRef = await store.blobs.putJson(snapshot);
+  recordContextSnapshot2(store, snapshot.id, blobRef, 0);
+  const decisionRef = await store.blobs.putJson({ error: err });
+  const step = {
+    step_id: `stp_${randomUUID2()}`,
+    run_id: runId,
+    parent_step_id: prior.step_id,
+    sequence: prior.sequence + 1,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    model: "continuation",
+    context_snapshot_id: snapshot.id,
+    decision_ref: decisionRef,
+    action: { kind: "none" },
+    outcome: {
+      status: "error",
+      is_error: true,
+      summary: err.message.slice(0, 200)
+    },
+    tokens: { input: 0, output: 0, cached_read: 0, cache_creation: 0 },
+    latency_ms: 0,
+    cost_cents: 0,
+    tags: ["continuation", "error", err.kind],
+    status: "error"
+  };
+  insertStep2(store, step);
+  return step;
+}
+async function tagStep(store, stepId, tag) {
+  const row = store.db.prepare("SELECT tags FROM steps WHERE step_id = ?").get(stepId);
+  if (!row) return;
+  const tags = JSON.parse(row.tags);
+  if (!tags.includes(tag)) tags.push(tag);
+  store.db.prepare("UPDATE steps SET tags = ? WHERE step_id = ?").run(JSON.stringify(tags), stepId);
+}
+function buildToolIndex(store, originRunId) {
+  const out = /* @__PURE__ */ new Map();
+  const steps = listSteps5(store, originRunId);
+  for (const s of steps) {
+    if (s.action.kind !== "tool_call" || !s.action.tool_name) continue;
+    if (!s.outcome.tool_result_ref) continue;
+    const sig = toolSignature({
+      tool_name: s.action.tool_name,
+      tool_input: s.action.tool_input
+    });
+    out.set(sig, {
+      result: { __ref: s.outcome.tool_result_ref },
+      is_error: s.outcome.is_error ?? false,
+      summary: s.outcome.summary
+    });
+  }
+  return out;
+}
+function toolSignature(call) {
+  return `${call.tool_name}::${hashJson2(call.tool_input ?? null)}`;
+}
+async function resolveSimulatedResult(store, result) {
+  if (result && typeof result === "object" && "__ref" in result && typeof result.__ref === "string") {
+    const ref = result.__ref;
+    const text = await store.blobs.tryGetString(ref);
+    if (!text) return result;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return result;
+}
+
+// src/slack.ts
+var SlackNotifier = class {
+  opts;
+  bucket = [];
+  // post timestamps
+  detach;
+  constructor(opts) {
+    if (!opts.webhookUrl || !/^https:\/\/hooks\.slack\.com\//.test(opts.webhookUrl)) {
+      throw new Error("invalid Slack webhook URL");
+    }
+    this.opts = {
+      webhookUrl: opts.webhookUrl,
+      serverUrl: opts.serverUrl ?? "",
+      events: opts.events ?? ["alert"],
+      rateLimitPerMinute: opts.rateLimitPerMinute ?? 30,
+      channel: opts.channel
+    };
+  }
+  attach(live) {
+    if (this.detach) this.detach();
+    const handler = (e) => void this.handleEvent(e);
+    live.on("data", handler);
+    this.detach = () => live.off("data", handler);
+  }
+  detachFrom() {
+    if (this.detach) this.detach();
+    this.detach = void 0;
+  }
+  async handleEvent(e) {
+    if (!this.opts.events.includes(e.type)) return;
+    const payload = this.formatPayload(e);
+    if (!payload) return;
+    if (!this.acquireRateLimitToken()) return;
+    try {
+      const res = await fetch(this.opts.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!res.ok) {
+        console.warn(
+          `[meter/slack] webhook returned ${res.status}: ${await res.text()}`
+        );
+      }
+    } catch (err) {
+      console.warn(`[meter/slack] post failed:`, err.message);
+    }
+  }
+  /**
+   * Send a one-off test message — used by `meter slack test`.
+   */
+  async sendTest() {
+    const payload = {
+      blocks: [
+        {
+          type: "header",
+          text: { type: "plain_text", text: "Meterbility is connected" }
+        },
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: "If you can read this, your webhook is wired correctly. Alerts will arrive here when an agent run loops, stalls, or crosses a context threshold."
+          }
+        }
+      ]
+    };
+    if (!this.acquireRateLimitToken()) {
+      throw new Error("rate-limited");
+    }
+    const res = await fetch(this.opts.webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) throw new Error(`webhook ${res.status}: ${await res.text()}`);
+  }
+  acquireRateLimitToken() {
+    const now = Date.now();
+    this.bucket = this.bucket.filter((t) => now - t < 6e4);
+    if (this.bucket.length >= this.opts.rateLimitPerMinute) return false;
+    this.bucket.push(now);
+    return true;
+  }
+  formatPayload(e) {
+    const link = (runId) => this.opts.serverUrl ? `${this.opts.serverUrl.replace(/\/$/, "")}/runs/${runId}` : `run ${runId.slice(0, 12)}`;
+    if (e.type === "alert") {
+      const color = alertColor(e.kind);
+      return {
+        ...this.opts.channel ? { channel: this.opts.channel } : {},
+        attachments: [
+          {
+            color,
+            blocks: [
+              {
+                type: "section",
+                text: {
+                  type: "mrkdwn",
+                  text: `*${labelForAlert(e.kind)}* on run \`${e.run_id.slice(0, 12)}\`
+${escapeSlack(e.message)}`
+                }
+              },
+              {
+                type: "actions",
+                elements: [
+                  {
+                    type: "button",
+                    text: { type: "plain_text", text: "Open in Meterbility" },
+                    url: link(e.run_id)
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      };
+    }
+    if (e.type === "run:created") {
+      return {
+        ...this.opts.channel ? { channel: this.opts.channel } : {},
+        blocks: [
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: `\u25B6\uFE0E New run: *${escapeSlack(e.run.title ?? e.run.run_id)}* (${escapeSlack(e.run.source_runtime)})
+<${link(e.run.run_id)}|open in Meterbility>`
+            }
+          }
+        ]
+      };
+    }
+    if (e.type === "run:completed") {
+      const icon = e.run.status === "ok" ? "\u2705" : e.run.status === "error" ? "\u274C" : "\u23F9";
+      return {
+        ...this.opts.channel ? { channel: this.opts.channel } : {},
+        blocks: [
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: `${icon} *${escapeSlack(e.run.title ?? e.run.run_id)}* finished \xB7 ${e.run.step_count} steps \xB7 ${formatCost(e.run.cost_cents)}
+<${link(e.run.run_id)}|open in Meterbility>`
+            }
+          }
+        ]
+      };
+    }
+    return void 0;
+  }
+};
+function alertColor(kind) {
+  switch (kind) {
+    case "loop":
+      return "#f85149";
+    case "tool_called":
+      return "#58a6ff";
+    case "context_threshold":
+      return "#d29922";
+    case "stall":
+      return "#8b949e";
+    default:
+      return "#bc8cff";
+  }
+}
+function labelForAlert(kind) {
+  switch (kind) {
+    case "loop":
+      return "Loop detected";
+    case "tool_called":
+      return "Watched tool called";
+    case "context_threshold":
+      return "Context utilization";
+    case "stall":
+      return "Run stalled";
+    default:
+      return kind;
+  }
+}
+function formatCost(cents) {
+  const dollars = cents / 100;
+  if (dollars === 0) return "$0.00";
+  if (Math.abs(dollars) >= 5e-3) return `$${dollars.toFixed(2)}`;
+  return `$${dollars.toFixed(4)}`;
+}
+function escapeSlack(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/regression.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { getRun as getRun5, listSteps as listSteps6 } from "@meterbility/collector";
+function listTests(store) {
+  const rows = store.db.prepare(
+    "SELECT test_id, name, description, assertions_json, canonical_run_id, created_at FROM regression_tests ORDER BY name"
+  ).all();
+  return rows.map((r) => ({
+    test_id: r.test_id,
+    name: r.name,
+    description: r.description ?? void 0,
+    assertions: JSON.parse(r.assertions_json),
+    canonical_run_id: r.canonical_run_id ?? void 0,
+    created_at: r.created_at
+  }));
+}
+function getTestByName(store, name) {
+  const r = store.db.prepare(
+    "SELECT test_id, name, description, assertions_json, canonical_run_id, created_at FROM regression_tests WHERE name = ?"
+  ).get(name);
+  if (!r) return void 0;
+  return {
+    test_id: r.test_id,
+    name: r.name,
+    description: r.description ?? void 0,
+    assertions: JSON.parse(r.assertions_json),
+    canonical_run_id: r.canonical_run_id ?? void 0,
+    created_at: r.created_at
+  };
+}
+function createTest(store, args) {
+  const test = {
+    test_id: `tst_${randomUUID3()}`,
+    name: args.name,
+    description: args.description,
+    assertions: args.assertions,
+    canonical_run_id: args.canonical_run_id,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  store.db.prepare(
+    `INSERT INTO regression_tests(test_id, name, description, assertions_json, canonical_run_id, created_at)
+       VALUES (?,?,?,?,?,?)`
+  ).run(
+    test.test_id,
+    test.name,
+    test.description ?? null,
+    JSON.stringify(test.assertions),
+    test.canonical_run_id ?? null,
+    test.created_at
+  );
+  return test;
+}
+function deleteTest(store, name) {
+  const res = store.db.prepare("DELETE FROM regression_tests WHERE name = ?").run(name);
+  return res.changes > 0;
+}
+function addAssertion(store, testName, assertion) {
+  const t = getTestByName(store, testName);
+  if (!t) throw new Error(`test not found: ${testName}`);
+  t.assertions.push(assertion);
+  store.db.prepare(
+    "UPDATE regression_tests SET assertions_json = ? WHERE test_id = ?"
+  ).run(JSON.stringify(t.assertions), t.test_id);
+  return t;
+}
+function deriveAssertionsFromRun(run, steps) {
+  const toolCounts = /* @__PURE__ */ new Map();
+  for (const s of steps) {
+    if (s.action.kind === "tool_call" && s.action.tool_name) {
+      toolCounts.set(
+        s.action.tool_name,
+        (toolCounts.get(s.action.tool_name) ?? 0) + 1
+      );
+    }
+  }
+  const out = [
+    { kind: "final_status", value: run.status, label: "final status" },
+    { kind: "no_error_step", value: 0, label: "no errored step" },
+    {
+      kind: "min_steps",
+      value: Math.max(1, Math.floor(steps.length * 0.5)),
+      label: "min steps (50% of canonical)"
+    },
+    {
+      kind: "max_steps",
+      value: Math.ceil(steps.length * 1.5),
+      label: "max steps (150% of canonical)"
+    },
+    {
+      kind: "max_cost_cents",
+      value: Math.ceil(run.cost_cents * 1.5),
+      label: "max cost (150% of canonical)"
+    }
+  ];
+  for (const [tool] of toolCounts) {
+    out.push({
+      kind: "includes_tool_call",
+      value: tool,
+      label: `must call ${tool}`
+    });
+  }
+  return out;
+}
+function runTest(store, test, runId) {
+  const run = getRun5(store, runId);
+  if (!run) throw new Error(`run not found: ${runId}`);
+  const steps = listSteps6(store, run.run_id);
+  const results = test.assertions.map(
+    (a) => evaluateAssertion(a, run, steps)
+  );
+  const passed = results.every((r) => r.passed);
+  const result = {
+    result_id: `res_${randomUUID3()}`,
+    test_id: test.test_id,
+    test_name: test.name,
+    run_id: run.run_id,
+    passed,
+    assertions: results,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  store.db.prepare(
+    `INSERT INTO regression_results(result_id, test_id, run_id, passed, details_json, created_at)
+       VALUES (?,?,?,?,?,?)`
+  ).run(
+    result.result_id,
+    result.test_id,
+    result.run_id,
+    passed ? 1 : 0,
+    JSON.stringify(results),
+    result.created_at
+  );
+  return result;
+}
+function evaluateAssertion(assertion, run, steps) {
+  switch (assertion.kind) {
+    case "includes_tool_call": {
+      const want = String(assertion.value);
+      const found = steps.some(
+        (s) => s.action.kind === "tool_call" && s.action.tool_name === want
+      );
+      return {
+        assertion,
+        passed: found,
+        reason: found ? `${want} was called` : `${want} was never called`
+      };
+    }
+    case "excludes_tool_call": {
+      const want = String(assertion.value);
+      const found = steps.some(
+        (s) => s.action.kind === "tool_call" && s.action.tool_name === want
+      );
+      return {
+        assertion,
+        passed: !found,
+        reason: !found ? `${want} was correctly absent` : `${want} was called (banned)`
+      };
+    }
+    case "tool_call_count": {
+      const want = Number(assertion.value);
+      const count = steps.filter((s) => s.action.kind === "tool_call").length;
+      return {
+        assertion,
+        passed: count === want,
+        reason: `expected ${want} tool calls, got ${count}`
+      };
+    }
+    case "output_contains": {
+      const want = String(assertion.value);
+      const last = steps.findLast?.((s) => s.action.kind === "message") ?? [...steps].reverse().find((s) => s.action.kind === "message");
+      const text = last?.action.text ?? "";
+      const found = text.includes(want);
+      return {
+        assertion,
+        passed: found,
+        reason: found ? `final message contained "${want.slice(0, 40)}"` : `final message did not contain "${want.slice(0, 40)}"`
+      };
+    }
+    case "output_does_not_contain": {
+      const want = String(assertion.value);
+      const last = steps.findLast?.((s) => s.action.kind === "message") ?? [...steps].reverse().find((s) => s.action.kind === "message");
+      const text = last?.action.text ?? "";
+      const found = text.includes(want);
+      return {
+        assertion,
+        passed: !found,
+        reason: !found ? `forbidden phrase absent` : `final message contained forbidden phrase`
+      };
+    }
+    case "min_steps": {
+      const want = Number(assertion.value);
+      return {
+        assertion,
+        passed: steps.length >= want,
+        reason: `expected \u2265${want} steps, got ${steps.length}`
+      };
+    }
+    case "max_steps": {
+      const want = Number(assertion.value);
+      return {
+        assertion,
+        passed: steps.length <= want,
+        reason: `expected \u2264${want} steps, got ${steps.length}`
+      };
+    }
+    case "final_status": {
+      const want = String(assertion.value);
+      return {
+        assertion,
+        passed: run.status === want,
+        reason: `expected status=${want}, got ${run.status}`
+      };
+    }
+    case "max_cost_cents": {
+      const want = Number(assertion.value);
+      return {
+        assertion,
+        passed: run.cost_cents <= want,
+        reason: `expected \u2264$${(want / 100).toFixed(2)}, got $${(run.cost_cents / 100).toFixed(2)}`
+      };
+    }
+    case "no_error_step": {
+      const errored = steps.find((s) => s.status === "error");
+      return {
+        assertion,
+        passed: !errored,
+        reason: errored ? `step #${errored.sequence} errored` : "no errored steps"
+      };
+    }
+    case "step_status_at": {
+      if (assertion.at === void 0) {
+        return {
+          assertion,
+          passed: false,
+          reason: "step_status_at requires `at`"
+        };
+      }
+      const step = steps.find((s) => s.sequence === assertion.at);
+      if (!step) {
+        return {
+          assertion,
+          passed: false,
+          reason: `no step at sequence ${assertion.at}`
+        };
+      }
+      const want = String(assertion.value);
+      return {
+        assertion,
+        passed: step.status === want,
+        reason: `step #${assertion.at}: expected status=${want}, got ${step.status}`
+      };
+    }
+  }
+}
+function listResults(store, testId, limit = 50) {
+  const rows = testId ? store.db.prepare(
+    "SELECT * FROM regression_results WHERE test_id = ? ORDER BY created_at DESC LIMIT ?"
+  ).all(testId, limit) : store.db.prepare(
+    "SELECT * FROM regression_results ORDER BY created_at DESC LIMIT ?"
+  ).all(limit);
+  const tests = listTests(store);
+  const nameMap = new Map(tests.map((t) => [t.test_id, t.name]));
+  return rows.map((r) => ({
+    result_id: r.result_id,
+    test_id: r.test_id,
+    test_name: nameMap.get(r.test_id) ?? "(deleted)",
+    run_id: r.run_id,
+    passed: r.passed === 1,
+    assertions: JSON.parse(r.details_json),
+    created_at: r.created_at
+  }));
+}
+
+// src/web.ts
+function buildApp(store, opts = {}) {
+  const app = new Hono();
+  const controller = opts.controller ?? new LiveController(store);
+  app.use("/api/*", async (c, next) => {
+    const expected = getSetting(store, "web.bind_token");
+    if (!expected) return next();
+    const header = c.req.header("authorization") ?? "";
+    const match = /^Bearer\s+(.+)$/i.exec(header);
+    if (!match || match[1] !== expected) {
+      return c.json(
+        { error: "unauthorized: invalid or missing Bearer token" },
+        401
+      );
+    }
+    return next();
+  });
+  if (opts.live && !opts.controller) {
+    opts.live.on("data", (e) => {
+      for (const fn of controller.subscribers) {
+        fn(e);
+      }
+    });
+  }
+  const shellOpts = () => ({
+    liveMode: controller.isLive() || opts.live !== void 0
+  });
+  app.get("/", (c) => {
+    const isLive = controller.isLive() || opts.live !== void 0;
+    const entries = controller.isLive() ? controller.fleetEntries() : opts.live ? opts.live.fleetEntries() : buildFleetEntries(store, { limit: 50 });
+    return c.html(
+      renderShell(
+        "Meterbility \xB7 Fleet",
+        renderFleet(entries, { liveMode: isLive }),
+        shellOpts()
+      )
+    );
+  });
+  app.get("/runs", (c) => {
+    const status = c.req.query("status");
+    const tool = c.req.query("tool");
+    const project = c.req.query("project")?.toLowerCase();
+    let runs = listRuns3(store, {
+      limit: 500,
+      status: status === "ok" || status === "error" || status === "in_progress" || status === "abandoned" ? status : void 0,
+      containsTool: tool || void 0
+    });
+    if (project) {
+      runs = runs.filter(
+        (r) => (r.cwd ?? "").toLowerCase().includes(project)
+      );
+    }
+    return c.html(
+      renderShell(
+        "Runs",
+        renderRunList(runs, {
+          totalAvailable: listRuns3(store, { limit: 1e3 }).length,
+          filters: { status, tool, project }
+        }),
+        shellOpts()
+      )
+    );
+  });
+  app.get("/api/live", (c) => {
+    c.header("Content-Type", "text/event-stream");
+    c.header("Cache-Control", "no-cache");
+    c.header("Connection", "keep-alive");
+    return stream(c, async (s) => {
+      const send = (e) => {
+        void s.write(`event: ${e.type}
+data: ${JSON.stringify(e)}
+
+`);
+      };
+      controller.on("data", send);
+      send({ type: "fleet:snapshot", entries: controller.fleetEntries() });
+      await new Promise((resolve) => {
+        s.onAbort(() => {
+          controller.off("data", send);
+          resolve();
+        });
+      });
+    });
+  });
+  app.get(
+    "/api/live/status",
+    (c) => c.json({ live: controller.isLive() })
+  );
+  app.post("/api/live/start", async (c) => {
+    let liveOpts;
+    try {
+      const body = await c.req.json();
+      if (body) liveOpts = body;
+    } catch {
+    }
+    await controller.start(liveOpts);
+    return c.json({ live: controller.isLive() });
+  });
+  app.post("/api/live/stop", (c) => {
+    controller.stop();
+    return c.json({ live: controller.isLive() });
+  });
+  app.get("/runs/:id", async (c) => {
+    const runId = c.req.param("id");
+    const run = getRun6(store, runId);
+    if (!run) return c.notFound();
+    const steps = listSteps7(store, run.run_id);
+    const annotations = listAnnotations(store, "run", run.run_id);
+    const forks = listForks(store, run.run_id);
+    const stepDecisions = await loadDecisionPreviews(store, steps);
+    const allFcs = listFileChanges2(store, { runId: run.run_id });
+    const fcByStep = /* @__PURE__ */ new Map();
+    for (const fc of allFcs) {
+      const list = fcByStep.get(fc.step_id) ?? [];
+      list.push(fc);
+      fcByStep.set(fc.step_id, list);
+    }
+    const probePanel = run.status === "in_progress" ? renderProbePanel(run.run_id, readProbeState2(run.run_id)) : "";
+    const shell = renderShell(
+      run.title ?? run.run_id,
+      renderRun(run, steps, annotations, forks, stepDecisions, fcByStep, probePanel),
+      shellOpts()
+    );
+    if (process.env.METERBILITY_DEBUG && shell.length > 2e6) {
+      console.warn(
+        `meter: run ${run.run_id.slice(0, 12)} page is ${(shell.length / 1024 / 1024).toFixed(1)}MB \u2014 consider lazy pretty fetch`
+      );
+    }
+    return c.html(shell);
+  });
+  app.get("/runs/:id/files", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.notFound();
+    const fcs = listFileChanges2(store, { runId: run.run_id });
+    const steps = listSteps7(store, run.run_id);
+    const captureEnabled = getSetting(store, "capture.files.enabled") !== "false";
+    const rendered = renderFilesPage({
+      run,
+      fileChanges: fcs,
+      steps,
+      captureEnabled
+    });
+    const shell = renderShell(
+      `${run.title ?? run.run_id} \xB7 files`,
+      `${rendered.stylesHtml}${rendered.bodyHtml}${rendered.scriptsHtml}`,
+      shellOpts()
+    );
+    return c.html(shell);
+  });
+  app.get("/runs/:id/files/:path{.+}", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.notFound();
+    const path = decodeURIComponent(c.req.param("path"));
+    const tabParam = c.req.query("tab");
+    const tab = tabParam === "history" || tabParam === "raw" ? tabParam : "final";
+    const fcs = listFileChanges2(store, { runId: run.run_id });
+    if (fcs.length === 0) return c.notFound();
+    const tree = buildFileTree(fcs);
+    const flat = flattenForDefaultSelection(tree);
+    const node = flat.find((n) => n.path === path);
+    if (!node) return c.notFound();
+    c.header("Content-Type", "text/html; charset=utf-8");
+    return c.body(renderRightPane({ runId: run.run_id, node, tab }));
+  });
+  app.get("/api/runs/:id/files", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.notFound();
+    return c.json(listFileChanges2(store, { runId: run.run_id }));
+  });
+  app.get("/api/runs/:id/files/diff", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.notFound();
+    const path = c.req.query("path");
+    if (!path) return c.json({ error: "missing required ?path=" }, 400);
+    return c.json(listFileChanges2(store, { runId: run.run_id, path }));
+  });
+  app.get("/api/steps/:id/file_changes", (c) => {
+    const step = getStep3(store, c.req.param("id"));
+    if (!step) return c.notFound();
+    return c.json(listFileChanges2(store, { stepId: step.step_id }));
+  });
+  app.get("/api/file_change/:id", (c) => {
+    const fc = getFileChange(store, c.req.param("id"));
+    return fc ? c.json(fc) : c.notFound();
+  });
+  app.get("/api/runs/:id/probe", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.json({ error: "run not found" }, 404);
+    return c.json(readProbeState2(run.run_id));
+  });
+  app.get("/api/runs/:id/probe/panel", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.json({ error: "run not found" }, 404);
+    if (run.status !== "in_progress") return c.json({ error: "run sealed" }, 404);
+    c.header("Content-Type", "text/html; charset=utf-8");
+    return c.body(renderProbePanel(run.run_id, readProbeState2(run.run_id)));
+  });
+  app.post("/api/runs/:id/probe/pause", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.json({ error: "run not found" }, 404);
+    const state = probeRequestPause(run.run_id);
+    recordProbeIntervention(store, run.run_id, "probe_pause", {
+      paused_at: new Date(state.requested_at_ms ?? Date.now()).toISOString()
+    });
+    return c.json(state);
+  });
+  app.post("/api/runs/:id/probe/resume", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.json({ error: "run not found" }, 404);
+    const pre = readProbeState2(run.run_id);
+    const state = probeRequestResume(run.run_id);
+    if (pre.inject !== null) {
+      recordProbeIntervention(store, run.run_id, "probe_edit", {
+        inject_bytes: pre.inject.length,
+        resumed_at: new Date(state.resumed_at_ms ?? Date.now()).toISOString()
+      });
+    }
+    return c.json(state);
+  });
+  app.post("/api/runs/:id/probe/inject", async (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.json({ error: "run not found" }, 404);
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "invalid JSON body" }, 400);
+    }
+    if (body.clear) {
+      consumeProbeInject(run.run_id);
+      return c.json(readProbeState2(run.run_id));
+    }
+    if (typeof body.message !== "string" || body.message.length === 0) {
+      return c.json({ error: "message is required (use { clear: true } to discard)" }, 400);
+    }
+    const current = readProbeState2(run.run_id);
+    if (current.inject !== null && !body.force) {
+      return c.json(
+        {
+          error: "a pending inject is already queued (pass { force: true } to overwrite)",
+          current_inject: current.inject
+        },
+        409
+      );
+    }
+    return c.json(probeSetInject(run.run_id, body.message));
+  });
+  app.post("/api/runs/:id/probe/clear", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    const target = run?.run_id ?? c.req.param("id");
+    clearProbe(target);
+    return c.json({ cleared: target });
+  });
+  const redirectToCanonical = (newPath) => (c) => {
+    c.header("Deprecation", "true");
+    c.header("Link", `<${newPath}>; rel="successor-version"`);
+    return c.redirect(newPath, 308);
+  };
+  app.get(
+    "/api/probe/:run_id",
+    (c) => redirectToCanonical(`/api/runs/${encodeURIComponent(c.req.param("run_id"))}/probe`)(c)
+  );
+  app.get(
+    "/api/probe/:run_id/panel",
+    (c) => redirectToCanonical(
+      `/api/runs/${encodeURIComponent(c.req.param("run_id"))}/probe/panel`
+    )(c)
+  );
+  app.post(
+    "/api/probe/:run_id/pause",
+    (c) => redirectToCanonical(
+      `/api/runs/${encodeURIComponent(c.req.param("run_id"))}/probe/pause`
+    )(c)
+  );
+  app.post(
+    "/api/probe/:run_id/resume",
+    (c) => redirectToCanonical(
+      `/api/runs/${encodeURIComponent(c.req.param("run_id"))}/probe/resume`
+    )(c)
+  );
+  app.post(
+    "/api/probe/:run_id/inject",
+    (c) => redirectToCanonical(
+      `/api/runs/${encodeURIComponent(c.req.param("run_id"))}/probe/inject`
+    )(c)
+  );
+  app.post(
+    "/api/probe/:run_id/clear",
+    (c) => redirectToCanonical(
+      `/api/runs/${encodeURIComponent(c.req.param("run_id"))}/probe/clear`
+    )(c)
+  );
+  app.get("/api/runs/:id/step-card/:seq", async (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.notFound();
+    const seq = Number(c.req.param("seq"));
+    if (!Number.isFinite(seq)) return c.json({ error: "bad seq" }, 400);
+    const step = getStepBySequence2(store, run.run_id, seq);
+    if (!step) return c.notFound();
+    const decisions = await loadDecisionPreviews(store, [step]);
+    const fcs = listFileChanges2(store, { stepId: step.step_id });
+    const fragment = renderStepCardFragment(step, decisions.get(step.step_id) ?? "", fcs);
+    c.header("Content-Type", "text/html; charset=utf-8");
+    return c.body(fragment);
+  });
+  app.get("/diff", (c) => {
+    const a = c.req.query("a");
+    const b = c.req.query("b");
+    const showShared = c.req.query("shared") === "1";
+    if (!a || !b) return c.text("usage: /diff?a=<run-id>&b=<run-id>", 400);
+    const runA = getRun6(store, a);
+    const runB = getRun6(store, b);
+    if (!runA || !runB) return c.notFound();
+    const result = diffRuns(store, runA.run_id, runB.run_id);
+    return c.html(
+      renderShell(
+        "Diff",
+        renderDiff(runA, runB, result, { showShared }),
+        shellOpts()
+      )
+    );
+  });
+  app.get("/api/runs", (c) => c.json(listRuns3(store, { limit: 200 })));
+  app.get("/api/runs/:id", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    return run ? c.json(run) : c.notFound();
+  });
+  app.get("/api/runs/:id/steps", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.notFound();
+    return c.json(listSteps7(store, run.run_id));
+  });
+  app.get("/api/steps/:id", (c) => {
+    const step = getStep3(store, c.req.param("id"));
+    return step ? c.json(step) : c.notFound();
+  });
+  app.get("/api/blob/:hash", async (c) => {
+    const raw = c.req.param("hash");
+    const ref = resolveSnapshotBlobRef3(store, raw);
+    const text = await store.blobs.tryGetString(ref);
+    if (!text) return c.notFound();
+    c.header("Content-Type", "text/plain; charset=utf-8");
+    return c.body(text);
+  });
+  app.get("/api/blob/:hash/render", async (c) => {
+    const raw = c.req.param("hash");
+    const langOverride = c.req.query("lang");
+    const pathHint = c.req.query("path");
+    const ref = resolveSnapshotBlobRef3(store, raw);
+    const buf = await store.blobs.tryGetBuffer(ref);
+    if (!buf) return c.notFound();
+    const sniff = sniffMimeAndLang(buf, pathHint);
+    if (sniff.mime.startsWith("image/")) {
+      return new Response(
+        new Uint8Array(
+          buf.buffer,
+          buf.byteOffset,
+          buf.byteLength
+        ),
+        {
+          status: 200,
+          headers: {
+            "Content-Type": sniff.mime,
+            "Cache-Control": "public, max-age=31536000, immutable"
+          }
+        }
+      );
+    }
+    if (sniff.binary) {
+      return new Response(
+        new Uint8Array(
+          buf.buffer,
+          buf.byteOffset,
+          buf.byteLength
+        ),
+        {
+          status: 200,
+          headers: {
+            "Content-Type": "application/octet-stream",
+            "Cache-Control": "public, max-age=31536000, immutable"
+          }
+        }
+      );
+    }
+    const effLang = langOverride && langOverride !== "auto" ? langOverride : sniff.lang ?? "plaintext";
+    const cacheKey = renderCacheKey(ref, effLang);
+    const cached = await store.blobs.tryGetString(cacheKey);
+    if (cached !== void 0) {
+      c.header("Content-Type", "text/html; charset=utf-8");
+      c.header("Cache-Control", "public, max-age=31536000, immutable");
+      return c.body(cached);
+    }
+    const html = await renderHighlighted(buf, effLang);
+    try {
+      await store.blobs.putWithKey(html, cacheKey);
+    } catch {
+    }
+    c.header("Content-Type", "text/html; charset=utf-8");
+    c.header("Cache-Control", "public, max-age=31536000, immutable");
+    return c.body(html);
+  });
+  app.get("/contexts/:id", async (c) => {
+    const snapshotId = c.req.param("id");
+    const ref = resolveSnapshotBlobRef3(store, snapshotId);
+    const manifestText = await store.blobs.tryGetString(ref);
+    if (!manifestText) return c.notFound();
+    let manifest;
+    try {
+      manifest = JSON.parse(manifestText);
+    } catch {
+      return c.text("invalid snapshot JSON", 500);
+    }
+    const rendered = await resolveContext(store, manifest);
+    const runQ = c.req.query("run");
+    const stepQ = c.req.query("step");
+    const seqQ = c.req.query("seq");
+    const run = runQ ? getRun6(store, runQ) : void 0;
+    if (run) rendered.runtime = run.source_runtime;
+    const meta = {
+      runId: run?.run_id,
+      stepId: stepQ ?? void 0,
+      sequence: seqQ !== void 0 ? Number(seqQ) : void 0
+    };
+    return c.html(
+      renderShell(
+        `Context \xB7 ${snapshotId.slice(0, 12)}`,
+        renderContext(snapshotId, rendered, meta),
+        shellOpts()
+      )
+    );
+  });
+  app.get("/api/diff", (c) => {
+    const a = c.req.query("a");
+    const b = c.req.query("b");
+    if (!a || !b) return c.json({ error: "missing a/b" }, 400);
+    const ra = getRun6(store, a);
+    const rb = getRun6(store, b);
+    if (!ra || !rb) return c.json({ error: "run not found" }, 404);
+    return c.json(diffRuns(store, ra.run_id, rb.run_id));
+  });
+  app.post("/api/runs/:id/close", async (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.json({ error: "run not found" }, 404);
+    let status = "ok";
+    try {
+      const body = await c.req.json();
+      if (body?.status) {
+        if (body.status !== "ok" && body.status !== "error" && body.status !== "abandoned") {
+          return c.json(
+            { error: `invalid status: ${body.status}. allowed: ok | error | abandoned` },
+            400
+          );
+        }
+        status = body.status;
+      }
+    } catch {
+    }
+    setRunStatus3(store, run.run_id, status, (/* @__PURE__ */ new Date()).toISOString());
+    updateRunTotals3(store, run.run_id);
+    const updated = getRun6(store, run.run_id);
+    return c.json(updated);
+  });
+  app.post("/api/runs/close-stale", async (c) => {
+    let body = {};
+    try {
+      body = await c.req.json() ?? {};
+    } catch {
+    }
+    const olderThanMin = body.older_than_minutes ?? 60;
+    const source = body.source;
+    const status = body.status === "error" || body.status === "abandoned" ? body.status : "ok";
+    const cutoffMs = Date.now() - olderThanMin * 6e4;
+    const all = listRuns3(store, { limit: 1e3 });
+    const targets = all.filter((r) => {
+      if (r.status !== "in_progress") return false;
+      if (source && r.source_runtime !== source) return false;
+      const startedMs = Date.parse(r.started_at);
+      return Number.isFinite(startedMs) && startedMs <= cutoffMs;
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const r of targets) {
+      setRunStatus3(store, r.run_id, status, now);
+      updateRunTotals3(store, r.run_id);
+    }
+    return c.json({
+      closed: targets.length,
+      run_ids: targets.map((r) => r.run_id),
+      status
+    });
+  });
+  app.post("/api/annotate", async (c) => {
+    const body = await c.req.json();
+    if (!body.target_kind || !body.target_id) {
+      return c.json({ error: "missing target_kind / target_id" }, 400);
+    }
+    let resolvedId = body.target_id;
+    if (body.target_kind === "run") {
+      const run = getRun6(store, body.target_id);
+      if (!run) return c.json({ error: "run not found" }, 404);
+      resolvedId = run.run_id;
+    } else if (body.target_kind === "step") {
+      const step = getStep3(store, body.target_id);
+      if (!step) return c.json({ error: "step not found" }, 404);
+      resolvedId = step.step_id;
+    }
+    const ann = insertAnnotation2(store, {
+      targetKind: body.target_kind,
+      targetId: resolvedId,
+      author: body.author ?? "anonymous",
+      verdict: body.verdict,
+      note: body.note
+    });
+    return c.json(ann);
+  });
+  app.get("/api/runs/:id/annotations", (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.notFound();
+    return c.json(listAnnotations(store, "run", run.run_id));
+  });
+  app.get("/api/steps/:id/annotations", (c) => {
+    const step = getStep3(store, c.req.param("id"));
+    if (!step) return c.notFound();
+    return c.json(listAnnotations(store, "step", step.step_id));
+  });
+  app.post("/api/fork", async (c) => {
+    const body = await c.req.json();
+    if (!body.origin_run_id || body.at === void 0 || !body.edit_type) {
+      return c.json({ error: "missing origin_run_id / at / edit_type" }, 400);
+    }
+    const apiKey = resolveSetting(
+      store,
+      "anthropic.api_key",
+      "ANTHROPIC_API_KEY"
+    );
+    const model = body.model ?? getSetting(store, "fork.default_model") ?? "claude-opus-4-7";
+    const responder = body.fake ? fakeResponder(body.fake) : body.live && apiKey ? anthropicResponder(store, { apiKey, model }) : void 0;
+    try {
+      const result = await forkRun(
+        store,
+        {
+          origin_run_id: body.origin_run_id,
+          at: body.at,
+          edit: {
+            type: body.edit_type,
+            payload: body.edit_payload ?? null
+          }
+        },
+        responder
+      );
+      let continuation;
+      if (body.continue && body.continue !== "none") {
+        if (body.continue !== "simulate" && body.continue !== "live") {
+          return c.json({ error: `invalid continue mode: ${body.continue}` }, 400);
+        }
+        if (body.continue === "live" && !apiKey) {
+          return c.json(
+            { error: "live continuation requires ANTHROPIC_API_KEY" },
+            400
+          );
+        }
+        const modelCaller = async (args) => {
+          const { default: Anthropic } = await import("@anthropic-ai/sdk");
+          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 usage = resp.usage;
+          const cc = usage?.cache_creation;
+          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: usage?.cache_read_input_tokens ?? 0,
+              cache_creation: cc?.ephemeral_5m_input_tokens ?? usage?.cache_creation_input_tokens ?? 0,
+              cache_creation_1h: cc?.ephemeral_1h_input_tokens ?? 0
+            },
+            latency_ms: t1 - t0
+          };
+        };
+        const allowSet = new Set(body.allow_tools ?? []);
+        const toolExecutor = body.continue === "live" ? async (call) => {
+          if (!allowSet.has(call.tool_name)) {
+            return {
+              output: { meter_note: `tool '${call.tool_name}' not allowed` },
+              is_error: false,
+              summary: `skipped: ${call.tool_name}`
+            };
+          }
+          if (call.tool_name === "Bash") {
+            const cmd = call.tool_input?.command;
+            if (!cmd) {
+              return { output: { error: "missing command" }, is_error: true, summary: "missing command" };
+            }
+            if (/\brm\s+-[rRfF]|sudo\b|--no-verify/.test(cmd)) {
+              return { output: { error: "destructive command rejected" }, is_error: true, summary: "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 executor; no-op` },
+            is_error: false,
+            summary: `no-op: ${call.tool_name}`
+          };
+        } : (async () => ({ output: {}, is_error: false }));
+        const cont = await continueFork(store, result.fork_run_id, {
+          mode: body.continue,
+          modelCaller,
+          toolExecutor,
+          maxIterations: body.max_iterations ?? 25,
+          originRunId: body.origin_run_id
+        });
+        continuation = {
+          mode: body.continue,
+          iterations: cont.iterations_run,
+          steps_added: cont.steps_added,
+          terminal_reason: cont.terminal_reason
+        };
+      }
+      return c.json({ ...result, continuation });
+    } catch (err) {
+      return c.json({ error: err.message }, 400);
+    }
+  });
+  app.get("/api/tests", (c) => c.json(listTests(store)));
+  app.get("/api/tests/:name", (c) => {
+    const t = getTestByName(store, c.req.param("name"));
+    return t ? c.json(t) : c.notFound();
+  });
+  app.get("/api/tests/:name/results", (c) => {
+    const t = getTestByName(store, c.req.param("name"));
+    if (!t) return c.notFound();
+    return c.json(listResults(store, t.test_id, 50));
+  });
+  app.post("/api/tests", async (c) => {
+    const body = await c.req.json();
+    if (!body.name) return c.json({ error: "missing name" }, 400);
+    let assertions = body.assertions ?? [];
+    let canonicalRunId;
+    if (body.from_run_id) {
+      const run = getRun6(store, body.from_run_id);
+      if (!run) return c.json({ error: "from_run_id not found" }, 404);
+      const steps = listSteps7(store, run.run_id);
+      assertions = deriveAssertionsFromRun(run, steps);
+      canonicalRunId = run.run_id;
+    }
+    try {
+      const t = createTest(store, {
+        name: body.name,
+        description: body.description,
+        assertions,
+        canonical_run_id: canonicalRunId
+      });
+      return c.json(t);
+    } catch (err) {
+      return c.json({ error: err.message }, 400);
+    }
+  });
+  app.put("/api/tests/:name/assertions", async (c) => {
+    const name = c.req.param("name");
+    const body = await c.req.json();
+    const t = getTestByName(store, name);
+    if (!t) return c.notFound();
+    store.db.prepare("UPDATE regression_tests SET assertions_json = ? WHERE test_id = ?").run(JSON.stringify(body.assertions), t.test_id);
+    return c.json(getTestByName(store, name));
+  });
+  app.post("/api/tests/:name/assertions", async (c) => {
+    const name = c.req.param("name");
+    const body = await c.req.json();
+    try {
+      const t = addAssertion(store, name, body.assertion);
+      return c.json(t);
+    } catch (err) {
+      return c.json({ error: err.message }, 400);
+    }
+  });
+  app.delete("/api/tests/:name", (c) => {
+    const ok = deleteTest(store, c.req.param("name"));
+    return ok ? c.json({ ok: true }) : c.notFound();
+  });
+  app.post("/api/tests/:name/run", async (c) => {
+    const name = c.req.param("name");
+    const body = await c.req.json().catch(() => ({}));
+    const t = getTestByName(store, name);
+    if (!t) return c.notFound();
+    let runs = body.run_id ? [getRun6(store, body.run_id)].filter((r) => !!r) : listRuns3(store, { limit: body.limit ?? 50 });
+    const results = runs.map((r) => runTest(store, t, r.run_id));
+    return c.json(results);
+  });
+  app.get("/tests", (c) => {
+    const tests = listTests(store);
+    const recent = listResults(store, void 0, 20);
+    return c.html(renderShell("Tests", renderTests(tests, recent), shellOpts()));
+  });
+  app.get("/settings", async (c) => {
+    const { renderSettings } = await import("./html-QXNPWM2W.js");
+    const slackWebhook = resolveSetting(store, "slack.webhook", "METERBILITY_SLACK_WEBHOOK");
+    const apiKey = resolveSetting(store, "anthropic.api_key", "ANTHROPIC_API_KEY");
+    const pgUrl = resolveSetting(store, "postgres.url", "METERBILITY_DB_URL");
+    return c.html(
+      renderShell(
+        "Settings",
+        renderSettings({
+          slackWebhook,
+          slackWebhookFromEnv: !!process.env.METERBILITY_SLACK_WEBHOOK,
+          apiKey,
+          apiKeyFromEnv: !!process.env.ANTHROPIC_API_KEY,
+          postgresUrl: pgUrl,
+          postgresUrlFromEnv: !!process.env.METERBILITY_DB_URL,
+          watchedTools: getSetting(store, "live.watch_tools") ?? "",
+          stallSeconds: Number(getSetting(store, "live.stall_seconds") ?? 120),
+          defaultModel: getSetting(store, "fork.default_model") ?? "claude-opus-4-7",
+          defaultMaxIterations: Number(
+            getSetting(store, "fork.default_max_iterations") ?? 25
+          )
+        }),
+        shellOpts()
+      )
+    );
+  });
+  app.post("/api/settings", async (c) => {
+    const body = await c.req.json();
+    if (!body.key) return c.json({ error: "missing key" }, 400);
+    if (body.value === void 0 || body.value === "") {
+      deleteSetting(store, body.key);
+    } else {
+      setSetting(store, body.key, body.value);
+    }
+    return c.json({ ok: true });
+  });
+  app.get("/api/doctor", async (c) => {
+    const { existsSync: existsSync2 } = await import("fs");
+    const { stat } = await import("fs/promises");
+    const { claudeHome, claudeProjectsRoot: claudeProjectsRoot2, dbPath, meterHome } = await import("@meterbility/shared");
+    const { discoverSessions: discoverSessions2 } = await import("@meterbility/claude-code-adapter");
+    const checks = [];
+    const node = process.versions.node;
+    const [major, minor] = node.split(".").map(Number);
+    checks.push({
+      name: "Node",
+      status: major > 20 || major === 20 && minor >= 6 || major >= 22 ? "ok" : major >= 20 ? "warn" : "fail",
+      detail: `v${node}`
+    });
+    checks.push({ name: "METERBILITY_HOME", status: "ok", detail: meterHome() });
+    checks.push({
+      name: "CLAUDE_HOME",
+      status: existsSync2(claudeHome()) ? "ok" : "fail",
+      detail: claudeHome()
+    });
+    checks.push({
+      name: "Claude projects dir",
+      status: existsSync2(claudeProjectsRoot2()) ? "ok" : "warn",
+      detail: claudeProjectsRoot2()
+    });
+    try {
+      const sessions = await discoverSessions2();
+      checks.push({
+        name: "Session discovery",
+        status: sessions.length > 0 ? "ok" : "warn",
+        detail: sessions.length === 0 ? "no .jsonl session files found" : `${sessions.length} session(s)`
+      });
+    } catch (err) {
+      checks.push({
+        name: "Session discovery",
+        status: "fail",
+        detail: err.message
+      });
+    }
+    try {
+      const s = await stat(dbPath());
+      checks.push({
+        name: "SQLite store",
+        status: "ok",
+        detail: `${dbPath()} (${s.size} bytes)`
+      });
+    } catch (err) {
+      checks.push({
+        name: "SQLite store",
+        status: "fail",
+        detail: err.message
+      });
+    }
+    return c.json({ checks });
+  });
+  app.post("/api/ingest", async (c) => {
+    const body = await c.req.json();
+    if (!body.runtime) return c.json({ error: "missing runtime" }, 400);
+    try {
+      let runs = 0;
+      let steps = 0;
+      let bytes = 0;
+      let composers = 0;
+      if (body.runtime === "claude-code") {
+        const { discoverSessions: discoverSessions2, ingestSession: ingestSession2 } = await import("@meterbility/claude-code-adapter");
+        let paths = [];
+        if (body.path) paths = [body.path];
+        else {
+          const sessions = await discoverSessions2();
+          paths = sessions.map((s) => s.path);
+          if (body.limit) paths = paths.slice(0, body.limit);
+        }
+        for (const p of paths) {
+          const r = await ingestSession2(store, p);
+          if (r.status === "ok") {
+            runs += 1;
+            steps += r.steps_added;
+            bytes += r.bytes_read;
+          }
+        }
+      } else if (body.runtime === "codex-cli") {
+        const { discoverCodexSessions, ingestCodexSession } = await import("@meterbility/codex-cli-adapter");
+        let paths = [];
+        if (body.path) paths = [body.path];
+        else {
+          const sessions = await discoverCodexSessions();
+          paths = sessions.map((s) => s.path);
+          if (body.limit) paths = paths.slice(0, body.limit);
+        }
+        for (const p of paths) {
+          const r = await ingestCodexSession(store, p);
+          if (r.status === "ok") {
+            runs += 1;
+            steps += r.steps_added;
+            bytes += r.bytes_read;
+          }
+        }
+      } else if (body.runtime === "cursor") {
+        const { ingestCursorGlobal } = await import("@meterbility/cursor-adapter");
+        const r = await ingestCursorGlobal(store, { limit: body.limit });
+        if (r.status === "ok") {
+          composers = r.composers_ingested;
+          steps = r.steps_added;
+        } else {
+          return c.json({ error: r.reason ?? "ingest failed" }, 400);
+        }
+      } else {
+        return c.json({ error: "unknown runtime" }, 400);
+      }
+      return c.json({
+        ok: true,
+        runtime: body.runtime,
+        runs,
+        composers,
+        steps,
+        bytes
+      });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.post("/api/slack/test", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const url = body.webhook ?? resolveSetting(store, "slack.webhook", "METERBILITY_SLACK_WEBHOOK");
+    if (!url) return c.json({ error: "missing webhook" }, 400);
+    try {
+      const n = new SlackNotifier({ webhookUrl: url });
+      await n.sendTest();
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ error: err.message }, 400);
+    }
+  });
+  app.post("/api/db/postgres-init", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const url = body.url ?? resolveSetting(store, "postgres.url", "METERBILITY_DB_URL");
+    if (!url) return c.json({ error: "missing url" }, 400);
+    try {
+      const { PostgresStore } = await import("@meterbility/store-postgres");
+      const pg = await PostgresStore.open({ url });
+      try {
+        const r = await pg.client.query(
+          "SELECT value FROM meta WHERE key='schema_version'"
+        );
+        return c.json({
+          ok: true,
+          schema_version: r.rows[0]?.value ?? null
+        });
+      } finally {
+        await pg.close();
+      }
+    } catch (err) {
+      return c.json({ error: err.message }, 400);
+    }
+  });
+  app.post("/api/db/postgres-sync", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const url = body.url ?? resolveSetting(store, "postgres.url", "METERBILITY_DB_URL");
+    if (!url) return c.json({ error: "missing url" }, 400);
+    try {
+      const { PostgresStore, syncSqliteToPostgres } = await import("@meterbility/store-postgres");
+      const pg = await PostgresStore.open({ url });
+      try {
+        const r = await syncSqliteToPostgres(store, pg, {
+          limitRuns: body.limit
+        });
+        return c.json({ ok: true, ...r });
+      } finally {
+        await pg.close();
+      }
+    } catch (err) {
+      return c.json({ error: err.message }, 400);
+    }
+  });
+  app.get("/api/runs/:id/export", async (c) => {
+    const run = getRun6(store, c.req.param("id"));
+    if (!run) return c.notFound();
+    const includeBlobs = c.req.query("blobs") !== "0";
+    const includeFileBlobs = c.req.query("file_blobs") === "1";
+    const steps = listSteps7(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 (includeBlobs) {
+      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(
+          resolveSnapshotBlobRef3(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;
+    }
+    c.header(
+      "Content-Disposition",
+      `attachment; filename="${run.run_id}.meter.json"`
+    );
+    return c.json(trace);
+  });
+  return app;
+}
+async function resolveContext(store, snapshot) {
+  let totalChars = 0;
+  const components = [];
+  const fetchText = async (ref) => {
+    const text = await store.blobs.tryGetString(ref) ?? "(missing blob)";
+    totalChars += text.length;
+    return text;
+  };
+  for (const c of snapshot.components) {
+    if (c.type === "system_prompt") {
+      components.push({
+        type: "system_prompt",
+        ref: c.content_ref,
+        text: await fetchText(c.content_ref)
+      });
+    } else if (c.type === "tool_definitions") {
+      components.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
+        });
+      }
+      components.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)
+        });
+      }
+      components.push({ type: "retrieved_documents", docs });
+    } else if (c.type === "compaction_summary") {
+      components.push({
+        type: "compaction_summary",
+        ref: c.content_ref,
+        text: await fetchText(c.content_ref),
+        replaces_steps: c.replaces_steps
+      });
+    }
+  }
+  return { components, totalChars };
+}
+async function loadDecisionPreviews(store, steps) {
+  const out = /* @__PURE__ */ new Map();
+  for (const s of steps) {
+    const text = await store.blobs.tryGetString(s.decision_ref);
+    if (text) out.set(s.step_id, text.slice(0, DECISION_PREVIEW_LIMIT));
+  }
+  return out;
+}
+function serveApp(store, opts = {}) {
+  const controller = new LiveController(store);
+  if (opts.live) {
+    void controller.start(opts.liveOptions);
+  }
+  const app = buildApp(store, { controller });
+  const port = opts.port ?? 4317;
+  const host = opts.host ?? "127.0.0.1";
+  const server = serve({ fetch: app.fetch, port, hostname: host });
+  return {
+    url: `http://${host}:${port}`,
+    controller,
+    get live() {
+      return controller.inspector;
+    },
+    close: () => {
+      controller.stop();
+      server.close();
+    }
+  };
+}
+export {
+  DECISION_PREVIEW_LIMIT,
+  LiveController,
+  LiveInspector,
+  SlackNotifier,
+  addAssertion,
+  anthropicResponder,
+  appendLiveStep,
+  buildApp,
+  buildFleetEntries,
+  classifyRunStatus,
+  contextUtilization,
+  continueFork,
+  createTest,
+  deleteTest,
+  deriveAssertionsFromRun,
+  detectLoop,
+  diffRuns,
+  fakeResponder,
+  forkRun,
+  getTestByName,
+  listResults,
+  listTests,
+  materializePrefix,
+  prettyMultilineString,
+  prettyTab,
+  prettyValue,
+  reformatJsonString,
+  resolveSimulatedResult,
+  rewriteSnapshot,
+  runTest,
+  serveApp
+};