debuganything 0.0.0-stage → 1.0.0

package/dist/chunk-VGYXHXTY.js

@@ -0,0 +1,1015 @@
+#!/usr/bin/env node
+import {
+  dockerAdapter
+} from "./chunk-YY6M5RIJ.js";
+import {
+  psmemAdapter,
+  snapshotMemoryGeneric
+} from "./chunk-EMR42ZJQ.js";
+import {
+  fsUsageAdapter,
+  gdbAdapter,
+  jvmAdapter,
+  lldbAdapter,
+  mergeResults,
+  perfAdapter,
+  pyspyAdapter,
+  sampleMacosAdapter,
+  straceAdapter,
+  tcpdumpAdapter
+} from "./chunk-MLDOO673.js";
+import {
+  lsofAdapter
+} from "./chunk-NFL22T3H.js";
+import {
+  ResultBuilder,
+  failedResult,
+  humanBytes
+} from "./chunk-5BXTDASF.js";
+import {
+  listProcesses,
+  resolveTarget
+} from "./chunk-5RAKTYW5.js";
+import {
+  ToolArgs,
+  ToolName,
+  createSession,
+  detachSession,
+  loadRun,
+  loadSession,
+  platform,
+  recordRun,
+  requireAttached,
+  saveSession,
+  sessionsDir
+} from "./chunk-D742WJPT.js";
+import {
+  VERSION
+} from "./chunk-32IDKAZK.js";
+import {
+  ConsentRequiredError,
+  isRoot,
+  redact,
+  requireConsent
+} from "./chunk-STFC7C5C.js";
+
+// src/tools.ts
+import { join as join2 } from "path";
+import { writeFile } from "fs/promises";
+
+// src/readiness.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync } from "fs";
+import { delimiter, join } from "path";
+import { arch, release } from "os";
+import { execa } from "execa";
+
+// src/adapters/heap_node.ts
+import { createWriteStream } from "fs";
+import { readFile } from "fs/promises";
+function summarizeHeapSnapshot(json, topN = 15) {
+  const snap = JSON.parse(json);
+  const nf = snap.snapshot.meta.node_fields;
+  const ef = snap.snapshot.meta.edge_fields;
+  const nodeTypes = snap.snapshot.meta.node_types[0];
+  const edgeTypes = snap.snapshot.meta.edge_types[0];
+  const NF = nf.length;
+  const EF = ef.length;
+  const iType = nf.indexOf("type");
+  const iName = nf.indexOf("name");
+  const iSize = nf.indexOf("self_size");
+  const iEdges = nf.indexOf("edge_count");
+  const eType = ef.indexOf("type");
+  const eName = ef.indexOf("name_or_index");
+  const eTo = ef.indexOf("to_node");
+  const nodes = snap.nodes;
+  const edges = snap.edges;
+  const strings = snap.strings;
+  const n = nodes.length / NF;
+  const firstEdge = new Uint32Array(n + 1);
+  for (let i = 0, e = 0; i < n; i++) {
+    firstEdge[i] = e;
+    e += nodes[i * NF + iEdges] * EF;
+  }
+  firstEdge[n] = edges.length;
+  const byType = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (let i = 0; i < n; i++) {
+    const t = nodeTypes[nodes[i * NF + iType]] ?? "?";
+    const nm = strings[nodes[i * NF + iName]] ?? "?";
+    const s = nodes[i * NF + iSize];
+    total += s;
+    const bt = byType.get(t) ?? { count: 0, self_size: 0 };
+    bt.count++;
+    bt.self_size += s;
+    byType.set(t, bt);
+    const key = t === "object" || t === "closure" || t === "array" ? nm : `(${t})`;
+    const bn = byName.get(key) ?? { type: t, count: 0, self_size: 0 };
+    bn.count++;
+    bn.self_size += s;
+    byName.set(key, bn);
+  }
+  const weakIdx = edgeTypes.indexOf("weak");
+  const shortcutIdx = edgeTypes.indexOf("shortcut");
+  const traversable = (etIdx) => etIdx !== weakIdx && etIdx !== shortcutIdx;
+  const strong = new Set(["property", "element", "internal", "hidden", "shortcut", "context"].map((t) => edgeTypes.indexOf(t)).filter((i) => i >= 0));
+  const typeOf = (i) => nodeTypes[nodes[i * NF + iType]] ?? "?";
+  const nameOf = (i) => strings[nodes[i * NF + iName]] ?? "?";
+  const reach = (skip) => {
+    const visited = new Uint8Array(n);
+    const queue = new Int32Array(n);
+    let head = 0;
+    let tail = 0;
+    queue[tail++] = 0;
+    visited[0] = 1;
+    let bytes = 0;
+    let count = 0;
+    while (head < tail) {
+      const i = queue[head++];
+      count++;
+      bytes += nodes[i * NF + iSize];
+      for (let e = firstEdge[i]; e < firstEdge[i + 1]; e += EF) {
+        if (!traversable(edges[e + eType])) continue;
+        const to = edges[e + eTo] / NF;
+        if (to === skip || visited[to]) continue;
+        visited[to] = 1;
+        queue[tail++] = to;
+      }
+    }
+    return { count, bytes };
+  };
+  const full = reach(-1);
+  const candidates = /* @__PURE__ */ new Set();
+  const bySelf = Array.from({ length: n }, (_, i) => i).sort((a, b) => nodes[b * NF + iSize] - nodes[a * NF + iSize]).slice(0, 30);
+  for (const i of bySelf) candidates.add(i);
+  const byEdges = Array.from({ length: n }, (_, i) => i).sort((a, b) => nodes[b * NF + iEdges] - nodes[a * NF + iEdges]).slice(0, 30);
+  for (const i of byEdges) candidates.add(i);
+  const retained = [];
+  const skipTypes = /* @__PURE__ */ new Set(["synthetic", "hidden", "array", "code", "object shape", "number", "bigint", "symbol", "regexp"]);
+  for (const start of candidates) {
+    if (start === 0 || skipTypes.has(typeOf(start))) continue;
+    if (nameOf(start).startsWith("(") && typeOf(start) !== "native") continue;
+    const without = reach(start);
+    const sum = Math.max(nodes[start * NF + iSize], full.bytes - without.bytes);
+    retained.push({ name: nameOf(start).slice(0, 80) || `(${typeOf(start)})`, type: typeOf(start), retained_bytes: sum, self_size: nodes[start * NF + iSize], idx: start });
+  }
+  retained.sort((a, b) => b.retained_bytes - a.retained_bytes);
+  const top = retained.slice(0, topN);
+  const wanted = /* @__PURE__ */ new Map();
+  for (const r of top) if (r.idx !== void 0) wanted.set(r.idx, r);
+  const best = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n && wanted.size; i++) {
+    for (let e = firstEdge[i]; e < firstEdge[i + 1]; e += EF) {
+      const to = edges[e + eTo] / NF;
+      const r = wanted.get(to);
+      if (!r) continue;
+      const etIdx = edges[e + eType];
+      if (!strong.has(etIdx)) continue;
+      const et = edgeTypes[etIdx];
+      const en = et === "element" || et === "hidden" ? `[${edges[e + eName]}]` : strings[edges[e + eName]] ?? "?";
+      const ownerName = nameOf(i) || `(${typeOf(i)})`;
+      const score = (et === "context" ? 3 : et === "property" ? 2 : et === "internal" ? 1 : 0) + (ownerName.startsWith("(") ? 0 : 1);
+      const prev = best.get(to);
+      if (!prev || score > prev.score) best.set(to, { score, label: `${ownerName.slice(0, 40)}.${en}` });
+    }
+  }
+  for (const r of top) if (r.idx !== void 0) r.retainer = best.get(r.idx)?.label;
+  for (const r of top) delete r.idx;
+  return {
+    node_count: n,
+    edge_count: edges.length / EF,
+    total_size: total,
+    byType: [...byType].map(([type, v]) => ({ type, ...v })).sort((a, b) => b.self_size - a.self_size),
+    byName: [...byName].map(([name, v]) => ({ name, ...v })).sort((a, b) => b.self_size - a.self_size).slice(0, 25),
+    topRetained: top
+  };
+}
+async function listInspectorTargets(port = 9229, host = "127.0.0.1") {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), 2e3);
+  try {
+    const r = await fetch(`http://${host}:${port}/json/list`, { signal: ctrl.signal });
+    if (!r.ok) return [];
+    return await r.json();
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(t);
+  }
+}
+var Cdp = class _Cdp {
+  ws;
+  id = 0;
+  pending = /* @__PURE__ */ new Map();
+  events = /* @__PURE__ */ new Map();
+  constructor(ws) {
+    this.ws = ws;
+    ws.addEventListener("message", (ev) => {
+      const msg = JSON.parse(String(ev.data));
+      if (msg.id !== void 0) {
+        const p = this.pending.get(msg.id);
+        this.pending.delete(msg.id);
+        if (!p) return;
+        if (msg.error) p.reject(new Error(msg.error.message));
+        else p.resolve(msg.result);
+      } else if (msg.method) {
+        for (const h of this.events.get(msg.method) ?? []) h(msg.params);
+      }
+    });
+  }
+  static connect(url, timeoutMs = 5e3) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(url);
+      const t = setTimeout(() => {
+        ws.close();
+        reject(new Error("inspector connect timeout"));
+      }, timeoutMs);
+      ws.addEventListener("open", () => {
+        clearTimeout(t);
+        resolve(new _Cdp(ws));
+      });
+      ws.addEventListener("error", () => {
+        clearTimeout(t);
+        reject(new Error("inspector websocket error"));
+      });
+    });
+  }
+  on(method, h) {
+    this.events.set(method, [...this.events.get(method) ?? [], h]);
+  }
+  send(method, params = {}, timeoutMs = 3e4) {
+    const id = ++this.id;
+    this.ws.send(JSON.stringify({ id, method, params }));
+    return new Promise((resolve, reject) => {
+      const t = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timeout`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(t);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(t);
+          reject(e);
+        }
+      });
+    });
+  }
+  close() {
+    try {
+      this.ws.close();
+    } catch {
+    }
+  }
+};
+async function findInspector(pid, b, allowSignal) {
+  const ports = [9229, 9230, 9231, 9222];
+  const probe = async () => {
+    for (const port of ports) {
+      const list = await listInspectorTargets(port);
+      const t = list.find((x) => x.webSocketDebuggerUrl);
+      if (t) return { url: t.webSocketDebuggerUrl, port };
+    }
+    return void 0;
+  };
+  let found = await probe();
+  if (found) return found;
+  if (!allowSignal) return void 0;
+  try {
+    process.kill(pid, "SIGUSR1");
+    b.limitation(`sent SIGUSR1 to pid ${pid} to activate Node's inspector on 127.0.0.1:9229 (it stays enabled until the process exits)`);
+  } catch (err) {
+    b.limitation(`could not send SIGUSR1 to pid ${pid}: ${err.message}`);
+    return void 0;
+  }
+  for (let i = 0; i < 10 && !found; i++) {
+    await new Promise((r) => setTimeout(r, 300));
+    found = await probe();
+  }
+  return found;
+}
+async function takeHeapSnapshot(url, outPath) {
+  const cdp = await Cdp.connect(url);
+  const file = createWriteStream(outPath);
+  let bytes = 0;
+  let chunks = 0;
+  cdp.on("HeapProfiler.addHeapSnapshotChunk", (p) => {
+    const chunk = p.chunk;
+    bytes += chunk.length;
+    chunks++;
+    file.write(chunk);
+  });
+  try {
+    await cdp.send("HeapProfiler.enable");
+    await cdp.send("HeapProfiler.takeHeapSnapshot", { reportProgress: false, treatGlobalObjectsAsRoots: true, captureNumericValue: false }, 55e3);
+  } finally {
+    cdp.close();
+    await new Promise((r) => file.end(() => r()));
+  }
+  return { bytes, chunks };
+}
+async function snapshotMemory(ctx, args) {
+  const base = await snapshotMemoryGeneric(ctx, args);
+  if (args.heap === false) return base;
+  const { session, target } = ctx;
+  const b = new ResultBuilder("snapshot_memory", session, target);
+  const pid = target.pid;
+  const insp = await findInspector(pid, b, true);
+  if (!insp) {
+    b.limitation("no Node inspector reachable on 127.0.0.1:9229-9231 and SIGUSR1 did not open one; start the target with --inspect for heap snapshots");
+    return mergeResults(base, b.build(), []);
+  }
+  const outPath = b.artifactPath("heap.heapsnapshot");
+  let took;
+  try {
+    took = await takeHeapSnapshot(insp.url, outPath);
+    b.limitation(`heap snapshot: ${took.chunks} chunks, ${Math.round(took.bytes / 1024 / 1024)} MB JSON`);
+  } catch (err) {
+    b.limitation(`heap snapshot failed: ${err.message}`);
+    return mergeResults(base, b.build(), []);
+  }
+  await b.addArtifact(outPath, "heapsnapshot", { description: `V8 heap snapshot via inspector :${insp.port} (open in Chrome DevTools \u2192 Memory \u2192 Load)` });
+  let summary;
+  try {
+    summary = summarizeHeapSnapshot(await readFile(outPath, "utf8"));
+  } catch (err) {
+    b.limitation(`could not parse heap snapshot: ${err.message}`);
+    return mergeResults(base, b.build(), []);
+  }
+  const sumEv = b.evidenceOf("heap_summary", `heap ${humanBytes(summary.total_size)} in ${summary.node_count} objects; by type: ${summary.byType.slice(0, 4).map((t) => `${t.type} ${humanBytes(t.self_size)}`).join(", ")}`, { name: "heap_total", bytes: summary.total_size, objects: summary.node_count, by_type: summary.byType.slice(0, 8) }, { artifact: outPath });
+  const nameEv = b.evidenceOf("heap_summary", `by constructor (self size): ${summary.byName.slice(0, 5).map((x) => `${x.name} ${humanBytes(x.self_size)}\xD7${x.count}`).join(", ")}`, summary.byName.map((x) => ({ name: x.name, type: x.type, count: x.count, bytes: x.self_size })), { artifact: outPath });
+  const retEv = b.evidenceOf("heap_retainer", `top retainers: ${summary.topRetained.slice(0, 4).map((r) => `${r.name} (${r.type}) retains ${humanBytes(r.retained_bytes)}${r.retainer ? ` via ${r.retainer}` : ""}`).join("; ")}`, summary.topRetained.map((r) => ({ name: r.name, type: r.type, retained_bytes: r.retained_bytes, self_size: r.self_size, retainer: r.retainer })), { artifact: outPath });
+  const top = summary.topRetained[0];
+  if (top && top.retained_bytes > summary.total_size * 0.2 && top.type !== "synthetic") {
+    b.finding("warn", `${top.name} (${top.type}) retains ${humanBytes(top.retained_bytes)} = ${Math.round(100 * top.retained_bytes / summary.total_size)}% of the heap${top.retainer ? `, held by ${top.retainer}` : ""}`, [retEv, sumEv], "observed", "Take another snapshot_memory after load and diff_runs: if this retainer grows, it is the leak.");
+  }
+  const bigArrays = summary.byName.find((x) => x.type === "array" || x.name === "Array");
+  if (bigArrays && bigArrays.self_size > summary.total_size * 0.25) b.finding("info", `arrays hold ${humanBytes(bigArrays.self_size)} (${Math.round(100 * bigArrays.self_size / summary.total_size)}% of heap)`, [nameEv]);
+  b.limitation(`retained sizes are a reachability approximation (shared subgraphs are over-counted); open the .heapsnapshot in Chrome DevTools for exact dominator-tree numbers`);
+  b.next("snapshot_memory (again, after load)", "diff_runs");
+  return mergeResults(base, b.build(), []);
+}
+async function dumpStacks(ctx) {
+  const { session, target } = ctx;
+  const b = new ResultBuilder("dump_stacks", session, target);
+  const pid = target.pid;
+  const insp = await findInspector(pid, b, true);
+  if (!insp) {
+    b.limitation("no Node inspector reachable; falling back needs gdb/lldb (native frames only)");
+    return b.fail("node inspector not available; cannot attach").build();
+  }
+  const cdp = await Cdp.connect(insp.url);
+  try {
+    const paused = new Promise((resolve) => cdp.on("Debugger.paused", resolve));
+    await cdp.send("Debugger.enable");
+    const t0 = Date.now();
+    await cdp.send("Debugger.pause");
+    const p = await Promise.race([paused, new Promise((r) => setTimeout(() => r(void 0), 3e3))]);
+    const pauseLatency = Date.now() - t0;
+    if (p) await cdp.send("Debugger.resume").catch(() => void 0);
+    else await cdp.send("Debugger.disable").catch(() => void 0);
+    const frames = (p?.callFrames ?? []).map((f) => ({ func: f.functionName || "(anonymous)", file: f.url.replace(/^file:\/\//, "") || "(internal)", line: f.location.lineNumber + 1 }));
+    const userFrames = frames.filter((f) => !/^node:|^\(internal\)$/.test(f.file));
+    const raw = frames.map((f) => `${f.func} (${f.file}:${f.line})`).join("\n") || "(event loop idle: no JS frames on the stack)";
+    const art = await b.writeArtifact("node-stack.txt", raw, "raw_text", "Node main-thread JS stack via inspector Debugger.pause");
+    const ev = b.evidenceOf(
+      "stack",
+      frames.length ? `main thread (pause latency ${pauseLatency} ms): ${frames.slice(0, 4).map((f) => `${f.func}@${f.file.split("/").pop()}:${f.line}`).join(" \u2190 ")}` : `main thread idle in the event loop (no JS frames after ${pauseLatency} ms)`,
+      { thread: "main", pause_latency_ms: pauseLatency, frames, user_frames: userFrames.length },
+      { artifact: art }
+    );
+    if (userFrames.length && pauseLatency < 100) {
+      const f = userFrames[0];
+      b.finding("warn", `Node main thread is executing ${f.func} (${f.file.split("/").pop()}:${f.line}) \u2014 a synchronous task is running on the event loop`, [ev], "observed", `Hot JS stack: ${userFrames.slice(0, 5).map((x) => `${x.func}@${x.file.split("/").pop()}:${x.line}`).join(" \u2190 ")}. Handoff: attach a step debugger (e.g. mcp-debugger) at ${f.file}:${f.func}. Run profile_cpu to see if it is CPU-bound.`);
+    } else if (userFrames.length) {
+      b.finding("info", `caught the event loop in user code ${userFrames[0].func} (${userFrames[0].file.split("/").pop()}:${userFrames[0].line}) after ${pauseLatency} ms \u2014 a tick was running, not necessarily blocked`, [ev], "observed");
+    } else {
+      b.finding("info", `Node main thread was idle in the event loop (first JS tick after ${pauseLatency} ms was ${frames[0] ? `${frames[0].func} in ${frames[0].file}` : "none"}) \u2014 not stuck in JS; if callers hang, the work is pending on I/O or timers (inspect_sockets, trace_syscalls)`, [ev], "inferred");
+    }
+    b.limitation("JS main thread only; worker threads and libuv threadpool are not shown (use gdb/lldb for native threads)");
+    b.next("profile_cpu", "trace_syscalls", "inspect_sockets");
+    return b.build();
+  } finally {
+    cdp.close();
+  }
+}
+var heapNodeAdapter = {
+  name: "node-inspector",
+  tools: ["snapshot_memory", "dump_stacks"],
+  platforms: ["linux", "darwin"],
+  requires: [],
+  runtimes: ["node"],
+  priority: 20,
+  check(base) {
+    base.notes.push("uses Node's inspector protocol; sends SIGUSR1 to enable it if the target was not started with --inspect");
+    return base;
+  },
+  async run(tool, args, ctx) {
+    if (tool === "snapshot_memory") return snapshotMemory(ctx, args);
+    if (tool === "dump_stacks") return dumpStacks(ctx);
+    throw new Error(`node-inspector adapter cannot run ${tool}`);
+  }
+};
+
+// src/adapters/bpftrace.ts
+var bpftraceAdapter = {
+  name: "bpftrace",
+  tools: [],
+  platforms: ["linux"],
+  requires: ["bpftrace"],
+  install: { linux: "sudo apt install bpftrace" },
+  async run() {
+    throw new Error("bpftrace adapter is not implemented in v0");
+  }
+};
+
+// src/adapters/index.ts
+var adapters = [
+  jvmAdapter,
+  lsofAdapter,
+  pyspyAdapter,
+  straceAdapter,
+  fsUsageAdapter,
+  gdbAdapter,
+  lldbAdapter,
+  heapNodeAdapter,
+  psmemAdapter,
+  perfAdapter,
+  sampleMacosAdapter,
+  tcpdumpAdapter,
+  dockerAdapter,
+  bpftraceAdapter
+];
+function candidatesFor(tool, target, readiness) {
+  const ready = [];
+  const blocked = [];
+  for (const a of adapters) {
+    if (!a.tools.includes(tool)) continue;
+    const status = readiness.providers.find((p) => p.name === a.name);
+    if (a.runtimes && target.runtime && !a.runtimes.includes(target.runtime)) {
+      blocked.push({ adapter: a, reason: `serves ${a.runtimes.join("/")} targets, target is ${target.runtime}` });
+      continue;
+    }
+    if (!status || status.status !== "ready") {
+      blocked.push({ adapter: a, reason: `${status?.status ?? "unknown"}${status?.install_hint ? ` \u2014 ${status.install_hint}` : ""}` });
+      continue;
+    }
+    ready.push(a);
+  }
+  ready.sort((x, y) => (y.priority ?? 0) - (x.priority ?? 0));
+  return { ready, blocked };
+}
+
+// src/readiness.ts
+function which(binary) {
+  const paths = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  const extra = platform() === "darwin" ? ["/usr/sbin", "/sbin", "/opt/homebrew/bin", "/usr/local/bin"] : ["/usr/sbin", "/sbin", "/usr/local/bin"];
+  for (const p of [...paths, ...extra]) {
+    const full = join(p, binary);
+    if (existsSync(full)) return full;
+  }
+  return null;
+}
+async function readIntFile(path) {
+  try {
+    const v = parseInt((await readFile2(path, "utf8")).trim(), 10);
+    return Number.isFinite(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+async function sudoNonInteractive() {
+  if (!which("sudo")) return false;
+  try {
+    const r = await execa("sudo", ["-n", "true"], { reject: false, timeout: 3e3 });
+    return r.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function sipEnabled() {
+  if (platform() !== "darwin") return null;
+  try {
+    const r = await execa("csrutil", ["status"], { reject: false, timeout: 3e3 });
+    if (/enabled/i.test(r.stdout)) return true;
+    if (/disabled/i.test(r.stdout)) return false;
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function developerMode() {
+  if (platform() !== "darwin") return null;
+  try {
+    const r = await execa("DevToolsSecurity", ["-status"], { reject: false, timeout: 3e3 });
+    if (/enabled/i.test(r.stdout)) return true;
+    if (/disabled/i.test(r.stdout)) return false;
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function linuxCapabilities() {
+  if (platform() !== "linux") return [];
+  try {
+    const status = await readFile2("/proc/self/status", "utf8");
+    const m = /CapEff:\s*([0-9a-f]+)/i.exec(status);
+    if (!m) return [];
+    const eff = BigInt("0x" + m[1]);
+    const caps = [];
+    if (eff & 1n << 19n) caps.push("CAP_SYS_PTRACE");
+    if (eff & 1n << 13n) caps.push("CAP_NET_RAW");
+    if (eff & 1n << 12n) caps.push("CAP_NET_ADMIN");
+    if (eff & 1n << 21n) caps.push("CAP_SYS_ADMIN");
+    if (eff & 1n << 38n) caps.push("CAP_PERFMON");
+    if (eff & 1n << 39n) caps.push("CAP_BPF");
+    return caps;
+  } catch {
+    return [];
+  }
+}
+async function probeReadiness() {
+  const os = platform();
+  const root = isRoot();
+  const [ptraceScope, perfParanoid, sudo, sip, dev, caps] = await Promise.all([
+    os === "linux" ? readIntFile("/proc/sys/kernel/yama/ptrace_scope") : Promise.resolve(null),
+    os === "linux" ? readIntFile("/proc/sys/kernel/perf_event_paranoid") : Promise.resolve(null),
+    sudoNonInteractive(),
+    sipEnabled(),
+    developerMode(),
+    linuxCapabilities()
+  ]);
+  const providers = [];
+  for (const a of adapters) {
+    const requires = a.requires.map((b) => ({ binary: b, path: which(b) }));
+    const missing = requires.filter((r) => !r.path).map((r) => r.binary);
+    let status = "ready";
+    const notes = [];
+    if (!a.platforms.includes(os)) status = "unsupported_platform";
+    else if (a.tools.length === 0) status = "not_implemented";
+    else if (missing.length) status = "missing";
+    let base = {
+      name: a.name,
+      tools: a.tools,
+      status,
+      requires,
+      install_hint: status === "missing" ? a.install?.[os] : void 0,
+      notes
+    };
+    if (a.check && status === "ready") {
+      base = await a.check(base, { platform: os, isRoot: root, ptraceScope, perfParanoid });
+    }
+    if (a.runtimes?.length) base.notes.push(`serves ${a.runtimes.join("/")} targets`);
+    providers.push(base);
+  }
+  const available = /* @__PURE__ */ new Set();
+  const unavailable = /* @__PURE__ */ new Map();
+  for (const t of ToolName.options) {
+    if (["readiness", "attach", "detach", "list_processes", "diff_runs", "report", "import_artifact"].includes(t)) {
+      available.add(t);
+      continue;
+    }
+    const serving = providers.filter((p) => p.tools.includes(t));
+    if (serving.some((p) => p.status === "ready")) available.add(t);
+    else {
+      const reasons = serving.map((p) => `${p.name}: ${p.status}${p.install_hint ? ` (${p.install_hint})` : ""}`);
+      unavailable.set(t, reasons.join("; ") || "no adapter on this platform");
+    }
+  }
+  return {
+    os,
+    arch: arch(),
+    kernel: release(),
+    node: process.version,
+    dea_version: VERSION,
+    is_root: root,
+    has_sudo_noninteractive: sudo,
+    permissions: {
+      ptrace_scope: ptraceScope,
+      capabilities: caps,
+      sip_enabled: sip,
+      developer_mode: dev,
+      perf_event_paranoid: perfParanoid
+    },
+    providers,
+    tools_available: [...available],
+    tools_unavailable: [...unavailable].map(([tool, reason]) => ({ tool, reason })),
+    sessions_dir: sessionsDir()
+  };
+}
+
+// src/diff.ts
+var KEY_FIELDS = ["name", "frame", "function", "syscall", "remote", "type", "path", "fd", "state", "constructor", "key", "thread", "metric", "label"];
+var NUM_FIELDS = ["value", "retained_bytes", "self_size", "bytes", "rss_kb", "vsz_kb", "total_ms", "self", "total", "count", "packets", "errors", "objects", "fds", "samples", "self_pct", "total_pct"];
+function keyOf(row) {
+  for (const k of KEY_FIELDS) {
+    const v = row[k];
+    if (typeof v === "string" || typeof v === "number") return `${k}=${v}`;
+  }
+  return void 0;
+}
+function numericFields(row) {
+  const out = {};
+  for (const k of NUM_FIELDS) if (typeof row[k] === "number") out[k] = row[k];
+  return out;
+}
+function diffEvidence(a, b) {
+  const byKind = {};
+  const metrics = [];
+  const kinds = /* @__PURE__ */ new Set([...a.map((e) => e.kind), ...b.map((e) => e.kind)]);
+  for (const kind of kinds) {
+    const rowsA = /* @__PURE__ */ new Map();
+    const rowsB = /* @__PURE__ */ new Map();
+    const collect = (list, into) => {
+      for (const e of list.filter((x) => x.kind === kind)) {
+        if (Array.isArray(e.data)) {
+          for (const r of e.data) {
+            if (r && typeof r === "object") {
+              const k = keyOf(r);
+              if (k) into.set(k, r);
+            }
+          }
+        } else if (e.data && typeof e.data === "object") {
+          const r = e.data;
+          const nums = numericFields(r);
+          if (Object.keys(nums).length) into.set(keyOf(r) ?? e.summary.split(":")[0], r);
+        }
+      }
+    };
+    collect(a, rowsA);
+    collect(b, rowsB);
+    const entries = [];
+    for (const [k, rb] of rowsB) {
+      const ra = rowsA.get(k);
+      const nb = numericFields(rb);
+      if (!ra) {
+        const f = Object.keys(nb)[0];
+        entries.push({ key: k, status: "appeared", field: f, b: f ? nb[f] : void 0 });
+        continue;
+      }
+      const na = numericFields(ra);
+      const field = Object.keys(nb).find((f) => f in na);
+      if (!field) continue;
+      const delta = nb[field] - na[field];
+      entries.push({ key: k, status: delta > 0 ? "grew" : delta < 0 ? "shrank" : "same", field, a: na[field], b: nb[field], delta });
+    }
+    for (const [k, ra] of rowsA) {
+      if (!rowsB.has(k)) {
+        const na = numericFields(ra);
+        const f = Object.keys(na)[0];
+        entries.push({ key: k, status: "disappeared", field: f, a: f ? na[f] : void 0 });
+      }
+    }
+    entries.sort((x, y) => Math.abs(y.delta ?? y.b ?? y.a ?? 0) - Math.abs(x.delta ?? x.b ?? x.a ?? 0));
+    if (entries.length) {
+      if (kind === "metric" || kind === "metric_series") metrics.push(...entries);
+      else byKind[kind] = entries;
+    }
+  }
+  return { byKind, metrics };
+}
+async function diffRuns(session, a, b) {
+  const rb = new ResultBuilder("diff_runs", session, session.target);
+  if (a.tool !== b.tool) rb.limitation(`comparing different tools (${a.tool} vs ${b.tool}); only overlapping evidence kinds are diffed`);
+  const { byKind, metrics } = diffEvidence(a.evidence, b.evidence);
+  const header = rb.evidenceOf("diff", `${a.run_id ?? a.tool} (${a.started_at ?? "?"}) \u2192 ${b.run_id ?? b.tool} (${b.started_at ?? "?"})`, { a: a.run_id, b: b.run_id, a_started: a.started_at, b_started: b.started_at });
+  const isBytes = (f) => Boolean(f && /bytes|rss|vsz/.test(f));
+  const fmt = (v, f) => v === void 0 ? "?" : isBytes(f) ? f?.includes("kb") ? humanBytes(v * 1024) : humanBytes(v) : String(Math.round(v * 100) / 100);
+  if (metrics.length) {
+    const ev = rb.evidenceOf("diff", `metrics: ${metrics.slice(0, 6).map((m) => `${m.key} ${fmt(m.a, m.field)}\u2192${fmt(m.b, m.field)}`).join(", ")}`, metrics.slice(0, 40));
+    for (const m of metrics) {
+      if (m.status === "grew" && m.a && m.delta / m.a > 0.2) {
+        rb.finding("warn", `${m.key} grew ${fmt(m.a, m.field)} \u2192 ${fmt(m.b, m.field)} (+${(m.delta / m.a * 100).toFixed(0)}%)`, [ev, header]);
+      }
+    }
+  }
+  for (const [kind, entries] of Object.entries(byKind)) {
+    const grew = entries.filter((e) => e.status === "grew").slice(0, 10);
+    const appeared = entries.filter((e) => e.status === "appeared").slice(0, 10);
+    const gone = entries.filter((e) => e.status === "disappeared").slice(0, 10);
+    const shrank = entries.filter((e) => e.status === "shrank").slice(0, 10);
+    const ev = rb.evidenceOf("diff", `${kind}: ${grew.length} grew, ${shrank.length} shrank, ${appeared.length} appeared, ${gone.length} disappeared`, { grew, shrank, appeared, disappeared: gone });
+    const top = grew[0];
+    if (top && top.delta && top.a !== void 0 && (top.a === 0 || top.delta / top.a > 0.1)) {
+      rb.finding(
+        kind === "heap_retainer" || kind === "heap_summary" ? "high" : "warn",
+        `${kind}: ${top.key} grew ${fmt(top.a, top.field)} \u2192 ${fmt(top.b, top.field)}${grew.length > 1 ? ` (and ${grew.length - 1} more grew)` : ""}`,
+        [ev, header]
+      );
+    }
+    if (appeared.length && !top) rb.finding("info", `${kind}: ${appeared.length} new item(s), e.g. ${appeared[0].key}`, [ev, header]);
+  }
+  if (!metrics.length && Object.keys(byKind).length === 0) {
+    rb.finding("info", "no comparable numeric evidence between the two runs", [header]);
+    rb.limitation("diff_runs compares evidence rows keyed by name/frame/syscall/remote/path/etc with numeric fields; these runs had none in common");
+  }
+  rb.next("report");
+  return rb.build();
+}
+
+// src/report.ts
+import { readFile as readFile3 } from "fs/promises";
+var SEV_ICON = { high: "\u{1F534}", warn: "\u{1F7E0}", info: "\u{1F535}" };
+async function renderReport(session) {
+  const runs = [];
+  for (const r of session.runs) {
+    try {
+      runs.push(JSON.parse(await readFile3(r.file, "utf8")));
+    } catch {
+    }
+  }
+  return renderReportFromRuns(session, runs);
+}
+function renderReportFromRuns(session, runs) {
+  const t = session.target;
+  const lines = [];
+  lines.push(`# Debug Anything session ${session.id}`);
+  lines.push("");
+  lines.push(`- **Target:** ${t.kind} \`${t.id}\`${t.pid ? ` (pid ${t.pid}` + (t.comm ? `, ${t.comm}` : "") + ")" : ""}${t.runtime ? ` \u2014 runtime ${t.runtime}` : ""}`);
+  lines.push(`- **Host:** ${t.host} (${session.platform})`);
+  lines.push(`- **Created:** ${session.created_at}${session.detached_at ? ` \xB7 **Detached:** ${session.detached_at}` : ""}`);
+  lines.push(`- **Runs:** ${runs.length} \xB7 **Artifacts dir:** \`${session.dir}\``);
+  lines.push("");
+  const all = runs.flatMap((r) => r.findings.map((f) => ({ run: r, f })));
+  const order = { high: 0, warn: 1, info: 2 };
+  all.sort((a, b) => order[a.f.severity] - order[b.f.severity]);
+  lines.push("## Findings");
+  lines.push("");
+  if (all.length === 0) lines.push("_No findings recorded._");
+  for (const { run, f } of all) {
+    lines.push(`- ${SEV_ICON[f.severity]} **${f.severity.toUpperCase()}** ${redact(f.summary)}  `);
+    lines.push(`  _${f.confidence}_ \xB7 ${run.run_id ?? run.tool} \xB7 evidence: ${f.evidence_ids.map((e) => `\`${run.run_id ?? run.tool}/${e}\``).join(", ")}`);
+    if (f.detail) lines.push(`  ${redact(f.detail)}`);
+  }
+  lines.push("");
+  lines.push("## Runs");
+  lines.push("");
+  for (const r of runs) {
+    lines.push(`### ${r.run_id ?? r.tool} \u2014 ${r.ok ? "ok" : "FAILED"} (${r.duration_ms} ms)`);
+    lines.push("");
+    if (r.error) lines.push(`**Error:** ${redact(r.error)}
+`);
+    if (r.evidence.length) {
+      lines.push("| id | kind | summary | source |");
+      lines.push("|---|---|---|---|");
+      for (const e of r.evidence) {
+        const src = e.artifact ? `\`${shortPath(e.artifact)}\`${e.lines ? ` L${e.lines[0]}\u2013${e.lines[1]}` : ""}` : "";
+        lines.push(`| ${e.id} | ${e.kind} | ${escapeCell(redact(e.summary))} | ${src} |`);
+      }
+      lines.push("");
+    }
+    if (r.limitations.length) {
+      lines.push("**Limitations:**");
+      for (const l of r.limitations) lines.push(`- ${redact(l)}`);
+      lines.push("");
+    }
+    if (r.artifacts.length) {
+      lines.push("**Artifacts:**");
+      for (const a of r.artifacts) lines.push(`- \`${a.path}\` (${a.kind}, ${a.bytes} bytes${a.truncated ? ", truncated" : ""})`);
+      lines.push("");
+    }
+    if (r.suggested_next.length) lines.push(`_Suggested next:_ ${r.suggested_next.join(", ")}
+`);
+  }
+  lines.push("---");
+  lines.push("_Generated by DEA (Debug Anything). Every finding above cites evidence ids; raw artifacts are unredacted on disk._");
+  return lines.join("\n") + "\n";
+}
+function shortPath(p) {
+  const i = p.lastIndexOf("/");
+  return i >= 0 ? p.slice(i + 1) : p;
+}
+function escapeCell(s) {
+  return s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+
+// src/tools.ts
+var NO_TARGET = { kind: "pid", id: "-", host: "local" };
+var readinessCache = null;
+async function cachedReadiness(maxAgeMs = 3e4) {
+  if (readinessCache && Date.now() - readinessCache.at < maxAgeMs) return readinessCache.value;
+  const value = await probeReadiness();
+  readinessCache = { at: Date.now(), value };
+  return value;
+}
+var TOOL_DESCRIPTIONS = {
+  readiness: "Report OS, arch, which providers (strace, py-spy, perf, lsof, tcpdump, gdb/lldb, docker...) are usable, what is missing and how to install it, and permission status (ptrace_scope, sudo, SIP). Always call this first.",
+  attach: "Resolve a target (pid, container, k8s pod, or a command to spawn under capture) and open a session. Returns session_id used by every other tool. Read-only: nothing is modified.",
+  detach: "Stop any running captures for the session, finalize the report, keep artifacts under ~/.debuganything/sessions/<id>/.",
+  list_processes: "ps-style list (pid, comm, cpu, mem, user, container) for picking a target. Optional substring filter.",
+  trace_syscalls: "Linux strace of the target for N seconds: top syscalls by total time and count, slowest individual calls, error counts (ENOENT/EAGAIN/ECONNREFUSED...), blocked waits. Raw log saved as artifact.",
+  profile_cpu: "CPU profile for N seconds: py-spy (Python), perf (native/Node on Linux), sample (macOS). Returns top frames (self/total), hottest stacks, flamegraph.svg artifact.",
+  dump_stacks: "Instant snapshot of every thread's stack (py-spy dump / gdb / lldb / Node inspector). The key tool for hangs and deadlocks; flags threads waiting on the same lock.",
+  inspect_sockets: "lsof/ss view of the target: listening ports, established connections grouped by remote, states (CLOSE_WAIT pileups, TIME_WAIT counts), fd count vs ulimit.",
+  inspect_files: "Open file descriptors by type, growth over a short window, largest open files, deleted-but-open files (disk full but nothing there).",
+  capture_traffic: "tcpdump scoped to the target's ports for N seconds (max 30). Per-remote bytes/packets, retransmits, RSTs, DNS queries, TLS SNI. .pcap artifact. REQUIRES consent: true \u2014 ask the user first.",
+  snapshot_memory: "RSS/VSZ sampled over a window; Node: heap snapshot with top retainers by retained size; Python: py-spy dump with locals. Take two and diff_runs them to find what grows.",
+  diff_runs: "Diff two prior runs of the same tool in this session (e.g. snapshot_memory#1 vs snapshot_memory#2, profile_cpu#1 vs #2): what grew, appeared, disappeared.",
+  container_info: "docker inspect/stats/top/logs tail for the target container, host pid mapping, cgroup limits: throttled? OOM-killed before? restarts?",
+  report: "Markdown report of the whole session: findings, evidence excerpts, artifact paths. Optionally written to a file.",
+  import_artifact: "Analyze raw tool output you captured yourself (e.g. `sudo strace \u2026`, `sudo fs_usage \u2026`, `perf script`, `py-spy dump`, `lsof -F`, `tcpdump -nn -tt -r`) and turn it into the same evidence and findings Debug Anything would produce. Use when Debug Anything could not run the tool (no root, macOS)."
+};
+async function runTool(name, rawArgs) {
+  const schema = ToolArgs[name];
+  if (!schema) return failedResult(name, null, NO_TARGET, `unknown tool: ${name}`);
+  const parsed = schema.safeParse(rawArgs);
+  if (!parsed.success) {
+    return failedResult(name, null, NO_TARGET, `invalid arguments: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`);
+  }
+  const args = parsed.data;
+  try {
+    switch (name) {
+      case "readiness":
+        return await toolReadiness();
+      case "attach":
+        return await toolAttach(args);
+      case "detach":
+        return await toolDetach(args);
+      case "list_processes":
+        return await toolListProcesses(args);
+      case "diff_runs":
+        return await toolDiffRuns(args);
+      case "report":
+        return await toolReport(args);
+      case "import_artifact": {
+        const session = await loadSession(String(args.session_id));
+        const { importArtifact } = await import("./import-CT55AEEE.js");
+        return await recordRun(session, await importArtifact(session, args));
+      }
+      default:
+        return await dispatchAdapter(name, args);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const sessionId = typeof args.session_id === "string" ? args.session_id : "";
+    const limitations = err instanceof ConsentRequiredError ? ["consent required \u2014 ask the user, then pass consent: true"] : [];
+    const r = failedResult(name, null, NO_TARGET, msg, limitations);
+    return { ...r, session_id: sessionId };
+  }
+}
+async function toolReadiness() {
+  const r = await probeReadiness();
+  readinessCache = { at: Date.now(), value: r };
+  const b = new ResultBuilder("readiness", null, NO_TARGET);
+  const sys = b.evidenceOf("readiness", `${r.os}/${r.arch} node=${r.node} root=${r.is_root} sudo-n=${r.has_sudo_noninteractive} ptrace_scope=${r.permissions.ptrace_scope ?? "n/a"} sip=${r.permissions.sip_enabled ?? "n/a"}`, {
+    os: r.os,
+    arch: r.arch,
+    kernel: r.kernel,
+    node: r.node,
+    dea_version: r.dea_version,
+    is_root: r.is_root,
+    has_sudo_noninteractive: r.has_sudo_noninteractive,
+    permissions: r.permissions,
+    sessions_dir: r.sessions_dir
+  });
+  const prov = b.evidenceOf(
+    "readiness",
+    `${r.providers.filter((p) => p.status === "ready").length}/${r.providers.length} providers ready: ${r.providers.map((p) => `${p.name}=${p.status}`).join(" ")}`,
+    r.providers
+  );
+  const tools = b.evidenceOf("readiness", `tools available: ${r.tools_available.join(", ")}`, { available: r.tools_available, unavailable: r.tools_unavailable });
+  b.finding("info", `${r.tools_available.length} of 14 tools available on ${r.os}`, [tools, prov]);
+  for (const u of r.tools_unavailable) b.limitation(`${u.tool}: ${u.reason}`);
+  if (r.os === "linux" && r.permissions.ptrace_scope !== null && r.permissions.ptrace_scope >= 1 && !r.is_root) {
+    b.finding("warn", `ptrace_scope=${r.permissions.ptrace_scope}: strace/gdb/py-spy can only attach to your own child processes without root`, [sys], "observed", "Fix for this boot: sudo sysctl kernel.yama.ptrace_scope=0  (Debug Anything will not run this for you)");
+  }
+  if (r.os === "linux" && r.permissions.perf_event_paranoid !== null && r.permissions.perf_event_paranoid > 1 && !r.is_root) {
+    b.finding("warn", `perf_event_paranoid=${r.permissions.perf_event_paranoid}: perf cannot profile other users' processes without root`, [sys], "observed", "Fix for this boot: sudo sysctl kernel.perf_event_paranoid=1");
+  }
+  if (r.os === "darwin" && !r.is_root) {
+    b.limitation("macOS: attaching py-spy/lldb/sample to processes you did not start usually needs sudo; tcpdump always needs sudo or membership in the access_bpf group");
+  }
+  if (r.os === "win32") b.limitation("Windows is not supported yet (planned: ETW / procdump based adapters)");
+  b.next("list_processes", "attach");
+  return b.build();
+}
+async function toolAttach(args) {
+  if (platform() === "win32") return failedResult("attach", null, NO_TARGET, "Windows is not supported yet");
+  const isCommand = (args.kind ?? (await import("./target-WJE4WFYA.js")).guessKind(args.target)) === "command";
+  let target;
+  let session;
+  if (isCommand) {
+    session = await createSession({ kind: "command", id: args.target, host: "local" });
+    const spawned = await (await import("./target-WJE4WFYA.js")).spawnCommand(args.target, session.dir);
+    const { spawned: sp, ...t } = spawned;
+    target = t;
+    session.target = target;
+    session.spawned = sp;
+    await saveSession(session);
+  } else {
+    target = await resolveTarget(args.target, { kind: args.kind });
+    session = await createSession(target);
+  }
+  const b = new ResultBuilder("attach", session, target);
+  const ev = b.evidenceOf("process", `attached to ${target.kind} ${target.id}: pid=${target.pid ?? "?"} comm=${target.comm ?? "?"} runtime=${target.runtime ?? "?"} children=${target.pids?.length ?? 0}`, target);
+  b.finding("info", `session ${session.id} attached to pid ${target.pid ?? "?"} (${target.comm ?? "unknown"}, runtime ${target.runtime ?? "unknown"})`, [ev]);
+  if (!target.pid) b.limitation("no host pid for this target on this platform; pid-based tools (strace, py-spy, gdb, lsof) will not work. container_info still works.");
+  if (session.spawned) b.limitation(`spawned command; stdout/stderr tee'd to ${session.spawned.stdout} and ${session.spawned.stderr}`);
+  const readiness = await cachedReadiness();
+  const next = ["inspect_sockets", "inspect_files", "dump_stacks", "profile_cpu", "snapshot_memory", "trace_syscalls", "container_info"].filter((t) => readiness.tools_available.includes(t));
+  if (target.kind !== "container" && target.kind !== "pod") next.splice(next.indexOf("container_info"), next.includes("container_info") ? 1 : 0);
+  b.next(...next, "detach");
+  const result = b.build();
+  return recordRun(session, result);
+}
+async function toolDetach(args) {
+  const session = await loadSession(args.session_id);
+  await detachSession(session);
+  const b = new ResultBuilder("detach", session, session.target);
+  const md = await renderReport(session);
+  const reportPath = join2(session.dir, "report.md");
+  await writeFile(reportPath, md);
+  await b.addArtifact(reportPath, "markdown", { description: "session report" });
+  const ev = b.evidenceOf("note", `session ${session.id} detached after ${session.runs.length} run(s); report at ${reportPath}`, { runs: session.runs.map((r) => r.run_id), report: reportPath });
+  b.finding("info", `detached; ${session.runs.length} run(s) kept under ${session.dir}`, [ev]);
+  return b.build();
+}
+async function toolListProcesses(args) {
+  const b = new ResultBuilder("list_processes", null, NO_TARGET);
+  const procs = await listProcesses(args.filter, args.limit);
+  const ev = b.evidenceOf(
+    "process_list",
+    `${procs.length} process(es)${args.filter ? ` matching "${args.filter}"` : ""}, sorted by cpu then rss`,
+    procs.map((p) => ({ pid: p.pid, ppid: p.ppid, user: p.user, cpu: p.cpu, mem: p.mem, rss_kb: p.rss_kb, comm: p.comm, args: p.args.slice(0, 160), container: p.container }))
+  );
+  if (procs.length === 0) b.finding("info", `no processes match "${args.filter ?? ""}"`, [ev]);
+  else {
+    const top = procs[0];
+    b.finding("info", `top by cpu: pid ${top.pid} ${top.comm} (${top.cpu}% cpu, ${Math.round(top.rss_kb / 1024)} MB rss)`, [ev]);
+  }
+  b.next("attach");
+  return b.build();
+}
+async function loadRunRef(session, ref) {
+  const m = ref.match(/^([\w-]{6,}):(.+)$/);
+  if (m) {
+    const other = await loadSession(m[1]);
+    return { run: await loadRun(other, m[2]), from: other.id };
+  }
+  return { run: await loadRun(session, ref) };
+}
+async function toolDiffRuns(args) {
+  const session = await loadSession(args.session_id);
+  const [ra, rb] = await Promise.all([loadRunRef(session, args.a), loadRunRef(session, args.b)]);
+  const result = await diffRuns(session, ra.run, rb.run);
+  if (ra.from || rb.from) result.limitations.push(`cross-session diff: a=${ra.from ?? session.id}, b=${rb.from ?? session.id} \u2014 a healthy baseline vs this run; environment may differ between sessions`);
+  return recordRun(session, result);
+}
+async function toolReport(args) {
+  const session = await loadSession(args.session_id);
+  const md = await renderReport(session);
+  const b = new ResultBuilder("report", session, session.target);
+  const path = join2(session.dir, "report.md");
+  await writeFile(path, md);
+  await b.addArtifact(path, "markdown", { description: "session report" });
+  if (args.html) {
+    const { renderHtmlReport } = await import("./report_html-2ENM7HLC.js");
+    const htmlPath = args.out ? args.out.replace(/\.(md|html)$/, "") + ".html" : join2(session.dir, "report.html");
+    await writeFile(htmlPath, await renderHtmlReport(session));
+    await b.addArtifact(htmlPath, "log", { description: "self-contained HTML report (shareable)" });
+  }
+  if (args.out) {
+    await writeFile(args.out, md);
+    await b.addArtifact(args.out, "markdown", { description: "copy of session report" });
+  }
+  const allFindings = [];
+  for (const r of session.runs) {
+    try {
+      const tr = await loadRun(session, r.run_id);
+      for (const f of tr.findings) allFindings.push({ run: r.run_id, severity: f.severity, summary: f.summary });
+    } catch {
+    }
+  }
+  const ev = b.evidenceOf("note", `report with ${allFindings.length} finding(s) across ${session.runs.length} run(s)`, { findings: allFindings.slice(0, 50), markdown_preview: md.slice(0, 3e3) });
+  b.finding("info", `report written to ${path}`, [ev]);
+  return b.build();
+}
+async function dispatchAdapter(tool, args) {
+  const session = await requireAttached(String(args.session_id));
+  requireConsent(tool, args);
+  const readiness = await cachedReadiness();
+  const { ready, blocked } = candidatesFor(tool, session.target, readiness);
+  if (ready.length === 0) {
+    const reasons = blocked.map((c) => `${c.adapter.name}: ${c.reason}`);
+    const r = failedResult(tool, session, session.target, `no ready adapter for ${tool} on ${readiness.os}${session.target.runtime ? ` (runtime ${session.target.runtime})` : ""}`, reasons.length ? reasons : ["no adapter declares this tool for this platform"], ["readiness"]);
+    return recordRun(session, r);
+  }
+  let last;
+  for (const adapter of ready) {
+    const result = await adapter.run(tool, args, { session, target: session.target, readiness });
+    last = result;
+    if (result.ok) break;
+    if (!/cannot attach|not supported|requires|unsupported|needs/i.test(result.error ?? "")) break;
+  }
+  return recordRun(session, last);
+}
+
+export {
+  cachedReadiness,
+  TOOL_DESCRIPTIONS,
+  runTool
+};
+//# sourceMappingURL=chunk-VGYXHXTY.js.map