acp-devtools 0.2.0 → 0.3.0

package/dist/index.js

@@ -5,9 +5,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -25,6 +32,124 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../core/dist/acp/types.js
+var init_types = __esm({
+  "../core/dist/acp/types.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/acp/parser.js
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function classify(payload) {
+  if ("method" in payload && "id" in payload) {
+    const req = payload;
+    return { kind: "request", method: req.method, rpcId: req.id };
+  }
+  if ("method" in payload) {
+    const note = payload;
+    return { kind: "notification", method: note.method };
+  }
+  if ("error" in payload) {
+    const err = payload;
+    return { kind: "error", rpcId: err.id ?? null };
+  }
+  if ("result" in payload) {
+    const ok = payload;
+    return { kind: "response", rpcId: ok.id ?? null };
+  }
+  return { kind: "unknown" };
+}
+function parseFrame(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { raw, payload: null, kind: "unknown", parseError: `invalid JSON: ${message}` };
+  }
+  if (!isPlainObject(json) || json.jsonrpc !== "2.0") {
+    return { raw, payload: null, kind: "unknown", parseError: "not a JSON-RPC 2.0 message" };
+  }
+  const payload = json;
+  return { raw, payload, ...classify(payload) };
+}
+var LineFramer;
+var init_parser = __esm({
+  "../core/dist/acp/parser.js"() {
+    "use strict";
+    LineFramer = class {
+      buffer = "";
+      /** Push a chunk; returns zero or more complete frames (without the trailing `\n`). */
+      feed(chunk) {
+        this.buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        const lines = [];
+        let nl = this.buffer.indexOf("\n");
+        while (nl >= 0) {
+          let line = this.buffer.slice(0, nl);
+          this.buffer = this.buffer.slice(nl + 1);
+          if (line.endsWith("\r"))
+            line = line.slice(0, -1);
+          if (line.length > 0)
+            lines.push(line);
+          nl = this.buffer.indexOf("\n");
+        }
+        return lines;
+      }
+      /** Return and discard any unterminated trailing data. */
+      flush() {
+        if (this.buffer.length === 0)
+          return null;
+        const remaining = this.buffer;
+        this.buffer = "";
+        return remaining.length > 0 ? remaining : null;
+      }
+    };
+  }
+});
+
+// ../core/dist/acp/text.js
+function extractTextPreview(m) {
+  if (!m.payload || typeof m.payload !== "object")
+    return null;
+  const params = m.payload.params;
+  if (!params || typeof params !== "object")
+    return null;
+  if (m.method === "session/prompt") {
+    const blocks = params.prompt;
+    if (!Array.isArray(blocks))
+      return null;
+    const parts = [];
+    for (const block of blocks) {
+      if (block?.type === "text" && typeof block.text === "string") {
+        parts.push(block.text);
+      }
+    }
+    const joined = parts.join(" ").trim();
+    return joined.length > 0 ? joined : null;
+  }
+  if (m.method === "session/update") {
+    const update = params.update;
+    if (!update)
+      return null;
+    const text = update.content?.text ?? update.text;
+    if (typeof text === "string" && text.length > 0)
+      return text;
+    return null;
+  }
+  return null;
+}
+function isUserPrompt(m) {
+  return m.method === "session/prompt" && m.kind === "request";
+}
+var init_text = __esm({
+  "../core/dist/acp/text.js"() {
+    "use strict";
+  }
+});
+
 // ../core/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
   "../core/node_modules/ajv/dist/compile/codegen/code.js"(exports) {
@@ -7139,111 +7264,7 @@ var require__ = __commonJS({
   }
 });
 
-// ../core/dist/acp/parser.js
-var LineFramer = class {
-  buffer = "";
-  /** Push a chunk; returns zero or more complete frames (without the trailing `\n`). */
-  feed(chunk) {
-    this.buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-    const lines = [];
-    let nl = this.buffer.indexOf("\n");
-    while (nl >= 0) {
-      let line = this.buffer.slice(0, nl);
-      this.buffer = this.buffer.slice(nl + 1);
-      if (line.endsWith("\r"))
-        line = line.slice(0, -1);
-      if (line.length > 0)
-        lines.push(line);
-      nl = this.buffer.indexOf("\n");
-    }
-    return lines;
-  }
-  /** Return and discard any unterminated trailing data. */
-  flush() {
-    if (this.buffer.length === 0)
-      return null;
-    const remaining = this.buffer;
-    this.buffer = "";
-    return remaining.length > 0 ? remaining : null;
-  }
-};
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function classify(payload) {
-  if ("method" in payload && "id" in payload) {
-    const req = payload;
-    return { kind: "request", method: req.method, rpcId: req.id };
-  }
-  if ("method" in payload) {
-    const note = payload;
-    return { kind: "notification", method: note.method };
-  }
-  if ("error" in payload) {
-    const err = payload;
-    return { kind: "error", rpcId: err.id ?? null };
-  }
-  if ("result" in payload) {
-    const ok = payload;
-    return { kind: "response", rpcId: ok.id ?? null };
-  }
-  return { kind: "unknown" };
-}
-function parseFrame(raw) {
-  let json;
-  try {
-    json = JSON.parse(raw);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { raw, payload: null, kind: "unknown", parseError: `invalid JSON: ${message}` };
-  }
-  if (!isPlainObject(json) || json.jsonrpc !== "2.0") {
-    return { raw, payload: null, kind: "unknown", parseError: "not a JSON-RPC 2.0 message" };
-  }
-  const payload = json;
-  return { raw, payload, ...classify(payload) };
-}
-
-// ../core/dist/acp/text.js
-function extractTextPreview(m) {
-  if (!m.payload || typeof m.payload !== "object")
-    return null;
-  const params = m.payload.params;
-  if (!params || typeof params !== "object")
-    return null;
-  if (m.method === "session/prompt") {
-    const blocks = params.prompt;
-    if (!Array.isArray(blocks))
-      return null;
-    const parts = [];
-    for (const block of blocks) {
-      if (block?.type === "text" && typeof block.text === "string") {
-        parts.push(block.text);
-      }
-    }
-    const joined = parts.join(" ").trim();
-    return joined.length > 0 ? joined : null;
-  }
-  if (m.method === "session/update") {
-    const update = params.update;
-    if (!update)
-      return null;
-    const text = update.content?.text ?? update.text;
-    if (typeof text === "string" && text.length > 0)
-      return text;
-    return null;
-  }
-  return null;
-}
-
-// ../core/dist/acp/validate.js
-import { createRequire } from "module";
-
 // ../core/dist/acp/validate-factory.js
-var import__ = __toESM(require__(), 1);
-var ajvModule = import__.default;
-var Ajv2020 = ajvModule.default ?? ajvModule;
-var SCHEMA_ID = "acp";
 function toError(e) {
   const v = {
     path: e.instancePath || "/",
@@ -7326,13 +7347,31 @@ function createAcpValidator(schema3) {
   }
   return { validateAcpMessage: validateAcpMessage2, knownAcpMethods: knownAcpMethods2 };
 }
+var import__, ajvModule, Ajv2020, SCHEMA_ID;
+var init_validate_factory = __esm({
+  "../core/dist/acp/validate-factory.js"() {
+    "use strict";
+    import__ = __toESM(require__(), 1);
+    ajvModule = import__.default;
+    Ajv2020 = ajvModule.default ?? ajvModule;
+    SCHEMA_ID = "acp";
+  }
+});
 
 // ../core/dist/acp/validate.js
-var require2 = createRequire(import.meta.url);
-var schema = require2("@agentclientprotocol/sdk/schema/schema.json");
-var validator = createAcpValidator(schema);
-var validateAcpMessage = validator.validateAcpMessage;
-var knownAcpMethods = validator.knownAcpMethods;
+import { createRequire } from "module";
+var require2, schema, validator, validateAcpMessage, knownAcpMethods;
+var init_validate = __esm({
+  "../core/dist/acp/validate.js"() {
+    "use strict";
+    init_validate_factory();
+    require2 = createRequire(import.meta.url);
+    schema = require2("@agentclientprotocol/sdk/schema/schema.json");
+    validator = createAcpValidator(schema);
+    validateAcpMessage = validator.validateAcpMessage;
+    knownAcpMethods = validator.knownAcpMethods;
+  }
+});
 
 // ../core/dist/acp/session-metadata.js
 function asRecord(value) {
@@ -7517,6 +7556,11 @@ function extractSessionMetadata(messages) {
     extensions: extractExtensions(initReq)
   };
 }
+var init_session_metadata = __esm({
+  "../core/dist/acp/session-metadata.js"() {
+    "use strict";
+  }
+});
 
 // ../core/dist/acp/method-stats.js
 function buildPairIndex(messages) {
@@ -7610,9 +7654,18 @@ function percentile(sortedAsc, p) {
     return a;
   return a + (b - a) * (rank - lo);
 }
+function mean(values) {
+  if (values.length === 0)
+    return 0;
+  return values.reduce((acc, x) => acc + x, 0) / values.length;
+}
+var init_method_stats = __esm({
+  "../core/dist/acp/method-stats.js"() {
+    "use strict";
+  }
+});
 
 // ../core/dist/acp/session-diff.js
-var DEFAULT_MAX_CHANGES = 100;
 function buildSessionDiff(a, b, options = {}) {
   const maxChanges = options.maxChangesPerRow ?? DEFAULT_MAX_CHANGES;
   const sigA = signatures(a);
@@ -7789,6 +7842,14 @@ function deepDiff(a, b, path, out, max) {
 function leafEqual(a, b) {
   return Object.is(a, b);
 }
+var DEFAULT_MAX_CHANGES;
+var init_session_diff = __esm({
+  "../core/dist/acp/session-diff.js"() {
+    "use strict";
+    init_method_stats();
+    DEFAULT_MAX_CHANGES = 100;
+  }
+});
 
 // ../core/dist/acp/session-compare.js
 function comparableMetadata(m) {
@@ -7840,17 +7901,16 @@ function deltaOf(a, b) {
     return null;
   return b - a;
 }
+var init_session_compare = __esm({
+  "../core/dist/acp/session-compare.js"() {
+    "use strict";
+    init_session_diff();
+    init_method_stats();
+    init_session_metadata();
+  }
+});
 
 // ../core/dist/acp/perf-insights.js
-var DEFAULTS = {
-  minSamplesForTail: 3,
-  longTailRatio: 5,
-  minBusiestCount: 50,
-  minBusiestRatio: 2.5,
-  minHotspotShare: 0.4,
-  minSamplesForOutlier: 5,
-  outlierRatio: 3
-};
 function buildPerformanceInsights(messages, perMethod, cfg = {}) {
   const config = { ...DEFAULTS, ...cfg };
   const out = [];
@@ -7945,9 +8005,23 @@ function formatMs(ms) {
   const s = Math.round(ms % 6e4 / 1e3);
   return `${m}m${s}s`;
 }
+var DEFAULTS;
+var init_perf_insights = __esm({
+  "../core/dist/acp/perf-insights.js"() {
+    "use strict";
+    DEFAULTS = {
+      minSamplesForTail: 3,
+      longTailRatio: 5,
+      minBusiestCount: 50,
+      minBusiestRatio: 2.5,
+      minHotspotShare: 0.4,
+      minSamplesForOutlier: 5,
+      outlierRatio: 3
+    };
+  }
+});
 
 // ../core/dist/acp/sparkline.js
-var BLOCKS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
 function sampleEvenly(values, targetCount) {
   if (values.length <= targetCount)
     return values;
@@ -7970,9 +8044,13 @@ function asciiSparkline(values, targetWidth = 8) {
     return BLOCKS[idx];
   }).join("");
 }
-
-// ../core/dist/acp/spec-decoder.js
-import { createRequire as createRequire2 } from "module";
+var BLOCKS;
+var init_sparkline = __esm({
+  "../core/dist/acp/sparkline.js"() {
+    "use strict";
+    BLOCKS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+  }
+});
 
 // ../core/dist/acp/spec-decoder-factory.js
 function createSpecDecoder(schema3) {
@@ -8214,56 +8292,126 @@ function createSpecDecoder(schema3) {
   }
   return { resolveForMessage, knownMethods };
 }
+var init_spec_decoder_factory = __esm({
+  "../core/dist/acp/spec-decoder-factory.js"() {
+    "use strict";
+  }
+});
 
 // ../core/dist/acp/spec-decoder.js
-var require3 = createRequire2(import.meta.url);
-var schema2 = require3("@agentclientprotocol/sdk/schema/schema.json");
-var decoder = createSpecDecoder(schema2);
-var resolveSpecForMessage = decoder.resolveForMessage;
-var knownAcpSpecMethods = decoder.knownMethods;
+import { createRequire as createRequire2 } from "module";
+var require3, schema2, decoder, resolveSpecForMessage, knownAcpSpecMethods;
+var init_spec_decoder = __esm({
+  "../core/dist/acp/spec-decoder.js"() {
+    "use strict";
+    init_spec_decoder_factory();
+    require3 = createRequire2(import.meta.url);
+    schema2 = require3("@agentclientprotocol/sdk/schema/schema.json");
+    decoder = createSpecDecoder(schema2);
+    resolveSpecForMessage = decoder.resolveForMessage;
+    knownAcpSpecMethods = decoder.knownMethods;
+  }
+});
+
+// ../core/dist/acp/timeline-layout.js
+function buildTimelineLayout(messages) {
+  const empty = {
+    events: [],
+    startTs: 0,
+    endTs: 0,
+    durationMs: 0,
+    laneCounts: { "editor-req": 0, "agent-req": 0, notification: 0 }
+  };
+  if (messages.length === 0)
+    return empty;
+  const pairs = buildPairIndex(messages);
+  const bySeq = /* @__PURE__ */ new Map();
+  for (const m of messages)
+    bySeq.set(m.seq, m);
+  let startTs = Infinity;
+  let endTs = -Infinity;
+  const events = [];
+  const laneCounts = {
+    "editor-req": 0,
+    "agent-req": 0,
+    notification: 0
+  };
+  for (const m of messages) {
+    if (m.timestamp < startTs)
+      startTs = m.timestamp;
+    if (m.timestamp > endTs)
+      endTs = m.timestamp;
+    if (m.kind === "request") {
+      const lane = m.direction === "editor-to-agent" ? "editor-req" : "agent-req";
+      const pair = pairs.get(m.seq);
+      const pairedMsg = pair ? bySeq.get(pair.pairSeq) : void 0;
+      const erroredOut = pairedMsg?.kind === "error";
+      const evtEnd = pairedMsg ? pairedMsg.timestamp : m.timestamp;
+      if (evtEnd > endTs)
+        endTs = evtEnd;
+      events.push({
+        seq: m.seq,
+        startTs: m.timestamp,
+        endTs: evtEnd,
+        lane,
+        method: m.method ?? null,
+        kind: m.kind,
+        erroredOut,
+        pairedSeq: pairedMsg ? pairedMsg.seq : null
+      });
+      laneCounts[lane] += 1;
+    } else if (m.kind === "notification") {
+      events.push({
+        seq: m.seq,
+        startTs: m.timestamp,
+        endTs: m.timestamp,
+        lane: "notification",
+        method: m.method ?? null,
+        kind: m.kind,
+        erroredOut: false,
+        pairedSeq: null
+      });
+      laneCounts.notification += 1;
+    }
+  }
+  if (!Number.isFinite(startTs) || !Number.isFinite(endTs))
+    return empty;
+  return {
+    events,
+    startTs,
+    endTs,
+    durationMs: Math.max(0, endTs - startTs),
+    laneCounts
+  };
+}
+var init_timeline_layout = __esm({
+  "../core/dist/acp/timeline-layout.js"() {
+    "use strict";
+    init_method_stats();
+  }
+});
 
 // ../core/dist/acp/index.js
 import { AGENT_METHODS, CLIENT_METHODS, PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
+var init_acp = __esm({
+  "../core/dist/acp/index.js"() {
+    "use strict";
+    init_types();
+    init_parser();
+    init_text();
+    init_validate();
+    init_session_metadata();
+    init_method_stats();
+    init_session_diff();
+    init_session_compare();
+    init_perf_insights();
+    init_sparkline();
+    init_spec_decoder();
+    init_timeline_layout();
+  }
+});
 
 // ../core/dist/agents/registry.js
-var AGENT_REGISTRY = {
-  "claude-code": {
-    shortName: "claude-code",
-    displayName: "Claude Code",
-    description: "Anthropic Claude Code via @agentclientprotocol/claude-agent-acp",
-    command: "npx",
-    args: ["-y", "@agentclientprotocol/claude-agent-acp"],
-    aliases: [
-      // The original Zed-scoped package is deprecated as of late 2026,
-      // but still very common in existing captures + IDE configs.
-      ["npx", "-y", "@zed-industries/claude-code-acp"]
-    ]
-  },
-  codex: {
-    shortName: "codex",
-    displayName: "Codex",
-    description: "OpenAI Codex via @zed-industries/codex-acp",
-    command: "npx",
-    args: ["-y", "@zed-industries/codex-acp"]
-  },
-  goose: {
-    shortName: "goose",
-    displayName: "Goose",
-    description: "Block Goose \u2014 install separately, then this runs `goose acp`",
-    command: "goose",
-    args: ["acp"],
-    requiresExternalInstall: true
-  },
-  opencode: {
-    shortName: "opencode",
-    displayName: "OpenCode",
-    description: "SST OpenCode \u2014 install via opencode.ai/install, then `opencode acp`",
-    command: "opencode",
-    args: ["acp"],
-    requiresExternalInstall: true
-  }
-};
-var DEFAULT_AGENT = "claude-code";
 function resolveAgent(shortName) {
   const agent = AGENT_REGISTRY[shortName];
   if (!agent) {
@@ -8278,9 +8426,77 @@ function isAgentShortcut(name) {
 function listAgents() {
   return Object.values(AGENT_REGISTRY).slice();
 }
+function detectAgentShortcut(agentCommand) {
+  const trimmed = agentCommand.trim();
+  if (trimmed.length === 0)
+    return null;
+  for (const def of Object.values(AGENT_REGISTRY)) {
+    const variants = [
+      [def.command, ...def.args],
+      ...def.aliases ?? []
+    ];
+    for (const variant of variants) {
+      const exact = variant.join(" ");
+      if (trimmed === exact)
+        return def;
+      if (trimmed.startsWith(exact + " "))
+        return def;
+    }
+  }
+  return null;
+}
+var AGENT_REGISTRY, DEFAULT_AGENT;
+var init_registry = __esm({
+  "../core/dist/agents/registry.js"() {
+    "use strict";
+    AGENT_REGISTRY = {
+      "claude-code": {
+        shortName: "claude-code",
+        displayName: "Claude Code",
+        description: "Anthropic Claude Code via @agentclientprotocol/claude-agent-acp",
+        command: "npx",
+        args: ["-y", "@agentclientprotocol/claude-agent-acp"],
+        aliases: [
+          // The original Zed-scoped package is deprecated as of late 2026,
+          // but still very common in existing captures + IDE configs.
+          ["npx", "-y", "@zed-industries/claude-code-acp"]
+        ]
+      },
+      codex: {
+        shortName: "codex",
+        displayName: "Codex",
+        description: "OpenAI Codex via @zed-industries/codex-acp",
+        command: "npx",
+        args: ["-y", "@zed-industries/codex-acp"]
+      },
+      goose: {
+        shortName: "goose",
+        displayName: "Goose",
+        description: "Block Goose \u2014 install separately, then this runs `goose acp`",
+        command: "goose",
+        args: ["acp"],
+        requiresExternalInstall: true
+      },
+      opencode: {
+        shortName: "opencode",
+        displayName: "OpenCode",
+        description: "SST OpenCode \u2014 install via opencode.ai/install, then `opencode acp`",
+        command: "opencode",
+        args: ["acp"],
+        requiresExternalInstall: true
+      }
+    };
+    DEFAULT_AGENT = "claude-code";
+  }
+});
 
-// ../core/dist/proxy/proxy.js
-import { EventEmitter } from "events";
+// ../core/dist/agents/index.js
+var init_agents = __esm({
+  "../core/dist/agents/index.js"() {
+    "use strict";
+    init_registry();
+  }
+});
 
 // ../core/dist/proxy/subprocess.js
 import { spawn } from "child_process";
@@ -8304,164 +8520,101 @@ function spawnAgent(options) {
     kill: (signal = "SIGTERM") => child.kill(signal)
   };
 }
+var init_subprocess = __esm({
+  "../core/dist/proxy/subprocess.js"() {
+    "use strict";
+  }
+});
 
 // ../core/dist/proxy/proxy.js
-var AcpProxy = class extends EventEmitter {
-  options;
-  agent = null;
-  seq = 0;
-  editorFramer = new LineFramer();
-  agentFramer = new LineFramer();
-  constructor(options) {
-    super();
-    this.options = options;
-  }
-  on(event, listener) {
-    return super.on(event, listener);
-  }
-  async start() {
-    if (this.agent)
-      throw new Error("proxy already started");
-    const agent = spawnAgent(this.options);
-    this.agent = agent;
-    this.emit("started", { pid: agent.pid });
-    const editorIn = this.options.editorInput ?? process.stdin;
-    const editorOut = this.options.editorOutput ?? process.stdout;
-    const agentErr = this.options.agentErrorOutput === void 0 ? process.stderr : this.options.agentErrorOutput;
-    editorIn.on("data", (chunk) => {
-      this.capture("editor-to-agent", chunk);
-      agent.stdin.write(chunk);
-    });
-    editorIn.once("end", () => {
-      this.emit("editor-end");
-      agent.stdin.end();
-    });
-    editorIn.on("error", (err) => this.emit("error", err));
-    agent.stdout.on("data", (chunk) => {
-      this.capture("agent-to-editor", chunk);
-      editorOut.write(chunk);
-    });
-    agent.stdout.on("error", (err) => this.emit("error", err));
-    if (agentErr) {
-      agent.stderr.on("data", (chunk) => {
-        this.emit("agent-stderr", chunk);
-        agentErr.write(chunk);
-      });
-    }
-    agent.exited.then((info) => this.emit("agent-exit", info)).catch((err) => this.emit("error", err));
-  }
-  /** Wait for the underlying agent to exit. */
-  waitForExit() {
-    if (!this.agent)
-      throw new Error("proxy not started");
-    return this.agent.exited;
-  }
-  /** Send a signal to the agent. */
-  kill(signal = "SIGTERM") {
-    this.agent?.kill(signal);
-  }
-  capture(direction, chunk) {
-    const framer = direction === "editor-to-agent" ? this.editorFramer : this.agentFramer;
-    const frames = framer.feed(chunk);
-    for (const raw of frames) {
-      const parsed = parseFrame(raw);
-      const msg = {
-        seq: ++this.seq,
-        timestamp: Date.now(),
-        direction,
-        kind: parsed.kind,
-        raw,
-        payload: parsed.payload
-      };
-      if (parsed.method !== void 0)
-        msg.method = parsed.method;
-      if (parsed.rpcId !== void 0)
-        msg.rpcId = parsed.rpcId;
-      if (parsed.parseError !== void 0)
-        msg.parseError = parsed.parseError;
-      this.emit("message", msg);
-    }
+import { EventEmitter } from "events";
+var AcpProxy;
+var init_proxy = __esm({
+  "../core/dist/proxy/proxy.js"() {
+    "use strict";
+    init_parser();
+    init_subprocess();
+    AcpProxy = class extends EventEmitter {
+      options;
+      agent = null;
+      seq = 0;
+      editorFramer = new LineFramer();
+      agentFramer = new LineFramer();
+      constructor(options) {
+        super();
+        this.options = options;
+      }
+      on(event, listener) {
+        return super.on(event, listener);
+      }
+      async start() {
+        if (this.agent)
+          throw new Error("proxy already started");
+        const agent = spawnAgent(this.options);
+        this.agent = agent;
+        this.emit("started", { pid: agent.pid });
+        const editorIn = this.options.editorInput ?? process.stdin;
+        const editorOut = this.options.editorOutput ?? process.stdout;
+        const agentErr = this.options.agentErrorOutput === void 0 ? process.stderr : this.options.agentErrorOutput;
+        editorIn.on("data", (chunk) => {
+          this.capture("editor-to-agent", chunk);
+          agent.stdin.write(chunk);
+        });
+        editorIn.once("end", () => {
+          this.emit("editor-end");
+          agent.stdin.end();
+        });
+        editorIn.on("error", (err) => this.emit("error", err));
+        agent.stdout.on("data", (chunk) => {
+          this.capture("agent-to-editor", chunk);
+          editorOut.write(chunk);
+        });
+        agent.stdout.on("error", (err) => this.emit("error", err));
+        if (agentErr) {
+          agent.stderr.on("data", (chunk) => {
+            this.emit("agent-stderr", chunk);
+            agentErr.write(chunk);
+          });
+        }
+        agent.exited.then((info) => this.emit("agent-exit", info)).catch((err) => this.emit("error", err));
+      }
+      /** Wait for the underlying agent to exit. */
+      waitForExit() {
+        if (!this.agent)
+          throw new Error("proxy not started");
+        return this.agent.exited;
+      }
+      /** Send a signal to the agent. */
+      kill(signal = "SIGTERM") {
+        this.agent?.kill(signal);
+      }
+      capture(direction, chunk) {
+        const framer = direction === "editor-to-agent" ? this.editorFramer : this.agentFramer;
+        const frames = framer.feed(chunk);
+        for (const raw of frames) {
+          const parsed = parseFrame(raw);
+          const msg = {
+            seq: ++this.seq,
+            timestamp: Date.now(),
+            direction,
+            kind: parsed.kind,
+            raw,
+            payload: parsed.payload
+          };
+          if (parsed.method !== void 0)
+            msg.method = parsed.method;
+          if (parsed.rpcId !== void 0)
+            msg.rpcId = parsed.rpcId;
+          if (parsed.parseError !== void 0)
+            msg.parseError = parsed.parseError;
+          this.emit("message", msg);
+        }
+      }
+    };
   }
-};
+});
 
 // ../core/dist/proxy/playback.js
-var OUR_DIRECTION_FOR_ROLE = {
-  // mock-agent emits agent→editor and waits for editor→agent
-  agent: "agent-to-editor",
-  editor: "editor-to-agent"
-};
-var PlaybackEngine = class {
-  messages;
-  pointer = 0;
-  scriptIdToRealId = /* @__PURE__ */ new Map();
-  ourDirection;
-  constructor(messages, role) {
-    this.messages = messages;
-    this.ourDirection = OUR_DIRECTION_FOR_ROLE[role];
-  }
-  /**
-   * Advance through the script until either we have a line to EMIT, we
-   * need to WAIT for the other side, or the script is DONE. Notifications
-   * on our side are emitted immediately (no waiting).
-   */
-  next() {
-    while (this.pointer < this.messages.length) {
-      const msg = this.messages[this.pointer];
-      if (msg.direction === this.ourDirection) {
-        const prev = this.pointer > 0 ? this.messages[this.pointer - 1] : null;
-        const deltaSincePrevMs = prev ? Math.max(0, msg.timestamp - prev.timestamp) : 0;
-        this.pointer += 1;
-        return {
-          kind: "emit",
-          line: this.buildOutbound(msg),
-          message: msg,
-          deltaSincePrevMs
-        };
-      }
-      return { kind: "wait", expected: msg };
-    }
-    return { kind: "done" };
-  }
-  /**
-   * Record that the other side sent something the engine was WAITing for.
-   * Advances past the matching script frame; remembers the rpc_id mapping
-   * so any later response we emit can carry the wire's actual id.
-   *
-   * Returns `true` when an expected frame was consumed, `false` when there
-   * was nothing to consume (script already done or our turn) — caller can
-   * decide whether the off-script input is an error or just gets dropped.
-   */
-  onIncoming(line) {
-    if (this.pointer >= this.messages.length)
-      return false;
-    const msg = this.messages[this.pointer];
-    if (msg.direction === this.ourDirection)
-      return false;
-    const realId = extractRpcId(line);
-    if (msg.rpcId !== void 0 && msg.rpcId !== null && realId !== void 0) {
-      this.scriptIdToRealId.set(String(msg.rpcId), realId);
-    }
-    this.pointer += 1;
-    return true;
-  }
-  /** For tests / status output. */
-  get position() {
-    return this.pointer;
-  }
-  get exhausted() {
-    return this.pointer >= this.messages.length;
-  }
-  buildOutbound(msg) {
-    if (msg.kind !== "response" && msg.kind !== "error")
-      return msg.raw;
-    if (msg.rpcId === void 0 || msg.rpcId === null)
-      return msg.raw;
-    const realId = this.scriptIdToRealId.get(String(msg.rpcId));
-    if (realId === void 0)
-      return msg.raw;
-    return substituteRpcId(msg, realId);
-  }
-};
 function substituteRpcId(msg, realId) {
   if (!msg.payload)
     return msg.raw;
@@ -8478,47 +8631,103 @@ function extractRpcId(line) {
     return void 0;
   }
 }
+var OUR_DIRECTION_FOR_ROLE, PlaybackEngine;
+var init_playback = __esm({
+  "../core/dist/proxy/playback.js"() {
+    "use strict";
+    OUR_DIRECTION_FOR_ROLE = {
+      // mock-agent emits agent→editor and waits for editor→agent
+      agent: "agent-to-editor",
+      editor: "editor-to-agent"
+    };
+    PlaybackEngine = class {
+      messages;
+      pointer = 0;
+      scriptIdToRealId = /* @__PURE__ */ new Map();
+      ourDirection;
+      constructor(messages, role) {
+        this.messages = messages;
+        this.ourDirection = OUR_DIRECTION_FOR_ROLE[role];
+      }
+      /**
+       * Advance through the script until either we have a line to EMIT, we
+       * need to WAIT for the other side, or the script is DONE. Notifications
+       * on our side are emitted immediately (no waiting).
+       */
+      next() {
+        while (this.pointer < this.messages.length) {
+          const msg = this.messages[this.pointer];
+          if (msg.direction === this.ourDirection) {
+            const prev = this.pointer > 0 ? this.messages[this.pointer - 1] : null;
+            const deltaSincePrevMs = prev ? Math.max(0, msg.timestamp - prev.timestamp) : 0;
+            this.pointer += 1;
+            return {
+              kind: "emit",
+              line: this.buildOutbound(msg),
+              message: msg,
+              deltaSincePrevMs
+            };
+          }
+          return { kind: "wait", expected: msg };
+        }
+        return { kind: "done" };
+      }
+      /**
+       * Record that the other side sent something the engine was WAITing for.
+       * Advances past the matching script frame; remembers the rpc_id mapping
+       * so any later response we emit can carry the wire's actual id.
+       *
+       * Returns `true` when an expected frame was consumed, `false` when there
+       * was nothing to consume (script already done or our turn) — caller can
+       * decide whether the off-script input is an error or just gets dropped.
+       */
+      onIncoming(line) {
+        if (this.pointer >= this.messages.length)
+          return false;
+        const msg = this.messages[this.pointer];
+        if (msg.direction === this.ourDirection)
+          return false;
+        const realId = extractRpcId(line);
+        if (msg.rpcId !== void 0 && msg.rpcId !== null && realId !== void 0) {
+          this.scriptIdToRealId.set(String(msg.rpcId), realId);
+        }
+        this.pointer += 1;
+        return true;
+      }
+      /** For tests / status output. */
+      get position() {
+        return this.pointer;
+      }
+      get exhausted() {
+        return this.pointer >= this.messages.length;
+      }
+      buildOutbound(msg) {
+        if (msg.kind !== "response" && msg.kind !== "error")
+          return msg.raw;
+        if (msg.rpcId === void 0 || msg.rpcId === null)
+          return msg.raw;
+        const realId = this.scriptIdToRealId.get(String(msg.rpcId));
+        if (realId === void 0)
+          return msg.raw;
+        return substituteRpcId(msg, realId);
+      }
+    };
+  }
+});
+
+// ../core/dist/proxy/index.js
+var init_proxy2 = __esm({
+  "../core/dist/proxy/index.js"() {
+    "use strict";
+    init_proxy();
+    init_subprocess();
+    init_playback();
+  }
+});
 
 // ../core/dist/storage/sqlite.js
 import { chmodSync, existsSync, statSync } from "fs";
 import Database from "better-sqlite3";
-var SCHEMA_VERSION = 4;
-var SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS sessions (
-    id                       INTEGER PRIMARY KEY AUTOINCREMENT,
-    name                     TEXT,
-    agent_command            TEXT,
-    started_at               INTEGER NOT NULL,
-    ended_at                 INTEGER,
-    client_name              TEXT,
-    imported_at              INTEGER,
-    client_version           TEXT,
-    client_platform          TEXT,
-    agent_name               TEXT,
-    agent_version            TEXT,
-    protocol_version         INTEGER,
-    current_mode             TEXT,
-    current_model            TEXT,
-    agent_capabilities_json  TEXT
-);
-
-CREATE TABLE IF NOT EXISTS messages (
-    id           INTEGER PRIMARY KEY AUTOINCREMENT,
-    session_id   INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-    seq          INTEGER NOT NULL,
-    timestamp    INTEGER NOT NULL,
-    direction    TEXT    NOT NULL,
-    kind         TEXT    NOT NULL,
-    method       TEXT,
-    rpc_id       TEXT,
-    raw          TEXT    NOT NULL,
-    payload_json TEXT,
-    parse_error  TEXT
-);
-
-CREATE INDEX IF NOT EXISTS idx_messages_session_seq ON messages(session_id, seq);
-CREATE INDEX IF NOT EXISTS idx_messages_session_rpc ON messages(session_id, rpc_id);
-`;
 function hasColumn(db, table, column) {
   const cols = db.pragma(`table_info(${table})`);
   return cols.some((c) => c.name === column);
@@ -8575,13 +8784,55 @@ function openExistingDatabase(path) {
   }
   return openDatabase(path);
 }
+function getSchemaVersion(db) {
+  const row2 = db.pragma("user_version", { simple: true });
+  return typeof row2 === "number" ? row2 : Number(row2);
+}
+var SCHEMA_VERSION, SCHEMA_SQL;
+var init_sqlite = __esm({
+  "../core/dist/storage/sqlite.js"() {
+    "use strict";
+    SCHEMA_VERSION = 4;
+    SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS sessions (
+    id                       INTEGER PRIMARY KEY AUTOINCREMENT,
+    name                     TEXT,
+    agent_command            TEXT,
+    started_at               INTEGER NOT NULL,
+    ended_at                 INTEGER,
+    client_name              TEXT,
+    imported_at              INTEGER,
+    client_version           TEXT,
+    client_platform          TEXT,
+    agent_name               TEXT,
+    agent_version            TEXT,
+    protocol_version         INTEGER,
+    current_mode             TEXT,
+    current_model            TEXT,
+    agent_capabilities_json  TEXT
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id   INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+    seq          INTEGER NOT NULL,
+    timestamp    INTEGER NOT NULL,
+    direction    TEXT    NOT NULL,
+    kind         TEXT    NOT NULL,
+    method       TEXT,
+    rpc_id       TEXT,
+    raw          TEXT    NOT NULL,
+    payload_json TEXT,
+    parse_error  TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_session_seq ON messages(session_id, seq);
+CREATE INDEX IF NOT EXISTS idx_messages_session_rpc ON messages(session_id, rpc_id);
+`;
+  }
+});
 
 // ../core/dist/storage/session.js
-var SESSION_SELECT = `SELECT id, name, agent_command, started_at, ended_at,
-    client_name, imported_at, client_version, client_platform,
-    agent_name, agent_version, protocol_version, current_mode, current_model,
-    agent_capabilities_json
-    FROM sessions`;
 function rowToInfo(row2) {
   return {
     id: row2.id,
@@ -8622,84 +8873,94 @@ function parseRpcId(stored) {
   const asNum = Number(stored);
   return Number.isFinite(asNum) && String(asNum) === stored ? asNum : stored;
 }
-var Session = class _Session {
-  db;
-  info;
-  insertStmt;
-  endStmt;
-  listStmt;
-  constructor(db, info) {
-    this.db = db;
-    this.info = info;
-    this.insertStmt = db.prepare(`INSERT INTO messages (
+var SESSION_SELECT, Session;
+var init_session = __esm({
+  "../core/dist/storage/session.js"() {
+    "use strict";
+    init_session_metadata();
+    SESSION_SELECT = `SELECT id, name, agent_command, started_at, ended_at,
+    client_name, imported_at, client_version, client_platform,
+    agent_name, agent_version, protocol_version, current_mode, current_model,
+    agent_capabilities_json
+    FROM sessions`;
+    Session = class _Session {
+      db;
+      info;
+      insertStmt;
+      endStmt;
+      listStmt;
+      constructor(db, info) {
+        this.db = db;
+        this.info = info;
+        this.insertStmt = db.prepare(`INSERT INTO messages (
                 session_id, seq, timestamp, direction, kind,
                 method, rpc_id, raw, payload_json, parse_error
             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-    this.endStmt = db.prepare(`UPDATE sessions SET ended_at = ? WHERE id = ?`);
-    this.listStmt = db.prepare(`SELECT seq, timestamp, direction, kind, method, rpc_id, raw, payload_json, parse_error
+        this.endStmt = db.prepare(`UPDATE sessions SET ended_at = ? WHERE id = ?`);
+        this.listStmt = db.prepare(`SELECT seq, timestamp, direction, kind, method, rpc_id, raw, payload_json, parse_error
              FROM messages WHERE session_id = ? ORDER BY seq ASC`);
-  }
-  static start(db, options = {}) {
-    const startedAt = options.startedAt ?? Date.now();
-    const importedAt = options.importedAt ?? null;
-    const stmt = db.prepare(`INSERT INTO sessions (name, agent_command, started_at, imported_at) VALUES (?, ?, ?, ?)`);
-    const result = stmt.run(options.name ?? null, options.agentCommand ?? null, startedAt, importedAt);
-    const id = Number(result.lastInsertRowid);
-    return new _Session(db, {
-      id,
-      name: options.name ?? null,
-      agentCommand: options.agentCommand ?? null,
-      startedAt,
-      endedAt: null,
-      clientName: null,
-      importedAt,
-      clientVersion: null,
-      clientPlatform: null,
-      agentName: null,
-      agentVersion: null,
-      protocolVersion: null,
-      currentMode: null,
-      currentModel: null,
-      agentCapabilitiesJson: null
-    });
-  }
-  static load(db, sessionId) {
-    const row2 = db.prepare(`${SESSION_SELECT} WHERE id = ?`).get(sessionId);
-    if (!row2)
-      throw new Error(`session ${sessionId} not found`);
-    return new _Session(db, rowToInfo(row2));
-  }
-  static latest(db) {
-    const row2 = db.prepare(`${SESSION_SELECT} ORDER BY id DESC LIMIT 1`).get();
-    if (!row2)
-      throw new Error("database has no sessions");
-    return new _Session(db, rowToInfo(row2));
-  }
-  /**
-   * Persist a detected client name on the session row. Called once when the
-   * first `initialize` request is seen by the proxy. Subsequent calls
-   * overwrite — the latest title wins.
-   */
-  setClientName(name) {
-    this.db.prepare(`UPDATE sessions SET client_name = ? WHERE id = ?`).run(name, this.info.id);
-    this.info = { ...this.info, clientName: name };
-  }
-  /**
-   * Write the structured-metadata columns from a derived `SessionMetadata`.
-   * Used by:
-   * - The proxy on every metadata-relevant message (initialize, set_mode,
-   *   set_model, current_mode_update) so the UI's SessionPicker can label
-   *   `#21 · Zed 1.3.5 · claude-agent-acp 0.37.0` mid-session.
-   * - The `backfill-metadata` CLI command for pre-v4 / imported sessions.
-   *
-   * Idempotent — running on the same messages produces the same writes.
-   */
-  setMetadataFromMessages(messages) {
-    this.setMetadataFrom(extractSessionMetadata(messages));
-  }
-  setMetadataFrom(meta) {
-    const agentCapsJson = JSON.stringify(meta.agentCapabilities);
-    this.db.prepare(`UPDATE sessions SET
+      }
+      static start(db, options = {}) {
+        const startedAt = options.startedAt ?? Date.now();
+        const importedAt = options.importedAt ?? null;
+        const stmt = db.prepare(`INSERT INTO sessions (name, agent_command, started_at, imported_at) VALUES (?, ?, ?, ?)`);
+        const result = stmt.run(options.name ?? null, options.agentCommand ?? null, startedAt, importedAt);
+        const id = Number(result.lastInsertRowid);
+        return new _Session(db, {
+          id,
+          name: options.name ?? null,
+          agentCommand: options.agentCommand ?? null,
+          startedAt,
+          endedAt: null,
+          clientName: null,
+          importedAt,
+          clientVersion: null,
+          clientPlatform: null,
+          agentName: null,
+          agentVersion: null,
+          protocolVersion: null,
+          currentMode: null,
+          currentModel: null,
+          agentCapabilitiesJson: null
+        });
+      }
+      static load(db, sessionId) {
+        const row2 = db.prepare(`${SESSION_SELECT} WHERE id = ?`).get(sessionId);
+        if (!row2)
+          throw new Error(`session ${sessionId} not found`);
+        return new _Session(db, rowToInfo(row2));
+      }
+      static latest(db) {
+        const row2 = db.prepare(`${SESSION_SELECT} ORDER BY id DESC LIMIT 1`).get();
+        if (!row2)
+          throw new Error("database has no sessions");
+        return new _Session(db, rowToInfo(row2));
+      }
+      /**
+       * Persist a detected client name on the session row. Called once when the
+       * first `initialize` request is seen by the proxy. Subsequent calls
+       * overwrite — the latest title wins.
+       */
+      setClientName(name) {
+        this.db.prepare(`UPDATE sessions SET client_name = ? WHERE id = ?`).run(name, this.info.id);
+        this.info = { ...this.info, clientName: name };
+      }
+      /**
+       * Write the structured-metadata columns from a derived `SessionMetadata`.
+       * Used by:
+       * - The proxy on every metadata-relevant message (initialize, set_mode,
+       *   set_model, current_mode_update) so the UI's SessionPicker can label
+       *   `#21 · Zed 1.3.5 · claude-agent-acp 0.37.0` mid-session.
+       * - The `backfill-metadata` CLI command for pre-v4 / imported sessions.
+       *
+       * Idempotent — running on the same messages produces the same writes.
+       */
+      setMetadataFromMessages(messages) {
+        this.setMetadataFrom(extractSessionMetadata(messages));
+      }
+      setMetadataFrom(meta) {
+        const agentCapsJson = JSON.stringify(meta.agentCapabilities);
+        this.db.prepare(`UPDATE sessions SET
                     client_version = ?,
                     client_platform = ?,
                     agent_name = ?,
@@ -8709,34 +8970,35 @@ var Session = class _Session {
                     current_model = ?,
                     agent_capabilities_json = ?
                 WHERE id = ?`).run(meta.client.version, meta.client.platform, meta.agent.name, meta.agent.version, meta.protocolVersion, meta.runtime.currentMode, meta.runtime.currentModel, agentCapsJson, this.info.id);
-    this.info = {
-      ...this.info,
-      clientVersion: meta.client.version,
-      clientPlatform: meta.client.platform,
-      agentName: meta.agent.name,
-      agentVersion: meta.agent.version,
-      protocolVersion: meta.protocolVersion,
-      currentMode: meta.runtime.currentMode,
-      currentModel: meta.runtime.currentModel,
-      agentCapabilitiesJson: agentCapsJson
+        this.info = {
+          ...this.info,
+          clientVersion: meta.client.version,
+          clientPlatform: meta.client.platform,
+          agentName: meta.agent.name,
+          agentVersion: meta.agent.version,
+          protocolVersion: meta.protocolVersion,
+          currentMode: meta.runtime.currentMode,
+          currentModel: meta.runtime.currentModel,
+          agentCapabilitiesJson: agentCapsJson
+        };
+      }
+      record(message) {
+        this.insertStmt.run(this.info.id, message.seq, message.timestamp, message.direction, message.kind, message.method ?? null, message.rpcId === void 0 || message.rpcId === null ? null : String(message.rpcId), message.raw, message.payload ? JSON.stringify(message.payload) : null, message.parseError ?? null);
+      }
+      close(endedAt = Date.now()) {
+        this.endStmt.run(endedAt, this.info.id);
+        this.info = { ...this.info, endedAt };
+      }
+      *messages() {
+        for (const row2 of this.listStmt.iterate(this.info.id)) {
+          yield rowToMessage(row2);
+        }
+      }
     };
   }
-  record(message) {
-    this.insertStmt.run(this.info.id, message.seq, message.timestamp, message.direction, message.kind, message.method ?? null, message.rpcId === void 0 || message.rpcId === null ? null : String(message.rpcId), message.raw, message.payload ? JSON.stringify(message.payload) : null, message.parseError ?? null);
-  }
-  close(endedAt = Date.now()) {
-    this.endStmt.run(endedAt, this.info.id);
-    this.info = { ...this.info, endedAt };
-  }
-  *messages() {
-    for (const row2 of this.listStmt.iterate(this.info.id)) {
-      yield rowToMessage(row2);
-    }
-  }
-};
+});
 
 // ../core/dist/storage/export.js
-var EXPORT_VERSION = 1;
 function exportSession(session, options) {
   return exportSessionFromParts(session.info, session.messages(), options);
 }
@@ -8759,12 +9021,6 @@ function exportSessionFromParts(info, messages, options) {
 function serializeExport(exp, indent = 4) {
   return JSON.stringify(exp, null, indent) + "\n";
 }
-var ExportParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ExportParseError";
-  }
-};
 function parseExport(input) {
   let raw;
   try {
@@ -8866,22 +9122,21 @@ function parseMessage(raw, idx) {
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+var EXPORT_VERSION, ExportParseError;
+var init_export = __esm({
+  "../core/dist/storage/export.js"() {
+    "use strict";
+    EXPORT_VERSION = 1;
+    ExportParseError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ExportParseError";
+      }
+    };
+  }
+});
 
 // ../core/dist/storage/redact.js
-var REDACTED_PLACEHOLDER = "<REDACTED>";
-var SENSITIVE_HEADER_NAMES = /* @__PURE__ */ new Set([
-  "authorization",
-  "proxy-authorization",
-  "proxy-authentication",
-  "x-api-key",
-  "x-api-token",
-  "x-auth-token",
-  "api-key",
-  "api_key",
-  "proxy_key",
-  "cookie",
-  "set-cookie"
-]);
 function redactMessage(message) {
   if (message.payload == null) {
     return { redacted: message, count: 0 };
@@ -8968,110 +9223,171 @@ function redactSessionExport(exp) {
     fieldsRedacted
   };
 }
+var REDACTED_PLACEHOLDER, SENSITIVE_HEADER_NAMES;
+var init_redact = __esm({
+  "../core/dist/storage/redact.js"() {
+    "use strict";
+    REDACTED_PLACEHOLDER = "<REDACTED>";
+    SENSITIVE_HEADER_NAMES = /* @__PURE__ */ new Set([
+      "authorization",
+      "proxy-authorization",
+      "proxy-authentication",
+      "x-api-key",
+      "x-api-token",
+      "x-auth-token",
+      "api-key",
+      "api_key",
+      "proxy_key",
+      "cookie",
+      "set-cookie"
+    ]);
+  }
+});
+
+// ../core/dist/storage/index.js
+var init_storage = __esm({
+  "../core/dist/storage/index.js"() {
+    "use strict";
+    init_sqlite();
+    init_session();
+    init_export();
+    init_redact();
+  }
+});
+
+// ../core/dist/ws/events.js
+var WS_PROTOCOL_VERSION;
+var init_events = __esm({
+  "../core/dist/ws/events.js"() {
+    "use strict";
+    WS_PROTOCOL_VERSION = 1;
+  }
+});
 
 // ../core/dist/ws/server.js
 import { WebSocketServer } from "ws";
-var WsBroadcaster = class {
-  options;
-  server = null;
-  session = null;
-  messages = [];
-  sessionEnded = false;
-  constructor(options) {
-    this.options = options;
-  }
-  /** Start the server. Resolves when it is listening; rejects on bind errors. */
-  start() {
-    if (this.server)
-      throw new Error("broadcaster already started");
-    return new Promise((resolve2, reject) => {
-      const host = this.options.host ?? "127.0.0.1";
-      const wss = new WebSocketServer({ host, port: this.options.port });
-      this.server = wss;
-      const onError = (err) => reject(err);
-      wss.once("error", onError);
-      wss.once("listening", () => {
-        wss.off("error", onError);
-        wss.on("error", () => void 0);
-        wss.on("connection", (ws) => this.onConnection(ws));
-        const address = wss.address();
-        resolve2({ port: address.port, url: `ws://${host}:${address.port}` });
-      });
-    });
+var WsBroadcaster;
+var init_server = __esm({
+  "../core/dist/ws/server.js"() {
+    "use strict";
+    WsBroadcaster = class {
+      options;
+      server = null;
+      session = null;
+      messages = [];
+      sessionEnded = false;
+      constructor(options) {
+        this.options = options;
+      }
+      /** Start the server. Resolves when it is listening; rejects on bind errors. */
+      start() {
+        if (this.server)
+          throw new Error("broadcaster already started");
+        return new Promise((resolve2, reject) => {
+          const host = this.options.host ?? "127.0.0.1";
+          const wss = new WebSocketServer({ host, port: this.options.port });
+          this.server = wss;
+          const onError = (err) => reject(err);
+          wss.once("error", onError);
+          wss.once("listening", () => {
+            wss.off("error", onError);
+            wss.on("error", () => void 0);
+            wss.on("connection", (ws) => this.onConnection(ws));
+            const address = wss.address();
+            resolve2({ port: address.port, url: `ws://${host}:${address.port}` });
+          });
+        });
+      }
+      async stop() {
+        const wss = this.server;
+        if (!wss)
+          return;
+        this.server = null;
+        for (const client of wss.clients)
+          client.close(1e3, "shutdown");
+        await Promise.race([
+          new Promise((resolve2) => wss.close(() => resolve2())),
+          new Promise((resolve2) => setTimeout(resolve2, 500))
+        ]);
+        for (const client of wss.clients)
+          client.terminate();
+      }
+      publishSessionStart(session) {
+        this.session = session;
+        this.messages = [];
+        this.sessionEnded = false;
+        this.broadcast({ type: "session.start", session });
+      }
+      publishMessage(message) {
+        if (!this.session) {
+          throw new Error("publishMessage called before publishSessionStart");
+        }
+        this.messages.push(message);
+        this.broadcast({ type: "message", message });
+      }
+      publishSessionEnd(session) {
+        this.session = session;
+        this.sessionEnded = true;
+        this.broadcast({ type: "session.end", session });
+      }
+      /**
+       * Pre-load a finished session for the replay command. Must be called before
+       * clients connect; live `publish*` calls afterwards are not supported.
+       */
+      loadHistory(session, messages) {
+        this.session = session;
+        this.messages = [...messages];
+        this.sessionEnded = session.endedAt !== null;
+      }
+      onConnection(ws) {
+        if (this.session) {
+          this.send(ws, { type: "session.start", session: this.session });
+          for (const m of this.messages) {
+            this.send(ws, { type: "message", message: m });
+          }
+          this.send(ws, { type: "replay.done" });
+          if (this.sessionEnded) {
+            this.send(ws, { type: "session.end", session: this.session });
+          }
+        }
+      }
+      broadcast(event) {
+        const wss = this.server;
+        if (!wss)
+          return;
+        const data = JSON.stringify(event);
+        for (const client of wss.clients) {
+          if (client.readyState === 1)
+            client.send(data);
+        }
+      }
+      send(ws, event) {
+        ws.send(JSON.stringify(event));
+      }
+    };
   }
-  async stop() {
-    const wss = this.server;
-    if (!wss)
-      return;
-    this.server = null;
-    for (const client of wss.clients)
-      client.close(1e3, "shutdown");
-    await Promise.race([
-      new Promise((resolve2) => wss.close(() => resolve2())),
-      new Promise((resolve2) => setTimeout(resolve2, 500))
-    ]);
-    for (const client of wss.clients)
-      client.terminate();
-  }
-  publishSessionStart(session) {
-    this.session = session;
-    this.messages = [];
-    this.sessionEnded = false;
-    this.broadcast({ type: "session.start", session });
-  }
-  publishMessage(message) {
-    if (!this.session) {
-      throw new Error("publishMessage called before publishSessionStart");
-    }
-    this.messages.push(message);
-    this.broadcast({ type: "message", message });
-  }
-  publishSessionEnd(session) {
-    this.session = session;
-    this.sessionEnded = true;
-    this.broadcast({ type: "session.end", session });
-  }
-  /**
-   * Pre-load a finished session for the replay command. Must be called before
-   * clients connect; live `publish*` calls afterwards are not supported.
-   */
-  loadHistory(session, messages) {
-    this.session = session;
-    this.messages = [...messages];
-    this.sessionEnded = session.endedAt !== null;
-  }
-  onConnection(ws) {
-    if (this.session) {
-      this.send(ws, { type: "session.start", session: this.session });
-      for (const m of this.messages) {
-        this.send(ws, { type: "message", message: m });
-      }
-      this.send(ws, { type: "replay.done" });
-      if (this.sessionEnded) {
-        this.send(ws, { type: "session.end", session: this.session });
-      }
-    }
-  }
-  broadcast(event) {
-    const wss = this.server;
-    if (!wss)
-      return;
-    const data = JSON.stringify(event);
-    for (const client of wss.clients) {
-      if (client.readyState === 1)
-        client.send(data);
-    }
+});
+
+// ../core/dist/ws/index.js
+var init_ws = __esm({
+  "../core/dist/ws/index.js"() {
+    "use strict";
+    init_events();
+    init_server();
   }
-  send(ws, event) {
-    ws.send(JSON.stringify(event));
+});
+
+// ../core/dist/discovery/types.js
+var init_types2 = __esm({
+  "../core/dist/discovery/types.js"() {
+    "use strict";
   }
-};
+});
 
 // ../core/dist/discovery/registry.js
 import { mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-var DEFAULT_BASE = join(homedir(), ".acp-devtools");
 function discoveryBaseDir() {
   return process.env.ACP_DEVTOOLS_HOME ?? DEFAULT_BASE;
 }
@@ -9144,6 +9460,22 @@ function listActive(options = {}) {
   out.sort((a, b) => b.startedAt - a.startedAt);
   return out;
 }
+var DEFAULT_BASE;
+var init_registry2 = __esm({
+  "../core/dist/discovery/registry.js"() {
+    "use strict";
+    DEFAULT_BASE = join(homedir(), ".acp-devtools");
+  }
+});
+
+// ../core/dist/discovery/index.js
+var init_discovery = __esm({
+  "../core/dist/discovery/index.js"() {
+    "use strict";
+    init_types2();
+    init_registry2();
+  }
+});
 
 // ../core/dist/server/paths.js
 import { homedir as homedir2 } from "os";
@@ -9154,13 +9486,31 @@ function acpHomeDir() {
 function defaultCapturesDbPath() {
   return join2(acpHomeDir(), "captures.db");
 }
+var init_paths = __esm({
+  "../core/dist/server/paths.js"() {
+    "use strict";
+  }
+});
 
 // ../core/dist/server/queries.js
 import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
 import { dirname } from "path";
-function listSessionsSummary(dbPath, limit = 200) {
+function listSessionsSummary(dbPath, limit = 200, filters = {}) {
   if (!existsSync2(dbPath))
     return [];
+  const where = [];
+  const params = [];
+  if (filters.imported === true)
+    where.push("s.imported_at IS NOT NULL");
+  if (filters.imported === false)
+    where.push("s.imported_at IS NULL");
+  if (filters.client) {
+    where.push(`(instr(lower(coalesce(s.client_name, '')), ?)
+              + instr(lower(coalesce(s.client_version, '')), ?)
+              + instr(lower(coalesce(s.client_platform, '')), ?)) > 0`);
+    const needle = filters.client.toLowerCase();
+    params.push(needle, needle, needle);
+  }
   const db = openDatabase(dbPath);
   try {
     return db.prepare(
@@ -9177,22 +9527,16 @@ function listSessionsSummary(dbPath, limit = 200) {
                     s.current_mode, s.current_model,
                     (SELECT COUNT(*) FROM messages WHERE session_id = s.id) AS message_count
                  FROM sessions s
+                 ${where.length > 0 ? `WHERE ${where.join(" AND ")}` : ""}
                  ORDER BY COALESCE(s.imported_at, s.started_at) DESC
                  LIMIT ?`
-    ).all(limit);
+    ).all(...params, limit);
   } finally {
     db.close();
   }
 }
-var FIND_BY_CLIENT_POOL_SIZE = 500;
 function findSessionsByClient(dbPath, needle, limit = 200) {
-  const pool = listSessionsSummary(dbPath, FIND_BY_CLIENT_POOL_SIZE);
-  const lower = needle.toLowerCase();
-  const matches = pool.filter((s) => {
-    const candidates = [s.client_name, s.client_version, s.client_platform].filter((v) => typeof v === "string");
-    return candidates.some((c) => c.toLowerCase().includes(lower));
-  });
-  return matches.slice(0, limit);
+  return listSessionsSummary(dbPath, limit, { client: needle });
 }
 function insertImportedSession(dbPath, exp, options = {}) {
   mkdirSync2(dirname(dbPath), { recursive: true });
@@ -9232,17 +9576,16 @@ function deleteSession(dbPath, sessionId) {
     db.close();
   }
 }
+var init_queries = __esm({
+  "../core/dist/server/queries.js"() {
+    "use strict";
+    init_session();
+    init_sqlite();
+  }
+});
 
 // ../core/dist/server/replay.js
 import { existsSync as existsSync3 } from "fs";
-var DEFAULT_LOGGER = {
-  log: (message) => {
-    console.log(message);
-  },
-  warn: (message, err) => {
-    console.warn(message, err);
-  }
-};
 function streamReplay(ws, sessionId, dbPath, logger = DEFAULT_LOGGER) {
   const tag = `[replay #${sessionId}]`;
   if (!existsSync3(dbPath)) {
@@ -9315,14 +9658,56 @@ function safeClose(ws) {
   } catch {
   }
 }
+var DEFAULT_LOGGER;
+var init_replay = __esm({
+  "../core/dist/server/replay.js"() {
+    "use strict";
+    init_session();
+    init_sqlite();
+    DEFAULT_LOGGER = {
+      log: (message) => {
+        console.log(message);
+      },
+      warn: (message, err) => {
+        console.warn(message, err);
+      }
+    };
+  }
+});
 
 // ../core/dist/server/http.js
 import { existsSync as existsSync4 } from "fs";
 import { WebSocketServer as WebSocketServer2 } from "ws";
+function stripPort(host) {
+  if (host.startsWith("[")) {
+    const end = host.indexOf("]");
+    return end === -1 ? host : host.slice(1, end);
+  }
+  const colon = host.lastIndexOf(":");
+  if (colon !== -1 && host.indexOf(":") === colon)
+    return host.slice(0, colon);
+  return host;
+}
+function isAllowedHost(hostHeader, allowedHosts = []) {
+  if (allowedHosts.some((h) => WILDCARD_BINDS.has(h)))
+    return true;
+  if (typeof hostHeader !== "string" || hostHeader.length === 0)
+    return false;
+  const host = stripPort(hostHeader.trim()).toLowerCase();
+  if (LOOPBACK_HOSTS.has(host))
+    return true;
+  return allowedHosts.some((h) => stripPort(h).toLowerCase() === host);
+}
 function createApiHandler(options) {
   return (req, res) => {
     const url = req.url ?? "";
-    const path = url.split("?")[0];
+    const path = url.split("?")[0] ?? "";
+    if (path.startsWith("/api/") && !isAllowedHost(req.headers.host, options.allowedHosts)) {
+      res.statusCode = 403;
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ error: "forbidden host" }));
+      return true;
+    }
     if (path === "/api/active") {
       handleActive(req, res);
       return true;
@@ -9460,7 +9845,6 @@ function handleSessionMessages(req, res, dbPath, sessionId) {
     db.close();
   }
 }
-var IMPORT_MAX_BYTES = 64 * 1024 * 1024;
 function handleImport(req, res, dbPath) {
   if (req.method !== "POST") {
     res.statusCode = 405;
@@ -9534,15 +9918,126 @@ function attachReplayUpgrade(httpServer, options) {
     const match = url.match(/^\/replay\/(\d+)/);
     if (!match)
       return;
+    if (!isAllowedHost(req.headers.host, options.allowedHosts)) {
+      socket.write("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+      socket.destroy();
+      return;
+    }
     const sessionId = Number(match[1]);
     wss.handleUpgrade(req, socket, head, (ws) => {
       streamReplay(ws, sessionId, options.capturesDbPath);
     });
   });
 }
+var LOOPBACK_HOSTS, WILDCARD_BINDS, IMPORT_MAX_BYTES;
+var init_http = __esm({
+  "../core/dist/server/http.js"() {
+    "use strict";
+    init_registry2();
+    init_export();
+    init_session();
+    init_sqlite();
+    init_queries();
+    init_replay();
+    LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
+    WILDCARD_BINDS = /* @__PURE__ */ new Set(["0.0.0.0", "::", "*"]);
+    IMPORT_MAX_BYTES = 64 * 1024 * 1024;
+  }
+});
 
-// src/program.ts
-import { Command } from "commander";
+// ../core/dist/server/index.js
+var init_server2 = __esm({
+  "../core/dist/server/index.js"() {
+    "use strict";
+    init_paths();
+    init_queries();
+    init_replay();
+    init_http();
+  }
+});
+
+// ../core/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  AGENT_METHODS: () => AGENT_METHODS,
+  AGENT_REGISTRY: () => AGENT_REGISTRY,
+  AcpProxy: () => AcpProxy,
+  CLIENT_METHODS: () => CLIENT_METHODS,
+  DEFAULT_AGENT: () => DEFAULT_AGENT,
+  EXPORT_VERSION: () => EXPORT_VERSION,
+  ExportParseError: () => ExportParseError,
+  LineFramer: () => LineFramer,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  PlaybackEngine: () => PlaybackEngine,
+  REDACTED_PLACEHOLDER: () => REDACTED_PLACEHOLDER,
+  SCHEMA_VERSION: () => SCHEMA_VERSION,
+  Session: () => Session,
+  WS_PROTOCOL_VERSION: () => WS_PROTOCOL_VERSION,
+  WsBroadcaster: () => WsBroadcaster,
+  acpHomeDir: () => acpHomeDir,
+  activeDir: () => activeDir,
+  asciiSparkline: () => asciiSparkline,
+  attachReplayUpgrade: () => attachReplayUpgrade,
+  buildMetadataDiff: () => buildMetadataDiff,
+  buildMethodStatsDiff: () => buildMethodStatsDiff,
+  buildPairIndex: () => buildPairIndex,
+  buildPerMethodStats: () => buildPerMethodStats,
+  buildPerformanceInsights: () => buildPerformanceInsights,
+  buildSessionDiff: () => buildSessionDiff,
+  buildTimelineLayout: () => buildTimelineLayout,
+  createApiHandler: () => createApiHandler,
+  defaultCapturesDbPath: () => defaultCapturesDbPath,
+  deleteSession: () => deleteSession,
+  detectAgentShortcut: () => detectAgentShortcut,
+  diffJson: () => diffJson,
+  discoveryBaseDir: () => discoveryBaseDir,
+  exportSession: () => exportSession,
+  exportSessionFromParts: () => exportSessionFromParts,
+  extractRpcId: () => extractRpcId,
+  extractSessionMetadata: () => extractSessionMetadata,
+  extractTextPreview: () => extractTextPreview,
+  findSessionsByClient: () => findSessionsByClient,
+  getSchemaVersion: () => getSchemaVersion,
+  insertImportedSession: () => insertImportedSession,
+  isAgentShortcut: () => isAgentShortcut,
+  isPidAlive: () => isPidAlive,
+  isUserPrompt: () => isUserPrompt,
+  knownAcpMethods: () => knownAcpMethods,
+  knownAcpSpecMethods: () => knownAcpSpecMethods,
+  listActive: () => listActive,
+  listAgents: () => listAgents,
+  listSessionsSummary: () => listSessionsSummary,
+  mean: () => mean,
+  openDatabase: () => openDatabase,
+  openExistingDatabase: () => openExistingDatabase,
+  parseExport: () => parseExport,
+  parseFrame: () => parseFrame,
+  percentile: () => percentile,
+  redactMessage: () => redactMessage,
+  redactSessionExport: () => redactSessionExport,
+  removeActiveFile: () => removeActiveFile,
+  resolveAgent: () => resolveAgent,
+  resolveSpecForMessage: () => resolveSpecForMessage,
+  sampleEvenly: () => sampleEvenly,
+  serializeExport: () => serializeExport,
+  spawnAgent: () => spawnAgent,
+  streamReplay: () => streamReplay,
+  substituteRpcId: () => substituteRpcId,
+  validateAcpMessage: () => validateAcpMessage,
+  writeActiveFile: () => writeActiveFile
+});
+var init_dist = __esm({
+  "../core/dist/index.js"() {
+    "use strict";
+    init_acp();
+    init_agents();
+    init_proxy2();
+    init_storage();
+    init_ws();
+    init_discovery();
+    init_server2();
+  }
+});
 
 // src/commands/backfill-metadata.ts
 function backfillSession(db, id) {
@@ -9580,8 +10075,8 @@ function listSessionIds(db) {
   const rows = db.prepare(`SELECT id FROM sessions ORDER BY id ASC`).all();
   return rows.map((r) => r.id);
 }
-function registerBackfillMetadataCommand(program2) {
-  program2.command("backfill-metadata").description(
+function registerBackfillMetadataCommand(program) {
+  program.command("backfill-metadata").description(
     "Recompute structured session metadata (client/agent/runtime) for saved sessions by re-scanning their captured messages. Used for sessions that pre-date the v4 schema or were imported from JSON."
   ).argument("[id]", "backfill a single session only (default: all)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--json", "machine-readable JSON output").action((idArg, opts) => {
     let targetId = null;
@@ -9627,11 +10122,17 @@ function registerBackfillMetadataCommand(program2) {
     }
   });
 }
+var init_backfill_metadata = __esm({
+  "src/commands/backfill-metadata.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
 
 // src/commands/delete.ts
 import { existsSync as existsSync5 } from "fs";
-function registerDeleteCommand(program2) {
-  program2.command("delete").description(
+function registerDeleteCommand(program) {
+  program.command("delete").description(
     "Delete one or more saved sessions from the captures database forever. Cascades to messages via the schema. No interactive prompt \u2014 pair with `acp-devtools list` to verify ids before invoking."
   ).argument("<id...>", "one or more session ids to delete").option("--db <path>", "captures database", defaultCapturesDbPath()).action((rawIds, opts) => {
     const ids = [];
@@ -9679,23 +10180,14 @@ function labelFor(s) {
   if (s.client_name) return s.client_name;
   return s.agent_command ?? "";
 }
+var init_delete = __esm({
+  "src/commands/delete.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
 
 // src/lib/style.ts
-var ESC = String.fromCharCode(27);
-var CODES = {
-  reset: 0,
-  bold: 1,
-  dim: 2,
-  italic: 3,
-  underline: 4,
-  red: 31,
-  green: 32,
-  yellow: 33,
-  blue: 34,
-  magenta: 35,
-  cyan: 36,
-  gray: 90
-};
 function colorEnabled(stream = process.stdout, env = process.env) {
   if (env.FORCE_COLOR === "0" || env.FORCE_COLOR === "false") return false;
   if (env.FORCE_COLOR !== void 0) return true;
@@ -9723,13 +10215,34 @@ function createStyler(enabled = colorEnabled()) {
     gray: wrap("gray")
   };
 }
-var ANSI_PATTERN = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
 function stripAnsi(s) {
   return s.replace(ANSI_PATTERN, "");
 }
 function visibleWidth(s) {
   return stripAnsi(s).length;
 }
+var ESC, CODES, ANSI_PATTERN;
+var init_style = __esm({
+  "src/lib/style.ts"() {
+    "use strict";
+    ESC = String.fromCharCode(27);
+    CODES = {
+      reset: 0,
+      bold: 1,
+      dim: 2,
+      italic: 3,
+      underline: 4,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      gray: 90
+    };
+    ANSI_PATTERN = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
+  }
+});
 
 // src/lib/palette.ts
 function colorKind(s, kind, text) {
@@ -9758,6 +10271,11 @@ function colorLatency(s, ms, text) {
 function colorSessionKind(s, imported, text) {
   return imported ? s.yellow(text) : s.green(text);
 }
+var init_palette = __esm({
+  "src/lib/palette.ts"() {
+    "use strict";
+  }
+});
 
 // src/lib/table.ts
 function renderTable(s, columns, rows, opts = {}) {
@@ -9792,12 +10310,22 @@ function renderTable(s, columns, rows, opts = {}) {
   }
   return out.map((l) => l + "\n").join("");
 }
+var init_table = __esm({
+  "src/lib/table.ts"() {
+    "use strict";
+    init_style();
+  }
+});
 
 // src/commands/diff.ts
-function registerDiffCommand(program2) {
-  program2.command("diff").description(
+function registerDiffCommand(program) {
+  program.command("diff").description(
     'Align two saved sessions and show what changed between them \u2014 added / removed frames and field-level payload differences. Useful for "worked yesterday, broke today" and A/B comparisons of two agents on the same prompt.'
-  ).argument("<a>", "baseline session id (left side)").argument("<b>", "new session id (right side)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--full", "print unchanged frames too (default collapses equal runs)").option("--json", "machine-readable JSON instead of human-readable text").action((rawA, rawB, opts) => {
+  ).argument("<a>", "baseline session id (left side)").argument("<b>", "new session id (right side)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--full", "print unchanged frames too (default collapses equal runs)").option("--json", "machine-readable JSON instead of human-readable text").option(
+    "--raw",
+    "skip default redaction of auth headers / proxy tokens (use only when the output stays on YOUR machine)",
+    false
+  ).action((rawA, rawB, opts) => {
     const idA = parseId(rawA);
     const idB = parseId(rawB);
     let db;
@@ -9828,6 +10356,32 @@ function registerDiffCommand(program2) {
       process.exit(1);
     }
     db.close();
+    let fieldsRedacted = 0;
+    let messagesAffected = 0;
+    if (!opts.raw) {
+      const redactAll = (msgs) => msgs.map((m) => {
+        const r = redactMessage(m);
+        if (r.count > 0) {
+          messagesAffected += 1;
+          fieldsRedacted += r.count;
+        }
+        return r.redacted;
+      });
+      msgsA = redactAll(msgsA);
+      msgsB = redactAll(msgsB);
+    }
+    const writeRedactionNote = () => {
+      if (opts.raw) {
+        process.stderr.write(
+          "acp-devtools: --raw was set; output may contain auth headers / proxy tokens \u2014 do not share publicly\n"
+        );
+      } else if (fieldsRedacted > 0) {
+        process.stderr.write(
+          `acp-devtools: redacted ${fieldsRedacted} field(s) across ${messagesAffected} message(s) \u2014 re-run with --raw to compare live values
+`
+        );
+      }
+    };
     const diff = buildSessionDiff(msgsA, msgsB);
     const meta = buildMetadataDiff(msgsA, msgsB);
     const perf = buildMethodStatsDiff(msgsA, msgsB);
@@ -9846,24 +10400,19 @@ function registerDiffCommand(program2) {
           2
         ) + "\n"
       );
+      writeRedactionNote();
       return;
     }
     const st = createStyler(colorEnabled(process.stdout));
     process.stdout.write(
       renderDiff(infoA, infoB, msgsA.length, msgsB.length, diff, meta, perf, Boolean(opts.full), st)
     );
+    writeRedactionNote();
   });
 }
-var defaultStyler = () => createStyler(colorEnabled(process.stdout));
 function heading(st, label) {
   return st.bold(st.yellow(label));
 }
-var OP_COLOR = {
-  equal: (st, t) => st.dim(t),
-  changed: (st, t) => st.yellow(t),
-  added: (st, t) => st.green(t),
-  removed: (st, t) => st.red(t)
-};
 function parseId(raw) {
   const id = Number(raw);
   if (!Number.isInteger(id) || id <= 0) {
@@ -9887,19 +10436,6 @@ function shortLabel(info) {
   if (bits.length === 0 && info.name) bits.push(info.name);
   return bits.join(" \xB7 ") || "\u2014";
 }
-var KIND_LABEL = {
-  request: "REQ",
-  response: "RSP",
-  notification: "NTF",
-  error: "ERR",
-  unknown: "UNK"
-};
-var OP_MARKER = {
-  equal: "=",
-  changed: "\u2260",
-  added: "\u25B8",
-  removed: "\u25C2"
-};
 function dirArrow(m) {
   return m.direction === "editor-to-agent" ? "\u2192A" : "A\u2190";
 }
@@ -9976,7 +10512,6 @@ function renderInfoSection(meta, st = defaultStyler()) {
   }
   return lines.join("");
 }
-var PERF_METHOD_MAX = 40;
 function colorDelta(st, ms) {
   if (ms == null) return st.dim("\u2014");
   const text = signedLatency(ms);
@@ -10020,7 +10555,6 @@ function signedLatency(ms) {
   const sign = ms > 0 ? "+" : "\u2212";
   return sign + formatLatency(Math.abs(ms));
 }
-var VALUE_MAX = 60;
 function fmtValue(v) {
   let s;
   try {
@@ -10033,17 +10567,43 @@ function fmtValue(v) {
   if (s.length > VALUE_MAX) s = s.slice(0, VALUE_MAX - 1) + "\u2026";
   return s;
 }
+var defaultStyler, OP_COLOR, KIND_LABEL, OP_MARKER, PERF_METHOD_MAX, VALUE_MAX;
+var init_diff = __esm({
+  "src/commands/diff.ts"() {
+    "use strict";
+    init_dist();
+    init_style();
+    init_palette();
+    init_table();
+    defaultStyler = () => createStyler(colorEnabled(process.stdout));
+    OP_COLOR = {
+      equal: (st, t) => st.dim(t),
+      changed: (st, t) => st.yellow(t),
+      added: (st, t) => st.green(t),
+      removed: (st, t) => st.red(t)
+    };
+    KIND_LABEL = {
+      request: "REQ",
+      response: "RSP",
+      notification: "NTF",
+      error: "ERR",
+      unknown: "UNK"
+    };
+    OP_MARKER = {
+      equal: "=",
+      changed: "\u2260",
+      added: "\u25B8",
+      removed: "\u25C2"
+    };
+    PERF_METHOD_MAX = 40;
+    VALUE_MAX = 60;
+  }
+});
 
 // src/commands/doctor.ts
 import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { homedir as homedir3, platform, release } from "os";
 import { join as join3 } from "path";
-var STATUS_MARK = {
-  ok: "\u2713",
-  warn: "!",
-  fail: "\u2717",
-  info: "\xB7"
-};
 function colorStatus(s, status, text) {
   switch (status) {
     case "ok":
@@ -10157,8 +10717,6 @@ function probeZed() {
   );
   return { name: "Zed", path, exists: existsSync6(path) };
 }
-var JETBRAINS_VERSIONED = /^[A-Z][A-Za-z]+\d{4}\.\d/;
-var JETBRAINS_UNVERSIONED = /* @__PURE__ */ new Set(["Fleet", "Toolbox"]);
 function probeJetBrains() {
   const baseDirs = [];
   if (platform() === "darwin") {
@@ -10252,8 +10810,8 @@ function exitCodeFromSections(sections) {
   }
   return 0;
 }
-function registerDoctorCommand(program2) {
-  program2.command("doctor").description("Diagnose acp-devtools setup and report any issues").option("--json", "output machine-readable JSON instead of human text").option("--no-color", "disable ANSI colour output").action((opts) => {
+function registerDoctorCommand(program) {
+  program.command("doctor").description("Diagnose acp-devtools setup and report any issues").option("--json", "output machine-readable JSON instead of human text").option("--no-color", "disable ANSI colour output").action((opts) => {
     const sections = [
       { title: "Environment", results: checkEnvironment() },
       { title: "State", results: checkState() },
@@ -10273,16 +10831,36 @@ function registerDoctorCommand(program2) {
     process.exit(exitCodeFromSections(sections));
   });
 }
-
-// src/commands/export.ts
-import { writeFileSync as writeFileSync2 } from "fs";
+var STATUS_MARK, JETBRAINS_VERSIONED, JETBRAINS_UNVERSIONED;
+var init_doctor = __esm({
+  "src/commands/doctor.ts"() {
+    "use strict";
+    init_dist();
+    init_style();
+    STATUS_MARK = {
+      ok: "\u2713",
+      warn: "!",
+      fail: "\u2717",
+      info: "\xB7"
+    };
+    JETBRAINS_VERSIONED = /^[A-Z][A-Za-z]+\d{4}\.\d/;
+    JETBRAINS_UNVERSIONED = /* @__PURE__ */ new Set(["Fleet", "Toolbox"]);
+  }
+});
 
 // src/version.ts
-var CLI_VERSION = "0.2.0";
+var CLI_VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    CLI_VERSION = "0.3.0";
+  }
+});
 
 // src/commands/export.ts
-function registerExportCommand(program2) {
-  program2.command("export").description("Export a recorded session as self-contained JSON (suitable for sharing and for mock-replay)").argument("[id]", "session id to export (default: latest in the database)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("-o, --output <file>", "write to a file instead of stdout").option("--no-pretty", "emit compact JSON (no indent, single line)").option(
+import { writeFileSync as writeFileSync2 } from "fs";
+function registerExportCommand(program) {
+  program.command("export").description("Export a recorded session as self-contained JSON (suitable for sharing and for mock-replay)").argument("[id]", "session id to export (default: latest in the database)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("-o, --output <file>", "write to a file instead of stdout").option("--no-pretty", "emit compact JSON (no indent, single line)").option(
     "--raw",
     "skip default redaction of auth headers / proxy tokens (use only when the export stays on YOUR machine)",
     false
@@ -10342,12 +10920,19 @@ function registerExportCommand(program2) {
     }
   });
 }
+var init_export2 = __esm({
+  "src/commands/export.ts"() {
+    "use strict";
+    init_dist();
+    init_version();
+  }
+});
 
 // src/commands/import.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { basename } from "path";
-function registerImportCommand(program2) {
-  program2.command("import").description(
+function registerImportCommand(program) {
+  program.command("import").description(
     "Insert a JSON session export into the captures database as a new saved session. The new session appears in the inspector picker under its IMPORTED section, with imported_at set to now."
   ).argument("<file>", "path to a JSON export produced by `acp-devtools export`").option(
     "--db <path>",
@@ -10385,21 +10970,16 @@ function registerImportCommand(program2) {
     }
   });
 }
+var init_import = __esm({
+  "src/commands/import.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
 
 // src/commands/inspect.ts
-var DIR_FROM_CODE = {
-  out: "editor-to-agent",
-  in: "agent-to-editor"
-};
-var KIND_FROM_CODE = {
-  req: "request",
-  rsp: "response",
-  ntf: "notification",
-  err: "error",
-  unk: "unknown"
-};
-function registerInspectCommand(program2) {
-  program2.command("inspect").description(
+function registerInspectCommand(program) {
+  program.command("inspect").description(
     "Print messages of a saved session to stdout \u2014 the terminal equivalent of the inspector timeline. Combine with grep / jq for shell-side analysis."
   ).argument("<id>", "session id (see `acp-devtools list`)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--limit <n>", "maximum messages to print", "500").option("--from-seq <n>", "start from this seq number (inclusive)").option(
     "--dir <codes>",
@@ -10543,13 +11123,6 @@ function passes(m, f) {
   if (f.grep && !m.raw.toLowerCase().includes(f.grep)) return false;
   return true;
 }
-var KIND_LABEL2 = {
-  request: "REQ",
-  response: "RSP",
-  notification: "NTF",
-  error: "ERR",
-  unknown: "UNK"
-};
 function toTableRow(m, pair, specCell = "") {
   let paired = "\u2014";
   let latency = "\u2014";
@@ -10609,9 +11182,6 @@ function formatBytes2(n) {
   if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
   return `${(n / 1024 / 1024).toFixed(1)}MB`;
 }
-var PREVIEW_MAX = 50;
-var METHOD_MAX = 40;
-var RPC_MAX = 10;
 function colorSpec(s, cell) {
   if (cell === "\u2713") return s.green(cell);
   if (cell.startsWith("\u26A0")) return s.red(cell);
@@ -10656,10 +11226,41 @@ function truncate(s, max) {
   if (s.length <= max) return s;
   return s.slice(0, Math.max(1, max - 1)) + "\u2026";
 }
+var DIR_FROM_CODE, KIND_FROM_CODE, KIND_LABEL2, PREVIEW_MAX, METHOD_MAX, RPC_MAX;
+var init_inspect = __esm({
+  "src/commands/inspect.ts"() {
+    "use strict";
+    init_dist();
+    init_style();
+    init_palette();
+    init_table();
+    DIR_FROM_CODE = {
+      out: "editor-to-agent",
+      in: "agent-to-editor"
+    };
+    KIND_FROM_CODE = {
+      req: "request",
+      rsp: "response",
+      ntf: "notification",
+      err: "error",
+      unk: "unknown"
+    };
+    KIND_LABEL2 = {
+      request: "REQ",
+      response: "RSP",
+      notification: "NTF",
+      error: "ERR",
+      unknown: "UNK"
+    };
+    PREVIEW_MAX = 50;
+    METHOD_MAX = 40;
+    RPC_MAX = 10;
+  }
+});
 
 // src/commands/list.ts
-function registerListCommand(program2) {
-  program2.command("list").description(
+function registerListCommand(program) {
+  program.command("list").description(
     "List saved sessions in the captures database, newest first. Use `acp-devtools doctor` for live captures (those are not in the database)."
   ).option("--db <path>", "captures database", defaultCapturesDbPath()).option("--limit <n>", "maximum rows to show", "50").option("--imported", "only show imported sessions").option("--saved", "only show non-imported (live-captured) saved sessions").option(
     "--client <substring>",
@@ -10671,18 +11272,17 @@ function registerListCommand(program2) {
 `);
       process.exit(2);
     }
-    let rows = listSessionsSummary(opts.db, limit);
-    if (opts.imported) rows = rows.filter((r) => r.imported_at !== null);
-    if (opts.saved) rows = rows.filter((r) => r.imported_at === null);
-    if (opts.client) {
-      const needle = opts.client.toLowerCase();
-      rows = rows.filter((r) => {
-        const fields = [r.client_name, r.client_version, r.client_platform].filter(
-          (v) => typeof v === "string"
-        );
-        return fields.some((f) => f.toLowerCase().includes(needle));
-      });
+    if (opts.imported && opts.saved) {
+      process.stderr.write(
+        "acp-devtools: --imported and --saved are mutually exclusive\n"
+      );
+      process.exit(2);
     }
+    const filters = {};
+    if (opts.imported) filters.imported = true;
+    if (opts.saved) filters.imported = false;
+    if (opts.client) filters.client = opts.client;
+    const rows = listSessionsSummary(opts.db, limit, filters);
     if (opts.json) {
       process.stdout.write(JSON.stringify(rows, null, 2) + "\n");
       return;
@@ -10709,13 +11309,6 @@ function formatAge(deltaMs) {
   if (h < 24) return `${h}h${m % 60 > 0 ? `${m % 60}m` : ""}`;
   return `${Math.floor(h / 24)}d`;
 }
-var COLUMNS = [
-  { title: "ID", align: "left" },
-  { title: "AGE", align: "right" },
-  { title: "KIND", align: "left" },
-  { title: "MSGS", align: "right" },
-  { title: "SESSION", align: "left" }
-];
 function formatTable(rows) {
   const s = createStyler(colorEnabled(process.stdout));
   const now = Date.now();
@@ -10731,70 +11324,28 @@ function formatTable(rows) {
   });
   return renderTable(s, COLUMNS, body);
 }
+var COLUMNS;
+var init_list = __esm({
+  "src/commands/list.ts"() {
+    "use strict";
+    init_dist();
+    init_style();
+    init_palette();
+    init_table();
+    COLUMNS = [
+      { title: "ID", align: "left" },
+      { title: "AGE", align: "right" },
+      { title: "KIND", align: "left" },
+      { title: "MSGS", align: "right" },
+      { title: "SESSION", align: "left" }
+    ];
+  }
+});
 
 // src/commands/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-var SERVER_INSTRUCTIONS = `acp-devtools exposes a local SQLite store of captured
-Agent Client Protocol (ACP) sessions. ACP is the editor\u2194agent JSON-RPC
-protocol used by Claude Code, Goose, Codex, and other IDE agents.
-
-Every tool here is **read-only** \u2014 nothing in this server writes to the
-database. Use it to investigate:
-
-- a slow session (\`get_latency_stats\` returns per-method p50/p99/max
-  plus auto-detected insights: hotspot, long-tail, outlier, busiest,
-  errors)
-- a misbehaving agent (\`find_spec_violations\` validates every frame
-  against the ACP JSON schema)
-- specific events (\`get_session_messages\` + \`get_message\` for the
-  raw JSON-RPC payload)
-- capture inventory (\`list_sessions\`, \`find_sessions_by_client\`)
-- one-shot digest of a session (\`get_session_summary\` bundles
-  metadata + latency stats + insights in one call \u2014 preferred over
-  three separate calls when you just need an overview)
-- a regression or A/B comparison between two sessions
-  (\`diff_sessions\` aligns two captures and reports added / removed
-  frames and field-level payload changes)
-
-A typical investigation:
-1. \`list_sessions\` to see what is captured
-2. \`get_session_summary({session_id})\` for the headline numbers and
-   auto-detected insights \u2014 start here when you don't know what's
-   wrong yet
-3. drill into a specific method or message with
-   \`get_session_messages\` / \`get_message\` / \`get_paired\`
-
-For common investigations the server also exposes canned prompts via
-\`prompts/list\` \u2014 \`triage_slow_session\`, \`audit_spec_violations\`,
-\`compare_clients\`. Each prompt seeds the right tool sequence.
-
-Every tool declares an \`outputSchema\`, so results include both
-\`content\` (text JSON) and \`structuredContent\` (typed object matching
-the schema). Prefer \`structuredContent\` if your client supports it \u2014
-it avoids re-parsing the text payload.
-
-Schema notes: sessions have a structured-metadata layer populated by the
-\`backfill-metadata\` CLI; \`client_name\` / \`client_version\` /
-\`client_platform\` may be null on freshly imported captures until that
-command runs.
-
-Redaction: every tool that returns frame contents OR derived views
-of them (\`get_message\`, \`get_session_messages\`, \`search_messages\`,
-\`get_session_metadata\`, \`get_session_summary\`, \`diff_sessions\`)
-redacts auth headers and proxy tokens (\`Authorization\`,
-\`X-Api-Key\`, JetBrains \`_meta.proxyConfig.proxies[*].proxy.headers.*\`,
-etc). Sensitive fields appear as \`<REDACTED>\`. This is
-unconditional; there is no opt-out flag, because the human owns the
-share decision (use \`acp-devtools export <id> --raw\` on the CLI when
-the export stays on your machine). \`search_messages\` indexes the
-pre-redaction bytes so you can still find a frame by a token fragment,
-but the returned \`raw\` is the redacted copy \u2014 do not quote the live
-secret back to the user. \`diff_sessions\` operates on already-redacted
-frames, so a token that rotated between two sessions shows up as equal
-("<REDACTED>" on both sides) rather than as a change \u2014 this is
-intentional, treating "token rotated" as a leaked side channel.`;
 function annotations(meta) {
   return {
     title: meta.title,
@@ -10809,60 +11360,8 @@ function structuredResult(payload) {
     structuredContent: payload
   };
 }
-var sessionSummaryRowSchema = z.object({
-  id: z.number(),
-  name: z.string().nullable(),
-  agent_command: z.string().nullable(),
-  started_at: z.number(),
-  ended_at: z.number().nullable(),
-  message_count: z.number(),
-  client_name: z.string().nullable(),
-  imported_at: z.number().nullable(),
-  client_version: z.string().nullable(),
-  client_platform: z.string().nullable(),
-  agent_name: z.string().nullable(),
-  agent_version: z.string().nullable(),
-  protocol_version: z.number().nullable(),
-  current_mode: z.string().nullable(),
-  current_model: z.string().nullable()
-});
-var insightSchema = z.object({
-  kind: z.enum(["hotspot", "long-tail", "outlier", "busiest", "errors"]),
-  summary: z.string(),
-  detail: z.string().optional(),
-  methods: z.array(z.string())
-});
-var perMethodSchema = z.object({
-  method: z.string(),
-  kind: z.enum(["request", "notification"]),
-  count: z.number(),
-  sampleSize: z.number(),
-  p50: z.number().nullable(),
-  p99: z.number().nullable(),
-  max: z.number().nullable(),
-  totalLatencyMs: z.number().nullable(),
-  latencies: z.array(z.number())
-});
-var messageSchema = z.object({
-  seq: z.number(),
-  timestamp: z.number(),
-  direction: z.enum(["editor-to-agent", "agent-to-editor"]),
-  kind: z.enum(["request", "response", "notification", "error", "unknown"]),
-  method: z.string().optional(),
-  rpcId: z.union([z.string(), z.number()]).optional(),
-  raw: z.string(),
-  payload: z.unknown().nullable(),
-  parseError: z.string().optional()
-});
-var latencySchema = z.object({
-  sampleSize: z.number(),
-  p50: z.number().nullable(),
-  p90: z.number().nullable(),
-  p99: z.number().nullable(),
-  max: z.number().nullable()
-});
-function registerMcpCommand(program2) {
-  program2.command("mcp").description(
+function registerMcpCommand(program) {
+  program.command("mcp").description(
     'Run an MCP server over stdio that exposes saved captures as read-only tools. Wire into Claude Code via .claude/mcp_servers.json \u2014 then ask Claude to "find spec violations in last 10 sessions" or "compare p99 of WebStorm vs Zed".'
   ).option("--db <path>", "captures database", defaultCapturesDbPath()).option("--name <name>", "server name advertised in MCP handshake", "acp-devtools").action(async (opts) => {
     const server = buildMcpServer(opts);
@@ -11426,17 +11925,132 @@ function errorResult(message) {
     content: [{ type: "text", text: message }]
   };
 }
+var SERVER_INSTRUCTIONS, sessionSummaryRowSchema, insightSchema, perMethodSchema, messageSchema, latencySchema;
+var init_mcp = __esm({
+  "src/commands/mcp.ts"() {
+    "use strict";
+    init_dist();
+    init_version();
+    SERVER_INSTRUCTIONS = `acp-devtools exposes a local SQLite store of captured
+Agent Client Protocol (ACP) sessions. ACP is the editor\u2194agent JSON-RPC
+protocol used by Claude Code, Goose, Codex, and other IDE agents.
 
-// src/commands/mock-agent.ts
-import { mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2 } from "path";
+Every tool here is **read-only** \u2014 nothing in this server writes to the
+database. Use it to investigate:
+
+- a slow session (\`get_latency_stats\` returns per-method p50/p99/max
+  plus auto-detected insights: hotspot, long-tail, outlier, busiest,
+  errors)
+- a misbehaving agent (\`find_spec_violations\` validates every frame
+  against the ACP JSON schema)
+- specific events (\`get_session_messages\` + \`get_message\` for the
+  raw JSON-RPC payload)
+- capture inventory (\`list_sessions\`, \`find_sessions_by_client\`)
+- one-shot digest of a session (\`get_session_summary\` bundles
+  metadata + latency stats + insights in one call \u2014 preferred over
+  three separate calls when you just need an overview)
+- a regression or A/B comparison between two sessions
+  (\`diff_sessions\` aligns two captures and reports added / removed
+  frames and field-level payload changes)
+
+A typical investigation:
+1. \`list_sessions\` to see what is captured
+2. \`get_session_summary({session_id})\` for the headline numbers and
+   auto-detected insights \u2014 start here when you don't know what's
+   wrong yet
+3. drill into a specific method or message with
+   \`get_session_messages\` / \`get_message\` / \`get_paired\`
+
+For common investigations the server also exposes canned prompts via
+\`prompts/list\` \u2014 \`triage_slow_session\`, \`audit_spec_violations\`,
+\`compare_clients\`. Each prompt seeds the right tool sequence.
+
+Every tool declares an \`outputSchema\`, so results include both
+\`content\` (text JSON) and \`structuredContent\` (typed object matching
+the schema). Prefer \`structuredContent\` if your client supports it \u2014
+it avoids re-parsing the text payload.
+
+Schema notes: sessions have a structured-metadata layer populated by the
+\`backfill-metadata\` CLI; \`client_name\` / \`client_version\` /
+\`client_platform\` may be null on freshly imported captures until that
+command runs.
+
+Redaction: every tool that returns frame contents OR derived views
+of them (\`get_message\`, \`get_session_messages\`, \`search_messages\`,
+\`get_session_metadata\`, \`get_session_summary\`, \`diff_sessions\`)
+redacts auth headers and proxy tokens (\`Authorization\`,
+\`X-Api-Key\`, JetBrains \`_meta.proxyConfig.proxies[*].proxy.headers.*\`,
+etc). Sensitive fields appear as \`<REDACTED>\`. This is
+unconditional; there is no opt-out flag, because the human owns the
+share decision (use \`acp-devtools export <id> --raw\` on the CLI when
+the export stays on your machine). \`search_messages\` indexes the
+pre-redaction bytes so you can still find a frame by a token fragment,
+but the returned \`raw\` is the redacted copy \u2014 do not quote the live
+secret back to the user. \`diff_sessions\` operates on already-redacted
+frames, so a token that rotated between two sessions shows up as equal
+("<REDACTED>" on both sides) rather than as a change \u2014 this is
+intentional, treating "token rotated" as a leaked side channel.`;
+    sessionSummaryRowSchema = z.object({
+      id: z.number(),
+      name: z.string().nullable(),
+      agent_command: z.string().nullable(),
+      started_at: z.number(),
+      ended_at: z.number().nullable(),
+      message_count: z.number(),
+      client_name: z.string().nullable(),
+      imported_at: z.number().nullable(),
+      client_version: z.string().nullable(),
+      client_platform: z.string().nullable(),
+      agent_name: z.string().nullable(),
+      agent_version: z.string().nullable(),
+      protocol_version: z.number().nullable(),
+      current_mode: z.string().nullable(),
+      current_model: z.string().nullable()
+    });
+    insightSchema = z.object({
+      kind: z.enum(["hotspot", "long-tail", "outlier", "busiest", "errors"]),
+      summary: z.string(),
+      detail: z.string().optional(),
+      methods: z.array(z.string())
+    });
+    perMethodSchema = z.object({
+      method: z.string(),
+      kind: z.enum(["request", "notification"]),
+      count: z.number(),
+      sampleSize: z.number(),
+      p50: z.number().nullable(),
+      p99: z.number().nullable(),
+      max: z.number().nullable(),
+      totalLatencyMs: z.number().nullable(),
+      latencies: z.array(z.number())
+    });
+    messageSchema = z.object({
+      seq: z.number(),
+      timestamp: z.number(),
+      direction: z.enum(["editor-to-agent", "agent-to-editor"]),
+      kind: z.enum(["request", "response", "notification", "error", "unknown"]),
+      method: z.string().optional(),
+      rpcId: z.union([z.string(), z.number()]).optional(),
+      raw: z.string(),
+      payload: z.unknown().nullable(),
+      parseError: z.string().optional()
+    });
+    latencySchema = z.object({
+      sampleSize: z.number(),
+      p50: z.number().nullable(),
+      p90: z.number().nullable(),
+      p99: z.number().nullable(),
+      max: z.number().nullable()
+    });
+  }
+});
 
 // src/commands/playback-source.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { basename as basename2 } from "path";
 function loadPlaybackScript(opts) {
   if (opts.script && opts.session !== void 0) {
-    throw new Error("--script and --session are mutually exclusive");
+    throw new PlaybackUsageError("--script and --session are mutually exclusive");
   }
   if (opts.script) {
     let text;
@@ -11455,7 +12069,7 @@ function loadPlaybackScript(opts) {
     if (opts.session !== void 0) {
       const id = Number(opts.session);
       if (!Number.isInteger(id) || id <= 0) {
-        throw new Error(`invalid --session "${opts.session}"`);
+        throw new PlaybackUsageError(`invalid --session "${opts.session}"`);
       }
       session = Session.load(db, id);
     } else {
@@ -11475,10 +12089,25 @@ function loadPlaybackScript(opts) {
     db.close();
   }
 }
+var PlaybackUsageError;
+var init_playback_source = __esm({
+  "src/commands/playback-source.ts"() {
+    "use strict";
+    init_dist();
+    PlaybackUsageError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "PlaybackUsageError";
+      }
+    };
+  }
+});
 
 // src/commands/mock-agent.ts
-function registerMockAgentCommand(program2) {
-  program2.command("mock-agent").description(
+import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } from "path";
+function registerMockAgentCommand(program) {
+  program.command("mock-agent").description(
     "Pretend to be an ACP agent by replaying a recorded session script. Reads JSON-RPC from stdin (real editor), writes recorded responses to stdout. Wire it into an IDE `agent_servers` config to drive plugin tests without a live LLM. By default reads from the shared captures database (latest session); use --session for a specific id or --script for a JSON export from a teammate."
   ).option("--session <id>", "session id from the captures database (default: latest)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--script <file>", "load from a JSON export instead of the database (mutually exclusive with --session)").option("--log <mode>", "echo every wire frame to stderr (json | pretty | none)", "none").option(
     "--realtime",
@@ -11500,7 +12129,7 @@ function registerMockAgentCommand(program2) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`acp-devtools: ${msg}
 `);
-      process.exit(1);
+      process.exit(err instanceof PlaybackUsageError ? 2 : 1);
     }
     const engine = new PlaybackEngine(loaded.messages, "agent");
     process.stderr.write(
@@ -11560,11 +12189,18 @@ function registerMockAgentCommand(program2) {
       }
     };
     let pendingTimer = null;
+    let stdinEnded = false;
     const emit = (line) => {
       process.stdout.write(line + "\n");
       log("\u2190", line);
       capture(line, "agent-to-editor");
     };
+    const finishIfDrained = () => {
+      if (stdinEnded && !pendingTimer) {
+        closeSession();
+        process.exit(0);
+      }
+    };
     const drain = () => {
       if (pendingTimer) return;
       while (true) {
@@ -11583,9 +12219,7 @@ function registerMockAgentCommand(program2) {
           emit(step.line);
           continue;
         }
-        if (step.kind === "done") {
-          return;
-        }
+        finishIfDrained();
         return;
       }
     };
@@ -11605,19 +12239,25 @@ function registerMockAgentCommand(program2) {
       }
     });
     process.stdin.on("end", () => {
+      stdinEnded = true;
       drain();
-      closeSession();
-      process.exit(0);
     });
     drain();
   });
 }
+var init_mock_agent = __esm({
+  "src/commands/mock-agent.ts"() {
+    "use strict";
+    init_dist();
+    init_playback_source();
+  }
+});
 
 // src/commands/mock-editor.ts
 import { mkdirSync as mkdirSync4 } from "fs";
 import { dirname as dirname3 } from "path";
-function registerMockEditorCommand(program2) {
-  program2.command("mock-editor").description(
+function registerMockEditorCommand(program) {
+  program.command("mock-editor").description(
     "Pretend to be an editor by replaying a recorded session script. Spawns the given agent as a child process, sends it the recorded editor-side frames in order, and reads agent responses. Useful for CI tests of your own ACP agent without a real IDE. By default reads from the shared captures database (latest session); use --session for a specific id or --script for a JSON export from a teammate."
   ).passThroughOptions().argument("<agent>", "agent executable (e.g. `node fixtures/mock-agent.js` or the path to a real ACP agent)").argument("[agent-args...]", "arguments forwarded to the agent").option("--session <id>", "session id from the captures database (default: latest)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--script <file>", "load from a JSON export instead of the database (mutually exclusive with --session)").option("--cwd <dir>", "working directory for the agent").option("--log <mode>", "echo every wire frame to stderr (json | pretty | none)", "none").option(
     "--realtime",
@@ -11639,7 +12279,7 @@ function registerMockEditorCommand(program2) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`acp-devtools: ${msg}
 `);
-      process.exit(1);
+      process.exit(err instanceof PlaybackUsageError ? 2 : 1);
     }
     const engine = new PlaybackEngine(loaded.messages, "editor");
     process.stderr.write(
@@ -11780,14 +12420,17 @@ function registerMockEditorCommand(program2) {
     }
   });
 }
+var init_mock_editor = __esm({
+  "src/commands/mock-editor.ts"() {
+    "use strict";
+    init_dist();
+    init_playback_source();
+  }
+});
 
 // src/commands/proxy.ts
 import { mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname4 } from "path";
-var DIRECTION_LABEL = {
-  "editor-to-agent": "\u2192 AGENT",
-  "agent-to-editor": "\u2190 AGENT"
-};
 function formatPretty(msg) {
   const time = new Date(msg.timestamp).toISOString().slice(11, 23);
   const dir = DIRECTION_LABEL[msg.direction];
@@ -11797,9 +12440,9 @@ function formatPretty(msg) {
   return `${head}${id}${err}
   ${msg.raw}`;
 }
-function registerProxyCommand(program2) {
+function registerProxyCommand(program) {
   const knownAgentList = listAgents().map((a) => a.shortName).join(", ");
-  program2.command("proxy").description("Run an ACP agent through a capturing proxy").passThroughOptions().argument("[agent]", 'agent executable (e.g. "goose"); optional when --agent is set').argument("[agent-args...]", "arguments forwarded to the agent").option(
+  program.command("proxy").description("Run an ACP agent through a capturing proxy").passThroughOptions().argument("[agent]", 'agent executable (e.g. "goose"); optional when --agent is set').argument("[agent-args...]", "arguments forwarded to the agent").option(
     "--agent <name>",
     `preset for a known ACP agent (${knownAgentList})`
   ).option("--log <mode>", "message log format: json | pretty | none", "none").option("--cwd <dir>", "working directory for the agent").option(
@@ -11834,7 +12477,7 @@ function registerProxyCommand(program2) {
     } else {
       process.stderr.write(
         `acp-devtools: no agent specified.
-  Pass an agent command (\`acp-devtools proxy npx -y @zed-industries/claude-code-acp\`)
+  Pass an agent command (\`acp-devtools proxy npx -y @agentclientprotocol/claude-agent-acp\`)
   or use --agent <name> with one of: ${knownAgentList}.
 `
       );
@@ -12025,6 +12668,17 @@ function registerProxyCommand(program2) {
     }
   });
 }
+var DIRECTION_LABEL;
+var init_proxy3 = __esm({
+  "src/commands/proxy.ts"() {
+    "use strict";
+    init_dist();
+    DIRECTION_LABEL = {
+      "editor-to-agent": "\u2192 AGENT",
+      "agent-to-editor": "\u2190 AGENT"
+    };
+  }
+});
 
 // src/commands/replay.ts
 import { readFileSync as readFileSync4 } from "fs";
@@ -12080,8 +12734,8 @@ function loadFromSqlite(dbPath, idArg) {
     cleanup: () => db.close()
   };
 }
-function registerReplayCommand(program2) {
-  program2.command("replay").description(
+function registerReplayCommand(program) {
+  program.command("replay").description(
     "Serve a recorded session over WebSocket for replay in the UI. By default replays the latest session in the captures database; pass a session id, or --file to replay a JSON export."
   ).argument("[id]", "session id to replay (default: latest in the database)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--file <path>", "replay a JSON export file instead of a saved session").option("--ws-port <port>", "WebSocket port", "3737").option("--ws-host <host>", "WebSocket bind address", "127.0.0.1").action(async (idArg, opts) => {
     const wsPort = Number(opts.wsPort);
@@ -12138,10 +12792,16 @@ function registerReplayCommand(program2) {
     source.cleanup();
   });
 }
+var init_replay2 = __esm({
+  "src/commands/replay.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
 
 // src/commands/search.ts
-function registerSearchCommand(program2) {
-  program2.command("search").description(
+function registerSearchCommand(program) {
+  program.command("search").description(
     "Find messages containing a substring across every saved session. Substring match is case-insensitive. Use `inspect` to read individual messages once you know where to look."
   ).argument("<query>", "substring to search for (case-insensitive)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--limit <n>", "maximum hits to print", "50").option("--session <id>", "restrict search to a single session").option("--in-method", "match only method names (default: match anywhere in the raw frame)").option("--in-payload", "match only inside the payload (skip method-only hits)").option("--json", "emit machine-readable JSON instead of a table").action((query, opts) => {
     const limit = Number(opts.limit);
@@ -12213,7 +12873,6 @@ function registerSearchCommand(program2) {
     process.stdout.write(renderHits(s, hits, needle));
   });
 }
-var SNIPPET_LEN = 80;
 function makeSnippet(raw, needle) {
   const idx = raw.toLowerCase().indexOf(needle);
   if (idx < 0) return raw.slice(0, SNIPPET_LEN);
@@ -12223,12 +12882,6 @@ function makeSnippet(raw, needle) {
   const suffix = end < raw.length ? "\u2026" : "";
   return prefix + raw.slice(start, end).replace(/\s+/g, " ") + suffix;
 }
-var METHOD_MAX2 = 32;
-var COLUMNS2 = [
-  { title: "LOC", align: "left" },
-  { title: "METHOD", align: "left" },
-  { title: "MATCH", align: "left" }
-];
 function renderHits(s, hits, needle) {
   const body = hits.map((h) => [
     s.cyan(`#${h.sessionId}/${h.seq}`),
@@ -12257,12 +12910,32 @@ function truncate2(s, max) {
   if (s.length <= max) return s;
   return s.slice(0, Math.max(1, max - 1)) + "\u2026";
 }
+var SNIPPET_LEN, METHOD_MAX2, COLUMNS2;
+var init_search = __esm({
+  "src/commands/search.ts"() {
+    "use strict";
+    init_dist();
+    init_style();
+    init_table();
+    SNIPPET_LEN = 80;
+    METHOD_MAX2 = 32;
+    COLUMNS2 = [
+      { title: "LOC", align: "left" },
+      { title: "METHOD", align: "left" },
+      { title: "MATCH", align: "left" }
+    ];
+  }
+});
 
 // src/commands/session-info.ts
-function registerSessionInfoCommand(program2) {
-  program2.command("session-info").description(
+function registerSessionInfoCommand(program) {
+  program.command("session-info").description(
     "Print derived client/agent metadata for a saved session \u2014 the terminal equivalent of the inspector's session info panel."
-  ).argument("<id>", "session id (see `acp-devtools list`)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--json", "machine-readable JSON instead of human-readable text").action((rawId, opts) => {
+  ).argument("<id>", "session id (see `acp-devtools list`)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--json", "machine-readable JSON instead of human-readable text").option(
+    "--raw",
+    "skip default redaction of auth headers / proxy tokens (use only when the output stays on YOUR machine)",
+    false
+  ).action((rawId, opts) => {
     const id = Number(rawId);
     if (!Number.isInteger(id) || id <= 0) {
       process.stderr.write(`acp-devtools: invalid id "${rawId}"
@@ -12292,8 +12965,30 @@ function registerSessionInfoCommand(program2) {
     }
     const messages = [];
     for (const m of session.messages()) messages.push(m);
-    const meta = extractSessionMetadata(messages);
     db.close();
+    let fieldsRedacted = 0;
+    let messagesAffected = 0;
+    const display = opts.raw ? messages : messages.map((m) => {
+      const r = redactMessage(m);
+      if (r.count > 0) {
+        messagesAffected += 1;
+        fieldsRedacted += r.count;
+      }
+      return r.redacted;
+    });
+    const meta = extractSessionMetadata(display);
+    const writeRedactionNote = () => {
+      if (opts.raw) {
+        process.stderr.write(
+          "acp-devtools: --raw was set; output may contain auth headers / proxy tokens \u2014 do not share publicly\n"
+        );
+      } else if (fieldsRedacted > 0) {
+        process.stderr.write(
+          `acp-devtools: redacted ${fieldsRedacted} field(s) across ${messagesAffected} message(s) \u2014 re-run with --raw to print them
+`
+        );
+      }
+    };
     if (opts.json) {
       process.stdout.write(
         JSON.stringify(
@@ -12313,9 +13008,11 @@ function registerSessionInfoCommand(program2) {
           2
         ) + "\n"
       );
+      writeRedactionNote();
       return;
     }
     renderText(session, meta, messages.length);
+    writeRedactionNote();
   });
 }
 function renderText(session, meta, msgCount) {
@@ -12325,12 +13022,10 @@ function renderText(session, meta, msgCount) {
 `);
   w.write(s.dim("\u2500".repeat(48)) + "\n");
   const clientLabel = meta.client.title ?? meta.client.name ?? session.info.clientName ?? "\u2014";
-  const clientVer = meta.client.version ? ` v${meta.client.version}` : "";
   const clientPlatform = meta.client.platform ? ` (${meta.client.platform})` : "";
-  w.write(pad(s, "Client", `${clientLabel}${clientVer}${clientPlatform}`));
+  w.write(pad(s, "Client", `${withVersion(clientLabel, meta.client.version)}${clientPlatform}`));
   const agentLabel = meta.agent.name ?? shortAgent(session.info.agentCommand) ?? "\u2014";
-  const agentVer = meta.agent.version ? ` v${meta.agent.version}` : "";
-  w.write(pad(s, "Agent", `${agentLabel}${agentVer}`));
+  w.write(pad(s, "Agent", withVersion(agentLabel, meta.agent.version)));
   w.write(pad(s, "Protocol", meta.protocolVersion !== null ? `ACP v${meta.protocolVersion}` : "\u2014"));
   w.write(
     pad(
@@ -12378,6 +13073,10 @@ ${heading2(s, "JETBRAINS EXTENSIONS")}
     );
   }
 }
+function withVersion(label, version) {
+  if (!version || label.includes(version)) return label;
+  return `${label} v${version}`;
+}
 function heading2(s, label) {
   return s.bold(s.yellow(label));
 }
@@ -12400,11 +13099,17 @@ function shortAgent(agentCommand) {
   }
   return parts[0] ?? null;
 }
+var init_session_info = __esm({
+  "src/commands/session-info.ts"() {
+    "use strict";
+    init_dist();
+    init_style();
+  }
+});
 
 // src/commands/stats.ts
-var percentile2 = percentile;
-function registerStatsCommand(program2) {
-  program2.command("stats").description(
+function registerStatsCommand(program) {
+  program.command("stats").description(
     "Aggregate counts and latency percentiles for one saved session \u2014 the equivalent of the inspector's footer StatsBar."
   ).argument("<id>", "session id (see `acp-devtools list`)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--by-method", "add a per-method breakdown table (method \xB7 count \xB7 p50 \xB7 p99)").option("--json", "machine-readable JSON instead of human-readable text").action((rawId, opts) => {
     const id = Number(rawId);
@@ -12512,13 +13217,13 @@ function computeStats(info, messages) {
       p90: latencies.length ? percentile2(latencies, 90) : null,
       p99: latencies.length ? percentile2(latencies, 99) : null,
       max: latencies.length ? latencies[latencies.length - 1] : null,
-      mean: latencies.length ? Math.round(mean(latencies)) : null
+      mean: latencies.length ? Math.round(mean2(latencies)) : null
     },
     perMethod,
     insights
   };
 }
-function mean(xs) {
+function mean2(xs) {
   return xs.reduce((acc, x) => acc + x, 0) / xs.length;
 }
 function formatLatency3(ms) {
@@ -12623,27 +13328,6 @@ function renderStats(s, stats, byMethod) {
   }
   return lines.join("");
 }
-var INSIGHT_GLYPH = {
-  hotspot: "!",
-  "long-tail": "~",
-  outlier: "*",
-  busiest: "#",
-  errors: "x"
-};
-var INSIGHT_LABEL = {
-  hotspot: "HOTSPOT  ",
-  "long-tail": "LONG TAIL",
-  outlier: "OUTLIER  ",
-  busiest: "BUSIEST  ",
-  errors: "ERRORS   "
-};
-var INSIGHT_COLOR = {
-  hotspot: "red",
-  "long-tail": "yellow",
-  outlier: "magenta",
-  busiest: "cyan",
-  errors: "red"
-};
 function renderInsights(s, insights) {
   const lines = [heading3(s, "INSIGHTS") + "\n"];
   for (const i of insights) {
@@ -12656,7 +13340,6 @@ function renderInsights(s, insights) {
   }
   return lines.join("");
 }
-var METHOD_MAX3 = 40;
 function renderPerMethod(s, rows) {
   const columns = [
     { title: "METHOD", align: "left" },
@@ -12681,6 +13364,39 @@ function renderPerMethod(s, rows) {
   });
   return renderTable(s, columns, body);
 }
+var percentile2, INSIGHT_GLYPH, INSIGHT_LABEL, INSIGHT_COLOR, METHOD_MAX3;
+var init_stats = __esm({
+  "src/commands/stats.ts"() {
+    "use strict";
+    init_dist();
+    init_style();
+    init_palette();
+    init_table();
+    percentile2 = percentile;
+    INSIGHT_GLYPH = {
+      hotspot: "!",
+      "long-tail": "~",
+      outlier: "*",
+      busiest: "#",
+      errors: "x"
+    };
+    INSIGHT_LABEL = {
+      hotspot: "HOTSPOT  ",
+      "long-tail": "LONG TAIL",
+      outlier: "OUTLIER  ",
+      busiest: "BUSIEST  ",
+      errors: "ERRORS   "
+    };
+    INSIGHT_COLOR = {
+      hotspot: "red",
+      "long-tail": "yellow",
+      outlier: "magenta",
+      busiest: "cyan",
+      errors: "red"
+    };
+    METHOD_MAX3 = 40;
+  }
+});
 
 // src/commands/ui.ts
 import { createReadStream, existsSync as existsSync7, statSync as statSync3 } from "fs";
@@ -12688,26 +13404,6 @@ import { createServer } from "http";
 import { dirname as dirname5, extname, join as join4, normalize, resolve, sep } from "path";
 import { fileURLToPath } from "url";
 import { spawn as spawn2 } from "child_process";
-var MIME_TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".mjs": "application/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".map": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".ico": "image/x-icon",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".txt": "text/plain; charset=utf-8"
-};
 function uiDistDir() {
   const here = dirname5(fileURLToPath(import.meta.url));
   return resolve(here, "ui");
@@ -12762,8 +13458,8 @@ function openBrowser(url) {
   } catch {
   }
 }
-function registerUiCommand(program2) {
-  program2.command("ui").description("Serve the acp-devtools UI from an embedded static bundle").option("--port <port>", "HTTP port to bind", "3737").option("--host <host>", "HTTP bind address", "127.0.0.1").option("--no-open", "don't auto-open the browser").option(
+function registerUiCommand(program) {
+  program.command("ui").description("Serve the acp-devtools UI from an embedded static bundle").option("--port <port>", "HTTP port to bind", "3737").option("--host <host>", "HTTP bind address", "127.0.0.1").option("--no-open", "don't auto-open the browser").option(
     "--captures-db <file>",
     "path to the captures SQLite database (default: ~/.acp-devtools/captures.db)"
   ).action(async (opts) => {
@@ -12783,15 +13479,17 @@ function registerUiCommand(program2) {
       process.exit(1);
     }
     const capturesDbPath = opts.capturesDb ?? defaultCapturesDbPath();
+    const allowedHosts = [opts.host];
     const apiHandler = createApiHandler({
       capturesDbPath,
-      binaryPath: process.argv[1] ?? null
+      binaryPath: process.argv[1] ?? null,
+      allowedHosts
     });
     const server = createServer((req, res) => {
       if (apiHandler(req, res)) return;
       serveStatic(req, res, rootDir);
     });
-    attachReplayUpgrade(server, { capturesDbPath });
+    attachReplayUpgrade(server, { capturesDbPath, allowedHosts });
     await new Promise((resolveListen, rejectListen) => {
       server.once("error", rejectListen);
       server.listen(port, opts.host, () => {
@@ -12826,10 +13524,37 @@ function registerUiCommand(program2) {
     });
   });
 }
+var MIME_TYPES;
+var init_ui = __esm({
+  "src/commands/ui.ts"() {
+    "use strict";
+    init_dist();
+    MIME_TYPES = {
+      ".html": "text/html; charset=utf-8",
+      ".js": "application/javascript; charset=utf-8",
+      ".mjs": "application/javascript; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".map": "application/json; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".ico": "image/x-icon",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".otf": "font/otf",
+      ".txt": "text/plain; charset=utf-8"
+    };
+  }
+});
 
 // src/commands/validate.ts
-function registerValidateCommand(program2) {
-  program2.command("validate").description(
+function registerValidateCommand(program) {
+  program.command("validate").description(
     "Check every frame in a session against the official ACP JSON schema (`@agentclientprotocol/sdk`). Use to confirm that an editor or agent you do not control speaks the protocol correctly \u2014 same data the inspector's \u26A0 SPEC badges surface."
   ).argument("<id>", "session id (see `acp-devtools list`)").option("--db <path>", "captures database", defaultCapturesDbPath()).option("--limit <n>", "maximum violations to print", "200").option("--method <pattern>", "only check messages whose method contains this substring").option("--json", "machine-readable JSON").action((rawId, opts) => {
     const id = Number(rawId);
@@ -12933,16 +13658,6 @@ function registerValidateCommand(program2) {
     process.exit(1);
   });
 }
-var METHOD_MAX4 = 28;
-var SCHEMA_MAX = 28;
-var PATH_MAX = 38;
-var COLUMNS3 = [
-  { title: "SEQ", align: "right" },
-  { title: "METHOD", align: "left" },
-  { title: "SCHEMA", align: "left" },
-  { title: "PATH", align: "left" },
-  { title: "ERROR", align: "left" }
-];
 function renderViolations(s, violations) {
   const body = violations.map((v) => [
     s.dim(`#${v.seq}`),
@@ -12957,6 +13672,26 @@ function truncate3(s, max) {
   if (s.length <= max) return s;
   return s.slice(0, Math.max(1, max - 1)) + "\u2026";
 }
+var METHOD_MAX4, SCHEMA_MAX, PATH_MAX, COLUMNS3;
+var init_validate2 = __esm({
+  "src/commands/validate.ts"() {
+    "use strict";
+    init_dist();
+    init_inspect();
+    init_style();
+    init_table();
+    METHOD_MAX4 = 28;
+    SCHEMA_MAX = 28;
+    PATH_MAX = 38;
+    COLUMNS3 = [
+      { title: "SEQ", align: "right" },
+      { title: "METHOD", align: "left" },
+      { title: "SCHEMA", align: "left" },
+      { title: "PATH", align: "left" },
+      { title: "ERROR", align: "left" }
+    ];
+  }
+});
 
 // src/lib/help.ts
 import { homedir as homedir4 } from "os";
@@ -12966,102 +13701,6 @@ function tidyHome(text, home = homedir4()) {
   const collapsed = text.split(escapedHome).join("~").split(home).join("~");
   return collapsed.replace(/~[^"\s)]*/g, (segment) => segment.replace(/\\+/g, "/"));
 }
-var GROUPS = [
-  { title: "Capture", commands: ["proxy", "mock-agent", "mock-editor"] },
-  {
-    title: "Inspect",
-    commands: ["list", "inspect", "search", "stats", "diff", "session-info", "validate"]
-  },
-  { title: "View", commands: ["ui", "replay"] },
-  { title: "Manage", commands: ["export", "import", "delete", "backfill-metadata"] },
-  { title: "Setup", commands: ["doctor", "mcp"] }
-];
-var SUMMARIES = {
-  proxy: "Capture an agent's traffic through a proxy",
-  "mock-agent": "Replay a session as a fake ACP agent",
-  "mock-editor": "Replay a session as a fake editor",
-  list: "List saved sessions, newest first",
-  inspect: "Print a session's frames to stdout",
-  search: "Search frame payloads across sessions",
-  stats: "Latency percentiles for one session",
-  diff: "Compare two sessions frame by frame",
-  "session-info": "Show a session's client/agent metadata",
-  validate: "Check frames against the ACP spec",
-  ui: "Open the web inspector",
-  replay: "Stream a session to the UI over WebSocket",
-  export: "Export a session to self-contained JSON",
-  import: "Import a JSON export into the store",
-  delete: "Delete saved sessions permanently",
-  "backfill-metadata": "Recompute session metadata columns",
-  doctor: "Diagnose setup and report issues",
-  mcp: "Expose captures to Claude over MCP"
-};
-var ROOT_EXAMPLES = [
-  "# Capture a Claude Code session (Zed adapter)",
-  "acp-devtools proxy npx -y @zed-industries/claude-code-acp",
-  "",
-  "# Browse captured sessions in the web inspector",
-  "acp-devtools ui",
-  "",
-  "# List sessions, then print one to the terminal",
-  "acp-devtools list",
-  "acp-devtools inspect 12",
-  "",
-  "# Diagnose your setup when nothing's being captured",
-  "acp-devtools doctor"
-];
-var EXAMPLES = {
-  proxy: [
-    "# Wrap the Zed Claude Code adapter and capture every frame",
-    "acp-devtools proxy npx -y @zed-industries/claude-code-acp",
-    "",
-    "# Capture headless, into a specific database",
-    "acp-devtools proxy --no-ws --save-to /tmp/run.db node ./my-agent.js"
-  ],
-  ui: [
-    "# Serve the inspector on :3737 and open a browser",
-    "acp-devtools ui",
-    "",
-    "# Pick a port and stay headless",
-    "acp-devtools ui --port 4000 --no-open"
-  ],
-  list: [
-    "acp-devtools list",
-    "",
-    "# Machine-readable JSON",
-    "acp-devtools list --json"
-  ],
-  inspect: [
-    "acp-devtools inspect 12",
-    "",
-    "# Only request/response frames for one method",
-    "acp-devtools inspect 12 --method session/prompt --paired"
-  ],
-  search: ["acp-devtools search session/prompt", "acp-devtools search rate_limit --in-payload"],
-  stats: ["acp-devtools stats 12", "acp-devtools stats 12 --by-method"],
-  diff: ["# Worked yesterday, broke today?", "acp-devtools diff 41 42"],
-  export: [
-    "acp-devtools export 12 -o session-12.json",
-    "",
-    "# Straight to stdout for sharing",
-    "acp-devtools export 12 > session-12.json"
-  ],
-  import: ["acp-devtools import session-12.json"],
-  delete: ["acp-devtools delete 12", "acp-devtools delete 12 13 14"],
-  replay: ["acp-devtools replay 12", "acp-devtools replay --file session-12.json"],
-  validate: ["acp-devtools validate 12"],
-  "session-info": ["acp-devtools session-info 12"],
-  doctor: ["acp-devtools doctor"],
-  mcp: ["# Read-only MCP server over stdio (wire into .claude/mcp_servers.json)", "acp-devtools mcp"],
-  "backfill-metadata": [
-    "acp-devtools backfill-metadata",
-    "",
-    "# Recompute a single session",
-    "acp-devtools backfill-metadata 12"
-  ]
-};
-var INDENT = "  ";
-var GAP = 3;
 function heading4(s, title) {
   return s.bold(s.yellow(title.toUpperCase()));
 }
@@ -13189,8 +13828,8 @@ function formatCommandHelp(cmd, helper, s, width) {
   }
   return out.join("\n");
 }
-function configureCliHelp(program2) {
-  program2.configureHelp({
+function configureCliHelp(program) {
+  program.configureHelp({
     helpWidth: process.stdout.columns ?? 80,
     formatHelp(cmd, helper) {
       const s = createStyler(colorEnabled(process.stdout));
@@ -13199,37 +13838,252 @@ function configureCliHelp(program2) {
     }
   });
   const err = createStyler(colorEnabled(process.stderr));
-  program2.configureOutput({
+  program.configureOutput({
     outputError(str, write) {
       write(err.red(str));
     }
   });
 }
+var GROUPS, SUMMARIES, ROOT_EXAMPLES, EXAMPLES, INDENT, GAP;
+var init_help = __esm({
+  "src/lib/help.ts"() {
+    "use strict";
+    init_style();
+    GROUPS = [
+      { title: "Capture", commands: ["proxy", "mock-agent", "mock-editor"] },
+      {
+        title: "Inspect",
+        commands: ["list", "inspect", "search", "stats", "diff", "session-info", "validate"]
+      },
+      { title: "View", commands: ["ui", "replay"] },
+      { title: "Manage", commands: ["export", "import", "delete", "backfill-metadata"] },
+      { title: "Setup", commands: ["doctor", "mcp"] }
+    ];
+    SUMMARIES = {
+      proxy: "Capture an agent's traffic through a proxy",
+      "mock-agent": "Replay a session as a fake ACP agent",
+      "mock-editor": "Replay a session as a fake editor",
+      list: "List saved sessions, newest first",
+      inspect: "Print a session's frames to stdout",
+      search: "Search frame payloads across sessions",
+      stats: "Latency percentiles for one session",
+      diff: "Compare two sessions frame by frame",
+      "session-info": "Show a session's client/agent metadata",
+      validate: "Check frames against the ACP spec",
+      ui: "Open the web inspector",
+      replay: "Stream a session to the UI over WebSocket",
+      export: "Export a session to self-contained JSON",
+      import: "Import a JSON export into the store",
+      delete: "Delete saved sessions permanently",
+      "backfill-metadata": "Recompute session metadata columns",
+      doctor: "Diagnose setup and report issues",
+      mcp: "Expose captures to Claude over MCP"
+    };
+    ROOT_EXAMPLES = [
+      "# Capture a Claude Code session (Zed adapter)",
+      "acp-devtools proxy npx -y @agentclientprotocol/claude-agent-acp",
+      "",
+      "# Browse captured sessions in the web inspector",
+      "acp-devtools ui",
+      "",
+      "# List sessions, then print one to the terminal",
+      "acp-devtools list",
+      "acp-devtools inspect 12",
+      "",
+      "# Diagnose your setup when nothing's being captured",
+      "acp-devtools doctor"
+    ];
+    EXAMPLES = {
+      proxy: [
+        "# Wrap the Zed Claude Code adapter and capture every frame",
+        "acp-devtools proxy npx -y @agentclientprotocol/claude-agent-acp",
+        "",
+        "# Capture headless, into a specific database",
+        "acp-devtools proxy --no-ws --save-to /tmp/run.db node ./my-agent.js"
+      ],
+      ui: [
+        "# Serve the inspector on :3737 and open a browser",
+        "acp-devtools ui",
+        "",
+        "# Pick a port and stay headless",
+        "acp-devtools ui --port 4000 --no-open"
+      ],
+      list: [
+        "acp-devtools list",
+        "",
+        "# Machine-readable JSON",
+        "acp-devtools list --json"
+      ],
+      inspect: [
+        "acp-devtools inspect 12",
+        "",
+        "# Only request/response frames for one method",
+        "acp-devtools inspect 12 --method session/prompt --paired"
+      ],
+      search: ["acp-devtools search session/prompt", "acp-devtools search rate_limit --in-payload"],
+      stats: ["acp-devtools stats 12", "acp-devtools stats 12 --by-method"],
+      diff: ["# Worked yesterday, broke today?", "acp-devtools diff 41 42"],
+      export: [
+        "acp-devtools export 12 -o session-12.json",
+        "",
+        "# Straight to stdout for sharing",
+        "acp-devtools export 12 > session-12.json"
+      ],
+      import: ["acp-devtools import session-12.json"],
+      delete: ["acp-devtools delete 12", "acp-devtools delete 12 13 14"],
+      replay: ["acp-devtools replay 12", "acp-devtools replay --file session-12.json"],
+      validate: ["acp-devtools validate 12"],
+      "session-info": ["acp-devtools session-info 12"],
+      doctor: ["acp-devtools doctor"],
+      mcp: ["# Read-only MCP server over stdio (wire into .claude/mcp_servers.json)", "acp-devtools mcp"],
+      "backfill-metadata": [
+        "acp-devtools backfill-metadata",
+        "",
+        "# Recompute a single session",
+        "acp-devtools backfill-metadata 12"
+      ]
+    };
+    INDENT = "  ";
+    GAP = 3;
+  }
+});
 
 // src/program.ts
+var program_exports = {};
+__export(program_exports, {
+  buildProgram: () => buildProgram
+});
+import { Command } from "commander";
 function buildProgram() {
-  const program2 = new Command();
-  program2.name("acp-devtools").description("Visual debugger / inspector for the Agent Client Protocol (ACP)").version(CLI_VERSION).enablePositionalOptions();
-  configureCliHelp(program2);
-  registerProxyCommand(program2);
-  registerReplayCommand(program2);
-  registerUiCommand(program2);
-  registerDoctorCommand(program2);
-  registerExportCommand(program2);
-  registerImportCommand(program2);
-  registerDeleteCommand(program2);
-  registerDiffCommand(program2);
-  registerListCommand(program2);
-  registerInspectCommand(program2);
-  registerSearchCommand(program2);
-  registerSessionInfoCommand(program2);
-  registerStatsCommand(program2);
-  registerBackfillMetadataCommand(program2);
-  registerMcpCommand(program2);
-  registerMockAgentCommand(program2);
-  registerMockEditorCommand(program2);
-  registerValidateCommand(program2);
-  return program2;
+  const program = new Command();
+  program.name("acp-devtools").description("Visual debugger / inspector for the Agent Client Protocol (ACP)").version(CLI_VERSION).enablePositionalOptions();
+  configureCliHelp(program);
+  registerProxyCommand(program);
+  registerReplayCommand(program);
+  registerUiCommand(program);
+  registerDoctorCommand(program);
+  registerExportCommand(program);
+  registerImportCommand(program);
+  registerDeleteCommand(program);
+  registerDiffCommand(program);
+  registerListCommand(program);
+  registerInspectCommand(program);
+  registerSearchCommand(program);
+  registerSessionInfoCommand(program);
+  registerStatsCommand(program);
+  registerBackfillMetadataCommand(program);
+  registerMcpCommand(program);
+  registerMockAgentCommand(program);
+  registerMockEditorCommand(program);
+  registerValidateCommand(program);
+  return program;
+}
+var init_program = __esm({
+  "src/program.ts"() {
+    "use strict";
+    init_backfill_metadata();
+    init_delete();
+    init_diff();
+    init_doctor();
+    init_export2();
+    init_import();
+    init_inspect();
+    init_list();
+    init_mcp();
+    init_mock_agent();
+    init_mock_editor();
+    init_proxy3();
+    init_replay2();
+    init_search();
+    init_session_info();
+    init_stats();
+    init_ui();
+    init_validate2();
+    init_help();
+    init_version();
+  }
+});
+
+// src/lib/native-error.ts
+var BINDING_PATTERNS = [
+  /Could not locate the bindings file/i,
+  /better[_-]sqlite3/i,
+  /node[_-]gyp/i,
+  /prebuild[-_]install/i,
+  /\.node['"]?\)?:?\s/i,
+  /Cannot find module .*\.node/i,
+  /NODE_MODULE_VERSION/i
+];
+function isNativeBindingError(err) {
+  if (!err) return false;
+  const msg = err instanceof Error ? `${err.message}
+${err.stack ?? ""}` : String(err);
+  return BINDING_PATTERNS.some((re) => re.test(msg));
+}
+function detectInstallSource(ctx) {
+  const p = (ctx.binaryPath ?? "").toLowerCase();
+  if (!p) return "unknown";
+  if (p.includes("/cellar/acp-devtools/") || p.includes("/homebrew/")) {
+    return "homebrew";
+  }
+  if (p.includes("linuxbrew")) return "homebrew";
+  if (p.includes("/lib/node_modules/acp-devtools") || p.includes("\\node_modules\\acp-devtools") || p.includes("/npm/node_modules/acp-devtools") || p.includes("\\npm\\acp-devtools")) {
+    return "npm-global";
+  }
+  return "unknown";
+}
+function formatNativeBindingMessage(err, ctx) {
+  const source = detectInstallSource(ctx);
+  const detail = err instanceof Error ? err.message : String(err ?? "unknown error");
+  const lines = [
+    "acp-devtools: native module `better-sqlite3` failed to load.",
+    "",
+    "The SQLite binding (`build/Release/better_sqlite3.node`) is missing or",
+    "incompatible with this Node version. acp-devtools needs it to read and",
+    "write the captures database \u2014 every command depends on it.",
+    ""
+  ];
+  if (source === "homebrew") {
+    lines.push(
+      "You installed via Homebrew. Rebuild the binding in place:",
+      "",
+      '    PREFIX="$(brew --prefix acp-devtools)/libexec/lib/node_modules/acp-devtools"',
+      '    npm rebuild --prefix "$PREFIX" better-sqlite3',
+      "",
+      "Or reinstall once the formula fix lands:",
+      "",
+      "    brew update && brew reinstall acp-devtools",
+      ""
+    );
+  } else if (source === "npm-global") {
+    lines.push(
+      "You installed via `npm i -g`. Rebuild the binding:",
+      "",
+      "    npm rebuild -g better-sqlite3",
+      "",
+      "If that fails the prebuild lookup probably has no match for your Node",
+      "version, and source build needs Python 3 + a C++ toolchain (Xcode CLT",
+      "on macOS, build-essential on Linux, Visual Studio Build Tools on",
+      "Windows). Install those and retry, or pin to an older Node major.",
+      ""
+    );
+  } else {
+    lines.push(
+      "Try rebuilding the native dependency:",
+      "",
+      "    npm rebuild better-sqlite3",
+      "",
+      "If you installed globally via npm, add `-g`. If via Homebrew, run",
+      "`brew reinstall acp-devtools` once the formula is patched.",
+      ""
+    );
+  }
+  lines.push(
+    `Underlying error: ${detail}`,
+    `Node: ${process.version} \xB7 platform: ${process.platform}/${process.arch}`,
+    "Report unresolved cases at https://github.com/maksugr/acp-devtools/issues"
+  );
+  return lines.join("\n") + "\n";
 }
 
 // src/index.ts
@@ -13258,10 +14112,10 @@ var KNOWN_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "-V",
   "--version"
 ]);
-function expandArgv(rawArgs) {
+function expandArgv(rawArgs, defaultAgent, isAgentShortcut2) {
   if (rawArgs.length === 0) {
     if (!process.stdin.isTTY) {
-      return ["proxy", "--agent", DEFAULT_AGENT];
+      return ["proxy", "--agent", defaultAgent];
     }
     return rawArgs;
   }
@@ -13269,16 +14123,53 @@ function expandArgv(rawArgs) {
   if (KNOWN_SUBCOMMANDS.has(first)) {
     return rawArgs;
   }
-  if (isAgentShortcut(first)) {
+  if (isAgentShortcut2(first)) {
     return ["proxy", "--agent", first, ...rawArgs.slice(1)];
   }
-  return ["proxy", ...rawArgs];
+  return rawArgs;
 }
-var expanded = expandArgv(process.argv.slice(2));
-var program = buildProgram();
-program.parseAsync([process.argv[0], process.argv[1], ...expanded]).catch((err) => {
-  process.stderr.write(`acp-devtools: ${err instanceof Error ? err.message : String(err)}
-`);
+function reportFatal(err, prefix = "acp-devtools") {
+  if (isNativeBindingError(err)) {
+    process.stderr.write(
+      formatNativeBindingMessage(err, {
+        binaryPath: process.argv[1] ?? ""
+      })
+    );
+    process.exit(1);
+  }
+  process.stderr.write(
+    `${prefix}: ${err instanceof Error ? err.message : String(err)}
+`
+  );
   process.exit(1);
-});
+}
+async function main() {
+  let core;
+  let buildProgram2;
+  try {
+    core = await Promise.resolve().then(() => (init_dist(), dist_exports));
+    ({ buildProgram: buildProgram2 } = await Promise.resolve().then(() => (init_program(), program_exports)));
+  } catch (err) {
+    reportFatal(err, "acp-devtools: failed to start");
+  }
+  const expanded = expandArgv(
+    process.argv.slice(2),
+    core.DEFAULT_AGENT,
+    core.isAgentShortcut
+  );
+  const program = buildProgram2();
+  try {
+    await program.parseAsync([
+      process.argv[0],
+      process.argv[1],
+      ...expanded
+    ]);
+  } catch (err) {
+    reportFatal(err);
+  }
+}
+main();
+export {
+  expandArgv
+};
 //# sourceMappingURL=index.js.map