prismalens 0.3.0 → 0.4.0

package/dist/chunk-5BT3XQOG.js

@@ -0,0 +1,2990 @@
+import {
+  getDefaultModel
+} from "./chunk-XH6DIKTA.js";
+
+// ../@prismalens/config/dist/providers/harness.js
+var HARNESS_IDS = ["deepagents", "claude-code", "codex"];
+var HARNESS_REGISTRY = {
+  deepagents: {
+    id: "deepagents",
+    label: "deepagents (ACP)",
+    binary: "deepagents-acp",
+    transport: "acp",
+    modelPrefix: "openai:",
+    readOnlyFidelity: "cooperative",
+    readOnlyMechanism: "ACP session/request_permission auto-approved (prompt-only); OS enforcement arrives with the Sandbox port (ADR-0020/B.1)",
+    implemented: true
+  },
+  "claude-code": {
+    id: "claude-code",
+    label: "Claude Code (Agent SDK)",
+    binary: "claude",
+    transport: "agent-sdk",
+    modelPrefix: null,
+    readOnlyFidelity: "enforced",
+    // The reported mechanism is DERIVED from readOnlyDeny — no hand-typed tool list
+    // here to drift from what the runner enforces (ADR-0017 Amendment 2).
+    readOnlyMechanism: "Agent SDK disallowedTools + permissionMode",
+    readOnlyDeny: ["Edit", "Write", "MultiEdit", "NotebookEdit"],
+    implemented: true
+  },
+  codex: {
+    id: "codex",
+    label: "Codex",
+    binary: "codex",
+    transport: "subprocess-jsonl",
+    modelPrefix: null,
+    readOnlyFidelity: "enforced",
+    readOnlyMechanism: "OS sandbox (seccomp/landlock) \u2014 not yet wired",
+    implemented: false
+  }
+};
+var HARNESS_BINARY = {
+  deepagents: HARNESS_REGISTRY.deepagents.binary,
+  "claude-code": HARNESS_REGISTRY["claude-code"].binary,
+  codex: HARNESS_REGISTRY.codex.binary
+};
+var PERMISSION_MODES = [
+  "read-only",
+  "supervised",
+  "auto",
+  "dangerous"
+];
+function resolvePermissionOutcome(harnessId, mode) {
+  const registry = HARNESS_REGISTRY[harnessId];
+  if (mode === "read-only" || mode === "supervised") {
+    const mechanism = registry.readOnlyDeny?.length ? `disallowedTools deny-list: ${registry.readOnlyDeny.join(", ")}` : registry.readOnlyMechanism;
+    return { mode, fidelity: registry.readOnlyFidelity, mechanism };
+  }
+  return {
+    mode,
+    fidelity: "advisory",
+    mechanism: mode === "dangerous" ? "full access \u2014 no restrictions applied" : "writes auto-accepted \u2014 no read-only floor"
+  };
+}
+
+// ../@prismalens/config/dist/model.js
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogle } from "@ai-sdk/google";
+import { createGroq } from "@ai-sdk/groq";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { APICallError, generateText } from "ai";
+function resolveModel(providerId, model, creds = {}) {
+  const { apiKey, baseURL } = creds;
+  switch (providerId) {
+    case "anthropic":
+      return createAnthropic({ apiKey, ...baseURL ? { baseURL } : {} })(model);
+    case "openai":
+      return createOpenAI({ apiKey, ...baseURL ? { baseURL } : {} })(model);
+    case "google":
+      return createGoogle({ apiKey })(model);
+    case "groq":
+      return createGroq({ apiKey })(model);
+    case "ollama":
+    case "custom": {
+      if (!baseURL) {
+        throw new Error(`Provider "${providerId}" is OpenAI-compatible and requires a baseURL.`);
+      }
+      return createOpenAICompatible({
+        name: providerId,
+        baseURL,
+        ...apiKey ? { apiKey } : {}
+      })(model);
+    }
+    default: {
+      const unreachable = providerId;
+      throw new Error(`Unknown LLM provider: ${String(unreachable)}`);
+    }
+  }
+}
+async function pingModel(providerId, model, creds = {}, timeoutMs = 1e4) {
+  const resolvedModel = model ?? getDefaultModel(providerId);
+  if (!resolvedModel) {
+    return {
+      success: false,
+      error: `No model specified and provider "${providerId}" has no default model.`
+    };
+  }
+  try {
+    await generateText({
+      model: resolveModel(providerId, resolvedModel, creds),
+      prompt: "ping",
+      maxOutputTokens: 1,
+      abortSignal: AbortSignal.timeout(timeoutMs)
+    });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: describePingError(err) };
+  }
+}
+function describePingError(err) {
+  if (APICallError.isInstance(err)) {
+    const status = err.statusCode;
+    if (status === 401 || status === 403)
+      return "Invalid or unauthorized API key.";
+    if (status === 404)
+      return "Model or endpoint not found.";
+    if (status === 429)
+      return "Rate limited \u2014 try again shortly.";
+    if (status && status >= 500)
+      return `Provider error (${status}).`;
+    return err.message || `Provider returned ${status ?? "an error"}.`;
+  }
+  return err instanceof Error ? err.message : "Connection failed";
+}
+
+// ../@prismalens/engine/dist/sandbox/e2b.js
+import { EventEmitter } from "node:events";
+import { createRequire } from "node:module";
+import { PassThrough, Writable } from "node:stream";
+function loadE2b() {
+  const require2 = createRequire(import.meta.url);
+  return require2("e2b");
+}
+var DEFAULT_TEMPLATE = "base";
+function shellQuote(token) {
+  return `'${token.replaceAll("'", `'\\''`)}'`;
+}
+function definedEnv(env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env ?? {})) {
+    if (value !== void 0)
+      out[key] = value;
+  }
+  return out;
+}
+var E2bStdin = class extends Writable {
+  handle = null;
+  buffered = [];
+  endBuffered = false;
+  chain = Promise.resolve();
+  _write(chunk, _enc, cb) {
+    if (this.handle)
+      this.forward(Buffer.from(chunk));
+    else
+      this.buffered.push(Buffer.from(chunk));
+    cb();
+  }
+  _final(cb) {
+    if (this.handle)
+      this.closeRemote();
+    else
+      this.endBuffered = true;
+    cb();
+  }
+  /** Bind the resolved handle: replay buffered writes in order, then any pending EOF. */
+  attach(handle) {
+    this.handle = handle;
+    for (const chunk of this.buffered)
+      this.forward(chunk);
+    this.buffered.length = 0;
+    if (this.endBuffered)
+      this.closeRemote();
+  }
+  forward(chunk) {
+    const handle = this.handle;
+    if (!handle)
+      return;
+    this.chain = this.chain.then(() => handle.sendStdin(chunk).catch(() => {
+    }));
+  }
+  closeRemote() {
+    const handle = this.handle;
+    if (!handle)
+      return;
+    this.chain = this.chain.then(() => handle.closeStdin().catch(() => {
+    }));
+  }
+};
+var E2bSandboxProcess = class extends EventEmitter {
+  stdin;
+  stdout;
+  stderr;
+  killed = false;
+  timedOut = false;
+  appliedLimits;
+  stdoutPass;
+  stderrPass;
+  handle = null;
+  settled = false;
+  outputEnded = false;
+  deadline = null;
+  constructor(limits) {
+    super();
+    this.stdin = new E2bStdin();
+    this.stdoutPass = new PassThrough();
+    this.stderrPass = new PassThrough();
+    this.stdout = this.stdoutPass;
+    this.stderr = this.stderrPass;
+    const applied = {};
+    if (limits?.wallClockMs && limits.wallClockMs > 0) {
+      applied.wallClockMs = limits.wallClockMs;
+      this.deadline = setTimeout(() => {
+        this.timedOut = true;
+        this.kill("SIGKILL");
+      }, limits.wallClockMs);
+      this.deadline.unref();
+    }
+    this.appliedLimits = applied;
+  }
+  /** Push a remote-stdout chunk to the readable the ACP readline drains. */
+  pushStdout(data) {
+    if (!this.outputEnded)
+      this.stdoutPass.write(data);
+  }
+  /** Push a remote-stderr chunk to the readable the ACP client tails for diagnostics. */
+  pushStderr(data) {
+    if (!this.outputEnded)
+      this.stderrPass.write(data);
+  }
+  /** Bind the resolved remote command handle to the stdio forwarders. */
+  attach(handle) {
+    this.handle = handle;
+    if (this.killed) {
+      void handle.kill().catch(() => {
+      });
+      return;
+    }
+    this.stdin.attach(handle);
+  }
+  /** Terminal: the remote command exited — end the streams and emit `close`. */
+  closeWith(code) {
+    this.settle(() => this.emit("close", code, null));
+  }
+  /**
+   * Terminal: the VM/command failed to start — emit `error` and ONLY `error` (like
+   * node's failed-spawn path, which never reaches `close`). Consumers must treat
+   * `error` as terminal on its own — the ACP runner does (its error handler calls
+   * finish()); a consumer waiting solely on `close` would hang on this path.
+   * A failure that arrives AFTER an explicit kill is the kill's own consequence, so it
+   * degrades to a clean `close` rather than a spurious error.
+   */
+  failWith(err) {
+    if (this.killed) {
+      this.closeWith(null);
+      return;
+    }
+    this.settle(() => this.emit("error", err));
+  }
+  kill(_signal) {
+    this.killed = true;
+    if (this.stdin.writable)
+      this.stdin.end();
+    if (this.handle)
+      void this.handle.kill().catch(() => {
+      });
+    return true;
+  }
+  settle(emit) {
+    if (this.settled)
+      return;
+    this.settled = true;
+    if (this.deadline) {
+      clearTimeout(this.deadline);
+      this.deadline = null;
+    }
+    this.endOutput();
+    emit();
+  }
+  endOutput() {
+    if (this.outputEnded)
+      return;
+    this.outputEnded = true;
+    this.stdoutPass.end();
+    this.stderrPass.end();
+  }
+};
+function createE2bSandbox(options = {}) {
+  let e2b;
+  try {
+    e2b = options.loader ? options.loader() : loadE2b();
+  } catch {
+    throw new Error("e2b sandbox unavailable: could not resolve the 'e2b' package. Install it (`npm i e2b`) or select a different sandbox mode (--sandbox process|srt).");
+  }
+  const apiKey = options.apiKey ?? process.env.E2B_API_KEY;
+  if (!apiKey) {
+    throw new Error("e2b sandbox unavailable: E2B_API_KEY is not set. Export E2B_API_KEY (https://e2b.dev/dashboard) or select a different sandbox mode (--sandbox process|srt).");
+  }
+  const template = options.template ?? process.env.E2B_TEMPLATE ?? DEFAULT_TEMPLATE;
+  const allowed = options.allowedDomains ?? [];
+  const network = allowed.length > 0 ? { network: { allowOut: allowed } } : { allowInternetAccess: false };
+  const children = /* @__PURE__ */ new Set();
+  let vmPromise = null;
+  let vm = null;
+  const VM_LIFETIME_HEADROOM_MS = 6e4;
+  const ensureVm = (minLifetimeMs) => {
+    if (!vmPromise) {
+      const needed = minLifetimeMs !== void 0 ? minLifetimeMs + VM_LIFETIME_HEADROOM_MS : void 0;
+      const timeoutMs = options.timeoutMs !== void 0 || needed !== void 0 ? Math.max(options.timeoutMs ?? 0, needed ?? 0) : void 0;
+      vmPromise = e2b.Sandbox.create(template, {
+        apiKey,
+        ...timeoutMs !== void 0 ? { timeoutMs } : {},
+        ...network
+      }).then((created) => {
+        vm = created;
+        return created;
+      });
+    }
+    return vmPromise;
+  };
+  return {
+    id: "e2b",
+    fidelity: "enforced",
+    spawn(command, args, spawnOptions) {
+      const proc = new E2bSandboxProcess(spawnOptions.limits);
+      children.add(proc);
+      proc.on("close", () => children.delete(proc));
+      const commandLine = [command, ...args].map(shellQuote).join(" ");
+      const envs = definedEnv(spawnOptions.env);
+      void (async () => {
+        try {
+          const sandbox = await ensureVm(spawnOptions.limits?.wallClockMs);
+          const handle = await sandbox.commands.run(commandLine, {
+            background: true,
+            stdin: true,
+            cwd: spawnOptions.cwd,
+            envs,
+            onStdout: (d) => proc.pushStdout(d),
+            onStderr: (d) => proc.pushStderr(d)
+          });
+          proc.attach(handle);
+          handle.wait().then((res) => proc.closeWith(res.exitCode ?? null), (err) => {
+            const code = err.exitCode;
+            if (typeof code === "number")
+              proc.closeWith(code);
+            else
+              proc.failWith(err instanceof Error ? err : new Error(String(err)));
+          });
+        } catch (err) {
+          proc.failWith(err instanceof Error ? err : new Error(String(err)));
+        }
+      })();
+      return proc;
+    },
+    async destroy() {
+      for (const child of children) {
+        if (!child.killed)
+          child.kill();
+      }
+      children.clear();
+      if (vmPromise) {
+        try {
+          const sandbox = vm ?? await vmPromise;
+          await sandbox.kill();
+        } catch {
+        }
+        vmPromise = null;
+        vm = null;
+      }
+    }
+  };
+}
+
+// ../@prismalens/engine/dist/sandbox/process-floor.js
+import { spawn } from "node:child_process";
+var SAFE_ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "TMPDIR",
+  "TZ",
+  "PWD"
+];
+function buildFloorEnv(extra) {
+  const env = {};
+  for (const key of SAFE_ENV_ALLOWLIST) {
+    const value = process.env[key];
+    if (value !== void 0)
+      env[key] = value;
+  }
+  for (const [key, value] of Object.entries(extra ?? {})) {
+    if (value !== void 0)
+      env[key] = value;
+  }
+  return env;
+}
+function withLimits(child, limits, enforced = {}) {
+  const applied = { ...enforced };
+  const proc = child;
+  proc.timedOut = false;
+  if (limits?.wallClockMs && limits.wallClockMs > 0) {
+    applied.wallClockMs = limits.wallClockMs;
+    const timer = setTimeout(() => {
+      proc.timedOut = true;
+      proc.kill("SIGKILL");
+    }, limits.wallClockMs);
+    timer.unref();
+    child.on("close", () => clearTimeout(timer));
+  }
+  proc.appliedLimits = applied;
+  return proc;
+}
+function createProcessFloorSandbox() {
+  const children = /* @__PURE__ */ new Set();
+  return {
+    id: "process-floor",
+    fidelity: "cooperative",
+    spawn(command, args, options) {
+      const child = spawn(command, args, {
+        cwd: options.cwd,
+        env: buildFloorEnv(options.env),
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const proc = withLimits(child, options.limits);
+      children.add(proc);
+      proc.on("close", () => children.delete(proc));
+      return proc;
+    },
+    async destroy() {
+      for (const child of children) {
+        if (!child.killed)
+          child.kill();
+      }
+      children.clear();
+    }
+  };
+}
+
+// ../@prismalens/engine/dist/sandbox/srt.js
+import { spawn as spawn2 } from "node:child_process";
+import { accessSync, constants, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { tmpdir } from "node:os";
+import { delimiter, dirname, join } from "node:path";
+function resolveSrtPackageEntry() {
+  try {
+    const require2 = createRequire2(import.meta.url);
+    const pkgJsonPath = require2.resolve("@anthropic-ai/sandbox-runtime/package.json");
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.srt;
+    if (!bin)
+      return null;
+    const cliPath = join(dirname(pkgJsonPath), bin);
+    accessSync(cliPath, constants.R_OK);
+    return { command: process.execPath, prefixArgs: [cliPath] };
+  } catch {
+    return null;
+  }
+}
+function resolveSrtBinaryOnPath() {
+  const pathVar = process.env.PATH;
+  if (!pathVar)
+    return null;
+  for (const dir of pathVar.split(delimiter)) {
+    if (!dir)
+      continue;
+    const candidate = join(dir, "srt");
+    try {
+      accessSync(candidate, constants.X_OK);
+      return { command: candidate, prefixArgs: [] };
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveSrtEntry() {
+  return resolveSrtPackageEntry() ?? resolveSrtBinaryOnPath();
+}
+function isSrtAvailable() {
+  return resolveSrtEntry() !== null;
+}
+var systemdRunPath;
+function resolveSystemdRun() {
+  if (systemdRunPath !== void 0)
+    return systemdRunPath;
+  systemdRunPath = null;
+  const pathVar = process.env.PATH;
+  if (pathVar) {
+    for (const dir of pathVar.split(delimiter)) {
+      if (!dir)
+        continue;
+      const candidate = join(dir, "systemd-run");
+      try {
+        accessSync(candidate, constants.X_OK);
+        systemdRunPath = candidate;
+        break;
+      } catch {
+      }
+    }
+  }
+  return systemdRunPath;
+}
+function memoryMaxArg(memoryMb) {
+  if (!memoryMb || memoryMb <= 0)
+    return null;
+  return `MemoryMax=${Math.round(memoryMb)}M`;
+}
+function cpuQuotaArg(cpuCores) {
+  if (!cpuCores || cpuCores <= 0)
+    return null;
+  return `CPUQuota=${Math.round(cpuCores * 100)}%`;
+}
+function writeSrtSettings(allowedDomains) {
+  const settingsDir = mkdtempSync(join(tmpdir(), "pl-srt-"));
+  const settingsPath = join(settingsDir, "srt-settings.json");
+  writeFileSync(settingsPath, JSON.stringify({
+    network: {
+      allowedDomains,
+      deniedDomains: [],
+      // Hard-deny non-allowlisted hosts regardless of any ask-callback: srt
+      // only guarantees denial when strictAllowlist is set (its CLI happens
+      // to run without an ask callback today, but "enforced" must not hinge
+      // on that implementation detail — an interactive prompt would also
+      // wedge our piped JSON-RPC stdin).
+      strictAllowlist: true
+    },
+    filesystem: { denyRead: [], allowWrite: ["."], denyWrite: [] }
+  }));
+  return { settingsDir, settingsPath };
+}
+var SRT_EGRESS_WATCHDOG_MS = 15e3;
+function runEgressProbeWithWatchdog(spawnChild, timeoutMs = SRT_EGRESS_WATCHDOG_MS) {
+  return new Promise((resolveCode) => {
+    let settled = false;
+    let timer;
+    const finish = (code) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      resolveCode(code);
+    };
+    let child;
+    try {
+      child = spawnChild(finish);
+    } catch {
+      finish("");
+      return;
+    }
+    timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      finish("");
+    }, timeoutMs);
+    timer.unref?.();
+  });
+}
+function defaultSrtEgressRunner(targetUrl) {
+  const entry = resolveSrtEntry();
+  if (!entry)
+    return Promise.resolve("");
+  let hostname;
+  try {
+    hostname = new URL(targetUrl).hostname;
+  } catch {
+    return Promise.resolve("");
+  }
+  const { settingsDir, settingsPath } = writeSrtSettings([hostname]);
+  const srtArgv = [
+    ...entry.prefixArgs,
+    "--settings",
+    settingsPath,
+    "--",
+    "curl",
+    "-sS",
+    "-o",
+    "/dev/null",
+    "-w",
+    "%{http_code}",
+    "--max-time",
+    "8",
+    targetUrl
+  ];
+  return runEgressProbeWithWatchdog((finish) => {
+    const child = spawn2(entry.command, srtArgv, {
+      env: buildFloorEnv(),
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const chunks = [];
+    child.stdout.on("data", (d) => chunks.push(d));
+    child.on("error", () => finish(""));
+    child.on("close", () => finish(Buffer.concat(chunks).toString().trim()));
+    return child;
+  }).finally(() => {
+    try {
+      rmSync(settingsDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+}
+var SRT_EGRESS_UNHEALTHY_TTL_MS = 5 * 6e4;
+var egressProbeCache = /* @__PURE__ */ new Map();
+async function probeSrtEgress(targetUrl, opts = {}) {
+  const now = opts.now ?? Date.now;
+  const cached = egressProbeCache.get(targetUrl);
+  if (cached !== void 0 && (cached.expiresAt === void 0 || now() < cached.expiresAt)) {
+    return cached.healthy;
+  }
+  let healthy = false;
+  try {
+    const code = (await (opts.runner ?? defaultSrtEgressRunner)(targetUrl)).trim();
+    healthy = /^\d{3}$/.test(code) && code !== "000";
+  } catch {
+    healthy = false;
+  }
+  egressProbeCache.set(targetUrl, healthy ? { healthy: true } : { healthy: false, expiresAt: now() + SRT_EGRESS_UNHEALTHY_TTL_MS });
+  return healthy;
+}
+function createSrtSandbox(options = {}) {
+  const entry = resolveSrtEntry();
+  if (!entry) {
+    throw new Error("srt sandbox unavailable: could not resolve '@anthropic-ai/sandbox-runtime' or an `srt` binary on PATH. Install it (`npm i -g @anthropic-ai/sandbox-runtime`) or select a different sandbox mode (--sandbox process).");
+  }
+  const { settingsDir, settingsPath } = writeSrtSettings(options.allowedDomains ?? []);
+  const children = /* @__PURE__ */ new Set();
+  return {
+    id: "srt",
+    fidelity: "enforced",
+    spawn(command, args, spawnOptions) {
+      const srtArgv = [
+        ...entry.prefixArgs,
+        "--settings",
+        settingsPath,
+        "--",
+        command,
+        ...args
+      ];
+      const memArg = memoryMaxArg(spawnOptions.limits?.memoryMb);
+      const cpuArg = cpuQuotaArg(spawnOptions.limits?.cpuCores);
+      const systemdRun = memArg || cpuArg ? resolveSystemdRun() : null;
+      const enforced = {};
+      let spawnCommand = entry.command;
+      let spawnArgs = srtArgv;
+      if (systemdRun) {
+        const props = [];
+        if (memArg) {
+          props.push("-p", memArg);
+          enforced.memoryMb = spawnOptions.limits?.memoryMb;
+        }
+        if (cpuArg) {
+          props.push("-p", cpuArg);
+          enforced.cpuCores = spawnOptions.limits?.cpuCores;
+        }
+        spawnCommand = systemdRun;
+        spawnArgs = [
+          "--user",
+          "--scope",
+          "--quiet",
+          ...props,
+          "--",
+          entry.command,
+          ...srtArgv
+        ];
+      }
+      const child = spawn2(spawnCommand, spawnArgs, {
+        cwd: spawnOptions.cwd,
+        env: buildFloorEnv(spawnOptions.env),
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const proc = withLimits(child, spawnOptions.limits, enforced);
+      children.add(proc);
+      proc.on("close", () => children.delete(proc));
+      return proc;
+    },
+    async destroy() {
+      for (const child of children) {
+        if (!child.killed)
+          child.kill();
+      }
+      children.clear();
+      try {
+        rmSync(settingsDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+
+// ../@prismalens/engine/dist/sandbox/wsl.js
+import { readFile } from "node:fs/promises";
+async function detectWsl() {
+  if (process.platform !== "linux")
+    return false;
+  if (process.env.WSL_DISTRO_NAME)
+    return true;
+  const version = await readFile("/proc/version", "utf8").catch(() => "");
+  return /microsoft/i.test(version);
+}
+
+// ../@prismalens/engine/dist/sandbox/select.js
+var SANDBOX_MODES = ["auto", "process", "srt", "e2b"];
+function floorSelection(requested, degradeReason) {
+  const sandbox = createProcessFloorSandbox();
+  return { sandbox, requested, actual: sandbox.id, degradeReason };
+}
+async function resolveSandbox(mode, options = {}) {
+  switch (mode) {
+    case "process": {
+      const sandbox = createProcessFloorSandbox();
+      return { sandbox, requested: mode, actual: sandbox.id };
+    }
+    case "srt": {
+      const sandbox = createSrtSandbox(options);
+      return { sandbox, requested: mode, actual: sandbox.id };
+    }
+    case "e2b": {
+      const sandbox = createE2bSandbox(options);
+      return { sandbox, requested: mode, actual: sandbox.id };
+    }
+    case "auto": {
+      if (!isSrtAvailable()) {
+        return floorSelection(mode, "srt unavailable");
+      }
+      if (options.probeUrl === void 0) {
+        return floorSelection(mode, "no egress allowlist derivable from config \u2014 an enforced zero-egress boundary would starve the harness (its own model endpoint included); set telemetry endpoints or force --sandbox srt");
+      }
+      if (await (options.wslDetector ?? detectWsl)()) {
+        return {
+          ...floorSelection(mode, "WSL detected \u2014 srt's egress bridge is unreliable under WSL, so auto uses the process floor without probing; force --sandbox srt to override"),
+          degradeExpected: true
+        };
+      }
+      const healthy = await probeSrtEgress(options.probeUrl, options.egressRunner ? { runner: options.egressRunner } : {});
+      if (healthy) {
+        const sandbox = createSrtSandbox(options);
+        return { sandbox, requested: mode, actual: sandbox.id };
+      }
+      return floorSelection(mode, "srt egress bridge unhealthy \u2014 WSL mirrored networking? Using the process floor");
+    }
+  }
+}
+
+// ../@prismalens/engine/dist/supervisor/conductor.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// ../@prismalens/engine/dist/supervisor/investigate.js
+import { randomUUID } from "node:crypto";
+
+// ../@prismalens/engine/dist/runner/acp-client.js
+import { createInterface } from "node:readline";
+var autoAllowReadOnly = (req) => {
+  const allow = req.options.find((o) => o.kind === "allow_once") ?? req.options.find((o) => (o.kind ?? "").startsWith("allow")) ?? req.options[0];
+  return allow ? { optionId: allow.optionId } : { reject: true };
+};
+var DEFAULT_COMMAND = "deepagents-acp";
+var DEFAULT_MODEL = "openai:gpt-oss:120b";
+function buildAcpArgs(model, config) {
+  const args = ["-m", model, "-w", config.cwd];
+  const native = config.native ?? {};
+  const strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  args.push(...strings(native.args));
+  return args;
+}
+var DEFAULT_INIT_TIMEOUT_MS = 3e4;
+var DEFAULT_PROMPT_TIMEOUT_MS = 18e4;
+var STDERR_TAIL = 500;
+function jsonRpcErrorText(error) {
+  const head = error.message ?? `ACP error ${error.code}`;
+  if (error.data === void 0)
+    return head;
+  const data = typeof error.data === "string" ? error.data : JSON.stringify(error.data);
+  return `${head} \u2014 ${data.slice(0, 500)}`;
+}
+async function* runAcpBranch(config) {
+  const command = config.command ?? DEFAULT_COMMAND;
+  const model = config.model ?? DEFAULT_MODEL;
+  const args = config.args ?? buildAcpArgs(model, config);
+  const permission = config.permission ?? autoAllowReadOnly;
+  const initTimeout = config.initTimeoutMs ?? DEFAULT_INIT_TIMEOUT_MS;
+  const promptTimeout = config.promptTimeoutMs ?? DEFAULT_PROMPT_TIMEOUT_MS;
+  const sandbox = config.sandbox ?? createProcessFloorSandbox();
+  const ownsSandbox = config.sandbox === void 0;
+  const child = sandbox.spawn(command, args, {
+    cwd: config.cwd,
+    env: config.env,
+    ...config.limits ? { limits: config.limits } : {}
+  });
+  const queue = [];
+  let wake = null;
+  let finished = false;
+  const stderrChunks = [];
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  const pushItem = (item) => {
+    queue.push(item);
+    wake?.();
+    wake = null;
+  };
+  const finish = () => {
+    finished = true;
+    wake?.();
+    wake = null;
+  };
+  const send = (obj) => {
+    if (child.stdin.writable)
+      child.stdin.write(`${JSON.stringify(obj)}
+`);
+  };
+  const request = (method, params, timeoutMs) => new Promise((resolve, reject) => {
+    const id = nextId++;
+    const timer = setTimeout(() => {
+      if (pending.delete(id)) {
+        reject(new Error(`ACP ${method} timed out after ${timeoutMs}ms`));
+      }
+    }, timeoutMs);
+    pending.set(id, {
+      resolve: (result) => {
+        clearTimeout(timer);
+        resolve(result);
+      },
+      reject: (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+    send({ jsonrpc: "2.0", id, method, params });
+  });
+  const answerPermission = (msg) => {
+    const params = msg.params ?? {};
+    const options = params.options ?? [];
+    const decision = permission({
+      options,
+      toolCall: params.toolCall
+    });
+    if ("optionId" in decision) {
+      send({
+        jsonrpc: "2.0",
+        id: msg.id,
+        result: {
+          outcome: { outcome: "selected", optionId: decision.optionId }
+        }
+      });
+      return;
+    }
+    const reject = options.find((o) => (o.kind ?? "").startsWith("reject"));
+    send({
+      jsonrpc: "2.0",
+      id: msg.id,
+      result: reject ? { outcome: { outcome: "selected", optionId: reject.optionId } } : { outcome: { outcome: "cancelled" } }
+    });
+  };
+  const handleServerRequest = (msg) => {
+    const method = msg.method ?? "";
+    if (method === "session/request_permission") {
+      answerPermission(msg);
+    } else if (method.startsWith("fs/")) {
+      send({
+        jsonrpc: "2.0",
+        id: msg.id,
+        error: { code: -32601, message: "fs capability not offered" }
+      });
+    } else {
+      send({ jsonrpc: "2.0", id: msg.id, result: {} });
+    }
+  };
+  const rl = createInterface({ input: child.stdout });
+  rl.on("line", (raw) => {
+    const line = raw.trim();
+    if (!line)
+      return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (msg.id !== void 0 && msg.method) {
+      handleServerRequest(msg);
+    } else if (msg.id !== void 0) {
+      const p = pending.get(msg.id);
+      if (p) {
+        pending.delete(msg.id);
+        if (msg.error) {
+          p.reject(new Error(jsonRpcErrorText(msg.error)));
+        } else {
+          p.resolve(msg.result);
+        }
+      }
+    } else if (msg.method === "session/update") {
+      const update = msg.params?.update;
+      if (update && typeof update === "object") {
+        pushItem({ kind: "update", update });
+      }
+    }
+  });
+  child.stderr.on("data", (d) => stderrChunks.push(d.toString()));
+  child.on("error", (err) => {
+    pushItem({
+      kind: "error",
+      message: `failed to start ${command}: ${err.message}`
+    });
+    finish();
+  });
+  child.on("close", (code, signal) => {
+    if (finished)
+      return;
+    const tail = stderrChunks.join("").trim().slice(-STDERR_TAIL);
+    const message = child.timedOut ? `harness exceeded its wall-clock limit (${config.limits?.wallClockMs}ms) and was killed${tail ? `: ${tail}` : ""}` : `harness exited early (code=${code} signal=${signal})${tail ? `: ${tail}` : ""}`;
+    pushItem({ kind: "error", message });
+    finish();
+  });
+  try {
+    await request("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: {
+        fs: { readTextFile: false, writeTextFile: false }
+      }
+    }, initTimeout);
+    const sessionResult = await request("session/new", { cwd: config.cwd, mcpServers: config.mcpServers ?? [] }, initTimeout);
+    const sessionId = sessionResult?.sessionId;
+    if (!sessionId)
+      throw new Error("ACP session/new returned no sessionId");
+    request("session/prompt", { sessionId, prompt: [{ type: "text", text: config.prompt }] }, promptTimeout).then((res) => {
+      const stopReason = res?.stopReason;
+      pushItem({ kind: "done", stopReason: stopReason ?? "end_turn" });
+      finish();
+    }).catch((err) => {
+      pushItem({
+        kind: "error",
+        message: err instanceof Error ? err.message : String(err)
+      });
+      finish();
+    });
+    while (true) {
+      while (queue.length > 0) {
+        const item = queue.shift();
+        if (item)
+          yield item;
+      }
+      if (finished)
+        break;
+      await new Promise((r) => {
+        wake = r;
+      });
+    }
+    while (queue.length > 0) {
+      const item = queue.shift();
+      if (item)
+        yield item;
+    }
+  } catch (err) {
+    yield {
+      kind: "error",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    rl.close();
+    for (const p of pending.values())
+      p.reject(new Error("ACP client closing"));
+    pending.clear();
+    if (!child.killed)
+      child.kill();
+    if (ownsSandbox)
+      await sandbox.destroy();
+  }
+}
+
+// ../@prismalens/engine/dist/adapter/acp-adapter.js
+var DEFAULT_PREVIEW_LIMIT = 4e3;
+var AcpAdapter = class {
+  ctx;
+  seqCounter = 0;
+  now;
+  previewLimit;
+  /** Assistant text deltas accumulated since the last flush. */
+  pendingText = "";
+  /** tool_call metadata kept to enrich the later tool_call_update (paired by id). */
+  toolMeta = /* @__PURE__ */ new Map();
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.now = ctx.now ?? (() => /* @__PURE__ */ new Date());
+    this.previewLimit = ctx.previewLimit ?? DEFAULT_PREVIEW_LIMIT;
+  }
+  /**
+   * Map one ACP `update` to zero-or-one canonical event. Returns null for updates
+   * we don't surface (thought chunks, plan, mode/command updates) and for
+   * non-terminal tool progress frames (text deltas are accumulated, not emitted).
+   */
+  normalize(u) {
+    switch (u.sessionUpdate) {
+      case "agent_message_chunk":
+        this.pendingText += flattenAcpContent(u.content);
+        return null;
+      case "tool_call":
+        return this.toolCall(u);
+      case "tool_call_update":
+        return this.toolResult(u);
+      default:
+        return null;
+    }
+  }
+  /**
+   * Flush any accumulated assistant text as a text-only `agent_step`. Call before
+   * a terminal event so a pure-text turn (no tool call) is not lost.
+   */
+  flushText() {
+    if (this.pendingText.length === 0)
+      return null;
+    const text = this.pendingText;
+    this.pendingText = "";
+    return { kind: "agent_step", ...this.base(), text, toolCalls: [] };
+  }
+  /** Terminal: a branch finished. Emitted by the runner, not the harness stream. */
+  branchDone(reason) {
+    return { kind: "branch_done", ...this.base(), reason };
+  }
+  /** Terminal: a branch failed. */
+  error(message) {
+    return { kind: "error", ...this.base(), message };
+  }
+  /** Terminal: the run-level reduced report. */
+  report(report) {
+    return {
+      kind: "report",
+      runId: this.ctx.runId,
+      seq: this.nextSeq(),
+      ts: this.now().toISOString(),
+      report
+    };
+  }
+  // --- internals ---
+  toolCall(u) {
+    const toolCallId = u.toolCallId ?? "";
+    const name = pickName(u);
+    this.toolMeta.set(toolCallId, { name, kind: u.kind, rawInput: u.rawInput });
+    const text = this.pendingText;
+    this.pendingText = "";
+    return {
+      kind: "agent_step",
+      ...this.base(),
+      text,
+      toolCalls: [{ toolCallId, name, args: toArgs(u.rawInput) }]
+    };
+  }
+  toolResult(u) {
+    const status = u.status ?? "completed";
+    if (status !== "completed" && status !== "failed")
+      return null;
+    const toolCallId = u.toolCallId ?? "";
+    const meta = this.toolMeta.get(toolCallId);
+    const name = meta?.name ?? pickName(u);
+    const ok = status !== "failed";
+    const preview = truncate(flattenAcpContent(u.content), this.previewLimit);
+    return {
+      kind: "tool_result",
+      ...this.base(),
+      result: {
+        name,
+        toolCategory: mapToolCategory(meta?.kind ?? u.kind),
+        toolCallId,
+        source: deriveSource(name, meta?.rawInput),
+        ok,
+        error: ok ? null : preview || "tool failed",
+        preview
+      }
+    };
+  }
+  /** Common per-event fields shared by every branch-scoped event. */
+  base() {
+    return {
+      runId: this.ctx.runId,
+      branchId: this.ctx.branchId,
+      // ACP/deepagents is flat (verified 2026-06-29) — no nesting path, no label.
+      path: [],
+      seq: this.nextSeq(),
+      label: null,
+      ts: this.now().toISOString()
+    };
+  }
+  nextSeq() {
+    return this.seqCounter++;
+  }
+};
+function pickName(u) {
+  const title = typeof u.title === "string" ? u.title.trim() : "";
+  if (title)
+    return title;
+  const kind = typeof u.kind === "string" ? u.kind.trim() : "";
+  return kind || "tool";
+}
+function toArgs(rawInput) {
+  if (rawInput === void 0 || rawInput === null)
+    return {};
+  if (typeof rawInput === "object" && !Array.isArray(rawInput)) {
+    return unwrapInput(rawInput);
+  }
+  return { value: rawInput };
+}
+function unwrapInput(args) {
+  const keys = Object.keys(args);
+  if (keys.length === 1 && keys[0] === "input" && typeof args.input === "string") {
+    try {
+      const parsed = JSON.parse(args.input);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return args;
+}
+function flattenAcpContent(content) {
+  if (content === void 0 || content === null)
+    return "";
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content))
+    return content.map(flattenAcpBlock).join("");
+  return flattenAcpBlock(content);
+}
+function flattenAcpBlock(block) {
+  if (typeof block === "string")
+    return block;
+  if (block && typeof block === "object") {
+    const b = block;
+    if (typeof b.text === "string")
+      return b.text;
+    if (b.content && typeof b.content === "object") {
+      const inner = b.content;
+      if (typeof inner.text === "string")
+        return inner.text;
+    }
+  }
+  return "";
+}
+function deriveSource(name, input) {
+  if (input === void 0 || input === null)
+    return name;
+  const args = typeof input === "object" && !Array.isArray(input) ? unwrapInput(input) : input;
+  let rendered;
+  try {
+    rendered = JSON.stringify(args);
+  } catch {
+    rendered = String(args);
+  }
+  return `${name}(${rendered})`;
+}
+function mapToolCategory(kind) {
+  switch (kind) {
+    case "search":
+      return "search";
+    case "read":
+    case "edit":
+    case "move":
+    case "delete":
+      return "file";
+    default:
+      return null;
+  }
+}
+function mapStopReason(stopReason) {
+  switch (stopReason) {
+    case "end_turn":
+      return "submitted";
+    case "max_tokens":
+    case "max_turn_requests":
+      return "budget";
+    default:
+      return "no_progress";
+  }
+}
+function truncate(s, limit) {
+  return s.length > limit ? `${s.slice(0, limit)}\u2026` : s;
+}
+
+// ../@prismalens/engine/dist/runner/acp-run-branch.js
+async function* runBranch(items, ctx) {
+  const adapter = new AcpAdapter(ctx);
+  try {
+    for await (const item of items) {
+      if (item.kind === "update") {
+        const canonical = adapter.normalize(item.update);
+        if (canonical)
+          yield canonical;
+      } else if (item.kind === "done") {
+        const flushed2 = adapter.flushText();
+        if (flushed2)
+          yield flushed2;
+        yield adapter.branchDone(mapStopReason(item.stopReason));
+        return;
+      } else {
+        const flushed2 = adapter.flushText();
+        if (flushed2)
+          yield flushed2;
+        yield adapter.error(item.message);
+        return;
+      }
+    }
+    const flushed = adapter.flushText();
+    if (flushed)
+      yield flushed;
+    yield adapter.branchDone("submitted");
+  } catch (err) {
+    yield adapter.error(err instanceof Error ? err.message : String(err));
+  }
+}
+async function* runDeepAgentsBranch(config, ctx) {
+  yield* runBranch(runAcpBranch(config), ctx);
+}
+
+// ../@prismalens/engine/dist/runner/claude-code-runner.js
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join2 } from "node:path";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// ../@prismalens/engine/dist/adapter/claude-code-adapter.js
+var DEFAULT_PREVIEW_LIMIT2 = 4e3;
+var ClaudeCodeAdapter = class {
+  ctx;
+  seqCounter = 0;
+  now;
+  previewLimit;
+  /** Task tool_use_id → human subagent label (for depth resolution). */
+  taskLabels = /* @__PURE__ */ new Map();
+  /** tool_use_id → {name,input} so a later tool_result can be named + sourced. */
+  toolMeta = /* @__PURE__ */ new Map();
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.now = ctx.now ?? (() => /* @__PURE__ */ new Date());
+    this.previewLimit = ctx.previewLimit ?? DEFAULT_PREVIEW_LIMIT2;
+  }
+  /** Map one SDK message to zero-or-more canonical events. */
+  normalize(m) {
+    switch (m.type) {
+      case "assistant":
+        return this.assistant(m);
+      case "user":
+        return this.toolResults(m);
+      default:
+        return [];
+    }
+  }
+  /** Map a terminal `result` SDK message to the branch's terminal event. */
+  terminalFromResult(m) {
+    if (m.subtype === "success")
+      return this.branchDone("submitted", m);
+    if (m.subtype === "error_max_turns")
+      return this.branchDone("budget", m);
+    return this.error(m.result ?? `claude code ended: ${m.subtype ?? "unknown"}`);
+  }
+  branchDone(reason, m) {
+    return {
+      kind: "branch_done",
+      ...this.base(null),
+      reason,
+      ...m?.total_cost_usd !== void 0 ? { total_cost_usd: m.total_cost_usd } : {},
+      ...m?.usage !== void 0 ? { usage: m.usage } : {},
+      ...m?.modelUsage !== void 0 ? { modelUsage: m.modelUsage } : {},
+      ...m?.num_turns !== void 0 ? { num_turns: m.num_turns } : {},
+      ...m?.duration_ms !== void 0 ? { duration_ms: m.duration_ms } : {}
+    };
+  }
+  error(message) {
+    return { kind: "error", ...this.base(null), message };
+  }
+  report(report) {
+    return {
+      kind: "report",
+      runId: this.ctx.runId,
+      seq: this.nextSeq(),
+      ts: this.now().toISOString(),
+      report
+    };
+  }
+  // --- internals ---
+  assistant(m) {
+    const content = m.message?.content;
+    const blocks = Array.isArray(content) ? content : [];
+    const text = typeof content === "string" ? content : blocks.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+    const toolUses = blocks.filter((b) => b.type === "tool_use");
+    for (const tu of toolUses) {
+      const id = tu.id ?? "";
+      const name = tu.name ?? "tool";
+      if (id)
+        this.toolMeta.set(id, { name, input: tu.input });
+      if (id && name === "Task")
+        this.taskLabels.set(id, pickTaskLabel(tu.input));
+    }
+    if (!text && toolUses.length === 0)
+      return [];
+    return [
+      {
+        kind: "agent_step",
+        ...this.base(m.parent_tool_use_id ?? null),
+        text,
+        toolCalls: toolUses.map((tu) => ({
+          toolCallId: tu.id ?? "",
+          name: tu.name ?? "tool",
+          args: asRecord(tu.input)
+        }))
+      }
+    ];
+  }
+  toolResults(m) {
+    const content = m.message?.content;
+    if (!Array.isArray(content))
+      return [];
+    const out = [];
+    for (const b of content) {
+      if (b.type !== "tool_result")
+        continue;
+      const id = b.tool_use_id ?? "";
+      const meta = this.toolMeta.get(id);
+      const name = meta?.name ?? "tool";
+      const ok = b.is_error !== true;
+      const preview = truncate2(flattenContent(b.content), this.previewLimit);
+      out.push({
+        kind: "tool_result",
+        ...this.base(m.parent_tool_use_id ?? null),
+        result: {
+          name,
+          toolCategory: mapToolCategory2(name),
+          toolCallId: id,
+          source: deriveSource(name, meta?.input),
+          ok,
+          error: ok ? null : preview || "tool failed",
+          preview
+        }
+      });
+    }
+    return out;
+  }
+  /** Resolve depth from the spawning Task tool-call (deep, unlike flat ACP). */
+  base(parentToolUseId) {
+    const label = parentToolUseId ? this.taskLabels.get(parentToolUseId) ?? parentToolUseId : null;
+    return {
+      runId: this.ctx.runId,
+      branchId: this.ctx.branchId,
+      path: label ? [label] : [],
+      seq: this.nextSeq(),
+      label,
+      ts: this.now().toISOString()
+    };
+  }
+  nextSeq() {
+    return this.seqCounter++;
+  }
+};
+function pickTaskLabel(input) {
+  if (input && typeof input === "object") {
+    const o = input;
+    if (typeof o.subagent_type === "string" && o.subagent_type)
+      return o.subagent_type;
+    if (typeof o.description === "string" && o.description)
+      return o.description.slice(0, 40);
+  }
+  return "task";
+}
+function asRecord(input) {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    return input;
+  }
+  return input === void 0 || input === null ? {} : { value: input };
+}
+function flattenContent(content) {
+  if (content === void 0 || content === null)
+    return "";
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content))
+    return content.map(flattenBlock).join("");
+  return flattenBlock(content);
+}
+function flattenBlock(block) {
+  if (typeof block === "string")
+    return block;
+  if (block && typeof block === "object") {
+    const t = block.text;
+    if (typeof t === "string")
+      return t;
+  }
+  return "";
+}
+function mapToolCategory2(name) {
+  const n = name.toLowerCase();
+  if (n === "read" || n === "write" || n === "edit" || n === "multiedit")
+    return "file";
+  if (n === "grep" || n === "glob")
+    return "search";
+  return null;
+}
+function truncate2(s, cap) {
+  return s.length > cap ? `${s.slice(0, cap)}\u2026` : s;
+}
+
+// ../@prismalens/engine/dist/runner/claude-code-sandbox-spawn.js
+import { EventEmitter as EventEmitter2 } from "node:events";
+function sandboxSpawnClaudeCodeProcess(sandbox, opts = {}) {
+  return (options) => {
+    const child = sandbox.spawn(options.command, options.args, {
+      cwd: options.cwd ?? opts.cwd ?? process.cwd(),
+      env: opts.env ? { ...options.env, ...opts.env } : options.env,
+      ...opts.limits ? { limits: opts.limits } : {}
+    });
+    const emitter = new EventEmitter2();
+    let exitCode = null;
+    let exited = false;
+    child.on("close", (code, signal) => {
+      exitCode = code;
+      exited = true;
+      emitter.emit("exit", code, signal);
+    });
+    child.on("error", (err) => emitter.emit("error", err));
+    const onAbort = () => {
+      if (!exited && !child.killed)
+        child.kill("SIGKILL");
+    };
+    if (options.signal.aborted)
+      onAbort();
+    else
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    return {
+      stdin: child.stdin,
+      stdout: child.stdout,
+      get killed() {
+        return child.killed;
+      },
+      get exitCode() {
+        return exitCode;
+      },
+      kill(signal) {
+        return child.kill(signal);
+      },
+      on(event, listener) {
+        emitter.on(event, listener);
+      },
+      once(event, listener) {
+        emitter.once(event, listener);
+      },
+      off(event, listener) {
+        emitter.off(event, listener);
+      }
+    };
+  };
+}
+
+// ../@prismalens/engine/dist/runner/claude-code-runner.js
+var READ_ONLY_DENY = [
+  ...HARNESS_REGISTRY["claude-code"].readOnlyDeny ?? []
+];
+async function* runClaudeCodeBranch(config, ctx) {
+  const adapter = new ClaudeCodeAdapter(ctx);
+  let sawTerminal = false;
+  const mode = config.permissionMode ?? "read-only";
+  const readOnlyFloor = mode === "read-only" || mode === "supervised";
+  const permissionMode = mode === "auto" ? "acceptEdits" : "bypassPermissions";
+  const disallowedTools = readOnlyFloor ? config.disallowedTools ?? READ_ONLY_DENY : config.disallowedTools;
+  const sandbox = config.sandbox ?? createProcessFloorSandbox();
+  const ownsSandbox = config.sandbox === void 0;
+  let configDir;
+  try {
+    if (config.isolateSettings) {
+      configDir = await mkdtemp(join2(tmpdir2(), "claude-config-"));
+    }
+    const response = query({
+      prompt: config.prompt,
+      options: {
+        // NATIVE PASSTHROUGH first, so our posture keys below win on overlap.
+        ...config.native ?? {},
+        cwd: config.cwd,
+        ...config.model ? { model: config.model } : {},
+        // Behave as the real Claude Code harness (its tools + subagents).
+        systemPrompt: { type: "preset", preset: "claude_code" },
+        ...config.maxTurns ? { maxTurns: config.maxTurns } : {},
+        ...config.abortController ? { abortController: config.abortController } : {},
+        // prismalens posture-derived keys LAST — the read-only floor wins.
+        settingSources: config.isolateSettings ? [] : ["user", "project", "local"],
+        permissionMode,
+        ...disallowedTools ? { disallowedTools } : {},
+        spawnClaudeCodeProcess: sandboxSpawnClaudeCodeProcess(sandbox, {
+          cwd: config.cwd,
+          ...config.limits ? { limits: config.limits } : {},
+          ...configDir ? { env: { CLAUDE_CONFIG_DIR: configDir } } : {}
+        })
+      }
+    });
+    for await (const message of response) {
+      const m = message;
+      for (const ev of adapter.normalize(m))
+        yield ev;
+      if (m.type === "result") {
+        sawTerminal = true;
+        yield adapter.terminalFromResult(m);
+      }
+    }
+    if (!sawTerminal)
+      yield adapter.branchDone("submitted");
+  } catch (err) {
+    yield adapter.error(err instanceof Error ? err.message : String(err));
+  } finally {
+    if (ownsSandbox)
+      await sandbox.destroy();
+    if (configDir) {
+      await rm(configDir, { recursive: true, force: true });
+    }
+  }
+}
+
+// ../@prismalens/engine/dist/supervisor/decompose.js
+var DEFAULT_MAX_BRANCHES = 3;
+function decompose(context, opts = {}) {
+  if (context.alerts.length <= 1) {
+    return [{ branchId: "root", prompt: buildInvestigationPrompt(context) }];
+  }
+  const cap = Math.max(1, opts.maxBranches ?? DEFAULT_MAX_BRANCHES);
+  return context.alerts.slice(0, cap).map((focus, i) => ({
+    branchId: `b${i}`,
+    prompt: buildInvestigationPrompt(context, focus)
+  }));
+}
+function buildInvestigationPrompt(context, focus) {
+  const primary = focus ?? context.alerts[0];
+  const rest = focus ? context.alerts.filter((a) => a !== focus) : context.alerts.slice(1);
+  const t = context.telemetry;
+  const labels = JSON.stringify(primary.labels);
+  const annotations = JSON.stringify(primary.annotations);
+  const s = context.service;
+  const serviceBlock = s ? `
+
+AFFECTED SERVICE
+  name: ${s.name}${s.tier ? `   \xB7   tier: ${s.tier}` : ""}${s.repo ? `   \xB7   repo: ${s.repo}` : ""}${s.dependsOn?.length ? `
+  depends on: ${s.dependsOn.join(", ")}` : ""}` : "";
+  const relatedBlock = rest.length ? `
+
+RELATED FIRING ALERTS (same incident \u2014 correlate, don't investigate in isolation)
+${rest.map((a) => `  - ${a.alertname} (severity=${a.severity ?? "unknown"})`).join("\n")}` : "";
+  const logsSurface = context.logs?.url ? `
+  - Logs (${context.logs.kind ?? "log system"})   ${context.logs.url}      query recent logs for the affected service` : "";
+  return `You are an on-call Site Reliability Engineer running a LIVE investigation of a firing production alert. Your job is to find the ROOT CAUSE \u2014 the specific code path, configuration, dependency, or resource that produced this alert \u2014 not merely the symptom.
+
+FIRING ALERT
+  name:        ${primary.alertname}
+  severity:    ${primary.severity ?? "unknown"}
+  labels:      ${labels}
+  annotations: ${annotations}${serviceBlock}${relatedBlock}
+
+READ-ONLY SURFACES (never modify, deploy, restart, or write anything)
+  - Prometheus    ${t.prometheusUrl}
+      curl -s '${t.prometheusUrl}/api/v1/query' --data-urlencode 'query=<promql>'   \xB7   /api/v1/rules   \xB7   /api/v1/label/__name__/values
+  - Alertmanager  ${t.alertmanagerUrl}      curl -s '${t.alertmanagerUrl}/api/v2/alerts'
+  - Application API ${t.apiUrl}${logsSurface}
+  - Application SOURCE CODE is in your current working directory \u2014 ls / cat / grep / head.
+
+METHOD (work iteratively \u2014 think \u2192 run a command \u2192 observe \u2192 decide)
+  0. Shell tool calls take the full command as ONE string in the tool's \`command\` field \u2014 never an argv array
+     (a malformed tool call can abort the whole investigation).
+  1. File reads, greps, and globs stay INSIDE your current working directory \u2014 use relative paths only. Never search
+     from the filesystem root or pass absolute paths outside the repo (a permission error aborts the whole investigation).
+  2. Confirm the alert's signal in Prometheus: which metric/expression fired and how far past threshold.
+  3. After EACH command, say in one line what you learned and what you will check next; let the evidence pick the next probe.
+  4. Localize, then go to the code. Identify WHICH operation/endpoint/component the signal is about \u2014 e.g. for a latency
+     alert, find the SLOWEST endpoint or operation \u2014 then READ that code path's handler and the configuration it depends on.
+  5. Never run the same command with the same arguments twice. If your last couple of probes produced nothing new, stop and write the diagnosis.
+
+WHAT COUNTS AS A ROOT CAUSE (important)
+  Restating the symptom is NOT a root cause. "The service is slow / unresponsive / latency is high" is the alert restated,
+  not its cause. A surface symptom (e.g. requests timing out) is almost always a downstream EFFECT \u2014 keep digging until you
+  can name the concrete code, configuration, dependency, or resource responsible and explain the mechanism that links it to
+  the alert.
+
+OUTPUT
+  State the single most likely root cause and the mechanism. List the evidence as VALIDATED (a command/metric/file directly
+  showed it \u2014 quote the exact command) versus INFERRED (reasoned, not directly observed). Recommend a fix. Be specific and
+  concise; never assert without evidence.`;
+}
+
+// ../@prismalens/engine/dist/supervisor/fan-out.js
+var MAX_BRANCH_RESPAWNS = 1;
+function branchErrorEvent(runId, branchId, seq, message) {
+  return {
+    kind: "error",
+    runId,
+    branchId,
+    path: [],
+    seq,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    message
+  };
+}
+async function* runBranch2(branch, harness, runId) {
+  let seq = 0;
+  let sawEvent = false;
+  for (let attempt = 0; ; attempt++) {
+    const base = seq;
+    try {
+      for await (const ev of harness(branch.prompt, {
+        runId,
+        branchId: branch.branchId
+      })) {
+        sawEvent = true;
+        const stamped = base > 0 ? { ...ev, seq: ev.seq + base } : ev;
+        seq = stamped.seq + 1;
+        yield stamped;
+      }
+      return;
+    } catch (err) {
+      if (!sawEvent)
+        throw err;
+      const message = String(err?.message ?? err);
+      if (attempt < MAX_BRANCH_RESPAWNS) {
+        yield branchErrorEvent(runId, branch.branchId, seq++, `harness aborted mid-run \u2014 respawning branch once (attempt ${attempt + 2}/${MAX_BRANCH_RESPAWNS + 1}): ${message}`);
+        continue;
+      }
+      yield branchErrorEvent(runId, branch.branchId, seq, message);
+      return;
+    }
+  }
+}
+async function* fanOut(branches, harness, runId, opts = {}) {
+  if (branches.length === 0)
+    return;
+  if (branches.length === 1) {
+    yield* runBranch2(branches[0], harness, runId);
+    return;
+  }
+  yield* interleave(branches, harness, runId, opts.concurrency ?? branches.length);
+}
+async function* interleave(branches, harness, runId, concurrency) {
+  const buffer = [];
+  let wake = null;
+  let finished = false;
+  let cancelled = false;
+  const notify = () => {
+    if (wake) {
+      wake();
+      wake = null;
+    }
+  };
+  const pump = async (branch) => {
+    let seq = 0;
+    const it = runBranch2(branch, harness, runId)[Symbol.asyncIterator]();
+    try {
+      while (true) {
+        if (cancelled) {
+          await it.return?.(void 0);
+          break;
+        }
+        const { value: ev, done } = await it.next();
+        if (done)
+          break;
+        seq = ev.seq + 1;
+        buffer.push(ev);
+        notify();
+      }
+    } catch (err) {
+      buffer.push(branchErrorEvent(runId, branch.branchId, seq, String(err?.message ?? err)));
+      notify();
+    }
+  };
+  let cursor = 0;
+  const lane = async () => {
+    while (cursor < branches.length) {
+      await pump(branches[cursor++]);
+    }
+  };
+  const cap = Math.max(1, Math.min(concurrency, branches.length));
+  const lanes = Promise.all(Array.from({ length: cap }, lane)).then(() => {
+    finished = true;
+    notify();
+  });
+  try {
+    while (true) {
+      while (buffer.length > 0) {
+        yield buffer.shift();
+      }
+      if (finished)
+        break;
+      await new Promise((resolve) => {
+        wake = resolve;
+      });
+    }
+  } finally {
+    cancelled = true;
+    cursor = branches.length;
+    await lanes;
+  }
+}
+
+// ../@prismalens/config/dist/providers/agents.js
+import { z } from "zod";
+var INVESTIGATION_AGENTS = {
+  scout: {
+    id: "scout",
+    name: "Scout",
+    description: "Initial alert validation and triage",
+    role: "entry"
+  },
+  gatherer: {
+    id: "gatherer",
+    name: "Gatherer",
+    description: "Deep data collection from integrations",
+    role: "worker"
+  },
+  analyst: {
+    id: "analyst",
+    name: "Analyst",
+    description: "Root cause analysis and hypothesis generation",
+    role: "worker"
+  },
+  resolver: {
+    id: "resolver",
+    name: "Resolver",
+    description: "Remediation recommendations and fix suggestions",
+    role: "worker"
+  },
+  supervisor: {
+    id: "supervisor",
+    name: "Supervisor",
+    description: "Orchestrates agent workflow and routing",
+    role: "orchestrator"
+  }
+};
+var AGENT_IDS = Object.keys(INVESTIGATION_AGENTS);
+var agentIdSchema = z.enum(AGENT_IDS);
+var ROUTABLE_AGENT_IDS = Object.entries(INVESTIGATION_AGENTS).filter(([, a]) => a.role === "worker").map(([id]) => id);
+
+// ../@prismalens/contracts/dist/schemas/common.js
+import { z as z2 } from "zod";
+var GlobalRoleSchema = z2.enum(["owner", "admin", "member"]);
+var ServiceTypeSchema = z2.enum([
+  "service",
+  "database",
+  "queue",
+  "cache",
+  "gateway",
+  "external",
+  "infrastructure"
+]);
+var ServiceTierSchema = z2.enum([
+  "tier_1",
+  "tier_2",
+  "tier_3",
+  "tier_4"
+]);
+var DependencyTypeSchema = z2.enum(["runtime", "build", "data"]);
+var DependencyCriticalitySchema = z2.enum([
+  "required",
+  "optional",
+  "degraded"
+]);
+var SeveritySchema = z2.enum([
+  "critical",
+  "high",
+  "medium",
+  "low",
+  "info"
+]);
+var AlertStatusSchema = z2.enum([
+  "triggered",
+  "acknowledged",
+  "correlated",
+  "resolved",
+  "suppressed"
+]);
+var IncidentStatusSchema = z2.enum([
+  "triggered",
+  "investigating",
+  "identified",
+  "monitoring",
+  "resolved",
+  "closed"
+]);
+var PrioritySchema = z2.enum(["p1", "p2", "p3", "p4", "p5"]);
+var WorkflowStatusSchema = z2.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var RootCauseCategorySchema = z2.enum([
+  "code",
+  "config",
+  "infrastructure",
+  "external",
+  "unknown"
+]);
+var AgentNameSchema = z2.enum(AGENT_IDS);
+var AgentTypeSchema = z2.enum(["llm", "sequential", "loop"]);
+var ExecutionStatusSchema = z2.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed"
+]);
+var ToolExecutionStatusSchema = z2.enum([
+  "pending",
+  "running",
+  "success",
+  "error"
+]);
+var ToolCategorySchema = z2.enum([
+  "file",
+  "search",
+  "github",
+  "logs",
+  "analysis"
+]);
+var HypothesisStatusSchema = z2.enum([
+  "confirmed",
+  // direct evidence
+  "supported",
+  // consistent with evidence
+  "speculative",
+  // no evidence yet
+  "refuted"
+]);
+var EvidenceStatusSchema = z2.enum([
+  "verified",
+  // a tool directly showed it
+  "inferred"
+  // reasoned, not directly observed
+]);
+var EvidenceDirectionSchema = z2.enum(["supports", "contradicts"]);
+var RecommendationPrioritySchema = z2.enum([
+  "critical",
+  "high",
+  "medium",
+  "low"
+]);
+var RecommendationCategorySchema = z2.enum([
+  "code_fix",
+  "config_change",
+  "rollback",
+  "monitoring",
+  "investigation"
+]);
+var UrgencySchema = z2.enum(["immediate", "short_term", "long_term"]);
+var EffortEstimateSchema = z2.enum(["minutes", "hours", "days"]);
+var RecommendationStatusSchema = z2.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "rejected",
+  "deferred"
+]);
+var TimelineEntryTypeSchema = z2.enum([
+  "incident_created",
+  "alert_added",
+  "alert_removed",
+  "status_changed",
+  "severity_changed",
+  "assigned",
+  "investigation_started",
+  "investigation_completed",
+  "recommendation_added",
+  "recommendation_completed",
+  "comment",
+  "postmortem_created",
+  "custom"
+]);
+var TimelineSourceSchema = z2.enum(["system", "user", "ai_worker"]);
+var PostmortemStatusSchema = z2.enum([
+  "draft",
+  "in_review",
+  "published",
+  "archived"
+]);
+var CorrelationActionSchema = z2.enum([
+  "correlate",
+  "suppress",
+  "create_incident"
+]);
+var SettingTypeSchema = z2.enum([
+  "string",
+  "number",
+  "boolean",
+  "json",
+  "encrypted"
+]);
+var SettingCategorySchema = z2.enum([
+  "general",
+  "correlation",
+  "ai",
+  "notifications",
+  "setup"
+]);
+var ConnectionStatusSchema = z2.enum([
+  "ACTIVE",
+  "TOKEN_EXPIRED",
+  "REFRESH_FAILED",
+  "CREDENTIALS_INVALID",
+  "REVOKED",
+  "ERROR"
+]);
+var SuggestionStatusSchema = z2.enum([
+  "pending",
+  "accepted",
+  "rejected",
+  "ignored"
+]);
+var ChangeEventTypeSchema = z2.enum([
+  "deployment",
+  "config",
+  "migration",
+  "commit",
+  "rollback"
+]);
+var LicenseTypeSchema = z2.enum(["none", "subscription"]);
+var LicenseTierSchema = z2.enum(["community", "enterprise"]);
+var PaginationSchema = z2.object({
+  limit: z2.coerce.number().int().min(1).max(100).default(50),
+  offset: z2.coerce.number().int().min(0).default(0)
+});
+var IdParamSchema = z2.object({
+  id: z2.string().uuid()
+});
+var DateStringSchema = z2.string().datetime();
+var CoerceDateSchema = z2.coerce.date();
+var SuccessResponseSchema = z2.object({
+  success: z2.boolean()
+});
+var MessageResponseSchema = z2.object({
+  message: z2.string()
+});
+
+// ../@prismalens/contracts/dist/schemas/investigation.js
+import { z as z4 } from "zod";
+
+// ../@prismalens/contracts/dist/schemas/overlay.js
+import { z as z3 } from "zod";
+var MatchedChangeSchema = z3.object({
+  /** Which timeline table this row came from. */
+  kind: z3.enum(["deployment", "change_event"]),
+  /** Row id (Deployment.id or ChangeEvent.id). */
+  id: z3.string(),
+  /** Human label — deployment name or change description. */
+  title: z3.string(),
+  /** Origin — the change source (e.g. "render", "github") or "deployment". */
+  source: z3.string(),
+  /** Affected service name for this row, when known. */
+  serviceName: z3.string().nullable(),
+  /** When the change/deploy happened (ISO). */
+  timestamp: z3.string(),
+  /** Index into the report's ordered `hypotheses` this row matched. */
+  hypothesisIndex: z3.number().int().min(0),
+  /** The literal token (service name or identifier) that produced the match. */
+  matchedOn: z3.string()
+});
+var ServiceProximitySchema = z3.object({
+  serviceName: z3.string(),
+  proximity: z3.union([z3.literal(0), z3.literal(1), z3.literal(2)]),
+  relation: z3.enum(["self", "dependency", "dependent", "beyond"]),
+  /** Indices into the report's ordered `hypotheses` that name this service. */
+  hypothesisIndexes: z3.array(z3.number().int().min(0))
+});
+var SimilarIncidentSchema = z3.object({
+  incidentId: z3.string(),
+  incidentNumber: z3.number().int(),
+  title: z3.string(),
+  /** Normalised 0..1 similarity. */
+  score: z3.number().min(0).max(1),
+  factors: z3.object({
+    jaccard: z3.number().min(0).max(1),
+    sameService: z3.boolean(),
+    sharedCategory: z3.boolean()
+  })
+});
+var OverlaySchema = z3.object({
+  matchedChanges: z3.array(MatchedChangeSchema),
+  serviceProximity: z3.array(ServiceProximitySchema),
+  similarIncidents: z3.array(SimilarIncidentSchema),
+  /** When the overlay was computed (ISO). */
+  computedAt: z3.string()
+});
+
+// ../@prismalens/contracts/dist/schemas/investigation.js
+var EvidenceSchema = z4.object({
+  /** What was observed. */
+  observation: z4.string().min(1),
+  /** Where it came from — the exact command or origin that produced it. */
+  source: z4.string().min(1),
+  direction: EvidenceDirectionSchema,
+  status: EvidenceStatusSchema,
+  /**
+   * Links a finding to the live tool call that produced it
+   * (StreamToolResult.toolCallId), so the report view can drill into the
+   * originating output (ADR-0007). Null for `inferred` evidence with no single
+   * originating call.
+   */
+  toolCallId: z4.string().nullable().optional()
+});
+var HypothesisSchema = z4.object({
+  // Ordering is by ARRAY POSITION (most → least plausible) — the single source of
+  // truth, per ADR-0002's "ordered list". No numeric rank/confidence.
+  statement: z4.string().min(1),
+  status: HypothesisStatusSchema,
+  evidence: z4.array(EvidenceSchema)
+});
+var RuledOutSchema = z4.object({
+  // A candidate cause never promoted to a ranked hypothesis. (A hypothesis that WAS
+  // considered then disproved stays in `hypotheses` with status "refuted".)
+  statement: z4.string().min(1),
+  why: z4.string().min(1),
+  /** The contradicting evidence that ruled it out (direction "contradicts"). */
+  evidence: z4.array(EvidenceSchema)
+});
+var CoverageSchema = z4.object({
+  queried: z4.array(z4.string()),
+  notQueried: z4.array(z4.string())
+});
+var NextStepSchema = z4.object({
+  title: z4.string().min(1),
+  detail: z4.string().min(1),
+  priority: RecommendationPrioritySchema.nullable().optional()
+});
+var RunFidelitySandboxSchema = z4.object({
+  requested: z4.string(),
+  actual: z4.string(),
+  fidelity: z4.enum(["enforced", "cooperative"])
+});
+var RunFidelitySchema = z4.object({
+  harness: z4.string(),
+  mode: z4.string(),
+  fidelity: z4.enum(["enforced", "cooperative", "advisory"]),
+  mechanism: z4.string(),
+  /**
+   * The Sandbox boundary (ADR-0020) the harness was spawned into, when one was
+   * wired. Additive/optional — omitted when no sandbox applies (e.g. the
+   * in-process Agent SDK harness, or no boundary requested at all).
+   */
+  sandbox: RunFidelitySandboxSchema.optional()
+});
+var InvestigationReportSchema = z4.object({
+  summary: z4.string().min(1),
+  rootCause: z4.string().nullable(),
+  rootCauseCategory: RootCauseCategorySchema.nullable(),
+  /** Ordered most → least plausible (array order is the ordering). */
+  hypotheses: z4.array(HypothesisSchema),
+  ruledOut: z4.array(RuledOutSchema),
+  coverage: CoverageSchema,
+  nextSteps: z4.array(NextStepSchema),
+  /**
+   * Run-metadata, ADR-0017 honest fidelity — the enforcement the harness
+   * actually applied. Attached deterministically after synthesis; never
+   * LLM-generated.
+   */
+  fidelity: RunFidelitySchema.nullable().optional()
+});
+var ToolExecutionSchema = z4.object({
+  id: z4.string().uuid(),
+  agentExecutionId: z4.string().uuid(),
+  toolName: z4.string(),
+  toolCategory: ToolCategorySchema.nullable(),
+  arguments: z4.record(z4.unknown()).nullable(),
+  result: z4.record(z4.unknown()).nullable(),
+  status: ToolExecutionStatusSchema,
+  executionTimeMs: z4.number().int().nullable(),
+  dataQuality: z4.string().nullable(),
+  error: z4.string().nullable(),
+  executedAt: DateStringSchema
+});
+var AgentExecutionSchema = z4.object({
+  id: z4.string().uuid(),
+  investigationId: z4.string().uuid(),
+  agentName: AgentNameSchema,
+  agentType: AgentTypeSchema,
+  status: ExecutionStatusSchema,
+  startedAt: DateStringSchema.nullable(),
+  completedAt: DateStringSchema.nullable(),
+  executionTimeMs: z4.number().int().nullable(),
+  output: z4.record(z4.unknown()).nullable(),
+  inputTokens: z4.number().int().nullable(),
+  outputTokens: z4.number().int().nullable(),
+  error: z4.string().nullable(),
+  createdAt: DateStringSchema
+});
+var AgentExecutionWithToolsSchema = AgentExecutionSchema.extend({
+  toolExecutions: z4.array(ToolExecutionSchema).optional()
+});
+var InvestigationSchema = z4.object({
+  id: z4.string().uuid(),
+  incidentId: z4.string().uuid(),
+  status: WorkflowStatusSchema,
+  startedAt: DateStringSchema.nullable(),
+  completedAt: DateStringSchema.nullable(),
+  summary: z4.string().nullable(),
+  rootCause: z4.string().nullable(),
+  rootCauseCategory: RootCauseCategorySchema.nullable(),
+  /** The full ordered-evidence report (ADR-0002); supersedes the old confidence/dataQuality/rawOutput columns. */
+  report: InvestigationReportSchema.nullable().optional(),
+  /**
+   * App-side reduce overlay (ADR-0016 §5c) — post-report enrichment computed
+   * BESIDE the canonical report (related changes, service-graph proximity, similar
+   * incidents). Absent until computed; the engine never sees it (ADR-0011).
+   */
+  overlay: OverlaySchema.nullable().optional(),
+  error: z4.string().nullable(),
+  createdAt: DateStringSchema,
+  updatedAt: DateStringSchema
+});
+var CreateInvestigationSchema = z4.object({
+  incidentId: z4.string().uuid()
+});
+var RecommendationRefSchema = z4.object({
+  id: z4.string().uuid(),
+  title: z4.string(),
+  priority: z4.string(),
+  status: z4.string()
+});
+var InvestigationWithRelationsSchema = InvestigationSchema.extend({
+  agentExecutions: z4.array(AgentExecutionWithToolsSchema).optional(),
+  recommendations: z4.array(RecommendationRefSchema).optional()
+});
+var InvestigationStatusSchema = z4.object({
+  investigation: InvestigationSchema,
+  job: z4.object({
+    id: z4.string(),
+    state: z4.string(),
+    progress: z4.number().min(0).max(100).nullable(),
+    attemptsMade: z4.number().int(),
+    failedReason: z4.string().nullable()
+  }).nullable()
+});
+var InvestigationQuerySchema = z4.object({
+  incidentId: z4.string().uuid().optional(),
+  status: WorkflowStatusSchema.optional(),
+  limit: z4.coerce.number().int().min(1).max(100).default(50),
+  offset: z4.coerce.number().int().min(0).default(0)
+});
+var UpdateInvestigationStatusSchema = z4.object({
+  id: z4.string().uuid(),
+  status: WorkflowStatusSchema,
+  error: z4.string().optional(),
+  harnessThreadId: z4.string().uuid().optional()
+});
+var CreateToolExecutionInputSchema = z4.object({
+  toolName: z4.string(),
+  toolCategory: z4.string().optional(),
+  // Using string directly to be permissive for inputs
+  arguments: z4.record(z4.unknown()).nullable().optional(),
+  result: z4.record(z4.unknown()).nullable().optional(),
+  status: ToolExecutionStatusSchema.optional(),
+  executionTimeMs: z4.number().int().optional(),
+  dataQuality: z4.string().optional(),
+  error: z4.string().optional()
+});
+var CreateAgentExecutionInputSchema = z4.object({
+  agentName: z4.string(),
+  agentType: z4.string().optional(),
+  status: ExecutionStatusSchema.optional(),
+  startedAt: z4.string().datetime().optional(),
+  completedAt: z4.string().datetime().optional(),
+  executionTimeMs: z4.number().int().optional(),
+  output: z4.record(z4.unknown()).optional(),
+  inputTokens: z4.number().int().optional(),
+  outputTokens: z4.number().int().optional(),
+  error: z4.string().optional(),
+  toolExecutions: z4.array(CreateToolExecutionInputSchema).optional()
+});
+var CreateRecommendationInputSchema = z4.object({
+  title: z4.string(),
+  description: z4.string().optional(),
+  priority: z4.string().optional(),
+  // 'low' | 'medium' | 'high' | 'critical'
+  category: z4.string().optional(),
+  urgency: z4.string().optional(),
+  actionable: z4.boolean().optional(),
+  estimatedEffort: z4.string().optional()
+});
+var WriteInvestigationResultSchema = z4.object({
+  id: z4.string().uuid(),
+  status: WorkflowStatusSchema,
+  summary: z4.string().optional(),
+  rootCause: z4.string().optional(),
+  rootCauseCategory: z4.string().optional(),
+  /** The full ordered-evidence report (ADR-0002), persisted as Investigation.report. */
+  report: InvestigationReportSchema.optional(),
+  error: z4.string().optional(),
+  agentExecutions: z4.array(CreateAgentExecutionInputSchema).optional(),
+  recommendations: z4.array(CreateRecommendationInputSchema).optional()
+});
+var StreamToolResultSchema = z4.object({
+  /** Tool name — same key as the originating agent_step `toolCalls[].name`. */
+  name: z4.string().min(1),
+  toolCategory: ToolCategorySchema.nullable().optional(),
+  /** Links this result to its call. Derive from ToolMessage.tool_call_id. */
+  toolCallId: z4.string(),
+  /** The command/args that produced it (human-readable provenance). */
+  source: z4.string().min(1),
+  /**
+   * Derive from ToolMessage.status === "error" (NOT from "on_tool_end fired" —
+   * LangGraph ToolNode has handleToolErrors=true and emits a failed tool as a
+   * normal end event with status "error"; MCP tools may return error-as-content).
+   */
+  ok: z4.boolean(),
+  /** Failure message when !ok, for the drill-down. */
+  error: z4.string().nullable().optional(),
+  /** Truncated/sanitised result. */
+  preview: z4.string()
+});
+var StreamBaseShape = {
+  runId: z4.string().uuid(),
+  /**
+   * Slice 0: a single constant branch. Fan-out (Slice 1) varies it. The UI's
+   * ordering + idempotent-upsert key is (branchId, seq) — NOT seq alone, since each
+   * branch is a separate harness run with its own counter.
+   */
+  branchId: z4.string().min(1),
+  /**
+   * Structural nesting depth within a branch, from the harness checkpoint ns
+   * (LangGraph node names + task uuids; the `tools:` wrapper collapsed). These are
+   * NOT subagent names — see `label` for the human name. [] = branch top.
+   */
+  path: z4.array(z4.string()),
+  /** Per-branch monotonic sequence (adapter-assigned in arrival order). */
+  seq: z4.number().int(),
+  /**
+   * Human-readable node/subagent label when resolvable (from the spawning `task`
+   * tool-call's subagent_type via run_id parentage); null at the branch top.
+   */
+  label: z4.string().nullable().optional(),
+  /** Wall-clock emit time (adapter-stamped) for step/tool durations in the drill-down. */
+  ts: z4.string().datetime()
+};
+var CanonicalEventSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    kind: z4.literal("agent_step"),
+    ...StreamBaseShape,
+    text: z4.string(),
+    toolCalls: z4.array(z4.object({
+      /** Stable id from AIMessage tool_calls[].id; pairs with a tool_result. */
+      toolCallId: z4.string(),
+      name: z4.string().min(1),
+      /** Post-unwrap args (the deepagents {input:"<json>"} wrapper removed). */
+      args: z4.record(z4.unknown())
+    }))
+  }),
+  z4.object({
+    kind: z4.literal("tool_result"),
+    ...StreamBaseShape,
+    result: StreamToolResultSchema
+  }),
+  z4.object({
+    kind: z4.literal("branch_done"),
+    ...StreamBaseShape,
+    /**
+     * Supervisor classification (not a harness field). The adapter maps a thrown
+     * GraphRecursionError to "budget"; genuine failures emit an `error` event.
+     */
+    reason: z4.enum(["submitted", "budget", "no_progress"]),
+    usage: z4.object({
+      input_tokens: z4.number().int().min(0).optional(),
+      output_tokens: z4.number().int().min(0).optional()
+    }).nullable().optional(),
+    total_cost_usd: z4.number().min(0).optional(),
+    modelUsage: z4.record(z4.unknown()).nullable().optional(),
+    num_turns: z4.number().int().min(0).optional(),
+    duration_ms: z4.number().int().min(0).optional()
+  }),
+  z4.object({
+    kind: z4.literal("error"),
+    ...StreamBaseShape,
+    message: z4.string()
+  }),
+  z4.object({
+    kind: z4.literal("report"),
+    runId: z4.string().uuid(),
+    seq: z4.number().int(),
+    ts: z4.string().datetime(),
+    report: InvestigationReportSchema
+  }),
+  z4.object({
+    kind: z4.literal("llm_call"),
+    runId: z4.string().uuid(),
+    seq: z4.number().int(),
+    ts: z4.string().datetime(),
+    phase: z4.enum(["decompose", "map", "reduce"]),
+    provider: z4.string(),
+    model: z4.string(),
+    usage: z4.object({
+      inputTokens: z4.number().int().min(0).nullable(),
+      outputTokens: z4.number().int().min(0).nullable()
+    }).nullable(),
+    latencyMs: z4.number().int().min(0),
+    outcome: z4.enum(["ok", "error"]),
+    failureCause: z4.string().nullable()
+  })
+]);
+var AppendInvestigationEventsSchema = z4.object({
+  events: z4.array(z4.unknown())
+});
+var AppendInvestigationEventsResultSchema = z4.object({
+  accepted: z4.number().int(),
+  dropped: z4.number().int()
+});
+var GetInvestigationEventsSchema = z4.object({
+  id: z4.string().uuid(),
+  /** Exclusive `seq` cursor; omit for the first page. */
+  cursor: z4.coerce.number().int().min(0).optional(),
+  limit: z4.coerce.number().int().min(1).max(200).default(100)
+});
+var InvestigationEventsPageSchema = z4.object({
+  events: z4.array(CanonicalEventSchema),
+  nextCursor: z4.number().int().nullable()
+});
+var FiringAlertSchema = z4.object({
+  alertname: z4.string(),
+  severity: z4.string().nullable(),
+  labels: z4.record(z4.string()),
+  annotations: z4.record(z4.string()),
+  startsAt: z4.string().nullable()
+});
+var TelemetryEndpointsSchema = z4.object({
+  prometheusUrl: z4.string(),
+  alertmanagerUrl: z4.string(),
+  apiUrl: z4.string()
+});
+var IncidentContextSchema = z4.object({
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  severity: z4.string().optional(),
+  startedAt: z4.string().optional()
+});
+var ServiceContextSchema = z4.object({
+  name: z4.string().min(1),
+  tier: z4.string().optional(),
+  /** owner/name slug or a local path — where the harness reads the code. */
+  repo: z4.string().optional(),
+  /** Direct dependency names (blast-radius seed for a future reduce overlay). */
+  dependsOn: z4.array(z4.string()).optional()
+});
+var LogSystemContextSchema = z4.object({
+  kind: z4.string().optional(),
+  url: z4.string().optional()
+});
+var PriorInvestigationSchema = z4.object({
+  incidentTitle: z4.string().optional(),
+  summary: z4.string().optional(),
+  rootCause: z4.string().optional()
+});
+var InvestigationContextSchema = z4.object({
+  /** ≥1 firing alert. A single-alert run is the degenerate case, not empty. */
+  alerts: z4.array(FiringAlertSchema).min(1),
+  /** Read-only telemetry surfaces (resolved by the host — ADR-0011). */
+  telemetry: TelemetryEndpointsSchema,
+  incident: IncidentContextSchema.optional(),
+  service: ServiceContextSchema.optional(),
+  /** Repo slugs in play (owner/name); the harness cwd is the primary one. */
+  repos: z4.array(z4.string()).optional(),
+  logs: LogSystemContextSchema.optional(),
+  priorInvestigations: z4.array(PriorInvestigationSchema).optional()
+});
+function singleAlertContext(alert, telemetry, extras = {}) {
+  return {
+    alerts: [alert],
+    telemetry,
+    ...extras.incident ? { incident: extras.incident } : {},
+    ...extras.service ? { service: extras.service } : {},
+    ...extras.repos ? { repos: extras.repos } : {},
+    ...extras.logs ? { logs: extras.logs } : {},
+    ...extras.priorInvestigations ? { priorInvestigations: extras.priorInvestigations } : {}
+  };
+}
+
+// ../@prismalens/engine/dist/supervisor/synthesize.js
+import { generateObject, generateText as generateText2 } from "ai";
+var SYSTEM = `You are a senior Site Reliability Engineer writing the FINAL structured root-cause report for an incident investigation.
+
+Epistemics (strict): order hypotheses MOST \u2192 LEAST plausible by array position. Do NOT use numeric confidence/probability. Each hypothesis carries a discrete status and a list of evidence; each evidence item records what was observed, the exact source (the command/metric/file that produced it), whether it supports or contradicts, and whether it was directly verified or inferred. Ground every claim in the transcript \u2014 do not invent evidence.`;
+var MERGE_SYSTEM = `You are a senior Site Reliability Engineer consolidating SEVERAL per-branch root-cause reports into ONE report for the SAME incident. Each input report investigated a different firing alert of that incident.
+
+Merge rules (strict):
+- DEDUPE across branches: the SAME hypothesis raised by multiple branches becomes ONE hypothesis; UNITE its evidence (keep every distinct item, drop exact duplicates).
+- RANK by array position (most \u2192 least plausible). Position IS the rank \u2014 do NOT use numeric confidence/probability (ADR-0002 ordered-evidence).
+- ruledOut is the UNION across branches (dedupe identical entries).
+- coverage.queried / coverage.notQueried are the UNION across branches.
+- Ground every claim in the provided per-branch reports \u2014 do NOT invent evidence.`;
+var PREVIEW_CAP = 1200;
+var TRANSCRIPT_CAP = 24e3;
+var RAW_REPORT_NOTICE = "[RAW \u2014 un-synthesized harness output; no Tier-1 provider configured]";
+var defaultReportModel = (prompt, cfg, phase = "reduce") => runReportModel(cfg, prompt, phase);
+async function reduce(context, events, cfg, model = defaultReportModel) {
+  const groups = groupEventsByBranch(events);
+  if (groups.length <= 1) {
+    return model(synthesisPrompt(buildTranscript(context, events)), cfg, "reduce");
+  }
+  const nonEmpty = groups.filter((g) => hasToolEvidence(g.events));
+  if (nonEmpty.length === 1) {
+    const only = nonEmpty[0];
+    return model(synthesisPrompt(buildTranscript(context, only.events, branchFocus(context, only.branchId))), cfg, "reduce");
+  }
+  const perBranch = await Promise.all(nonEmpty.map((g) => model(synthesisPrompt(buildTranscript(context, g.events, branchFocus(context, g.branchId))), cfg, "map")));
+  return model(mergePrompt(context, perBranch), cfg, "reduce");
+}
+function rawReport(_context, events, synthError) {
+  const groups = groupEventsByBranch(events);
+  const surviving = groups.filter((g) => hasToolEvidence(g.events));
+  let summary = RAW_REPORT_NOTICE;
+  if (synthError !== void 0) {
+    summary += ` Synthesis failed: ${synthError}`;
+  }
+  summary += "\n\n";
+  const conclusions = surviving.map((g) => branchConclusion(g.events)).filter((c) => c !== "");
+  if (conclusions.length > 0) {
+    summary += conclusions.join("\n\n");
+  } else {
+    summary += "No branch conclusions gathered.";
+  }
+  return {
+    summary,
+    rootCause: null,
+    rootCauseCategory: null,
+    hypotheses: [],
+    ruledOut: [],
+    coverage: { queried: uniqueSources(events), notQueried: [] },
+    nextSteps: []
+  };
+}
+function branchConclusion(events) {
+  let last = "";
+  for (const e of events) {
+    if (e.kind === "agent_step" && e.text.trim() !== "") {
+      last = e.text.trim();
+    }
+  }
+  return last;
+}
+function uniqueSources(events) {
+  const sources = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.kind === "tool_result") {
+      sources.add(e.result.source);
+    }
+  }
+  return Array.from(sources);
+}
+function groupEventsByBranch(events) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (!("branchId" in ev))
+      continue;
+    const group = byId.get(ev.branchId);
+    if (group)
+      group.push(ev);
+    else
+      byId.set(ev.branchId, [ev]);
+  }
+  return [...byId.entries()].map(([branchId, evs]) => ({
+    branchId,
+    events: evs
+  }));
+}
+function branchFocus(context, branchId) {
+  const m = /^b(\d+)$/.exec(branchId);
+  return m ? context.alerts[Number(m[1])] : void 0;
+}
+function hasToolEvidence(events) {
+  return events.some((e) => e.kind === "tool_result");
+}
+function synthesisPrompt(transcript) {
+  return `${SYSTEM}
+
+=== INVESTIGATION TRANSCRIPT ===
+${transcript}
+=== END TRANSCRIPT ===
+
+Write the report now.`;
+}
+function mergePrompt(context, reports) {
+  const header = context.alerts.map((a) => a.alertname).join(", ");
+  const body = reports.map((r, i) => `--- BRANCH ${i} REPORT ---
+${JSON.stringify(r, null, 2)}`).join("\n\n");
+  return `${MERGE_SYSTEM}
+
+INCIDENT ALERTS: ${header}
+
+=== PER-BRANCH REPORTS ===
+${body}
+=== END REPORTS ===
+
+Write the consolidated report now.`;
+}
+var SHAPE_HINT = `{
+  "summary": string,
+  "rootCause": string | null,
+  "rootCauseCategory": "code" | "config" | "infrastructure" | "external" | "unknown" | null,
+  "hypotheses": [ { "statement": string, "status": "confirmed" | "supported" | "speculative" | "refuted", "evidence": [ { "observation": string, "source": string, "direction": "supports" | "contradicts", "status": "verified" | "inferred" } ] } ],
+  "ruledOut": [ { "statement": string, "why": string, "evidence": [ { "observation": string, "source": string, "direction": "supports" | "contradicts", "status": "verified" | "inferred" } ] } ],
+  "coverage": { "queried": string[], "notQueried": string[] },
+  "nextSteps": [ { "title": string, "detail": string, "priority": "critical" | "high" | "medium" | "low" | null } ]
+}`;
+async function runReportModel(cfg, prompt, phase = "reduce") {
+  const model = resolveModel(cfg.providerId, cfg.model, {
+    apiKey: cfg.apiKey,
+    baseURL: cfg.baseURL
+  });
+  const start = Date.now();
+  try {
+    const { object, usage } = await generateObject({
+      model,
+      // fidelity is run-metadata, attached deterministically AFTER synthesis
+      // (ADR-0017) — the LLM must NOT generate it, so omit it from the schema.
+      schema: InvestigationReportSchema.omit({ fidelity: true }),
+      prompt
+    });
+    cfg.onLlmCall?.({
+      phase,
+      provider: cfg.providerId,
+      model: cfg.model,
+      usage: toCallUsage(usage),
+      latencyMs: Date.now() - start,
+      outcome: "ok",
+      failureCause: null
+    });
+    return object;
+  } catch (err1) {
+    cfg.onLlmCall?.({
+      phase,
+      provider: cfg.providerId,
+      model: cfg.model,
+      usage: null,
+      latencyMs: Date.now() - start,
+      outcome: "error",
+      failureCause: err1 instanceof Error ? err1.message : String(err1)
+    });
+    const start2 = Date.now();
+    let fallbackUsage;
+    try {
+      const { text, usage } = await generateText2({
+        model,
+        prompt: `${prompt}
+
+Respond with ONLY a single JSON object (no prose, no code fences) matching exactly this shape:
+${SHAPE_HINT}`
+      });
+      fallbackUsage = usage;
+      const report = InvestigationReportSchema.parse(extractJsonObject(text));
+      cfg.onLlmCall?.({
+        phase,
+        provider: cfg.providerId,
+        model: cfg.model,
+        usage: toCallUsage(usage),
+        latencyMs: Date.now() - start2,
+        outcome: "ok",
+        failureCause: null
+      });
+      return report;
+    } catch (err2) {
+      cfg.onLlmCall?.({
+        phase,
+        provider: cfg.providerId,
+        model: cfg.model,
+        // Real usage when generateText succeeded but parsing failed.
+        usage: toCallUsage(fallbackUsage),
+        latencyMs: Date.now() - start2,
+        outcome: "error",
+        failureCause: err2 instanceof Error ? err2.message : String(err2)
+      });
+      throw err2;
+    }
+  }
+}
+function toCallUsage(usage) {
+  return usage ? {
+    inputTokens: usage.inputTokens ?? null,
+    outputTokens: usage.outputTokens ?? null
+  } : null;
+}
+function extractJsonObject(text) {
+  const cleaned = text.replace(/```(?:json)?/gi, "");
+  const start = cleaned.indexOf("{");
+  if (start === -1)
+    throw new Error("synthesize: no JSON object found in completion");
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < cleaned.length; i++) {
+    const ch = cleaned[i];
+    if (inString) {
+      if (escaped)
+        escaped = false;
+      else if (ch === "\\")
+        escaped = true;
+      else if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"')
+      inString = true;
+    else if (ch === "{")
+      depth++;
+    else if (ch === "}" && --depth === 0) {
+      return JSON.parse(cleaned.slice(start, i + 1));
+    }
+  }
+  throw new Error("synthesize: unterminated JSON object in completion");
+}
+function buildTranscript(context, events, focus) {
+  const primary = focus ?? context.alerts[0];
+  const rest = context.alerts.filter((a) => a !== primary);
+  const lines = [
+    `FIRING ALERT: ${primary.alertname} (severity=${primary.severity ?? "unknown"})`,
+    `annotations: ${JSON.stringify(primary.annotations)}`,
+    ...rest.length ? [`related alerts: ${rest.map((a) => a.alertname).join(", ")}`] : [],
+    "",
+    "AGENT INVESTIGATION (steps, tool calls, and observed results):"
+  ];
+  for (const ev of events) {
+    if (ev.kind === "agent_step") {
+      if (ev.text.trim())
+        lines.push(`
+[think] ${ev.text.trim()}`);
+      for (const tc of ev.toolCalls) {
+        lines.push(`[call] ${tc.name} ${JSON.stringify(tc.args).slice(0, 300)}`);
+      }
+    } else if (ev.kind === "tool_result") {
+      const r = ev.result;
+      lines.push(`[result ${r.ok ? "ok" : "ERROR"}] ${r.source}
+${truncate3(r.preview, PREVIEW_CAP)}`);
+    } else if (ev.kind === "branch_done") {
+      lines.push(`
+[branch ended: ${ev.reason}]`);
+    } else if (ev.kind === "error") {
+      lines.push(`
+[branch error: ${ev.message}]`);
+    }
+  }
+  return truncate3(lines.join("\n"), TRANSCRIPT_CAP);
+}
+function truncate3(s, cap) {
+  return s.length > cap ? `${s.slice(0, cap)}
+\u2026[truncated]` : s;
+}
+
+// ../@prismalens/engine/dist/supervisor/investigate.js
+function deepAgentsHarness(cfg) {
+  return (prompt, ctx) => runDeepAgentsBranch({ ...cfg, prompt, permission: cfg.permission ?? autoAllowReadOnly }, ctx);
+}
+function claudeCodeHarness(cfg) {
+  return (prompt, ctx) => runClaudeCodeBranch({ ...cfg, prompt }, ctx);
+}
+var CANCELLED_MESSAGE = "investigation cancelled by request";
+var CANCELLED_BRANCH_ID = "supervisor";
+function isCancelledError(message) {
+  return message === CANCELLED_MESSAGE;
+}
+function cancelledErrorEvent(runId, seq) {
+  return {
+    kind: "error",
+    runId,
+    branchId: CANCELLED_BRANCH_ID,
+    path: [],
+    seq,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    message: CANCELLED_MESSAGE
+  };
+}
+function stepWithSignal(iter, signal) {
+  if (signal?.aborted)
+    return Promise.resolve({ kind: "aborted" });
+  const step = iter.next().then((r) => r.done ? { kind: "done" } : { kind: "value", value: r.value });
+  if (!signal)
+    return step;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled)
+        return;
+      settled = true;
+      resolve({ kind: "aborted" });
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    step.then((s) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      resolve(s);
+    }, (err) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+  });
+}
+async function* investigateIncidentStream(opts) {
+  const runId = opts.runId ?? randomUUID();
+  const maxBranches = opts.maxBranches;
+  const branchConcurrency = maxBranches ?? DEFAULT_MAX_BRANCHES;
+  const branches = decompose(opts.context, maxBranches !== void 0 ? { maxBranches } : {});
+  const collected = [];
+  const iter = fanOut(branches, opts.harness, runId, {
+    concurrency: branchConcurrency
+  })[Symbol.asyncIterator]();
+  let cancelled = false;
+  let drained = false;
+  try {
+    while (true) {
+      const step = await stepWithSignal(iter, opts.signal);
+      if (step.kind === "aborted") {
+        cancelled = true;
+        break;
+      }
+      if (step.kind === "done") {
+        drained = true;
+        break;
+      }
+      collected.push(step.value);
+      yield step.value;
+    }
+  } finally {
+    if (!drained)
+      void Promise.resolve(iter.return?.(void 0)).catch(() => {
+      });
+  }
+  if (cancelled) {
+    yield cancelledErrorEvent(runId, collected.length);
+    return;
+  }
+  const toolResults = collected.filter((e) => e.kind === "tool_result").length;
+  if (toolResults === 0)
+    return;
+  if (opts.signal?.aborted) {
+    yield cancelledErrorEvent(runId, collected.length);
+    return;
+  }
+  let report;
+  if (!opts.synth.configured) {
+    report = rawReport(opts.context, collected);
+  } else {
+    const llmEvents = [];
+    const callerOnLlmCall = opts.synth.onLlmCall;
+    const synthCfg = {
+      ...opts.synth,
+      onLlmCall: (call) => {
+        callerOnLlmCall?.(call);
+        llmEvents.push({
+          kind: "llm_call",
+          runId,
+          seq: 0,
+          // Assigned properly when yielded
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          ...call
+        });
+      }
+    };
+    try {
+      report = await reduce(opts.context, collected, synthCfg, opts.model);
+      for (const ev of llmEvents) {
+        ev.seq = collected.length;
+        yield ev;
+        collected.push(ev);
+      }
+    } catch (err) {
+      for (const ev of llmEvents) {
+        ev.seq = collected.length;
+        yield ev;
+        collected.push(ev);
+      }
+      report = rawReport(opts.context, collected, err instanceof Error ? err.message : String(err));
+    }
+  }
+  if (opts.signal?.aborted) {
+    yield cancelledErrorEvent(runId, collected.length);
+    return;
+  }
+  yield {
+    kind: "report",
+    runId,
+    seq: collected.length,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    // Attach the deterministic fidelity AFTER synthesis (ADR-0017): the LLM never
+    // generates it — reduce() omits it, we spread it on here.
+    report: opts.fidelity ? { ...report, fidelity: opts.fidelity } : report
+  };
+}
+
+// ../@prismalens/engine/dist/supervisor/conductor.js
+async function conductRun(opts, io) {
+  const runId = opts.runId ?? randomUUID2();
+  await io.store.create();
+  let report = null;
+  let lastError = null;
+  let cancelled = false;
+  try {
+    for await (const event of investigateIncidentStream({ ...opts, runId })) {
+      await io.sink(event);
+      await io.store.append(event);
+      if (event.kind === "report")
+        report = event.report;
+      else if (event.kind === "error") {
+        lastError = event.message;
+        if (isCancelledError(event.message))
+          cancelled = true;
+      }
+    }
+  } catch (err2) {
+    const msg = String(err2?.message ?? err2);
+    await io.store.fail(msg);
+    return { runId, report: null, error: msg, failureKind: "error" };
+  }
+  if (cancelled) {
+    await io.store.flush?.();
+    return { runId, report: null, error: lastError, failureKind: "cancelled" };
+  }
+  if (report) {
+    await io.store.finish(report);
+    return { runId, report, error: null, failureKind: "none" };
+  }
+  const err = lastError ?? "investigation produced no evidence";
+  await io.store.fail(err);
+  return {
+    runId,
+    report: null,
+    error: err,
+    failureKind: lastError ? "error" : "no-evidence"
+  };
+}
+
+// ../@prismalens/engine/dist/config/resolve.js
+function resolveInvestigation(req) {
+  const context = req.context ? InvestigationContextSchema.parse(req.context) : singleAlertContext(resolveSeedAlert(req), requireTelemetry(req), {
+    ...req.incident ? { incident: req.incident } : {},
+    ...req.service ? { service: req.service } : {},
+    ...req.repos ? { repos: req.repos } : {},
+    ...req.logs ? { logs: req.logs } : {}
+  });
+  const mode = req.permissionMode ?? "read-only";
+  if (!HARNESS_REGISTRY[req.harness]) {
+    throw new Error(`Unknown harness: ${req.harness}`);
+  }
+  const outcome = resolvePermissionOutcome(req.harness, mode);
+  const native = req.harnessNative;
+  if (native && HARNESS_REGISTRY[req.harness]?.transport === "acp") {
+    const inert = ["shellAllowList", "sandbox"].filter((k) => k in native);
+    if (inert.length > 0) {
+      throw new Error(`deepagents native config ${inert.map((k) => `"${k}"`).join(", ")} no longer maps to anything \u2014 the published deepagents-acp binary has no shell-allowlist/sandbox flags (removed in the B.1 Sandbox-port spike). Remove ${inert.length > 1 ? "them" : "it"} and use --sandbox <process|srt|e2b> for real isolation (ADR-0020).`);
+    }
+  }
+  const mechanism = req.sandbox ? `${outcome.mechanism} \xB7 sandbox=${req.sandbox.id} (${req.sandbox.fidelity})` : outcome.mechanism;
+  const fidelity = {
+    harness: req.harness,
+    mode,
+    fidelity: outcome.fidelity,
+    mechanism,
+    // The structured sibling of the mechanism string above (ADR-0020 B.1.1
+    // follow-up) — same requested/actual/fidelity facts, machine-readable.
+    // `requested` defaults to `sandbox.id` when the caller didn't separately
+    // know the request, so the field is never a lie by omission.
+    ...req.sandbox ? {
+      sandbox: {
+        requested: req.requestedSandbox ?? req.sandbox.id,
+        actual: req.sandbox.id,
+        fidelity: req.sandbox.fidelity
+      }
+    } : {}
+  };
+  const harness = buildHarness(req.harness, req.cwd, {
+    model: req.model,
+    harnessEnv: req.harnessEnv,
+    initTimeoutMs: req.initTimeoutMs,
+    permissionMode: mode,
+    native: req.harnessNative,
+    ...req.sandbox ? { sandbox: req.sandbox } : {},
+    ...req.limits ? { limits: req.limits } : {},
+    ...req.maxTurns !== void 0 ? { maxTurns: req.maxTurns } : {},
+    ...req.isolateSettings ? { isolateSettings: req.isolateSettings } : {}
+  });
+  return {
+    context,
+    harness,
+    synth: req.synth,
+    cwd: req.cwd,
+    harnessName: req.harness,
+    fidelity,
+    ...req.maxBranches !== void 0 ? { maxBranches: req.maxBranches } : {}
+  };
+}
+function resolveSeedAlert(req) {
+  if (req.alert)
+    return coerceFiringAlert(req.alert);
+  if (req.query)
+    return synthesizeAlert(req.query);
+  throw new Error("No alert to investigate \u2014 supply a context, a FiringAlert payload, or a query.");
+}
+function requireTelemetry(req) {
+  if (!req.telemetry) {
+    throw new Error("Missing telemetry endpoints \u2014 required to build a single-alert context.");
+  }
+  return req.telemetry;
+}
+var HARNESS_RUNNERS = {
+  deepagents: (cwd, opts, model) => deepAgentsHarness({
+    cwd,
+    ...opts.initTimeoutMs ? { initTimeoutMs: opts.initTimeoutMs } : {},
+    ...model ? { model } : {},
+    ...opts.harnessEnv ? { env: opts.harnessEnv } : {},
+    ...opts.native ? { native: opts.native } : {},
+    ...opts.sandbox ? { sandbox: opts.sandbox } : {},
+    ...opts.limits ? { limits: opts.limits } : {}
+  }),
+  "claude-code": (cwd, opts, model) => claudeCodeHarness({
+    cwd,
+    ...model ? { model } : {},
+    ...opts.permissionMode ? { permissionMode: opts.permissionMode } : {},
+    ...opts.native ? { native: opts.native } : {},
+    ...opts.sandbox ? { sandbox: opts.sandbox } : {},
+    ...opts.limits ? { limits: opts.limits } : {},
+    ...opts.maxTurns ? { maxTurns: opts.maxTurns } : {},
+    ...opts.isolateSettings ? { isolateSettings: opts.isolateSettings } : {}
+  })
+};
+function buildHarness(harnessName, cwd, opts) {
+  const descriptor = HARNESS_REGISTRY[harnessName];
+  if (!descriptor)
+    throw new Error(`Unknown harness: ${harnessName}`);
+  if (!descriptor.implemented) {
+    throw new Error(`The '${harnessName}' harness is not implemented yet.`);
+  }
+  const model = opts.model && descriptor.modelPrefix ? `${descriptor.modelPrefix}${opts.model}` : opts.model;
+  const builder = HARNESS_RUNNERS[harnessName];
+  if (!builder) {
+    throw new Error(`No runner wired for harness: ${harnessName}`);
+  }
+  return builder(cwd, opts, model);
+}
+function synthesizeAlert(query2) {
+  return {
+    alertname: query2,
+    severity: "unknown",
+    labels: {},
+    annotations: {},
+    startsAt: null
+  };
+}
+function coerceFiringAlert(raw) {
+  const labels = asStringMap(raw.labels);
+  const annotations = asStringMap(raw.annotations);
+  const alertname = typeof raw.alertname === "string" && raw.alertname || labels.alertname || "unknown";
+  const severity = typeof raw.severity === "string" ? raw.severity : typeof labels.severity === "string" ? labels.severity : null;
+  const startsAt = typeof raw.startsAt === "string" ? raw.startsAt : null;
+  return { alertname, severity, labels, annotations, startsAt };
+}
+function asStringMap(x) {
+  if (x === null || typeof x !== "object")
+    return {};
+  const out = {};
+  for (const [k, v] of Object.entries(x)) {
+    if (typeof v === "string")
+      out[k] = v;
+  }
+  return out;
+}
+
+export {
+  HARNESS_IDS,
+  HARNESS_REGISTRY,
+  HARNESS_BINARY,
+  PERMISSION_MODES,
+  pingModel,
+  SeveritySchema,
+  resolveInvestigation,
+  coerceFiringAlert,
+  SANDBOX_MODES,
+  resolveSandbox,
+  conductRun
+};