@maximtop/opencode-debug-mode 0.1.0

package/dist/index.js

@@ -0,0 +1,3652 @@
+import {
+  DebugModeError
+} from "./chunk-2PCBVVWX.js";
+
+// src/plugin.ts
+import { readFile as readFile9 } from "fs/promises";
+import { tmpdir } from "os";
+import path13 from "path";
+
+// src/cleanup/service.ts
+import { spawn as spawn2 } from "child_process";
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile4, rm as rm2 } from "fs/promises";
+import { performance as performance2 } from "perf_hooks";
+
+// src/probes/extension-permissions.ts
+import { readFile, writeFile } from "fs/promises";
+import { applyEdits, modify, parse } from "jsonc-parser";
+var LOOPBACK_MATCH = /^http:\/\/(?:127\.0\.0\.1:\d{1,5}|\[::1\]:\d{1,5})\/\*$/u;
+var formatting = { tabSize: 2, insertSpaces: true, eol: "\n" };
+function readManifest(text) {
+  const errors = [];
+  const value = parse(text, errors, { allowTrailingComma: true, disallowComments: false });
+  if (errors.length > 0 || typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new DebugModeError("PERMISSION_MISMATCH", "Extension manifest is invalid");
+  }
+  return value;
+}
+function permissionProperty(manifest) {
+  if (manifest.manifest_version === 2) return "permissions";
+  if (manifest.manifest_version === 3) return "host_permissions";
+  throw new DebugModeError("PERMISSION_MISMATCH", "Extension manifest version must be 2 or 3");
+}
+async function addLoopbackPermission(manifestPath, matchPattern) {
+  if (!LOOPBACK_MATCH.test(matchPattern)) {
+    throw new DebugModeError("PERMISSION_MISMATCH", "Only an exact active loopback match pattern is allowed");
+  }
+  const text = await readFile(manifestPath, "utf8");
+  const manifest = readManifest(text);
+  const property = permissionProperty(manifest);
+  const current = manifest[property];
+  if (current !== void 0 && (!Array.isArray(current) || current.some((entry) => typeof entry !== "string"))) {
+    throw new DebugModeError("PERMISSION_MISMATCH", `Extension ${property} must be a string array`);
+  }
+  const permissions = current ?? [];
+  if (permissions.includes(matchPattern)) {
+    return { manifestPath, property, matchPattern, addedBySession: false };
+  }
+  const edits = Array.isArray(current) ? modify(text, [property, permissions.length], matchPattern, {
+    formattingOptions: formatting,
+    isArrayInsertion: true
+  }) : modify(text, [property], [matchPattern], { formattingOptions: formatting });
+  await writeFile(manifestPath, applyEdits(text, edits), "utf8");
+  return { manifestPath, property, matchPattern, addedBySession: true };
+}
+async function removeLoopbackPermission(manifestPath, change) {
+  if (!change.addedBySession) return { status: "already-clean" };
+  let text;
+  try {
+    text = await readFile(manifestPath, "utf8");
+  } catch (error2) {
+    if (error2.code === "ENOENT") return { status: "already-clean" };
+    return { status: "failed", reason: "manifest-read-failed" };
+  }
+  let manifest;
+  try {
+    manifest = readManifest(text);
+  } catch {
+    return { status: "failed", reason: "manifest-invalid" };
+  }
+  if (permissionProperty(manifest) !== change.property) return { status: "failed", reason: "manifest-version-changed" };
+  const current = manifest[change.property];
+  if (current === void 0) return { status: "already-clean" };
+  if (!Array.isArray(current) || current.some((entry) => typeof entry !== "string")) {
+    return { status: "failed", reason: "permission-structure-changed" };
+  }
+  const matches2 = current.flatMap((entry, index2) => entry === change.matchPattern ? [index2] : []);
+  if (matches2.length === 0) return { status: "already-clean" };
+  if (matches2.length !== 1) return { status: "failed", reason: "permission-ambiguous" };
+  const index = matches2[0];
+  if (index === void 0) return { status: "already-clean" };
+  const edits = modify(text, [change.property, index], void 0, { formattingOptions: formatting });
+  await writeFile(manifestPath, applyEdits(text, edits), "utf8");
+  return { status: "success" };
+}
+
+// src/probes/remove.ts
+import { createHash } from "crypto";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+function occurrences(value, needle) {
+  if (needle.length === 0) return 0;
+  return value.split(needle).length - 1;
+}
+function lineAt(value, index) {
+  return value.slice(0, index).split(/\r?\n/u).length;
+}
+async function removeOwnedProbe(probe) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    let source;
+    try {
+      source = await readFile2(probe.sourceFile, "utf8");
+    } catch (error2) {
+      if (error2.code === "ENOENT") return { status: "already-clean", file: probe.sourceFile };
+      return { status: "failed", file: probe.sourceFile, reason: "source-read-failed" };
+    }
+    const starts = occurrences(source, probe.markerStart);
+    const ends = occurrences(source, probe.markerEnd);
+    if (starts === 0 && ends === 0) return { status: "already-clean", file: probe.sourceFile };
+    const startIndex = source.indexOf(probe.markerStart);
+    if (starts !== 1 || ends !== 1 || startIndex < 0) {
+      return {
+        status: "failed",
+        file: probe.sourceFile,
+        reason: "marker-ambiguous",
+        ...startIndex < 0 ? {} : { line: lineAt(source, startIndex) }
+      };
+    }
+    if (probe.expectedBlock === void 0 || probe.expectedHash === void 0) {
+      return {
+        status: "failed",
+        file: probe.sourceFile,
+        reason: "marker-ownership-incomplete",
+        line: lineAt(source, startIndex)
+      };
+    }
+    if (occurrences(source, probe.expectedBlock) !== 1 || createHash("sha256").update(probe.expectedBlock).digest("hex") !== probe.expectedHash) {
+      return {
+        status: "failed",
+        file: probe.sourceFile,
+        reason: "marker-content-mismatch",
+        line: lineAt(source, startIndex)
+      };
+    }
+    const current = await readFile2(probe.sourceFile, "utf8");
+    if (current !== source) continue;
+    const blockIndex = source.indexOf(probe.expectedBlock);
+    const next = source.slice(0, blockIndex) + source.slice(blockIndex + probe.expectedBlock.length);
+    await writeFile2(probe.sourceFile, next, "utf8");
+    return { status: "success", file: probe.sourceFile };
+  }
+  return { status: "failed", file: probe.sourceFile, reason: "concurrent-source-change" };
+}
+
+// src/process/tree.ts
+import { spawn } from "child_process";
+import { performance } from "perf_hooks";
+
+// src/core/constants.ts
+var PACKAGE_ID = "opencode-debug-mode";
+var MANIFEST_SCHEMA_VERSION = 1;
+var STATE_SCHEMA_VERSION = 1;
+var EVENT_SCHEMA_VERSION = 1;
+var TEMP_BASE_NAME = "opencode-debug-mode-v1";
+var PROCESS_EVENT_PREFIX = "__OPENCODE_DEBUG_EVENT_V1__";
+var LIMITS = Object.freeze({
+  requestBytes: 64 * 1024,
+  scalarBytes: 8 * 1024,
+  events: 25e3,
+  evidenceBytes: 25 * 1024 * 1024,
+  checkpointBytes: 256 * 1024,
+  eventsPerBatch: 100,
+  idleMs: 30 * 60 * 1e3,
+  collectorReadyMs: 2e3,
+  cleanupMs: 5e3,
+  gracefulKillMs: 750,
+  forcedKillMs: 1500,
+  noSignalIterations: 3
+});
+
+// src/process/tree.ts
+var defaultExecute = (executable, args) => new Promise((resolve, reject) => {
+  const child = spawn(executable, args, { shell: false, windowsHide: true, stdio: "ignore" });
+  child.once("error", reject);
+  child.once("exit", (exitCode) => resolve({ exitCode }));
+});
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error2) {
+    return error2.code !== "ESRCH";
+  }
+}
+async function waitForExit(pid, milliseconds) {
+  const deadline = performance.now() + milliseconds;
+  while (performance.now() < deadline) {
+    if (!isAlive(pid)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  return !isAlive(pid);
+}
+function safeError(error2) {
+  const code = error2.code;
+  return typeof code === "string" ? code.slice(0, 64) : "termination-failed";
+}
+async function terminateTree(targetPid, options = {}) {
+  const started = performance.now();
+  const errors = [];
+  let graceful = false;
+  let forced = false;
+  const platform = options.platform ?? process.platform;
+  const gracefulMs = options.gracefulMs ?? LIMITS.gracefulKillMs;
+  const forceMs = options.forceMs ?? LIMITS.forcedKillMs;
+  if (!Number.isInteger(targetPid) || targetPid <= 0) {
+    return {
+      graceful: false,
+      forced: false,
+      remaining: false,
+      durationMs: performance.now() - started,
+      errors: ["invalid-pid"]
+    };
+  }
+  if (platform === "win32") {
+    const execute = options.execute ?? defaultExecute;
+    try {
+      const result = await execute("taskkill", ["/PID", String(targetPid), "/T"]);
+      graceful = result.exitCode === 0;
+    } catch (error2) {
+      errors.push(safeError(error2));
+    }
+    await waitForExit(targetPid, gracefulMs);
+    try {
+      const result = await execute("taskkill", ["/PID", String(targetPid), "/T", "/F"]);
+      forced = result.exitCode === 0;
+    } catch (error2) {
+      errors.push(safeError(error2));
+    }
+    await waitForExit(targetPid, forceMs);
+  } else {
+    try {
+      process.kill(-targetPid, "SIGTERM");
+      graceful = true;
+    } catch (error2) {
+      if (error2.code === "ESRCH") {
+        return { graceful: false, forced: false, remaining: false, durationMs: performance.now() - started, errors };
+      }
+      errors.push(safeError(error2));
+    }
+    if (!await waitForExit(targetPid, gracefulMs)) {
+      try {
+        process.kill(-targetPid, "SIGKILL");
+        forced = true;
+      } catch (error2) {
+        if (error2.code !== "ESRCH") errors.push(safeError(error2));
+      }
+      await waitForExit(targetPid, forceMs);
+    }
+  }
+  return {
+    graceful,
+    forced,
+    remaining: isAlive(targetPid),
+    durationMs: performance.now() - started,
+    errors
+  };
+}
+
+// src/cleanup/export.ts
+import { createHash as createHash2, randomBytes } from "crypto";
+import { createReadStream } from "fs";
+import { appendFile, mkdir as mkdir2, readdir, readFile as readFile3, realpath as realpath2, rename, rm, writeFile as writeFile3 } from "fs/promises";
+import path2 from "path";
+import { createInterface } from "readline";
+
+// src/evidence/sanitize.ts
+var MAX_DEPTH = 6;
+var MAX_KEYS = 50;
+var MAX_ARRAY = 100;
+var SECRET_KEYS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "access-token",
+  "refresh-token",
+  "api-key",
+  "apikey",
+  "private-key",
+  "client-secret"
+]);
+function normalizeKey(key) {
+  return key.toLowerCase().replace(/[_\s]+/g, "-");
+}
+function truncateUtf8(value, maximumBytes) {
+  if (Buffer.byteLength(value) <= maximumBytes) return value;
+  return Buffer.from(value).subarray(0, maximumBytes).toString("utf8").replace(/\uFFFD$/u, "");
+}
+function estimateOriginalBytes(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? void 0 : Buffer.byteLength(serialized);
+  } catch {
+    return void 0;
+  }
+}
+function sanitizeEvidenceData(input) {
+  const flags = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new WeakSet();
+  let droppedKeys = 0;
+  const visit = (value2, depth) => {
+    if (depth > MAX_DEPTH) {
+      flags.add("truncated");
+      return "[TRUNCATED: depth]";
+    }
+    if (value2 === null) return null;
+    if (typeof value2 === "string") {
+      const truncated = truncateUtf8(value2, LIMITS.scalarBytes);
+      if (truncated !== value2) flags.add("truncated");
+      return truncated;
+    }
+    if (typeof value2 === "boolean") return value2;
+    if (typeof value2 === "number") {
+      if (Number.isFinite(value2)) return value2;
+      flags.add("unsupported");
+      return `[${String(value2)}]`;
+    }
+    if (typeof value2 === "bigint") {
+      flags.add("unsupported");
+      return `[BigInt ${truncateUtf8(value2.toString(), 128)}]`;
+    }
+    if (typeof value2 === "undefined") {
+      flags.add("unsupported");
+      return "[undefined]";
+    }
+    if (typeof value2 === "function" || typeof value2 === "symbol") {
+      flags.add("unsupported");
+      return `[${typeof value2}]`;
+    }
+    if (Buffer.isBuffer(value2) || ArrayBuffer.isView(value2) || value2 instanceof ArrayBuffer) {
+      flags.add("binary");
+      const length = Buffer.isBuffer(value2) ? value2.byteLength : value2 instanceof ArrayBuffer ? value2.byteLength : value2.byteLength;
+      return `[Binary ${length} bytes]`;
+    }
+    if (value2 instanceof Date) return Number.isNaN(value2.getTime()) ? "[Invalid Date]" : value2.toISOString();
+    if (value2 instanceof RegExp) {
+      flags.add("unsupported");
+      return truncateUtf8(value2.toString(), 256);
+    }
+    if (value2 instanceof Error) {
+      flags.add("unsupported");
+      return { name: truncateUtf8(value2.name, 128), message: truncateUtf8(value2.message, LIMITS.scalarBytes) };
+    }
+    if (seen.has(value2)) {
+      flags.add("cycle");
+      return "[CYCLE]";
+    }
+    seen.add(value2);
+    if (Array.isArray(value2)) {
+      if (value2.length > MAX_ARRAY) {
+        flags.add("truncated");
+        droppedKeys += value2.length - MAX_ARRAY;
+      }
+      return value2.slice(0, MAX_ARRAY).map((entry) => visit(entry, depth + 1));
+    }
+    const record = value2;
+    try {
+      if (typeof record.nodeType === "number" && typeof record.nodeName === "string") {
+        flags.add("unsupported");
+        return `[DOM ${truncateUtf8(record.nodeName, 128)}]`;
+      }
+    } catch {
+      flags.add("unsupported");
+    }
+    const prototype = Object.getPrototypeOf(value2);
+    if (prototype !== Object.prototype && prototype !== null) {
+      flags.add("unsupported");
+      return `[Unsupported ${truncateUtf8(value2.constructor?.name ?? "object", 128)}]`;
+    }
+    let keys;
+    try {
+      keys = Object.keys(record).sort();
+    } catch {
+      flags.add("unsupported");
+      return "[Unreadable object]";
+    }
+    if (keys.length > MAX_KEYS) {
+      flags.add("truncated");
+      droppedKeys += keys.length - MAX_KEYS;
+      keys = keys.slice(0, MAX_KEYS);
+    }
+    const result = {};
+    for (const key of keys) {
+      if (SECRET_KEYS.has(normalizeKey(key))) {
+        result[key] = "[REDACTED]";
+        flags.add("redacted");
+        continue;
+      }
+      try {
+        result[key] = visit(record[key], depth + 1);
+      } catch {
+        result[key] = "[Unreadable property]";
+        flags.add("unsupported");
+      }
+    }
+    return result;
+  };
+  const value = visit(input, 0);
+  const storedBytes = Buffer.byteLength(JSON.stringify(value));
+  const originalBytes = estimateOriginalBytes(input);
+  return {
+    value,
+    flags: [...flags].sort(),
+    droppedKeys,
+    ...originalBytes === void 0 ? {} : { originalBytes },
+    storedBytes
+  };
+}
+
+// src/evidence/types.ts
+import { z as z2 } from "zod";
+
+// src/core/schemas.ts
+import { z } from "zod";
+var OpaqueIdSchema = z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
+var IsoTimestampSchema = z.string().datetime({ offset: true });
+var HexSha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
+var RunLabelSchema = z.enum(["pre-fix", "post-fix"]);
+
+// src/evidence/types.ts
+var SourceLocationSchema = z2.object({
+  file: z2.string().min(1).max(LIMITS.scalarBytes),
+  line: z2.number().int().positive(),
+  column: z2.number().int().positive().optional()
+}).strict();
+var EventInputSchema = z2.object({
+  schemaVersion: z2.literal(EVENT_SCHEMA_VERSION),
+  sessionId: OpaqueIdSchema,
+  runId: OpaqueIdSchema,
+  runLabel: RunLabelSchema,
+  hypothesisId: OpaqueIdSchema,
+  probeId: OpaqueIdSchema,
+  timestamp: IsoTimestampSchema,
+  message: z2.string().min(1).max(LIMITS.scalarBytes),
+  source: SourceLocationSchema,
+  data: z2.unknown().optional()
+}).strict();
+var SanitizationFlagSchema = z2.enum(["redacted", "truncated", "cycle", "binary", "unsupported"]);
+var EvidenceEventSchema = z2.object({
+  schemaVersion: z2.literal(EVENT_SCHEMA_VERSION),
+  eventId: OpaqueIdSchema,
+  receivedAt: IsoTimestampSchema,
+  timestamp: IsoTimestampSchema,
+  sessionId: OpaqueIdSchema,
+  runId: OpaqueIdSchema,
+  runLabel: RunLabelSchema,
+  hypothesisId: OpaqueIdSchema,
+  probeId: OpaqueIdSchema,
+  kind: z2.string().min(1).max(128),
+  message: z2.string().min(1).max(LIMITS.scalarBytes),
+  data: z2.unknown(),
+  source: SourceLocationSchema,
+  sanitization: z2.object({
+    flags: z2.array(SanitizationFlagSchema),
+    droppedKeys: z2.number().int().nonnegative(),
+    originalBytes: z2.number().int().nonnegative().optional(),
+    storedBytes: z2.number().int().nonnegative()
+  }).strict()
+}).strict();
+
+// src/investigation/schema.ts
+import { z as z3 } from "zod";
+var Text = z3.string().max(LIMITS.scalarBytes);
+var TextList = (maximum) => z3.array(Text).max(maximum);
+var EvidenceIds = z3.array(OpaqueIdSchema).max(500);
+var HypothesisSchema = z3.object({
+  id: OpaqueIdSchema,
+  rank: z3.number().int().min(1).max(4),
+  statement: Text,
+  confirmationSignals: TextList(20),
+  eliminationSignals: TextList(20),
+  status: z3.enum(["open", "confirmed", "eliminated"]),
+  evidenceRefs: EvidenceIds,
+  invalidatedBy: Text.optional()
+}).strict();
+var CompletedCheckSchema = z3.object({
+  id: OpaqueIdSchema,
+  summary: Text,
+  interpretation: Text,
+  conclusive: z3.boolean(),
+  evidenceRefs: EvidenceIds,
+  completedAt: IsoTimestampSchema,
+  invalidatedBy: Text.optional()
+}).strict();
+var RunReferenceSchema = z3.object({
+  id: OpaqueIdSchema,
+  label: RunLabelSchema,
+  status: z3.enum(["planned", "running", "waiting", "completed", "failed", "timed_out", "cancelled"]),
+  evidenceRefs: EvidenceIds
+}).strict();
+var ProbeReferenceSchema = z3.object({
+  id: OpaqueIdSchema,
+  runId: OpaqueIdSchema,
+  hypothesisId: OpaqueIdSchema,
+  sourceFile: Text,
+  status: z3.enum(["planned", "registered", "validated", "active", "removed", "ambiguous"])
+}).strict();
+var DeveloperConfirmationSchema = z3.object({ id: OpaqueIdSchema, statement: Text, confirmedAt: IsoTimestampSchema }).strict();
+var DecisionSchema = z3.object({ id: OpaqueIdSchema, summary: Text, evidenceRefs: EvidenceIds, decidedAt: IsoTimestampSchema }).strict();
+var InvestigationStateSchema = z3.object({
+  schemaVersion: z3.literal(STATE_SCHEMA_VERSION),
+  revision: z3.number().int().nonnegative(),
+  updatedAt: IsoTimestampSchema,
+  problemSummary: Text,
+  expectedBehavior: Text,
+  actualBehavior: Text,
+  runtimeContext: z3.object({ kind: z3.enum(["cli", "web", "extension", "other"]), target: Text }).strict(),
+  reproduction: z3.object({ method: Text, requiresUser: z3.boolean(), confirmed: z3.boolean().nullable() }).strict(),
+  successCriteria: TextList(50),
+  phase: z3.enum([
+    "intake",
+    "hypotheses",
+    "baseline",
+    "instrumenting",
+    "waiting_for_reproduction",
+    "analyzing",
+    "fixing",
+    "verifying",
+    "cleaning",
+    "completed",
+    "abandoned",
+    "escalated"
+  ]),
+  loopIteration: z3.number().int().min(0).max(3),
+  singleCauseEvidenceRef: OpaqueIdSchema.nullable(),
+  hypotheses: z3.array(HypothesisSchema).max(4),
+  completedChecks: z3.array(CompletedCheckSchema).max(100),
+  runs: z3.array(RunReferenceSchema).max(20),
+  probeRefs: z3.array(ProbeReferenceSchema).max(100),
+  decidingEvidenceIds: EvidenceIds,
+  developerConfirmations: z3.array(DeveloperConfirmationSchema).max(100),
+  decisions: z3.array(DecisionSchema).max(100),
+  nextAction: Text,
+  instrumentedFiles: TextList(200),
+  fixedFiles: TextList(200),
+  cleanup: z3.object({
+    status: z3.enum(["not_started", "running", "complete", "partial"]),
+    completedResources: TextList(1e3)
+  }).strict()
+}).strict();
+
+// src/session/paths.ts
+import { lstat, mkdir, mkdtemp, realpath } from "fs/promises";
+import path from "path";
+function isContained(parent, child) {
+  const relative = path.relative(parent, child);
+  return relative !== "" && !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+async function createSessionPaths(tempBase, projectRoot) {
+  const absoluteBase = path.resolve(tempBase);
+  try {
+    const existing = await lstat(absoluteBase);
+    if (existing.isSymbolicLink()) throw new Error("Temporary base must not be a symbolic link");
+    if (!existing.isDirectory()) throw new Error("Temporary base must be a directory");
+  } catch (error2) {
+    if (error2.code !== "ENOENT") throw error2;
+    await mkdir(absoluteBase, { recursive: true, mode: 448 });
+  }
+  await realpath(absoluteBase);
+  const canonicalProject = await realpath(projectRoot);
+  const sessionDir = await mkdtemp(path.join(absoluteBase, "session-"));
+  if (!isContained(absoluteBase, sessionDir)) throw new Error("Created session directory escaped the temporary base");
+  return Object.freeze({
+    baseDir: absoluteBase,
+    sessionDir,
+    projectRoot: canonicalProject,
+    manifestFile: path.join(sessionDir, "manifest.json"),
+    secretFile: path.join(sessionDir, "secret.bin"),
+    stateFile: path.join(sessionDir, "investigation-state.json"),
+    evidenceFile: path.join(sessionDir, "evidence.ndjson")
+  });
+}
+
+// src/cleanup/types.ts
+import { z as z4 } from "zod";
+var ResourceCleanupResultSchema = z4.object({
+  status: z4.enum(["success", "already-clean", "skipped", "failed"]),
+  reason: z4.string().max(8192).optional(),
+  location: z4.string().max(8192).optional()
+}).strict();
+var CleanupResultSchema = z4.object({
+  status: z4.enum(["complete", "partial"]),
+  reason: z4.string().max(256),
+  resources: z4.object({
+    collector: ResourceCleanupResultSchema,
+    processes: z4.array(ResourceCleanupResultSchema),
+    probes: z4.array(ResourceCleanupResultSchema),
+    permissions: z4.array(ResourceCleanupResultSchema),
+    files: z4.array(ResourceCleanupResultSchema),
+    secret: ResourceCleanupResultSchema,
+    sessionDirectory: ResourceCleanupResultSchema
+  }).strict(),
+  remainingArtifacts: z4.array(z4.string().max(8192)),
+  durationMs: z4.number().nonnegative(),
+  cleanCheck: z4.object({
+    command: z4.string().max(8192),
+    exitCode: z4.number().int().nullable(),
+    timedOut: z4.boolean(),
+    durationMs: z4.number().nonnegative()
+  }).strict().optional(),
+  retainedArtifactLocation: z4.string().max(8192).optional()
+}).strict();
+var FinalReportInputSchema = z4.object({
+  outcome: z4.enum(["completed", "unresolved", "abandoned", "escalated"]),
+  rootCause: z4.string().max(8192),
+  decidingEvidence: z4.array(z4.string().max(8192)).max(100),
+  hypotheses: z4.array(
+    z4.object({
+      id: z4.string().max(64),
+      status: z4.enum(["open", "confirmed", "eliminated"]),
+      statement: z4.string().max(8192)
+    }).strict()
+  ).max(4),
+  fix: z4.string().max(8192),
+  changedFiles: z4.array(z4.string().max(8192)).max(200),
+  verification: z4.array(z4.string().max(8192)).max(100)
+}).strict();
+var FinalReportSchema = FinalReportInputSchema.extend({
+  cleanup: CleanupResultSchema,
+  retainedArtifactLocation: z4.string().max(8192).optional()
+}).strict();
+
+// src/cleanup/export.ts
+function sha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function redactKnownSecrets(value, secrets) {
+  if (typeof value === "string") {
+    return secrets.reduce((text, secret) => secret.length === 0 ? text : text.replaceAll(secret, "[REDACTED]"), value);
+  }
+  if (Array.isArray(value)) return value.map((entry) => redactKnownSecrets(entry, secrets));
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, redactKnownSecrets(entry, secrets)]));
+  }
+  return value;
+}
+async function sanitizedEvidence(source, destination) {
+  let count = 0;
+  await writeFile3(destination, "", { mode: 384 });
+  const lines = createInterface({ input: createReadStream(source), crlfDelay: Number.POSITIVE_INFINITY });
+  for await (const line of lines) {
+    if (line.length === 0) continue;
+    const event = EvidenceEventSchema.parse(JSON.parse(line));
+    const sanitized = sanitizeEvidenceData(event.data);
+    await appendFile(
+      destination,
+      `${JSON.stringify({
+        ...event,
+        data: sanitized.value,
+        sanitization: {
+          flags: [.../* @__PURE__ */ new Set([...event.sanitization.flags, ...sanitized.flags])].sort(),
+          droppedKeys: event.sanitization.droppedKeys + sanitized.droppedKeys,
+          storedBytes: sanitized.storedBytes,
+          ...sanitized.originalBytes === void 0 ? {} : { originalBytes: sanitized.originalBytes }
+        }
+      })}
+`,
+      { mode: 384 }
+    );
+    count += 1;
+  }
+  return count;
+}
+function renderReport(report, cleanup, retainedPath) {
+  const hypotheses = report.hypotheses.map((value) => `- ${value.id}: ${value.status} \u2014 ${value.statement}`).join("\n");
+  return `# Debug investigation report
+
+Outcome: ${report.outcome}
+
+## Root cause
+
+${report.rootCause}
+
+## Deciding evidence
+
+${report.decidingEvidence.map((value) => `- ${value}`).join("\n")}
+
+## Hypotheses
+
+${hypotheses}
+
+## Fix
+
+${report.fix}
+
+Changed files: ${report.changedFiles.join(", ")}
+
+## Verification
+
+${report.verification.map((value) => `- ${value}`).join("\n")}
+
+## Cleanup
+
+Status: ${cleanup.status}
+
+Retained artifact: ${retainedPath}
+`;
+}
+async function stageRetainedBundle(input) {
+  if (!input.keepArtifacts || input.destination === void 0) {
+    throw new DebugModeError("DESTINATION_REQUIRED", "Explicit retention is not enabled");
+  }
+  let partialPath;
+  try {
+    const destination = await realpath2(input.destination);
+    const sessionDir = await realpath2(input.sessionDir);
+    if (destination === sessionDir || isContained(sessionDir, destination)) {
+      throw new DebugModeError("EXPORT_FAILED", "Retention destination cannot be inside the ephemeral session");
+    }
+    const suffix = randomBytes(8).toString("hex");
+    partialPath = path2.join(destination, `.partial-${PACKAGE_ID}-${suffix}`);
+    const finalPath = path2.join(
+      destination,
+      `${PACKAGE_ID}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/gu, "-")}-${suffix}`
+    );
+    await mkdir2(partialPath, { mode: 448 });
+    const state = InvestigationStateSchema.parse(JSON.parse(await readFile3(input.stateFile, "utf8")));
+    const sanitizedState = InvestigationStateSchema.parse(
+      sanitizeEvidenceData(redactKnownSecrets(state, [input.token, ...input.securityValues ?? []])).value
+    );
+    await writeFile3(
+      path2.join(partialPath, "investigation-state.json"),
+      `${JSON.stringify(sanitizedState, null, 2)}
+`,
+      {
+        mode: 384
+      }
+    );
+    const eventCount = await sanitizedEvidence(input.evidenceFile, path2.join(partialPath, "evidence.ndjson"));
+    return {
+      partialPath,
+      finalPath,
+      token: input.token,
+      securityValues: input.securityValues ?? [],
+      report: FinalReportInputSchema.parse(input.finalReport),
+      eventCount
+    };
+  } catch (error2) {
+    if (partialPath !== void 0) await rm(partialPath, { recursive: true, force: true }).catch(() => void 0);
+    if (error2 instanceof DebugModeError) throw error2;
+    throw new DebugModeError("EXPORT_FAILED", "Retained bundle could not be staged");
+  }
+}
+async function finalizeRetainedBundle(staged, cleanupInput) {
+  try {
+    const cleanup = CleanupResultSchema.parse(cleanupInput);
+    const report = renderReport(staged.report, cleanup, staged.finalPath);
+    await writeFile3(path2.join(staged.partialPath, "report.md"), report, { mode: 384 });
+    const publicFiles = ["evidence.ndjson", "investigation-state.json", "report.md"];
+    const files = {};
+    for (const name of publicFiles) {
+      const value = await readFile3(path2.join(staged.partialPath, name));
+      files[name] = { bytes: value.byteLength, sha256: sha256(value) };
+    }
+    const manifest = {
+      package: PACKAGE_ID,
+      schemaVersion: 1,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      eventCount: staged.eventCount,
+      files
+    };
+    await writeFile3(path2.join(staged.partialPath, "bundle-manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`, {
+      mode: 384
+    });
+    for (const name of await readdir(staged.partialPath)) {
+      const text = await readFile3(path2.join(staged.partialPath, name), "utf8");
+      if ([staged.token, ...staged.securityValues].some((secret) => secret.length > 0 && text.includes(secret))) {
+        throw new DebugModeError("EXPORT_FAILED", "Retained bundle failed its secret scan");
+      }
+    }
+    await rename(staged.partialPath, staged.finalPath);
+    return { path: staged.finalPath };
+  } catch (error2) {
+    await rm(staged.partialPath, { recursive: true, force: true }).catch(() => void 0);
+    if (error2 instanceof DebugModeError) throw error2;
+    throw new DebugModeError("EXPORT_FAILED", "Retained bundle could not be finalized");
+  }
+}
+
+// src/cleanup/service.ts
+var CleanupService = class {
+  constructor(session, dependencies = {}) {
+    this.session = session;
+    this.dependencies = dependencies;
+  }
+  session;
+  dependencies;
+  running;
+  completed;
+  async run(input) {
+    if (this.completed !== void 0) return this.completed;
+    this.running ??= this.execute(input);
+    this.completed = await this.running;
+    return this.completed;
+  }
+  async execute(input) {
+    const started = performance2.now();
+    const finalReport = FinalReportInputSchema.parse(input.finalReport);
+    const manifest = await this.session.manifestStore.modify((value) => ({
+      ...value,
+      status: "cleaning",
+      cleanup: { status: "running", completedResources: [] }
+    })).catch(() => this.session.manifestStore.read());
+    const state = await this.session.investigationStore.read().catch(() => void 0);
+    if (state !== void 0) {
+      await this.session.investigationStore.checkpoint(state.revision, {
+        ...state,
+        phase: "cleaning",
+        cleanup: { status: "running", completedResources: state.cleanup.completedResources }
+      }).catch(() => void 0);
+    }
+    let collector = { status: "skipped", reason: "not-running" };
+    if (manifest.collector !== null) {
+      if (this.dependencies.collector === void 0)
+        collector = { status: "failed", reason: "collector-runtime-unavailable" };
+      else {
+        try {
+          await this.dependencies.collector.close();
+          collector = { status: "success" };
+        } catch {
+          collector = { status: "failed", reason: "collector-close-failed" };
+        }
+      }
+    }
+    const processes = [];
+    for (const owned of manifest.processes) {
+      try {
+        if (this.dependencies.terminateProcess !== void 0)
+          processes.push(await this.dependencies.terminateProcess(owned));
+        else if (owned.targetPid !== void 0) {
+          const result2 = await terminateTree(owned.targetPid);
+          processes.push(result2.remaining ? { status: "failed", reason: "process-remains" } : { status: "success" });
+        } else processes.push({ status: "already-clean" });
+      } catch {
+        processes.push({ status: "failed", reason: "process-termination-failed" });
+      }
+    }
+    const probes = [];
+    for (const probe of manifest.probes) {
+      const result2 = await removeOwnedProbe(probe);
+      probes.push({
+        status: result2.status === "already-clean" ? "already-clean" : result2.status,
+        ...result2.reason === void 0 ? {} : { reason: result2.reason },
+        location: probe.sourceFile
+      });
+    }
+    const permissions = [];
+    for (const change of manifest.permissionChanges) {
+      const result2 = await removeLoopbackPermission(change.manifestPath, change);
+      permissions.push({
+        status: result2.status,
+        ...result2.reason === void 0 ? {} : { reason: result2.reason },
+        location: change.manifestPath
+      });
+    }
+    const files = [];
+    for (const owned of manifest.ownedFiles) files.push(await this.removeOwnedFile(owned));
+    const cleanCheck = input.cleanCheck === void 0 ? void 0 : await this.runCleanCheck(input.cleanCheck);
+    let staged;
+    if (manifest.keepArtifacts && manifest.retentionDestination !== void 0) {
+      try {
+        staged = await stageRetainedBundle({
+          keepArtifacts: true,
+          destination: manifest.retentionDestination,
+          sessionDir: manifest.sessionDir,
+          evidenceFile: this.session.paths.evidenceFile,
+          stateFile: this.session.paths.stateFile,
+          token: this.session.secret,
+          securityValues: this.dependencies.securityValues ?? [],
+          finalReport
+        });
+      } catch {
+        files.push({ status: "failed", reason: "retention-export-failed" });
+      }
+    }
+    let secret;
+    try {
+      const status = await (this.dependencies.removeSecret?.() ?? this.session.secretStore.remove());
+      secret = { status };
+    } catch {
+      secret = { status: "failed", reason: "secret-removal-failed" };
+    }
+    let sessionDirectory;
+    try {
+      await rm2(this.session.paths.sessionDir, { recursive: true, force: true });
+      sessionDirectory = { status: "success" };
+    } catch {
+      sessionDirectory = { status: "failed", reason: "session-directory-removal-failed" };
+    }
+    const resources = { collector, processes, probes, permissions, files, secret, sessionDirectory };
+    const failures = [collector, ...processes, ...probes, ...permissions, ...files, secret, sessionDirectory].filter(
+      (result2) => result2.status === "failed"
+    );
+    const remainingArtifacts = failures.flatMap((result2) => result2.location === void 0 ? [] : [result2.location]);
+    const result = {
+      status: failures.length === 0 ? "complete" : "partial",
+      reason: input.reason.slice(0, 256),
+      resources,
+      remainingArtifacts,
+      durationMs: performance2.now() - started,
+      ...cleanCheck === void 0 ? {} : { cleanCheck }
+    };
+    if (staged !== void 0) {
+      try {
+        const retained = await finalizeRetainedBundle(staged, result);
+        result.retainedArtifactLocation = retained.path;
+      } catch (error2) {
+        result.status = "partial";
+        result.resources.files.push({
+          status: "failed",
+          reason: error2 instanceof DebugModeError ? `retention-finalize-failed:${error2.code}:${error2.message}`.slice(0, 8192) : "retention-finalize-failed"
+        });
+      }
+    }
+    return result;
+  }
+  async removeOwnedFile(owned) {
+    try {
+      const content = await readFile4(owned.path);
+      if (createHash3("sha256").update(content).digest("hex") !== owned.sha256 || content.byteLength !== owned.bytes) {
+        return { status: "failed", reason: "owned-file-hash-mismatch", location: owned.path };
+      }
+      await rm2(owned.path);
+      return { status: "success", location: owned.path };
+    } catch (error2) {
+      if (error2.code === "ENOENT") return { status: "already-clean", location: owned.path };
+      return { status: "failed", reason: "owned-file-removal-failed", location: owned.path };
+    }
+  }
+  runCleanCheck(input) {
+    const started = performance2.now();
+    return new Promise((resolve) => {
+      const child = spawn2(input.executable, input.args, {
+        cwd: input.cwd,
+        shell: false,
+        stdio: "ignore",
+        windowsHide: true
+      });
+      let timedOut = false;
+      const timeout = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+      }, input.timeoutMs);
+      child.once("exit", (exitCode) => {
+        clearTimeout(timeout);
+        resolve({
+          command: [input.executable, ...input.args].join(" ").slice(0, 8192),
+          exitCode,
+          timedOut,
+          durationMs: performance2.now() - started
+        });
+      });
+      child.once("error", () => {
+        clearTimeout(timeout);
+        resolve({
+          command: input.executable.slice(0, 8192),
+          exitCode: null,
+          timedOut,
+          durationMs: performance2.now() - started
+        });
+      });
+    });
+  }
+};
+
+// src/collector/ingest.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { z as z5 } from "zod";
+
+// src/collector/body.ts
+var CollectorBodyError = class extends Error {
+  constructor(status, code) {
+    super(code);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+async function readBoundedJsonBody(request) {
+  const contentType = request.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+  if (contentType !== "application/json") throw new CollectorBodyError(415, "UNSUPPORTED_MEDIA_TYPE");
+  const declared = request.headers["content-length"];
+  if (declared !== void 0) {
+    if (!/^\d+$/u.test(declared)) throw new CollectorBodyError(400, "INVALID_REQUEST");
+    if (Number(declared) > LIMITS.requestBytes) {
+      request.resume();
+      throw new CollectorBodyError(413, "LIMIT_EXCEEDED");
+    }
+  }
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    bytes += buffer.byteLength;
+    if (bytes > LIMITS.requestBytes) {
+      request.resume();
+      throw new CollectorBodyError(413, "LIMIT_EXCEEDED");
+    }
+    chunks.push(buffer);
+  }
+  try {
+    return JSON.parse(Buffer.concat(chunks, bytes).toString("utf8"));
+  } catch {
+    throw new CollectorBodyError(400, "INVALID_REQUEST");
+  }
+}
+
+// src/collector/auth.ts
+import { createHash as createHash4, timingSafeEqual } from "crypto";
+var TOKEN = /^[A-Za-z0-9_-]{43}$/;
+function decode(value) {
+  if (!TOKEN.test(value)) return void 0;
+  const decoded = Buffer.from(value, "base64url");
+  if (decoded.byteLength !== 32 || decoded.toString("base64url") !== value) return void 0;
+  return decoded;
+}
+function authenticateBearer(header, expectedToken) {
+  if (header === void 0 || !header.startsWith("Bearer ") || header.indexOf(" ", 7) !== -1) return false;
+  const provided = decode(header.slice(7));
+  const expected = decode(expectedToken);
+  if (provided === void 0 || expected === void 0) return false;
+  const providedDigest = createHash4("sha256").update(provided).digest();
+  const expectedDigest = createHash4("sha256").update(expected).digest();
+  return timingSafeEqual(providedDigest, expectedDigest);
+}
+
+// src/collector/router.ts
+var ERROR_MESSAGES = {
+  INVALID_REQUEST: "Invalid request",
+  UNAUTHORIZED: "Unauthorized",
+  NOT_FOUND: "Not found",
+  METHOD_NOT_ALLOWED: "Method not allowed",
+  COLLECTOR_DRAINING: "Collector is draining"
+};
+function baseHeaders() {
+  return {
+    "Cache-Control": "no-store",
+    "X-Content-Type-Options": "nosniff",
+    "Content-Type": "application/json; charset=utf-8"
+  };
+}
+function json(response, status, value, headers = {}) {
+  response.writeHead(status, { ...baseHeaders(), ...headers });
+  response.end(JSON.stringify(value));
+}
+function error(response, status, code, retryable = false, headers = {}) {
+  json(response, status, { ok: false, error: { code, message: ERROR_MESSAGES[code], retryable } }, headers);
+}
+function validOrigin(value) {
+  if (value.length > 2048 || /[\s\r\n]/u.test(value)) return false;
+  return /^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^/]+$/u.test(value);
+}
+function preflight(request, response) {
+  const origin = request.headers.origin;
+  const requestedMethod = request.headers["access-control-request-method"];
+  const rawHeaders = request.headers["access-control-request-headers"] ?? "";
+  if (origin === void 0 || !validOrigin(origin) || requestedMethod !== "POST" || typeof rawHeaders !== "string" || rawHeaders.length > 256) {
+    error(response, 400, "INVALID_REQUEST");
+    return;
+  }
+  const requestedHeaders = rawHeaders.split(",").map((value) => value.trim().toLowerCase()).filter(Boolean);
+  if (requestedHeaders.some((value) => value !== "authorization" && value !== "content-type")) {
+    error(response, 400, "INVALID_REQUEST");
+    return;
+  }
+  response.writeHead(204, {
+    ...baseHeaders(),
+    "Access-Control-Allow-Origin": origin,
+    "Access-Control-Allow-Methods": "POST",
+    "Access-Control-Allow-Headers": "Authorization, Content-Type",
+    "Access-Control-Max-Age": "600",
+    Vary: "Origin"
+  });
+  response.end();
+}
+function createCollectorRouter(options) {
+  return async (request, response, status) => {
+    const rawUrl = request.url ?? "";
+    let url;
+    try {
+      url = new URL(rawUrl, "http://loopback.invalid");
+    } catch {
+      error(response, 404, "NOT_FOUND");
+      return;
+    }
+    if (url.search !== "") {
+      error(response, 404, "NOT_FOUND");
+      return;
+    }
+    const pathname = url.pathname;
+    if (request.method === "OPTIONS") {
+      if (pathname === "/v1/events") preflight(request, response);
+      else error(response, 404, "NOT_FOUND");
+      return;
+    }
+    const authorization = Array.isArray(request.headers.authorization) ? void 0 : request.headers.authorization;
+    if (!authenticateBearer(authorization, options.token)) {
+      error(response, 401, "UNAUTHORIZED");
+      return;
+    }
+    await options.onAuthenticated?.();
+    if (pathname === "/v1/health") {
+      if (request.method !== "GET") {
+        error(response, 405, "METHOD_NOT_ALLOWED", false, { Allow: "GET" });
+        return;
+      }
+      json(response, 200, { ok: true, status: status() });
+      return;
+    }
+    if (pathname === "/v1/events") {
+      if (request.method !== "POST") {
+        error(response, 405, "METHOD_NOT_ALLOWED", false, { Allow: "OPTIONS, POST" });
+        return;
+      }
+      if (status() === "draining") {
+        error(response, 429, "COLLECTOR_DRAINING", true);
+        return;
+      }
+      if (options.ingest === void 0) {
+        error(response, 400, "INVALID_REQUEST");
+        return;
+      }
+      const origin = request.headers.origin;
+      await options.ingest(request, response, typeof origin === "string" && validOrigin(origin) ? origin : void 0);
+      return;
+    }
+    error(response, 404, "NOT_FOUND");
+  };
+}
+function writeCollectorJson(response, status, value, origin) {
+  json(response, status, value, origin === void 0 ? {} : { "Access-Control-Allow-Origin": origin, Vary: "Origin" });
+}
+
+// src/collector/ingest.ts
+var EventBatchSchema = z5.object({ events: z5.array(EventInputSchema).min(1).max(LIMITS.eventsPerBatch) }).strict();
+function errorBody(code, message, retryable = false) {
+  return { ok: false, error: { code, message, retryable } };
+}
+function createIngestHandler(options) {
+  return async (request, response, origin) => {
+    await options.evidence.countRequest();
+    let body;
+    try {
+      body = await readBoundedJsonBody(request);
+    } catch (error2) {
+      if (error2 instanceof CollectorBodyError) {
+        await options.evidence.recordRejected();
+        writeCollectorJson(response, error2.status, errorBody(error2.code, error2.message), origin);
+        return;
+      }
+      throw error2;
+    }
+    const parsed = EventBatchSchema.safeParse(body);
+    if (!parsed.success) {
+      await options.evidence.recordRejected();
+      writeCollectorJson(response, 400, errorBody("INVALID_REQUEST", "Invalid event batch"), origin);
+      return;
+    }
+    const validated = [];
+    try {
+      for (const event of parsed.data.events) validated.push(await options.validateEvent(event));
+    } catch {
+      await options.evidence.recordRejected(parsed.data.events.length);
+      writeCollectorJson(response, 400, errorBody("INVALID_REQUEST", "Event ownership is invalid"), origin);
+      return;
+    }
+    let accepted = 0;
+    let sampled = 0;
+    let dropped = 0;
+    for (const event of validated) {
+      const result = await options.evidence.append(
+        {
+          ...event,
+          eventId: `event_${randomBytes2(16).toString("base64url")}`,
+          kind: "probe"
+        },
+        { sampled: await options.sample?.(event) ?? false }
+      );
+      if (result.status === "accepted") accepted += 1;
+      else if (result.status === "sampled") sampled += 1;
+      else if (result.status === "dropped") dropped += 1;
+    }
+    writeCollectorJson(response, 202, { ok: true, accepted, sampled, dropped }, origin);
+  };
+}
+
+// src/collector/server.ts
+import { randomBytes as randomBytes3 } from "crypto";
+import { createServer } from "http";
+var CollectorServer = class {
+  constructor(handler = (_request, response) => {
+    response.writeHead(404, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    response.end('{"ok":false,"error":{"code":"NOT_FOUND","message":"Not found","retryable":false}}');
+  }, onFailure) {
+    this.handler = handler;
+    this.onFailure = onFailure;
+  }
+  handler;
+  onFailure;
+  server;
+  sockets = /* @__PURE__ */ new Set();
+  state = "stopped";
+  handle;
+  failureReported = false;
+  async start() {
+    if (this.handle !== void 0 && this.state === "ready") return this.handle;
+    if (this.state !== "stopped") throw new DebugModeError("COLLECTOR_EXISTS", "A collector already exists");
+    this.state = "starting";
+    try {
+      this.handle = await this.bind("127.0.0.1");
+    } catch (error2) {
+      const code = error2.code;
+      if (code !== "EAFNOSUPPORT" && code !== "EADDRNOTAVAIL") {
+        this.state = "failed";
+        throw new DebugModeError("LOOPBACK_BIND_FAILED", "The IPv4 loopback collector could not bind");
+      }
+      try {
+        this.handle = await this.bind("::1");
+      } catch {
+        this.state = "failed";
+        throw new DebugModeError("LOOPBACK_BIND_FAILED", "Neither loopback address could bind");
+      }
+    }
+    this.state = "ready";
+    return this.handle;
+  }
+  get status() {
+    return this.state;
+  }
+  async close() {
+    if (this.state === "stopped") return;
+    this.state = "draining";
+    const server = this.server;
+    if (server === void 0) {
+      this.state = "stopped";
+      return;
+    }
+    await Promise.race([
+      new Promise((resolve) => server.close(() => resolve())),
+      new Promise(
+        (resolve) => setTimeout(() => {
+          for (const socket of this.sockets) socket.destroy();
+          server.closeAllConnections?.();
+          resolve();
+        }, 1e3)
+      )
+    ]);
+    for (const socket of this.sockets) socket.destroy();
+    this.sockets.clear();
+    this.server = void 0;
+    this.handle = void 0;
+    this.state = "stopped";
+  }
+  bind(host) {
+    return new Promise((resolve, reject) => {
+      const server = createServer(
+        {
+          requestTimeout: 5e3,
+          headersTimeout: 5e3,
+          keepAliveTimeout: 1e3,
+          maxHeaderSize: 16384,
+          connectionsCheckingInterval: 1e3
+        },
+        (request, response) => {
+          void Promise.resolve(
+            this.handler(request, response, () => this.state === "draining" ? "draining" : "ready")
+          ).catch(() => {
+            if (!response.headersSent) response.writeHead(500, { "Content-Type": "application/json" });
+            response.end('{"ok":false,"error":{"code":"INTERNAL_ERROR","message":"Request failed","retryable":false}}');
+          });
+        }
+      );
+      server.maxHeadersCount = 32;
+      this.server = server;
+      server.on("connection", (socket) => {
+        this.sockets.add(socket);
+        socket.once("close", () => this.sockets.delete(socket));
+      });
+      const startupTimeout = setTimeout(() => {
+        cleanupStartup();
+        server.close();
+        const error2 = new Error("Collector startup timed out");
+        error2.code = "ETIMEDOUT";
+        reject(error2);
+      }, LIMITS.collectorReadyMs);
+      const startupError = (error2) => {
+        cleanupStartup();
+        server.close();
+        reject(error2);
+      };
+      const listening = () => {
+        cleanupStartup();
+        const address = server.address();
+        if (address === null || typeof address === "string") {
+          reject(new Error("Collector returned no TCP address"));
+          return;
+        }
+        const handle = Object.freeze({
+          id: `collector_${randomBytes3(16).toString("base64url")}`,
+          host,
+          port: address.port,
+          status: "ready",
+          close: () => this.close()
+        });
+        server.on("error", () => void this.reportFailure("listener-error"));
+        server.on("close", () => {
+          if (this.state === "ready") void this.reportFailure("unexpected-close");
+        });
+        resolve(handle);
+      };
+      const cleanupStartup = () => {
+        clearTimeout(startupTimeout);
+        server.off("error", startupError);
+        server.off("listening", listening);
+      };
+      server.once("error", startupError);
+      server.once("listening", listening);
+      server.listen({ host, port: 0, exclusive: true });
+    });
+  }
+  async reportFailure(reason) {
+    if (this.failureReported) return;
+    this.failureReported = true;
+    this.state = "failed";
+    await this.onFailure?.(reason);
+  }
+};
+
+// src/core/clock.ts
+import { performance as performance3 } from "perf_hooks";
+var systemClock = Object.freeze({
+  now: () => /* @__PURE__ */ new Date(),
+  monotonicMs: () => performance3.now()
+});
+
+// src/evidence/store.ts
+import { appendFile as appendFile2, stat } from "fs/promises";
+import { z as z7 } from "zod";
+
+// src/session/types.ts
+import { z as z6 } from "zod";
+var EvidenceCountersSchema = z6.object({
+  accepted: z6.number().int().nonnegative(),
+  rejected: z6.number().int().nonnegative(),
+  sampled: z6.number().int().nonnegative(),
+  truncated: z6.number().int().nonnegative(),
+  dropped: z6.number().int().nonnegative(),
+  requests: z6.number().int().nonnegative()
+}).strict();
+var CollectorManifestSchema = z6.object({
+  id: OpaqueIdSchema,
+  host: z6.enum(["127.0.0.1", "::1"]),
+  port: z6.number().int().min(1).max(65535),
+  status: z6.enum(["starting", "ready", "draining", "stopped", "failed"]),
+  startedAt: IsoTimestampSchema,
+  stoppedAt: IsoTimestampSchema.optional()
+}).strict();
+var RunManifestSchema = z6.object({
+  id: OpaqueIdSchema,
+  label: RunLabelSchema,
+  reproduction: z6.string().max(LIMITS.scalarBytes),
+  status: z6.enum(["planned", "running", "waiting", "completed", "failed", "timed_out", "cancelled"]),
+  createdAt: IsoTimestampSchema,
+  completedAt: IsoTimestampSchema.optional()
+}).strict();
+var ProcessManifestSchema = z6.object({
+  id: OpaqueIdSchema,
+  runId: OpaqueIdSchema,
+  commandSummary: z6.string().max(LIMITS.scalarBytes),
+  supervisorPid: z6.number().int().positive().optional(),
+  targetPid: z6.number().int().positive().optional(),
+  ownerNonceHash: HexSha256Schema,
+  status: z6.enum(["starting", "running", "exited", "timed_out", "cancelled", "terminated", "failed"]),
+  startedAt: IsoTimestampSchema,
+  completedAt: IsoTimestampSchema.optional(),
+  exitCode: z6.number().int().nullable().optional(),
+  signal: z6.string().max(64).nullable().optional()
+}).strict();
+var ProbeManifestSchema = z6.object({
+  id: OpaqueIdSchema,
+  runId: OpaqueIdSchema,
+  hypothesisId: OpaqueIdSchema,
+  sourceFile: z6.string().min(1),
+  sourceLine: z6.number().int().positive(),
+  sourceColumn: z6.number().int().positive().optional(),
+  message: z6.string().min(1).max(LIMITS.scalarBytes),
+  transport: z6.enum(["process", "http-web", "extension-background", "extension-content"]),
+  captures: z6.array(z6.object({ label: z6.string().min(1).max(128), path: z6.string().min(1).max(512) }).strict()).max(20),
+  sampling: z6.discriminatedUnion("mode", [
+    z6.object({ mode: z6.literal("every"), n: z6.number().int().min(1).max(1e4) }).strict(),
+    z6.object({ mode: z6.literal("aggregate"), windowMs: z6.number().int().min(100).max(6e4) }).strict()
+  ]),
+  status: z6.enum(["planned", "registered", "validated", "active", "removed", "ambiguous"]),
+  validationStatus: z6.enum(["pending", "validated", "failed"]),
+  markerStart: z6.string().min(1),
+  markerEnd: z6.string().min(1),
+  expectedBlock: z6.string().optional(),
+  expectedHash: HexSha256Schema.optional()
+}).strict();
+var OwnedFileManifestSchema = z6.object({
+  path: z6.string().min(1),
+  sha256: HexSha256Schema,
+  bytes: z6.number().int().nonnegative(),
+  kind: z6.enum(["transport-helper", "temporary"])
+}).strict();
+var PermissionChangeSchema = z6.object({
+  manifestPath: z6.string().min(1),
+  property: z6.enum(["permissions", "host_permissions"]),
+  matchPattern: z6.string().min(1),
+  addedBySession: z6.boolean()
+}).strict();
+var CleanupProgressSchema = z6.object({
+  status: z6.enum(["not_started", "running", "complete", "partial"]),
+  completedResources: z6.array(z6.string().max(256)).max(1e4)
+}).strict();
+var ManifestSchema = z6.object({
+  package: z6.literal(PACKAGE_ID),
+  schemaVersion: z6.literal(MANIFEST_SCHEMA_VERSION),
+  revision: z6.number().int().nonnegative(),
+  sessionId: OpaqueIdSchema,
+  trustedSessionHash: HexSha256Schema,
+  projectRoot: z6.string().min(1),
+  sessionDir: z6.string().min(1),
+  status: z6.enum(["active", "cleaning", "cleaned", "partial"]),
+  createdAt: IsoTimestampSchema,
+  lastActivityAt: IsoTimestampSchema,
+  expiresAt: IsoTimestampSchema,
+  waitingForReproduction: z6.boolean(),
+  keepArtifacts: z6.boolean(),
+  retentionDestination: z6.string().min(1).optional(),
+  collector: CollectorManifestSchema.nullable(),
+  runs: z6.array(RunManifestSchema),
+  processes: z6.array(ProcessManifestSchema),
+  probes: z6.array(ProbeManifestSchema),
+  ownedFiles: z6.array(OwnedFileManifestSchema),
+  permissionChanges: z6.array(PermissionChangeSchema),
+  counters: EvidenceCountersSchema,
+  cleanup: CleanupProgressSchema
+}).strict();
+
+// src/evidence/read.ts
+import { createReadStream as createReadStream2 } from "fs";
+function matches(event, filter) {
+  if (filter.sessionId !== void 0 && event.sessionId !== filter.sessionId) return false;
+  if (filter.runId !== void 0 && event.runId !== filter.runId) return false;
+  if (filter.hypothesisId !== void 0 && event.hypothesisId !== filter.hypothesisId) return false;
+  if (filter.probeId !== void 0 && event.probeId !== filter.probeId) return false;
+  if (filter.from !== void 0 && event.timestamp < filter.from) return false;
+  if (filter.to !== void 0 && event.timestamp > filter.to) return false;
+  if (filter.keyword !== void 0 && !JSON.stringify(event).toLowerCase().includes(filter.keyword.toLowerCase()))
+    return false;
+  return true;
+}
+async function readEvidence(filename, filter = {}) {
+  const limit = Math.min(Math.max(filter.limit ?? 100, 1), 100);
+  const start = filter.cursor === void 0 ? 0 : Number(filter.cursor);
+  if (!Number.isSafeInteger(start) || start < 0) throw new Error("Evidence cursor is invalid");
+  const events = [];
+  let invalidLines = 0;
+  let trailingPartialLine = false;
+  let buffer = Buffer.alloc(0);
+  let offset = start;
+  let nextCursor = null;
+  const stream = createReadStream2(filename, { start });
+  try {
+    for await (const chunk of stream) {
+      buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+      while (true) {
+        const newline = buffer.indexOf(10);
+        if (newline < 0) break;
+        const line = buffer.subarray(0, newline);
+        buffer = buffer.subarray(newline + 1);
+        offset += newline + 1;
+        if (line.byteLength === 0) continue;
+        try {
+          const event = EvidenceEventSchema.parse(JSON.parse(line.toString("utf8")));
+          if (matches(event, filter)) {
+            events.push(event);
+            if (events.length >= limit) {
+              nextCursor = String(offset);
+              stream.destroy();
+              return { events, nextCursor, trailingPartialLine: false, invalidLines };
+            }
+          }
+        } catch {
+          invalidLines += 1;
+        }
+      }
+    }
+    trailingPartialLine = buffer.byteLength > 0;
+  } catch (error2) {
+    if (error2.code !== "ENOENT") throw error2;
+  } finally {
+    stream.destroy();
+  }
+  return { events, nextCursor, trailingPartialLine, invalidLines };
+}
+
+// src/evidence/store.ts
+var AppendEventSchema = EvidenceEventSchema.omit({ receivedAt: true, sanitization: true, data: true }).extend({
+  schemaVersion: z7.literal(EVENT_SCHEMA_VERSION),
+  data: z7.unknown().optional()
+});
+var EvidenceStore = class {
+  constructor(filename, onCounters, clock = systemClock, loadCounters) {
+    this.filename = filename;
+    this.onCounters = onCounters;
+    this.clock = clock;
+    this.loadCounters = loadCounters;
+  }
+  filename;
+  onCounters;
+  clock;
+  loadCounters;
+  tail = Promise.resolve();
+  currentBytes = 0;
+  initialized = false;
+  counters = {
+    accepted: 0,
+    rejected: 0,
+    sampled: 0,
+    truncated: 0,
+    dropped: 0,
+    requests: 0
+  };
+  async append(input, options = {}) {
+    return this.exclusive(async () => {
+      await this.initialize();
+      if (options.sampled === true) {
+        await this.increment("sampled");
+        return { status: "sampled" };
+      }
+      const parsed = AppendEventSchema.safeParse(input);
+      if (!parsed.success) {
+        await this.increment("rejected");
+        return { status: "rejected" };
+      }
+      if (this.counters.accepted >= LIMITS.events) {
+        await this.increment("dropped");
+        return { status: "dropped" };
+      }
+      const sanitized = sanitizeEvidenceData(parsed.data.data);
+      const event = EvidenceEventSchema.parse({
+        ...parsed.data,
+        data: sanitized.value,
+        receivedAt: this.clock.now().toISOString(),
+        sanitization: {
+          flags: sanitized.flags,
+          droppedKeys: sanitized.droppedKeys,
+          storedBytes: sanitized.storedBytes,
+          ...sanitized.originalBytes === void 0 ? {} : { originalBytes: sanitized.originalBytes }
+        }
+      });
+      const line = `${JSON.stringify(event)}
+`;
+      const bytes = Buffer.byteLength(line);
+      if (this.currentBytes + bytes > LIMITS.evidenceBytes) {
+        await this.increment("dropped");
+        return { status: "dropped" };
+      }
+      try {
+        await appendFile2(this.filename, line, { encoding: "utf8", mode: 384 });
+      } catch (error2) {
+        await this.increment("rejected");
+        throw error2;
+      }
+      this.currentBytes += bytes;
+      await this.increment("accepted");
+      if (sanitized.flags.includes("truncated")) await this.increment("truncated");
+      return { status: "accepted", event };
+    });
+  }
+  async read(filter = {}) {
+    await this.initialize();
+    const page = await readEvidence(this.filename, filter);
+    return { ...page, counters: EvidenceCountersSchema.parse(this.counters) };
+  }
+  snapshotCounters() {
+    return EvidenceCountersSchema.parse(this.counters);
+  }
+  async countRequest() {
+    await this.exclusive(async () => {
+      await this.initialize();
+      await this.increment("requests");
+    });
+  }
+  async recordRejected(count = 1) {
+    await this.exclusive(async () => {
+      await this.initialize();
+      for (let index = 0; index < count; index += 1) await this.increment("rejected");
+    });
+  }
+  async initialize() {
+    if (this.initialized) return;
+    if (this.loadCounters !== void 0) {
+      Object.assign(this.counters, EvidenceCountersSchema.parse(await this.loadCounters()));
+    }
+    try {
+      this.currentBytes = (await stat(this.filename)).size;
+    } catch (error2) {
+      if (error2.code !== "ENOENT") throw error2;
+    }
+    this.initialized = true;
+  }
+  async increment(field) {
+    this.counters[field] += 1;
+    await this.onCounters?.(EvidenceCountersSchema.parse(this.counters));
+  }
+  async exclusive(operation) {
+    const previous = this.tail;
+    let release;
+    this.tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+};
+
+// src/probes/helper.ts
+import { createHash as createHash5 } from "crypto";
+import { mkdir as mkdir3, realpath as realpath3, writeFile as writeFile4 } from "fs/promises";
+import path3 from "path";
+function helperSource(options) {
+  const listener = options.extensionBackground ? `
+const runtime = globalThis.browser?.runtime ?? globalThis.chrome?.runtime
+runtime?.onMessage?.addListener((message) => {
+  if (message?.type === "opencode-debug-event") __opencodeDebugEmit(message.event)
+})
+` : "";
+  return `const endpoint = ${JSON.stringify(options.endpoint)}
+const authorization = ${JSON.stringify(`Bearer ${options.token}`)}
+const queue = []
+let sending = false
+let dropped = 0
+
+function bound(value, depth = 0) {
+  if (depth > 6) return "[TRUNCATED]"
+  if (typeof value === "string") return value.slice(0, 8192)
+  if (Array.isArray(value)) return value.slice(0, 100).map((item) => bound(item, depth + 1))
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().slice(0, 50).map((key) => [key, bound(value[key], depth + 1)]))
+  }
+  return value
+}
+
+export function __opencodeDebugEmit(event) {
+  if (queue.length >= 100) { dropped += 1; return }
+  queue.push(bound(event))
+  void flush()
+}
+
+async function flush() {
+  if (sending) return
+  sending = true
+  try {
+    while (queue.length > 0) {
+      const events = queue.splice(0, 100)
+      if (dropped > 0) { events.push({ ...events[0], message: "dropped events", data: { dropped } }); dropped = 0 }
+      const response = await fetch(endpoint, {
+        method: "POST",
+        credentials: "omit",
+        headers: { Authorization: authorization, "Content-Type": "application/json" },
+        body: JSON.stringify({ events }),
+      })
+      if (!response.ok) break
+    }
+  } catch {
+    // Runtime evidence transport is best effort and never affects target behavior.
+  } finally {
+    sending = false
+  }
+}
+${listener}`;
+}
+var TransportHelper = class {
+  constructor(projectRoot, recordOwnedFile) {
+    this.projectRoot = projectRoot;
+    this.recordOwnedFile = recordOwnedFile;
+  }
+  projectRoot;
+  recordOwnedFile;
+  async create(options) {
+    const canonicalRoot = await realpath3(this.projectRoot);
+    const absoluteTarget = path3.resolve(canonicalRoot, options.targetPath);
+    if (!isContained(canonicalRoot, absoluteTarget)) {
+      throw new DebugModeError("HELPER_PATH_UNSAFE", "Transport helper must remain inside the project");
+    }
+    const parent = path3.dirname(absoluteTarget);
+    await mkdir3(parent, { recursive: true });
+    if (await realpath3(parent) !== parent) {
+      throw new DebugModeError("HELPER_PATH_UNSAFE", "Transport helper parent is not canonical");
+    }
+    const endpointHost = options.host === "::1" ? "[::1]" : options.host;
+    const source = helperSource({
+      endpoint: `http://${endpointHost}:${options.port}/v1/events`,
+      token: options.token,
+      extensionBackground: options.runtime === "extension-background"
+    });
+    await writeFile4(absoluteTarget, source, { flag: "wx", mode: 384 });
+    const bytes = Buffer.byteLength(source);
+    const sha2563 = createHash5("sha256").update(source).digest("hex");
+    await this.recordOwnedFile?.({ path: absoluteTarget, sha256: sha2563, bytes });
+    const relativePath = `./${path3.relative(canonicalRoot, absoluteTarget).split(path3.sep).join("/")}`;
+    return {
+      relativePath,
+      requiredImport: `import { __opencodeDebugEmit } from ${JSON.stringify(relativePath)}`,
+      sha256: sha2563,
+      bytes
+    };
+  }
+};
+
+// src/probes/registry.ts
+import { createHash as createHash6, randomBytes as randomBytes4 } from "crypto";
+import { readFile as readFile5, realpath as realpath4 } from "fs/promises";
+import path4 from "path";
+
+// src/probes/types.ts
+var SAFE_CAPTURE = /^[A-Za-z_$][\w$]*(?:(?:\.|\?\.)[A-Za-z_$][\w$]*)*$/;
+
+// src/probes/template.ts
+function createProbeTemplate(input) {
+  if (input.captures.some((capture) => !SAFE_CAPTURE.test(capture.path))) {
+    throw new DebugModeError("UNSAFE_CAPTURE", "Probe capture path is unsafe");
+  }
+  const ownership = `opencode-debug-mode session=${input.sessionId} run=${input.runId} hypothesis=${input.hypothesisId} probe=${input.probeId}`;
+  const data = input.captures.map((capture) => `${JSON.stringify(capture.label)}: ${capture.path}`).join(", ");
+  const event = `{
+  schemaVersion: 1,
+  sessionId: ${JSON.stringify(input.sessionId)},
+  runId: ${JSON.stringify(input.runId)},
+  runLabel: ${JSON.stringify(input.runLabel)},
+  hypothesisId: ${JSON.stringify(input.hypothesisId)},
+  probeId: ${JSON.stringify(input.probeId)},
+  timestamp: new Date().toISOString(),
+  message: ${JSON.stringify(input.message)},
+  source: { file: ${JSON.stringify(input.sourceFile)}, line: ${input.sourceLine} },
+  data: { ${data} },
+}`;
+  let emission;
+  if (input.transport === "process") {
+    emission = `void ((event) => process.stderr.write(${JSON.stringify(PROCESS_EVENT_PREFIX)} + JSON.stringify(event) + "\\n"))(${event})`;
+  } else if (input.transport === "extension-content") {
+    const adapter = input.contentAdapter ?? "chrome.runtime.sendMessage";
+    emission = `void ${adapter}({ type: "opencode-debug-event", event: ${event} })`;
+  } else {
+    emission = `void __opencodeDebugEmit(${event})`;
+  }
+  return {
+    markerBlock: `/* DEBUG-START ${ownership} */
+${emission}
+/* DEBUG-END ${ownership} */`
+  };
+}
+
+// src/probes/registry.ts
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]);
+function probeId() {
+  return `probe_${randomBytes4(16).toString("base64url")}`;
+}
+function sha2562(value) {
+  return createHash6("sha256").update(value).digest("hex");
+}
+function markerLines(sessionId, input, id) {
+  const ownership = `opencode-debug-mode session=${sessionId} run=${input.runId} hypothesis=${input.hypothesisId} probe=${id}`;
+  return { start: `/* DEBUG-START ${ownership} */`, end: `/* DEBUG-END ${ownership} */` };
+}
+var ProbeRegistry = class {
+  constructor(store, projectRoot, hasHypothesis) {
+    this.store = store;
+    this.projectRoot = projectRoot;
+    this.hasHypothesis = hasHypothesis;
+  }
+  store;
+  projectRoot;
+  hasHypothesis;
+  async plan(input) {
+    const manifest = await this.store.read();
+    if (!manifest.runs.some((run2) => run2.id === input.runId))
+      throw new DebugModeError("RUN_NOT_FOUND", "Run was not found");
+    if (!await this.hasHypothesis(input.hypothesisId)) {
+      throw new DebugModeError("STATE_INVALID", "Hypothesis was not found in the checkpoint");
+    }
+    if (!Number.isInteger(input.sourceLine) || input.sourceLine < 1) {
+      throw new DebugModeError("MARKER_MISMATCH", "Source line must be one-based");
+    }
+    if (input.message.length < 1 || Buffer.byteLength(input.message) > 8192) {
+      throw new DebugModeError("MARKER_MISMATCH", "Probe message is invalid");
+    }
+    if (input.captures.length > 20 || input.captures.some((capture) => !SAFE_CAPTURE.test(capture.path))) {
+      throw new DebugModeError("UNSAFE_CAPTURE", "Probe capture path is unsafe");
+    }
+    const absoluteSource = path4.resolve(this.projectRoot, input.sourceFile);
+    if (!isContained(this.projectRoot, absoluteSource)) {
+      throw new DebugModeError("HELPER_PATH_UNSAFE", "Probe source is outside the project");
+    }
+    if (!SUPPORTED_EXTENSIONS.has(path4.extname(absoluteSource).toLowerCase())) {
+      throw new DebugModeError("UNSUPPORTED_LANGUAGE", "Only JavaScript and TypeScript probes are supported");
+    }
+    const canonicalSource = await realpath4(absoluteSource);
+    if (!isContained(this.projectRoot, canonicalSource)) {
+      throw new DebugModeError("HELPER_PATH_UNSAFE", "Probe source resolves outside the project");
+    }
+    const id = probeId();
+    const markers = markerLines(manifest.sessionId, input, id);
+    const run = manifest.runs.find((candidate) => candidate.id === input.runId);
+    if (run === void 0) throw new DebugModeError("RUN_NOT_FOUND", "Run was not found");
+    const markerBlock = input.markerBlock ?? createProbeTemplate({
+      sessionId: manifest.sessionId,
+      runId: input.runId,
+      runLabel: run.label,
+      hypothesisId: input.hypothesisId,
+      probeId: id,
+      sourceFile: path4.relative(this.projectRoot, canonicalSource),
+      sourceLine: input.sourceLine,
+      message: input.message,
+      captures: input.captures,
+      transport: input.transport,
+      sampling: input.sampling
+    }).markerBlock;
+    const probe = {
+      id,
+      runId: input.runId,
+      hypothesisId: input.hypothesisId,
+      sourceFile: canonicalSource,
+      sourceLine: input.sourceLine,
+      ...input.sourceColumn === void 0 ? {} : { sourceColumn: input.sourceColumn },
+      message: input.message,
+      transport: input.transport,
+      captures: input.captures,
+      sampling: input.sampling,
+      status: "planned",
+      validationStatus: "pending",
+      markerStart: markers.start,
+      markerEnd: markers.end,
+      expectedBlock: markerBlock
+    };
+    await this.update(manifest, (value) => ({ ...value, probes: [...value.probes, probe] }));
+    return { ...probe, markerBlock };
+  }
+  async register(id) {
+    const manifest = await this.store.read();
+    const probe = manifest.probes.find((candidate) => candidate.id === id);
+    if (probe === void 0) throw new DebugModeError("MARKER_MISSING", "Probe was not planned");
+    if (probe.expectedBlock === void 0)
+      throw new DebugModeError("MARKER_MISMATCH", "Probe marker content is unavailable");
+    const source = await readFile5(probe.sourceFile, "utf8");
+    const occurrences2 = source.split(probe.expectedBlock).length - 1;
+    if (occurrences2 === 0) throw new DebugModeError("MARKER_MISSING", "Owned probe marker is missing");
+    if (occurrences2 !== 1) throw new DebugModeError("MARKER_MISMATCH", "Owned probe marker is not unique");
+    const updated = {
+      ...probe,
+      expectedHash: sha2562(probe.expectedBlock),
+      status: "registered",
+      validationStatus: "pending"
+    };
+    await this.update(manifest, (value) => ({
+      ...value,
+      probes: value.probes.map((candidate) => candidate.id === id ? updated : candidate)
+    }));
+    return updated;
+  }
+  async validate(probeIds) {
+    const manifest = await this.store.read();
+    if (probeIds.some((id) => !manifest.probes.some((probe) => probe.id === id && probe.status === "registered"))) {
+      throw new DebugModeError("MARKER_MISMATCH", "Only registered probes can be validated");
+    }
+    await this.update(manifest, (value) => ({
+      ...value,
+      probes: value.probes.map(
+        (probe) => probeIds.includes(probe.id) ? { ...probe, status: "validated", validationStatus: "validated" } : probe
+      )
+    }));
+  }
+  async requireValidatedForRun(runId) {
+    const manifest = await this.store.read();
+    if (manifest.probes.some((probe) => probe.runId === runId && probe.validationStatus !== "validated")) {
+      throw new DebugModeError("PROBE_NOT_VALIDATED", "Every active probe must pass an instrumentation check");
+    }
+  }
+  async validateEvent(input) {
+    const manifest = await this.store.read();
+    const probe = manifest.probes.find((candidate) => candidate.id === input.probeId);
+    const run = manifest.runs.find((candidate) => candidate.id === input.runId);
+    if (probe === void 0 || run === void 0 || input.sessionId !== manifest.sessionId || probe.runId !== input.runId || probe.hypothesisId !== input.hypothesisId || run.label !== input.runLabel) {
+      throw new DebugModeError("MARKER_MISMATCH", "Runtime event ownership does not match the registered probe");
+    }
+    return {
+      ...input,
+      source: {
+        file: path4.relative(this.projectRoot, probe.sourceFile),
+        line: probe.sourceLine,
+        ...probe.sourceColumn === void 0 ? {} : { column: probe.sourceColumn }
+      }
+    };
+  }
+  async update(_manifest, mutate) {
+    return this.store.modify(mutate);
+  }
+};
+
+// src/process/service.ts
+import { fork } from "child_process";
+import { createHash as createHash7, randomBytes as randomBytes5 } from "crypto";
+import { existsSync } from "fs";
+import path5 from "path";
+import { fileURLToPath } from "url";
+
+// src/process/line-decoder.ts
+import { StringDecoder } from "string_decoder";
+var ProcessLineDecoder = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  streams = {
+    stdout: { decoder: new StringDecoder("utf8"), pending: "", discarding: false },
+    stderr: { decoder: new StringDecoder("utf8"), pending: "", discarding: false }
+  };
+  push(stream, chunk) {
+    return this.consume(stream, this.streams[stream].decoder.write(chunk));
+  }
+  flush(stream) {
+    const state = this.streams[stream];
+    const records = this.consume(stream, state.decoder.end());
+    if (!state.discarding && state.pending.length > 0) {
+      records.push(this.decodeLine(stream, state.pending.replace(/\r$/u, "")));
+    }
+    state.pending = "";
+    state.discarding = false;
+    return records;
+  }
+  consume(stream, text) {
+    const state = this.streams[stream];
+    const records = [];
+    let remainder = text;
+    if (state.discarding) {
+      const newline = remainder.indexOf("\n");
+      if (newline < 0) return records;
+      state.discarding = false;
+      remainder = remainder.slice(newline + 1);
+    }
+    state.pending += remainder;
+    while (true) {
+      const newline = state.pending.indexOf("\n");
+      if (newline < 0) break;
+      const line = state.pending.slice(0, newline).replace(/\r$/u, "");
+      state.pending = state.pending.slice(newline + 1);
+      if (Buffer.byteLength(line) > this.options.maxLineBytes) {
+        records.push({ kind: "truncated", stream, maximumBytes: this.options.maxLineBytes });
+      } else {
+        records.push(this.decodeLine(stream, line));
+      }
+    }
+    if (Buffer.byteLength(state.pending) > this.options.maxLineBytes) {
+      state.pending = "";
+      state.discarding = true;
+      records.push({ kind: "truncated", stream, maximumBytes: this.options.maxLineBytes });
+    }
+    return records;
+  }
+  decodeLine(stream, text) {
+    if (!text.startsWith(PROCESS_EVENT_PREFIX)) return { kind: "output", stream, text };
+    try {
+      return { kind: "probe-candidate", stream, value: JSON.parse(text.slice(PROCESS_EVENT_PREFIX.length)) };
+    } catch {
+      return { kind: "output", stream, text, rejectedProbe: true };
+    }
+  }
+};
+
+// src/process/protocol.ts
+import { z as z8 } from "zod";
+var MAX_MESSAGE_BYTES = 64 * 1024;
+var BoundedString = z8.string().max(8192);
+var StartMessageSchema = z8.object({
+  type: z8.literal("start"),
+  executable: BoundedString.min(1),
+  args: z8.array(BoundedString).max(256),
+  cwd: BoundedString.min(1),
+  env: z8.record(z8.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), BoundedString).refine((value) => Object.keys(value).length <= 256),
+  timeoutMs: z8.number().int().min(1).max(3e5),
+  ownerNonce: z8.string().min(32).max(128).regex(/^[A-Za-z0-9_-]+$/)
+}).strict();
+var TerminateMessageSchema = z8.object({ type: z8.literal("terminate"), reason: BoundedString }).strict();
+var ParentMessageSchema = z8.discriminatedUnion("type", [StartMessageSchema, TerminateMessageSchema]);
+var ChildMessageSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("ready") }).strict(),
+  z8.object({ type: z8.literal("started"), targetPid: z8.number().int().positive() }).strict(),
+  z8.object({
+    type: z8.literal("result"),
+    targetPid: z8.number().int().positive(),
+    exitCode: z8.number().int().nullable(),
+    signal: z8.string().max(64).nullable(),
+    timedOut: z8.boolean(),
+    termination: z8.object({
+      graceful: z8.boolean(),
+      forced: z8.boolean(),
+      remaining: z8.boolean(),
+      durationMs: z8.number().nonnegative(),
+      errors: z8.array(z8.string().max(256)).max(20)
+    }).strict().optional()
+  }).strict(),
+  z8.object({ type: z8.literal("failure"), code: z8.string().max(128), message: z8.string().max(512) }).strict()
+]);
+function assertSize(value) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch {
+    throw new Error("IPC message is not serializable");
+  }
+  if (Buffer.byteLength(serialized) > MAX_MESSAGE_BYTES) throw new Error("IPC message exceeds 64 KiB");
+}
+function parseChildMessage(value) {
+  assertSize(value);
+  return ChildMessageSchema.parse(value);
+}
+
+// src/process/service.ts
+function generatedId(prefix) {
+  return `${prefix}${randomBytes5(16).toString("base64url")}`;
+}
+function defaultSupervisorPath() {
+  const directory = path5.dirname(fileURLToPath(import.meta.url));
+  const bundled = path5.join(directory, "process-supervisor.js");
+  if (existsSync(bundled)) return bundled;
+  return path5.resolve(directory, "../../dist/process-supervisor.js");
+}
+var ProcessService = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  dependencies;
+  async capture(input) {
+    const run = await this.dependencies.runs.require(input.runId);
+    const release = await this.dependencies.acquireLease();
+    const clock = this.dependencies.clock ?? systemClock;
+    const startedAt = clock.monotonicMs();
+    const decoder = new ProcessLineDecoder({ maxLineBytes: 8192 });
+    let stdoutEvents = 0;
+    let stderrEvents = 0;
+    let probeEvents = 0;
+    let writes = Promise.resolve();
+    let startedUpdate = Promise.resolve();
+    let child;
+    const processId = generatedId("process_");
+    const ownerNonce = randomBytes5(32).toString("base64url");
+    try {
+      child = fork(this.dependencies.supervisorPath ?? defaultSupervisorPath(), [], {
+        stdio: ["ignore", "pipe", "pipe", "ipc"]
+      });
+      if (child.pid === void 0) throw new DebugModeError("PROCESS_START_FAILED", "Supervisor did not receive a PID");
+      await this.waitForMessage(child, "ready", 2e3);
+      await this.addOwnedProcess({
+        id: processId,
+        runId: input.runId,
+        commandSummary: [path5.basename(input.executable), ...input.args.map((value) => path5.basename(value))].join(" ").slice(0, 8192),
+        supervisorPid: child.pid,
+        ownerNonceHash: createHash7("sha256").update(ownerNonce).digest("hex"),
+        status: "starting",
+        startedAt: clock.now().toISOString()
+      });
+      const consume = (stream, chunk) => {
+        for (const record of decoder.push(stream, chunk)) {
+          writes = writes.then(() => this.persistRecord(record, input, run.label)).then((kind) => {
+            if (kind === "probe") probeEvents += 1;
+            else if (kind === "stdout") stdoutEvents += 1;
+            else if (kind === "stderr") stderrEvents += 1;
+          });
+        }
+      };
+      child.stdout?.on("data", (chunk) => consume("stdout", chunk));
+      child.stderr?.on("data", (chunk) => consume("stderr", chunk));
+      const resultPromise = new Promise((resolve, reject) => {
+        child?.on("message", (value) => {
+          try {
+            const message = parseChildMessage(value);
+            if (message.type === "started") startedUpdate = this.markStarted(processId, message.targetPid);
+            if (message.type === "failure") reject(new DebugModeError("PROCESS_START_FAILED", message.message));
+            if (message.type === "result") resolve(message);
+          } catch {
+            reject(new DebugModeError("PROCESS_START_FAILED", "Supervisor returned an invalid message"));
+          }
+        });
+        child?.once("error", () => reject(new DebugModeError("PROCESS_START_FAILED", "Supervisor failed to start")));
+        child?.once("exit", (code) => {
+          if (code !== 0) reject(new DebugModeError("PROCESS_START_FAILED", "Supervisor exited unexpectedly"));
+        });
+      });
+      child.send({
+        type: "start",
+        executable: input.executable,
+        args: input.args,
+        cwd: input.cwd,
+        env: input.env,
+        timeoutMs: input.timeoutMs,
+        ownerNonce
+      });
+      const abort = () => {
+        if (child?.connected) child.send({ type: "terminate", reason: "abort" });
+      };
+      input.signal?.addEventListener("abort", abort, { once: true });
+      if (input.signal?.aborted === true) abort();
+      let result;
+      try {
+        result = await resultPromise;
+      } finally {
+        input.signal?.removeEventListener("abort", abort);
+      }
+      if (result.type !== "result") throw new DebugModeError("PROCESS_START_FAILED", "Supervisor returned no result");
+      for (const stream of ["stdout", "stderr"]) {
+        for (const record of decoder.flush(stream)) {
+          writes = writes.then(() => this.persistRecord(record, input, run.label)).then((kind) => {
+            if (kind === "probe") probeEvents += 1;
+            else if (kind === "stdout") stdoutEvents += 1;
+            else if (kind === "stderr") stderrEvents += 1;
+          });
+        }
+      }
+      await writes;
+      await startedUpdate;
+      await this.markCompleted(processId, result);
+      return {
+        processId,
+        runId: input.runId,
+        exitCode: result.exitCode,
+        signal: result.signal,
+        timedOut: result.timedOut,
+        durationMs: clock.monotonicMs() - startedAt,
+        stdoutEvents,
+        stderrEvents,
+        probeEvents
+      };
+    } finally {
+      if (child?.connected) child.disconnect();
+      release();
+    }
+  }
+  async persistRecord(record, input, runLabel) {
+    if (record.kind === "truncated") {
+      const result2 = await this.dependencies.evidence.append({
+        schemaVersion: EVENT_SCHEMA_VERSION,
+        eventId: generatedId("event_"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: this.dependencies.session.publicId,
+        runId: input.runId,
+        runLabel,
+        hypothesisId: "hyp_process",
+        probeId: "probe_process",
+        kind: `process.${record.stream}`,
+        message: "[TRUNCATED OUTPUT LINE]",
+        data: { maximumBytes: record.maximumBytes },
+        source: { file: "process", line: 1 }
+      });
+      return result2.status === "accepted" ? record.stream : "ignored";
+    }
+    if (record.kind === "output") {
+      if (record.text.length === 0) return "ignored";
+      const result2 = await this.dependencies.evidence.append({
+        schemaVersion: EVENT_SCHEMA_VERSION,
+        eventId: generatedId("event_"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: this.dependencies.session.publicId,
+        runId: input.runId,
+        runLabel,
+        hypothesisId: "hyp_process",
+        probeId: "probe_process",
+        kind: `process.${record.stream}`,
+        message: record.text,
+        data: null,
+        source: { file: "process", line: 1 }
+      });
+      return result2.status === "accepted" ? record.stream : "ignored";
+    }
+    const parsed = EventInputSchema.safeParse(record.value);
+    if (!parsed.success) return "ignored";
+    const validated = this.dependencies.probes === void 0 ? parsed.data : await this.dependencies.probes.validateEvent(parsed.data);
+    const result = await this.dependencies.evidence.append({
+      ...validated,
+      eventId: generatedId("event_"),
+      kind: "probe"
+    });
+    return result.status === "accepted" ? "probe" : "ignored";
+  }
+  async addOwnedProcess(owned) {
+    await this.updateManifest((manifest) => ({ ...manifest, processes: [...manifest.processes, owned] }));
+  }
+  async markStarted(id, targetPid) {
+    await this.updateManifest((manifest) => ({
+      ...manifest,
+      processes: manifest.processes.map(
+        (entry) => entry.id === id ? { ...entry, targetPid, status: "running" } : entry
+      )
+    }));
+  }
+  async markCompleted(id, result) {
+    await this.updateManifest((manifest) => ({
+      ...manifest,
+      processes: manifest.processes.map(
+        (entry) => entry.id === id ? {
+          ...entry,
+          status: result.timedOut ? "timed_out" : "exited",
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          exitCode: result.exitCode,
+          signal: result.signal
+        } : entry
+      )
+    }));
+  }
+  async updateManifest(mutate) {
+    await this.dependencies.session.manifestStore.modify(mutate);
+  }
+  waitForMessage(child, type, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new DebugModeError("PROCESS_START_FAILED", `Supervisor did not become ${type}`));
+      }, timeoutMs);
+      const message = (value) => {
+        try {
+          if (parseChildMessage(value).type === type) {
+            cleanup();
+            resolve();
+          }
+        } catch {
+          cleanup();
+          reject(new DebugModeError("PROCESS_START_FAILED", "Supervisor returned an invalid message"));
+        }
+      };
+      const exit = () => {
+        cleanup();
+        reject(new DebugModeError("PROCESS_START_FAILED", "Supervisor exited before becoming ready"));
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        child.off("message", message);
+        child.off("exit", exit);
+      };
+      child.on("message", message);
+      child.once("exit", exit);
+    });
+  }
+};
+
+// src/run/service.ts
+import { randomBytes as randomBytes6 } from "crypto";
+function createId(prefix) {
+  return `${prefix}${randomBytes6(16).toString("base64url")}`;
+}
+var RunService = class {
+  constructor(persistence, clock = systemClock, acquireLease) {
+    this.persistence = persistence;
+    this.clock = clock;
+    this.acquireLease = acquireLease;
+  }
+  persistence;
+  clock;
+  acquireLease;
+  waitingReleases = /* @__PURE__ */ new Map();
+  async start(input) {
+    const label = RunLabelSchema.parse(input.label);
+    const current = await this.persistence.read();
+    if (current.runs.length >= 20) throw new DebugModeError("RUN_LIMIT", "The run limit has been reached");
+    const now = this.clock.now().toISOString();
+    const run = {
+      id: createId("run_"),
+      label,
+      reproduction: input.reproduction.slice(0, 8192),
+      status: input.waitingForUser ? "waiting" : "running",
+      createdAt: now
+    };
+    await this.persistence.update(current.revision, (manifest) => ({
+      ...manifest,
+      waitingForReproduction: input.waitingForUser || manifest.waitingForReproduction,
+      runs: [...manifest.runs, run]
+    }));
+    if (input.waitingForUser && this.acquireLease !== void 0) {
+      this.waitingReleases.set(run.id, await this.acquireLease("waiting"));
+    }
+    return run;
+  }
+  async require(runId) {
+    const manifest = await this.persistence.read();
+    const run = manifest.runs.find((candidate) => candidate.id === runId);
+    if (run === void 0) throw new DebugModeError("RUN_NOT_FOUND", "Run was not found");
+    return run;
+  }
+  async complete(runId, status) {
+    const current = await this.persistence.read();
+    const index = current.runs.findIndex((candidate) => candidate.id === runId);
+    if (index < 0) throw new DebugModeError("RUN_NOT_FOUND", "Run was not found");
+    const existing = current.runs[index];
+    if (existing === void 0) throw new DebugModeError("RUN_NOT_FOUND", "Run was not found");
+    const updated = { ...existing, status, completedAt: this.clock.now().toISOString() };
+    await this.persistence.update(current.revision, (manifest) => ({
+      ...manifest,
+      waitingForReproduction: false,
+      runs: manifest.runs.map((candidate) => candidate.id === runId ? updated : candidate)
+    }));
+    this.waitingReleases.get(runId)?.();
+    this.waitingReleases.delete(runId);
+    return updated;
+  }
+};
+
+// src/session/orphan-recovery.ts
+import { lstat as lstat2, readdir as readdir2, realpath as realpath6 } from "fs/promises";
+import path8 from "path";
+
+// src/investigation/store.ts
+import { readFile as readFile6, stat as stat2 } from "fs/promises";
+
+// src/session/atomic-json.ts
+import { randomBytes as randomBytes7 } from "crypto";
+import { open, rename as rename2, rm as rm3 } from "fs/promises";
+import path6 from "path";
+async function atomicWriteJson(filename, value, maximumBytes) {
+  const serialized = `${JSON.stringify(value)}
+`;
+  const bytes = Buffer.byteLength(serialized);
+  if (bytes > maximumBytes) throw new RangeError(`Serialized JSON exceeds ${maximumBytes} bytes`);
+  const temporary = path6.join(
+    path6.dirname(filename),
+    `${path6.basename(filename)}.next-${randomBytes7(8).toString("hex")}`
+  );
+  let handle;
+  try {
+    handle = await open(temporary, "wx", 384);
+    await handle.writeFile(serialized, "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await rename2(temporary, filename);
+    return bytes;
+  } catch (error2) {
+    await handle?.close().catch(() => void 0);
+    await rm3(temporary, { force: true }).catch(() => void 0);
+    throw error2;
+  }
+}
+
+// src/investigation/store.ts
+function initialInvestigationState(now) {
+  return InvestigationStateSchema.parse({
+    schemaVersion: STATE_SCHEMA_VERSION,
+    revision: 0,
+    updatedAt: now,
+    problemSummary: "",
+    expectedBehavior: "",
+    actualBehavior: "",
+    runtimeContext: { kind: "other", target: "" },
+    reproduction: { method: "", requiresUser: false, confirmed: null },
+    successCriteria: [],
+    phase: "intake",
+    loopIteration: 0,
+    singleCauseEvidenceRef: null,
+    hypotheses: [],
+    completedChecks: [],
+    runs: [],
+    probeRefs: [],
+    decidingEvidenceIds: [],
+    developerConfirmations: [],
+    decisions: [],
+    nextAction: "",
+    instrumentedFiles: [],
+    fixedFiles: [],
+    cleanup: { status: "not_started", completedResources: [] }
+  });
+}
+var InvestigationStore = class {
+  constructor(filename, clock = systemClock) {
+    this.filename = filename;
+    this.clock = clock;
+  }
+  filename;
+  clock;
+  tail = Promise.resolve();
+  async create(state) {
+    const parsed = this.validate(state);
+    try {
+      await stat2(this.filename);
+      throw new DebugModeError("STATE_INVALID", "Investigation checkpoint already exists");
+    } catch (error2) {
+      if (error2.code !== "ENOENT") throw error2;
+    }
+    return this.write(parsed);
+  }
+  async read() {
+    const recovery = await this.readRecovery();
+    if (!recovery.ok) throw new DebugModeError(recovery.error.code, recovery.error.message);
+    return recovery.state;
+  }
+  async readRecovery() {
+    let raw;
+    try {
+      const info = await stat2(this.filename);
+      if (info.size > LIMITS.checkpointBytes) {
+        return { ok: false, error: { code: "STATE_INVALID", message: "Checkpoint exceeds its byte limit" } };
+      }
+      raw = await readFile6(this.filename, "utf8");
+    } catch (error2) {
+      if (error2.code === "ENOENT") {
+        return { ok: false, error: { code: "STATE_MISSING", message: "Investigation checkpoint is missing" } };
+      }
+      return { ok: false, error: { code: "STATE_INVALID", message: "Investigation checkpoint could not be read" } };
+    }
+    try {
+      const value = JSON.parse(raw);
+      if (typeof value === "object" && value !== null && "schemaVersion" in value && value.schemaVersion !== STATE_SCHEMA_VERSION) {
+        return {
+          ok: false,
+          error: { code: "STATE_VERSION_UNSUPPORTED", message: "Investigation checkpoint version is unsupported" }
+        };
+      }
+      return { ok: true, state: InvestigationStateSchema.parse(value), warnings: [] };
+    } catch {
+      return { ok: false, error: { code: "STATE_INVALID", message: "Investigation checkpoint is invalid" } };
+    }
+  }
+  async checkpoint(expectedRevision, state) {
+    return this.exclusive(async () => {
+      const current = await this.read();
+      if (current.revision !== expectedRevision) {
+        throw new DebugModeError("STALE_REVISION", `Expected revision ${expectedRevision}; found ${current.revision}`);
+      }
+      const candidate = this.validate({
+        ...state,
+        revision: expectedRevision + 1,
+        updatedAt: this.clock.now().toISOString()
+      });
+      const bytes = await this.write(candidate);
+      return { state: candidate, bytes };
+    });
+  }
+  validate(value) {
+    const result = InvestigationStateSchema.safeParse(value);
+    if (!result.success) throw new DebugModeError("STATE_INVALID", "Investigation checkpoint failed schema validation");
+    const bytes = Buffer.byteLength(`${JSON.stringify(result.data)}
+`);
+    if (bytes > LIMITS.checkpointBytes)
+      throw new DebugModeError("STATE_TOO_LARGE", "Investigation checkpoint is too large");
+    return result.data;
+  }
+  async write(state) {
+    try {
+      return await atomicWriteJson(this.filename, state, LIMITS.checkpointBytes);
+    } catch (error2) {
+      if (error2 instanceof RangeError)
+        throw new DebugModeError("STATE_TOO_LARGE", "Investigation checkpoint is too large");
+      throw error2;
+    }
+  }
+  async exclusive(operation) {
+    const previous = this.tail;
+    let release;
+    this.tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+};
+
+// src/session/manifest-store.ts
+import { readFile as readFile7, realpath as realpath5, stat as stat3 } from "fs/promises";
+import path7 from "path";
+var MANIFEST_MAX_BYTES = 1024 * 1024;
+function createInitialManifest(input) {
+  const expiresAt = new Date(new Date(input.now).getTime() + LIMITS.idleMs).toISOString();
+  const candidate = {
+    package: PACKAGE_ID,
+    schemaVersion: MANIFEST_SCHEMA_VERSION,
+    revision: 0,
+    sessionId: input.sessionId,
+    trustedSessionHash: input.trustedSessionHash,
+    projectRoot: input.projectRoot,
+    sessionDir: input.sessionDir,
+    status: "active",
+    createdAt: input.now,
+    lastActivityAt: input.now,
+    expiresAt,
+    waitingForReproduction: false,
+    keepArtifacts: input.keepArtifacts ?? false,
+    collector: null,
+    runs: [],
+    processes: [],
+    probes: [],
+    ownedFiles: [],
+    permissionChanges: [],
+    counters: { accepted: 0, rejected: 0, sampled: 0, truncated: 0, dropped: 0, requests: 0 },
+    cleanup: { status: "not_started", completedResources: [] },
+    ...input.retentionDestination === void 0 ? {} : { retentionDestination: input.retentionDestination }
+  };
+  return ManifestSchema.parse(candidate);
+}
+var ManifestStore = class {
+  constructor(filename) {
+    this.filename = filename;
+  }
+  filename;
+  tail = Promise.resolve();
+  async create(value) {
+    return this.exclusive(async () => {
+      const parsed = ManifestSchema.parse(value);
+      await this.verifyPaths(parsed);
+      try {
+        await stat3(this.filename);
+        throw new DebugModeError("SESSION_EXISTS", "Session manifest already exists");
+      } catch (error2) {
+        if (error2.code !== "ENOENT") throw error2;
+      }
+      await atomicWriteJson(this.filename, parsed, MANIFEST_MAX_BYTES);
+      return parsed;
+    });
+  }
+  async read() {
+    const info = await stat3(this.filename);
+    if (info.size > MANIFEST_MAX_BYTES) throw new Error("Manifest exceeds its byte limit");
+    const parsed = ManifestSchema.parse(JSON.parse(await readFile7(this.filename, "utf8")));
+    await this.verifyPaths(parsed);
+    return parsed;
+  }
+  async update(expectedRevision, mutate) {
+    return this.exclusive(async () => {
+      const current = await this.read();
+      if (current.revision !== expectedRevision) {
+        throw new DebugModeError("STALE_REVISION", `Expected revision ${expectedRevision}; found ${current.revision}`);
+      }
+      return this.writeNext(current, mutate);
+    });
+  }
+  async modify(mutate) {
+    return this.exclusive(async () => this.writeNext(await this.read(), mutate));
+  }
+  async writeNext(current, mutate) {
+    const next = ManifestSchema.parse({ ...mutate(structuredClone(current)), revision: current.revision + 1 });
+    await this.verifyPaths(next);
+    await atomicWriteJson(this.filename, next, MANIFEST_MAX_BYTES);
+    return next;
+  }
+  async verifyPaths(value) {
+    const actualSessionDir = await realpath5(path7.dirname(this.filename));
+    const declaredSessionDir = await realpath5(value.sessionDir);
+    if (actualSessionDir !== declaredSessionDir)
+      throw new Error("Manifest session directory does not match its location");
+    const packageBase = await realpath5(path7.dirname(actualSessionDir));
+    if (!isContained(packageBase, actualSessionDir)) throw new Error("Manifest is outside the package temporary base");
+    if (await realpath5(value.projectRoot) !== value.projectRoot) {
+      throw new Error("Manifest project root is not canonical");
+    }
+  }
+  async exclusive(operation) {
+    const previous = this.tail;
+    let release;
+    this.tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+};
+
+// src/session/secret-store.ts
+import { randomBytes as randomBytes8 } from "crypto";
+import { readFile as readFile8, unlink, writeFile as writeFile5 } from "fs/promises";
+var TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+var SecretStore = class {
+  constructor(filename) {
+    this.filename = filename;
+  }
+  filename;
+  async create() {
+    const value = randomBytes8(32).toString("base64url");
+    await writeFile5(this.filename, value, { flag: "wx", mode: 384 });
+    return value;
+  }
+  async read() {
+    const value = await readFile8(this.filename, "utf8");
+    if (!TOKEN_PATTERN.test(value) || Buffer.from(value, "base64url").byteLength !== 32) {
+      throw new Error("Stored collector credential is invalid");
+    }
+    return value;
+  }
+  async remove() {
+    let length;
+    try {
+      length = (await readFile8(this.filename)).byteLength;
+    } catch (error2) {
+      if (error2.code === "ENOENT") return "already-clean";
+      throw error2;
+    }
+    try {
+      await writeFile5(this.filename, randomBytes8(length), { flag: "r+" });
+    } catch {
+    }
+    try {
+      await unlink(this.filename);
+      return "success";
+    } catch (error2) {
+      if (error2.code === "ENOENT") return "already-clean";
+      throw error2;
+    }
+  }
+};
+
+// src/session/orphan-recovery.ts
+async function assertContainedReference(target, roots) {
+  const absolute = path8.resolve(target);
+  if (!roots.some((root) => absolute === root || isContained(root, absolute))) {
+    throw new Error("Manifest path escapes its owned roots");
+  }
+  try {
+    const canonical = await realpath6(absolute);
+    if (!roots.some((root) => canonical === root || isContained(root, canonical))) {
+      throw new Error("Manifest path resolves outside its owned roots");
+    }
+  } catch (error2) {
+    if (error2.code !== "ENOENT") throw error2;
+  }
+}
+async function recoverOrphans(options) {
+  const cleaned = [];
+  const ignored = [];
+  const errors = [];
+  let entries;
+  try {
+    entries = await readdir2(options.tempBase, { withFileTypes: true });
+  } catch (error2) {
+    if (error2.code === "ENOENT") return { cleaned, ignored, errors };
+    throw error2;
+  }
+  const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("session-")) {
+      ignored.push(entry.name);
+      continue;
+    }
+    const sessionDir = path8.join(options.tempBase, entry.name);
+    try {
+      if ((await lstat2(sessionDir)).isSymbolicLink()) {
+        ignored.push(entry.name);
+        continue;
+      }
+      const canonicalSessionDir = await realpath6(sessionDir);
+      if (options.activeSessionDirs?.has(canonicalSessionDir) === true) {
+        ignored.push(entry.name);
+        continue;
+      }
+      const manifestStore = new ManifestStore(path8.join(sessionDir, "manifest.json"));
+      const manifest = await manifestStore.read();
+      const canonicalProjectRoot = await realpath6(manifest.projectRoot);
+      if (await realpath6(manifest.sessionDir) !== canonicalSessionDir || new Date(manifest.expiresAt).getTime() >= now) {
+        ignored.push(entry.name);
+        continue;
+      }
+      for (const probe of manifest.probes) {
+        await assertContainedReference(probe.sourceFile, [canonicalProjectRoot]);
+      }
+      for (const permission of manifest.permissionChanges) {
+        await assertContainedReference(permission.manifestPath, [canonicalProjectRoot]);
+      }
+      for (const owned of manifest.ownedFiles) {
+        await assertContainedReference(owned.path, [canonicalProjectRoot, canonicalSessionDir]);
+      }
+      const paths = Object.freeze({
+        baseDir: options.tempBase,
+        sessionDir: manifest.sessionDir,
+        projectRoot: canonicalProjectRoot,
+        manifestFile: path8.join(manifest.sessionDir, "manifest.json"),
+        secretFile: path8.join(manifest.sessionDir, "secret.bin"),
+        stateFile: path8.join(manifest.sessionDir, "investigation-state.json"),
+        evidenceFile: path8.join(manifest.sessionDir, "evidence.ndjson")
+      });
+      const secretStore = new SecretStore(paths.secretFile);
+      const secret = await secretStore.read().catch(() => "");
+      const session = {
+        publicId: manifest.sessionId,
+        trustedHash: manifest.trustedSessionHash,
+        projectRoot: canonicalProjectRoot,
+        directory: canonicalProjectRoot,
+        paths,
+        manifestStore,
+        investigationStore: new InvestigationStore(paths.stateFile),
+        secretStore,
+        secret
+      };
+      if (options.cleanup !== void 0) await options.cleanup(session, manifest);
+      else {
+        const report = {
+          outcome: "abandoned",
+          rootCause: "Investigation ended after its orphaned session expired",
+          decidingEvidence: [],
+          hypotheses: [],
+          fix: "No recovery-time fix was applied",
+          changedFiles: [],
+          verification: ["Verified package-owned cleanup during startup recovery"]
+        };
+        await new CleanupService(session).run({ reason: "orphan-recovery", finalReport: report });
+      }
+      cleaned.push(manifest.sessionId);
+    } catch (error2) {
+      errors.push({
+        directory: entry.name,
+        reason: error2 instanceof Error ? error2.name.slice(0, 128) : "recovery-failed"
+      });
+    }
+  }
+  return { cleaned, ignored, errors };
+}
+
+// src/session/registry.ts
+import { createHash as createHash8, randomBytes as randomBytes9 } from "crypto";
+import { lstat as lstat3, readdir as readdir3, realpath as realpath7, rm as rm4 } from "fs/promises";
+import path9 from "path";
+function trustedSessionHash(openCodeSessionId) {
+  return createHash8("sha256").update("opencode-debug-mode:v1:", "utf8").update(openCodeSessionId, "utf8").digest("hex");
+}
+var SessionRegistry = class {
+  constructor(tempBase, clock = systemClock, cleanup) {
+    this.tempBase = tempBase;
+    this.clock = clock;
+    this.cleanup = cleanup;
+    this.timer = setInterval(() => void this.sweep(), 3e4);
+    this.timer.unref();
+  }
+  tempBase;
+  clock;
+  cleanup;
+  sessions = /* @__PURE__ */ new Map();
+  timer;
+  closed = false;
+  async start(trustedId, context, options = {}) {
+    this.assertOpen();
+    if (Number(process.versions.node.split(".")[0]) < 20) {
+      throw new DebugModeError("NODE_UNSUPPORTED", "Node.js 20 or newer is required");
+    }
+    if (options.keepArtifacts === true && options.retentionDestination === void 0) {
+      throw new DebugModeError("DESTINATION_REQUIRED", "An explicit retention destination is required");
+    }
+    const hash = trustedSessionHash(trustedId);
+    if (this.sessions.has(hash) || await this.findPersisted(hash) !== void 0) {
+      throw new DebugModeError("SESSION_EXISTS", "A debug session already exists for this OpenCode session");
+    }
+    const projectRoot = await realpath7(context.worktree);
+    const directory = await realpath7(context.directory);
+    if (directory !== projectRoot && !isContained(projectRoot, directory)) {
+      throw new DebugModeError("STORAGE_UNAVAILABLE", "The active directory is outside the worktree");
+    }
+    let paths;
+    try {
+      paths = await createSessionPaths(this.tempBase, projectRoot);
+      const secretStore = new SecretStore(paths.secretFile);
+      const secret = await secretStore.create();
+      const publicId = `session_${randomBytes9(16).toString("base64url")}`;
+      const manifestStore = new ManifestStore(paths.manifestFile);
+      const investigationStore = new InvestigationStore(paths.stateFile, this.clock);
+      const now = this.clock.now().toISOString();
+      await manifestStore.create(
+        createInitialManifest({
+          sessionId: publicId,
+          trustedSessionHash: hash,
+          projectRoot,
+          sessionDir: paths.sessionDir,
+          now,
+          keepArtifacts: options.keepArtifacts ?? false,
+          ...options.retentionDestination === void 0 ? {} : { retentionDestination: path9.resolve(options.retentionDestination) }
+        })
+      );
+      await investigationStore.create(initialInvestigationState(now));
+      const session = {
+        publicId,
+        trustedHash: hash,
+        projectRoot,
+        directory,
+        paths,
+        manifestStore,
+        investigationStore,
+        secretStore,
+        secret,
+        leases: /* @__PURE__ */ new Map()
+      };
+      this.sessions.set(hash, session);
+      return session;
+    } catch (error2) {
+      if (paths !== void 0) await rm4(paths.sessionDir, { recursive: true, force: true }).catch(() => void 0);
+      if (error2 instanceof DebugModeError) throw error2;
+      throw new DebugModeError("STORAGE_UNAVAILABLE", "The debug session could not be initialized");
+    }
+  }
+  async requireOwned(trustedId) {
+    this.assertOpen();
+    const hash = trustedSessionHash(trustedId);
+    const inMemory = this.sessions.get(hash);
+    if (inMemory !== void 0) return inMemory;
+    const persisted = await this.findPersisted(hash);
+    if (persisted === void 0) throw new DebugModeError("NO_ACTIVE_SESSION", "No active debug session exists");
+    this.sessions.set(hash, persisted);
+    return persisted;
+  }
+  async hasTrusted(trustedId) {
+    try {
+      await this.requireOwned(trustedId);
+      return true;
+    } catch (error2) {
+      if (error2 instanceof DebugModeError && error2.code === "NO_ACTIVE_SESSION") return false;
+      throw error2;
+    }
+  }
+  async touch(trustedId) {
+    const session = await this.requireOwned(trustedId);
+    await this.touchSession(session);
+  }
+  async touchSession(sessionValue) {
+    const session = this.sessions.get(sessionValue.trustedHash);
+    if (session === void 0 || session.publicId !== sessionValue.publicId) {
+      throw new DebugModeError("SESSION_OWNERSHIP_MISMATCH", "Session is not owned by this registry");
+    }
+    const now = this.clock.now();
+    await session.manifestStore.modify((manifest) => ({
+      ...manifest,
+      lastActivityAt: now.toISOString(),
+      expiresAt: new Date(now.getTime() + LIMITS.idleMs).toISOString()
+    }));
+  }
+  async acquireLease(trustedId, kind) {
+    const session = await this.requireOwned(trustedId);
+    return this.acquireLeaseForSession(session, kind);
+  }
+  acquireLeaseForSession(sessionValue, kind) {
+    const session = this.sessions.get(sessionValue.trustedHash);
+    if (session === void 0 || session.publicId !== sessionValue.publicId) {
+      throw new DebugModeError("SESSION_OWNERSHIP_MISMATCH", "Session is not owned by this registry");
+    }
+    session.leases.set(kind, (session.leases.get(kind) ?? 0) + 1);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const next = Math.max(0, (session.leases.get(kind) ?? 1) - 1);
+      if (next === 0) session.leases.delete(kind);
+      else session.leases.set(kind, next);
+    };
+  }
+  async sweep() {
+    if (this.closed) return;
+    const now = this.clock.now().getTime();
+    for (const [hash, session] of this.sessions) {
+      const manifest = await session.manifestStore.read().catch(() => void 0);
+      if (manifest === void 0 || manifest.waitingForReproduction || session.leases.size > 0 || new Date(manifest.lastActivityAt).getTime() + LIMITS.idleMs > now) {
+        continue;
+      }
+      if (this.cleanup !== void 0) await this.cleanup(session, "idle-expired");
+      this.sessions.delete(hash);
+    }
+  }
+  listActive() {
+    return [...this.sessions.values()];
+  }
+  forgetTrusted(trustedId) {
+    this.sessions.delete(trustedSessionHash(trustedId));
+  }
+  async closeAll() {
+    if (this.closed) return;
+    this.closed = true;
+    clearInterval(this.timer);
+    this.sessions.clear();
+  }
+  async findPersisted(hash) {
+    let entries;
+    try {
+      entries = await readdir3(this.tempBase, { withFileTypes: true, encoding: "utf8" });
+    } catch (error2) {
+      if (error2.code === "ENOENT") return void 0;
+      throw error2;
+    }
+    const matches2 = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !entry.name.startsWith("session-")) continue;
+      const sessionDir = path9.join(this.tempBase, entry.name);
+      if ((await lstat3(sessionDir)).isSymbolicLink()) continue;
+      try {
+        const manifestStore = new ManifestStore(path9.join(sessionDir, "manifest.json"));
+        const manifest = await manifestStore.read();
+        if (manifest.trustedSessionHash !== hash || manifest.status !== "active") continue;
+        if (!manifest.waitingForReproduction && new Date(manifest.expiresAt).getTime() < this.clock.now().getTime())
+          continue;
+        const paths = this.pathsFromManifest(manifest);
+        const secretStore = new SecretStore(paths.secretFile);
+        const secret = await secretStore.read();
+        const investigationStore = new InvestigationStore(paths.stateFile, this.clock);
+        const recovery = await investigationStore.readRecovery();
+        if (!recovery.ok) throw new DebugModeError(recovery.error.code, recovery.error.message);
+        matches2.push({
+          publicId: manifest.sessionId,
+          trustedHash: hash,
+          projectRoot: manifest.projectRoot,
+          directory: manifest.projectRoot,
+          paths,
+          manifestStore,
+          investigationStore,
+          secretStore,
+          secret,
+          leases: /* @__PURE__ */ new Map()
+        });
+      } catch {
+      }
+    }
+    if (matches2.length > 1) {
+      throw new DebugModeError("SESSION_OWNERSHIP_MISMATCH", "Multiple session manifests match this trusted session");
+    }
+    return matches2[0];
+  }
+  pathsFromManifest(manifest) {
+    return Object.freeze({
+      baseDir: this.tempBase,
+      sessionDir: manifest.sessionDir,
+      projectRoot: manifest.projectRoot,
+      manifestFile: path9.join(manifest.sessionDir, "manifest.json"),
+      secretFile: path9.join(manifest.sessionDir, "secret.bin"),
+      stateFile: path9.join(manifest.sessionDir, "investigation-state.json"),
+      evidenceFile: path9.join(manifest.sessionDir, "evidence.ndjson")
+    });
+  }
+  assertOpen() {
+    if (this.closed) throw new DebugModeError("NO_ACTIVE_SESSION", "The session registry is closed");
+  }
+};
+
+// src/tools/cleanup-tool.ts
+import path10 from "path";
+import { tool } from "@opencode-ai/plugin";
+
+// src/core/result.ts
+function success(data, warnings = []) {
+  return { ok: true, data, warnings };
+}
+function failure(code, message, retryable, options = {}) {
+  const error2 = {
+    code,
+    message: message.slice(0, 8192),
+    retryable
+  };
+  if (options.action !== void 0) error2.action = options.action.slice(0, 8192);
+  if (options.details !== void 0) error2.details = options.details;
+  return { ok: false, error: error2 };
+}
+
+// src/tools/common.ts
+function jsonSuccess(value) {
+  return JSON.stringify(success(value));
+}
+function jsonFailure(error2, fallback = "Tool operation failed") {
+  if (error2 instanceof DebugModeError) {
+    return JSON.stringify(
+      failure(error2.code, error2.message, error2.retryable, {
+        ...error2.action === void 0 ? {} : { action: error2.action },
+        ...error2.details === void 0 ? {} : { details: error2.details }
+      })
+    );
+  }
+  return JSON.stringify(failure("INTERNAL_ERROR", fallback, false));
+}
+
+// src/tools/cleanup-tool.ts
+var schema = tool.schema;
+var reportSchema = schema.object({
+  outcome: schema.enum(["completed", "unresolved", "abandoned", "escalated"]),
+  rootCause: schema.string().max(8192),
+  decidingEvidence: schema.array(schema.string().max(8192)).max(100),
+  hypotheses: schema.array(
+    schema.object({
+      id: schema.string().max(64),
+      status: schema.enum(["open", "confirmed", "eliminated"]),
+      statement: schema.string().max(8192)
+    }).strict()
+  ).max(4),
+  fix: schema.string().max(8192),
+  changedFiles: schema.array(schema.string().max(8192)).max(200),
+  verification: schema.array(schema.string().max(8192)).max(100)
+}).strict();
+function createCleanupTool(registry, cleanupFor) {
+  return tool({
+    description: "Tear down every owned debug resource and optionally retain a sanitized report",
+    args: {
+      reason: schema.enum(["completed", "unresolved", "abandoned", "escalated", "cancelled"]),
+      finalReport: reportSchema,
+      cleanCheck: schema.object({
+        executable: schema.string().min(1).max(8192),
+        args: schema.array(schema.string().max(8192)).max(256),
+        cwd: schema.string().min(1).max(8192),
+        timeoutMs: schema.number().int().min(1).max(3e5)
+      }).strict().optional()
+    },
+    execute: async (args, context) => {
+      try {
+        const session = await registry.requireOwned(context.sessionID);
+        const result = await cleanupFor(session).run({
+          reason: args.reason,
+          finalReport: args.finalReport,
+          ...args.cleanCheck === void 0 ? {} : { cleanCheck: args.cleanCheck }
+        });
+        const sanitize = (location) => {
+          if (location === void 0) return void 0;
+          const absolute = path10.resolve(location);
+          return absolute === session.projectRoot || isContained(session.projectRoot, absolute) ? path10.relative(session.projectRoot, absolute) || "." : void 0;
+        };
+        const resources = {
+          ...result.resources,
+          probes: result.resources.probes.map((value) => ({ ...value, location: sanitize(value.location) })),
+          permissions: result.resources.permissions.map((value) => ({ ...value, location: sanitize(value.location) })),
+          files: result.resources.files.map((value) => ({ ...value, location: sanitize(value.location) }))
+        };
+        return jsonSuccess({
+          ...result,
+          resources,
+          remainingArtifacts: result.remainingArtifacts.map(sanitize).filter(Boolean)
+        });
+      } catch (error2) {
+        return jsonFailure(error2, "Cleanup failed");
+      }
+    }
+  });
+}
+
+// src/tools/collector-tools.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+var schema2 = tool2.schema;
+function createCollectorStartTool(registry, collectorFor) {
+  return tool2({
+    description: "Start the authenticated loopback evidence collector",
+    args: {
+      runtime: schema2.enum(["web", "extension-background"]),
+      transportTargetPath: schema2.string().min(1).max(8192).optional(),
+      extensionManifestPath: schema2.string().min(1).max(8192).optional()
+    },
+    execute: async (args, context) => {
+      try {
+        const session = await registry.requireOwned(context.sessionID);
+        const result = await collectorFor(session).start({
+          runtime: args.runtime,
+          ...args.transportTargetPath === void 0 ? {} : { transportTargetPath: args.transportTargetPath },
+          ...args.extensionManifestPath === void 0 ? {} : { extensionManifestPath: args.extensionManifestPath }
+        });
+        await registry.touch(context.sessionID);
+        return jsonSuccess(result);
+      } catch (error2) {
+        return jsonFailure(error2, "Collector startup failed");
+      }
+    }
+  });
+}
+
+// src/tools/evidence-tools.ts
+import { tool as tool3 } from "@opencode-ai/plugin";
+var schema3 = tool3.schema;
+function createEvidenceReadTool(registry, evidenceFor) {
+  return tool3({
+    description: "Read a bounded filtered page of sanitized local evidence",
+    args: {
+      runId: schema3.string().optional(),
+      hypothesisId: schema3.string().optional(),
+      probeId: schema3.string().optional(),
+      from: schema3.string().optional(),
+      to: schema3.string().optional(),
+      keyword: schema3.string().max(8192).optional(),
+      cursor: schema3.string().regex(/^\d+$/).optional(),
+      limit: schema3.number().int().min(1).max(100).default(100)
+    },
+    execute: async (args, context) => {
+      try {
+        const session = await registry.requireOwned(context.sessionID);
+        const result = await evidenceFor(session).read({
+          sessionId: session.publicId,
+          limit: args.limit,
+          ...args.runId === void 0 ? {} : { runId: args.runId },
+          ...args.hypothesisId === void 0 ? {} : { hypothesisId: args.hypothesisId },
+          ...args.probeId === void 0 ? {} : { probeId: args.probeId },
+          ...args.from === void 0 ? {} : { from: args.from },
+          ...args.to === void 0 ? {} : { to: args.to },
+          ...args.keyword === void 0 ? {} : { keyword: args.keyword },
+          ...args.cursor === void 0 ? {} : { cursor: args.cursor }
+        });
+        await registry.touch(context.sessionID);
+        return jsonSuccess(result);
+      } catch (error2) {
+        return jsonFailure(error2, "Evidence is unavailable");
+      }
+    }
+  });
+}
+
+// src/tools/probe-tools.ts
+import path11 from "path";
+import { tool as tool4 } from "@opencode-ai/plugin";
+var schema4 = tool4.schema;
+function createProbePrepareTool(registry, probesFor) {
+  return tool4({
+    description: "Prepare one safe owned JavaScript or TypeScript probe",
+    args: {
+      runId: schema4.string().regex(/^[A-Za-z0-9_-]+$/),
+      hypothesisId: schema4.string().regex(/^[A-Za-z0-9_-]+$/),
+      sourceFile: schema4.string().min(1).max(8192),
+      sourceLine: schema4.number().int().positive(),
+      sourceColumn: schema4.number().int().positive().optional(),
+      message: schema4.string().min(1).max(8192),
+      captures: schema4.array(
+        schema4.object({ label: schema4.string().min(1).max(128), path: schema4.string().min(1).max(512) }).strict()
+      ).max(20),
+      transport: schema4.enum(["process", "http-web", "extension-background", "extension-content"]),
+      sampling: schema4.union([
+        schema4.object({ mode: schema4.literal("every"), n: schema4.number().int().min(1).max(1e4) }).strict(),
+        schema4.object({ mode: schema4.literal("aggregate"), windowMs: schema4.number().int().min(100).max(6e4) }).strict()
+      ])
+    },
+    execute: async (args, context) => {
+      try {
+        const session = await registry.requireOwned(context.sessionID);
+        const { sourceColumn, ...required } = args;
+        const probe = await probesFor(session).plan({
+          ...required,
+          ...sourceColumn === void 0 ? {} : { sourceColumn }
+        });
+        await registry.touch(context.sessionID);
+        return jsonSuccess({
+          probeId: probe.id,
+          markerBlock: probe.markerBlock,
+          source: path11.relative(session.projectRoot, probe.sourceFile),
+          line: probe.sourceLine
+        });
+      } catch (error2) {
+        return jsonFailure(error2, "Probe preparation failed");
+      }
+    }
+  });
+}
+function createProbeRegisterTool(registry, probesFor) {
+  return tool4({
+    description: "Verify and register an exact owned probe marker",
+    args: { probeId: schema4.string().regex(/^[A-Za-z0-9_-]+$/) },
+    execute: async (args, context) => {
+      try {
+        const session = await registry.requireOwned(context.sessionID);
+        const probe = await probesFor(session).register(args.probeId);
+        await registry.touch(context.sessionID);
+        return jsonSuccess({ probeId: probe.id, status: probe.status, validationStatus: probe.validationStatus });
+      } catch (error2) {
+        return jsonFailure(error2, "Probe registration failed");
+      }
+    }
+  });
+}
+
+// src/tools/run-tools.ts
+import path12 from "path";
+import { tool as tool5 } from "@opencode-ai/plugin";
+var schema5 = tool5.schema;
+var ApprovalClassSchema = schema5.enum([
+  "local-deterministic",
+  "credentials",
+  "device",
+  "external-state",
+  "materially-different"
+]);
+var ProcessArgs = {
+  approvalClass: ApprovalClassSchema,
+  purpose: schema5.enum(["instrumentation-check", "reproduction", "verification"]),
+  probeIds: schema5.array(schema5.string().regex(/^[A-Za-z0-9_-]+$/)).max(100),
+  executable: schema5.string().min(1).max(8192),
+  args: schema5.array(schema5.string().max(8192)).max(256),
+  cwd: schema5.string().min(1).max(8192),
+  env: schema5.record(schema5.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), schema5.string().max(8192)).refine((value) => Object.keys(value).length <= 256),
+  runId: schema5.string().regex(/^[A-Za-z0-9_-]+$/),
+  timeoutMs: schema5.number().int().min(1).max(3e5)
+};
+async function requestApproval(context, permission, executable, args) {
+  try {
+    await context.ask({
+      permission,
+      patterns: [[path12.basename(executable), ...args.map((value) => path12.basename(value))].join(" ").slice(0, 512)],
+      always: [],
+      metadata: { executable: path12.basename(executable), argumentCount: args.length }
+    });
+  } catch {
+    throw new DebugModeError("COMMAND_REQUIRES_APPROVAL", "The requested process command was not approved");
+  }
+}
+function serializeResult(result) {
+  return JSON.stringify(success(result));
+}
+function createProcessCaptureTool(dependencies) {
+  return tool5({
+    description: "Run one supervised command and capture bounded runtime evidence",
+    args: ProcessArgs,
+    execute: async (args, context) => {
+      try {
+        const session = await dependencies.registry.requireOwned(context.sessionID);
+        if (args.approvalClass !== "local-deterministic") {
+          await requestApproval(context, "debug_process_external", args.executable, args.args);
+        }
+        const resolvedCwd = path12.resolve(args.cwd);
+        const worktree = path12.resolve(context.worktree);
+        if (resolvedCwd !== worktree && !isContained(worktree, resolvedCwd)) {
+          await requestApproval(context, "external_directory", args.executable, args.args);
+        }
+        const probes = dependencies.probesFor(session);
+        if (args.purpose === "reproduction") await probes.requireValidatedForRun(args.runId);
+        const result = await dependencies.processFor(session).capture({
+          runId: args.runId,
+          executable: args.executable,
+          args: args.args,
+          cwd: resolvedCwd,
+          env: args.env,
+          timeoutMs: args.timeoutMs,
+          probeIds: args.probeIds,
+          purpose: args.purpose,
+          signal: context.abort
+        });
+        if (args.purpose === "instrumentation-check" && result.exitCode === 0) await probes.validate(args.probeIds);
+        return serializeResult(result);
+      } catch (error2) {
+        if (error2 instanceof DebugModeError) {
+          return JSON.stringify(
+            failure(error2.code, error2.message, error2.retryable, {
+              ...error2.action === void 0 ? {} : { action: error2.action },
+              ...error2.details === void 0 ? {} : { details: error2.details }
+            })
+          );
+        }
+        return JSON.stringify(failure("INTERNAL_ERROR", "Process capture failed", false));
+      }
+    }
+  });
+}
+function createRunStartTool(registry, runFor) {
+  return tool5({
+    description: "Start a correlated pre-fix or post-fix reproduction run",
+    args: {
+      label: schema5.enum(["pre-fix", "post-fix"]),
+      reproduction: schema5.string().min(1).max(8192),
+      waitingForUser: schema5.boolean().default(false)
+    },
+    execute: async (args, context) => {
+      try {
+        const session = await registry.requireOwned(context.sessionID);
+        const run = await runFor(session).start(args);
+        await registry.touch(context.sessionID);
+        return JSON.stringify(success({ runId: run.id, status: run.status, label: run.label }));
+      } catch (error2) {
+        if (error2 instanceof DebugModeError) return JSON.stringify(failure(error2.code, error2.message, error2.retryable));
+        return JSON.stringify(failure("INTERNAL_ERROR", "Run could not be started", false));
+      }
+    }
+  });
+}
+
+// src/tools/session-tools.ts
+import { tool as tool6 } from "@opencode-ai/plugin";
+var schema6 = tool6.schema;
+function createSessionStartTool(registry) {
+  return tool6({
+    description: "Start an isolated runtime-debugging session",
+    args: {
+      keepArtifacts: schema6.boolean().default(false),
+      retentionDestination: schema6.string().min(1).max(8192).optional()
+    },
+    execute: async (args, context) => {
+      try {
+        const session = await registry.start(
+          context.sessionID,
+          { directory: context.directory, worktree: context.worktree },
+          {
+            keepArtifacts: args.keepArtifacts,
+            ...args.retentionDestination === void 0 ? {} : { retentionDestination: args.retentionDestination }
+          }
+        );
+        return jsonSuccess({
+          sessionId: session.publicId,
+          status: "active",
+          limits: LIMITS,
+          capabilities: { process: true, web: true, extension: true, languages: ["javascript", "typescript"] }
+        });
+      } catch (error2) {
+        return jsonFailure(error2, "Debug session could not be started");
+      }
+    }
+  });
+}
+function createSessionStatusTool(registry) {
+  return tool6({
+    description: "Read the public status of the active debug session",
+    args: {},
+    execute: async (_args, context) => {
+      try {
+        const session = await registry.requireOwned(context.sessionID);
+        const manifest = await session.manifestStore.read();
+        const state = await session.investigationStore.readRecovery();
+        return jsonSuccess({
+          sessionId: session.publicId,
+          status: manifest.status,
+          phase: state.ok ? state.state.phase : "recovery-required",
+          revision: state.ok ? state.state.revision : manifest.revision,
+          collector: manifest.collector === null ? null : { status: manifest.collector.status, host: manifest.collector.host, port: manifest.collector.port },
+          processCount: manifest.processes.length,
+          probeCount: manifest.probes.length,
+          counters: manifest.counters,
+          limits: LIMITS
+        });
+      } catch (error2) {
+        return jsonFailure(error2, "Debug session status is unavailable");
+      }
+    }
+  });
+}
+
+// src/tools/state-tools.ts
+import { tool as tool7 } from "@opencode-ai/plugin";
+var schema7 = tool7.schema;
+function createStateReadTool(registry) {
+  return tool7({
+    description: "Read and reconcile the durable investigation checkpoint",
+    args: {},
+    execute: async (_args, context) => {
+      try {
+        const session = await registry.requireOwned(context.sessionID);
+        const result = await session.investigationStore.readRecovery();
+        if (!result.ok) throw Object.assign(new Error(result.error.message), { code: result.error.code });
+        return jsonSuccess({ state: result.state, recoveryWarnings: result.warnings });
+      } catch (error2) {
+        if (typeof error2 === "object" && error2 !== null && "code" in error2) {
+          const value = error2;
+          const { DebugModeError: DebugModeError2 } = await import("./errors-IQTPGK5R.js");
+          return jsonFailure(new DebugModeError2(value.code, value.message), "Checkpoint is unavailable");
+        }
+        return jsonFailure(error2, "Checkpoint is unavailable");
+      }
+    }
+  });
+}
+function createStateCheckpointTool(registry) {
+  return tool7({
+    description: "Atomically replace the durable investigation checkpoint",
+    args: { expectedRevision: schema7.number().int().nonnegative(), state: schema7.unknown() },
+    execute: async (args, context) => {
+      try {
+        const session = await registry.requireOwned(context.sessionID);
+        const result = await session.investigationStore.checkpoint(
+          args.expectedRevision,
+          args.state
+        );
+        await registry.touch(context.sessionID);
+        return jsonSuccess({ revision: result.state.revision, bytes: result.bytes });
+      } catch (error2) {
+        return jsonFailure(error2, "Checkpoint update failed");
+      }
+    }
+  });
+}
+
+// src/tools/index.ts
+function createDebugTools(dependencies) {
+  return {
+    debug_session_start: createSessionStartTool(dependencies.registry),
+    debug_session_status: createSessionStatusTool(dependencies.registry),
+    debug_state_read: createStateReadTool(dependencies.registry),
+    debug_state_checkpoint: createStateCheckpointTool(dependencies.registry),
+    debug_run_start: createRunStartTool(dependencies.registry, dependencies.runFor),
+    debug_process_capture: createProcessCaptureTool(dependencies),
+    debug_collector_start: createCollectorStartTool(dependencies.registry, dependencies.collectorFor),
+    debug_probe_prepare: createProbePrepareTool(dependencies.registry, dependencies.probesFor),
+    debug_probe_register: createProbeRegisterTool(dependencies.registry, dependencies.probesFor),
+    debug_evidence_read: createEvidenceReadTool(dependencies.registry, dependencies.evidenceFor),
+    debug_cleanup: createCleanupTool(dependencies.registry, dependencies.cleanupFor)
+  };
+}
+
+// src/plugin.ts
+async function updateManifest(session, mutate) {
+  return session.manifestStore.modify(mutate);
+}
+function terminalReport(outcome, reason) {
+  return {
+    outcome,
+    rootCause: reason,
+    decidingEvidence: [],
+    hypotheses: [],
+    fix: "No additional fix was applied during lifecycle cleanup",
+    changedFiles: [],
+    verification: ["Package-owned resources were cleaned by the lifecycle hook"]
+  };
+}
+function createDebugModePlugin(options = {}) {
+  return async (input) => {
+    const prompt = await readFile9(new URL("../assets/debug-agent.md", import.meta.url), "utf8");
+    const tempBase = options.tempBase ?? path13.join(tmpdir(), TEMP_BASE_NAME);
+    const clock = options.clock ?? systemClock;
+    const recovery = await recoverOrphans({ tempBase, now: clock.now() }).catch((error2) => ({
+      cleaned: [],
+      ignored: [],
+      errors: [{ directory: "<temp-base>", reason: error2 instanceof Error ? error2.name : "recovery-failed" }]
+    }));
+    if (recovery.errors.length > 0) {
+      await input.client.app.log({
+        body: {
+          service: "opencode-debug-mode",
+          level: "warn",
+          message: `Orphan recovery reported ${recovery.errors.length} failure(s)`
+        }
+      });
+    }
+    const services = /* @__PURE__ */ new Map();
+    let registry;
+    const forSession = (session) => {
+      const existing = services.get(session.publicId);
+      if (existing !== void 0) return existing;
+      const evidence = new EvidenceStore(
+        session.paths.evidenceFile,
+        async (counters) => {
+          await updateManifest(session, (manifest) => ({ ...manifest, counters })).catch(() => void 0);
+        },
+        clock,
+        async () => (await session.manifestStore.read()).counters
+      );
+      const runs = new RunService(
+        session.manifestStore,
+        clock,
+        (kind) => registry.acquireLeaseForSession(session, kind)
+      );
+      const probes = new ProbeRegistry(session.manifestStore, session.projectRoot, async (id) => {
+        const state = await session.investigationStore.read();
+        return state.hypotheses.some((hypothesis) => hypothesis.id === id);
+      });
+      const sampleCounts = /* @__PURE__ */ new Map();
+      const processService = new ProcessService({
+        session,
+        runs,
+        evidence,
+        probes,
+        acquireLease: async () => registry.acquireLeaseForSession(session, "process")
+      });
+      let collectorServer;
+      const collector = {
+        start: async (request) => {
+          const manifest = await session.manifestStore.read();
+          if (manifest.collector !== null) throw new DebugModeError("COLLECTOR_EXISTS", "A collector is already active");
+          const ingest = createIngestHandler({
+            evidence,
+            validateEvent: (event) => probes.validateEvent(event),
+            sample: async (event) => {
+              const probe = (await session.manifestStore.read()).probes.find(
+                (candidate) => candidate.id === event.probeId
+              );
+              if (probe?.sampling.mode !== "every" || probe.sampling.n === 1) return false;
+              const count = (sampleCounts.get(probe.id) ?? 0) + 1;
+              sampleCounts.set(probe.id, count);
+              return count % probe.sampling.n !== 0;
+            }
+          });
+          collectorServer = new CollectorServer(
+            createCollectorRouter({
+              token: session.secret,
+              ingest,
+              onAuthenticated: () => registry.touchSession(session)
+            }),
+            async () => {
+              await service.cleanup.run({
+                reason: "collector-failure",
+                finalReport: terminalReport("escalated", "Collector failed")
+              });
+            }
+          );
+          const handle = await collectorServer.start();
+          let permissionChange;
+          if (request.extensionManifestPath !== void 0) {
+            if (request.runtime !== "extension-background") {
+              await collectorServer.close();
+              throw new DebugModeError(
+                "PERMISSION_MISMATCH",
+                "Extension permissions require extension-background runtime"
+              );
+            }
+            const manifestPath = path13.resolve(session.projectRoot, request.extensionManifestPath);
+            if (!isContained(session.projectRoot, manifestPath)) {
+              await collectorServer.close();
+              throw new DebugModeError("PERMISSION_MISMATCH", "Extension manifest must be inside the project");
+            }
+            const host = handle.host === "::1" ? "[::1]" : handle.host;
+            permissionChange = await addLoopbackPermission(manifestPath, `http://${host}:${handle.port}/*`);
+          }
+          try {
+            await updateManifest(session, (value) => ({
+              ...value,
+              collector: {
+                id: handle.id,
+                host: handle.host,
+                port: handle.port,
+                status: "ready",
+                startedAt: clock.now().toISOString()
+              },
+              permissionChanges: permissionChange === void 0 ? value.permissionChanges : [...value.permissionChanges, permissionChange]
+            }));
+          } catch (error2) {
+            if (permissionChange !== void 0) {
+              await removeLoopbackPermission(permissionChange.manifestPath, permissionChange).catch(() => void 0);
+            }
+            await collectorServer.close();
+            throw error2;
+          }
+          let helper;
+          if (request.transportTargetPath !== void 0) {
+            const transportHelper = new TransportHelper(session.projectRoot, async (owned) => {
+              await updateManifest(session, (value) => ({
+                ...value,
+                ownedFiles: [...value.ownedFiles, { ...owned, kind: "transport-helper" }]
+              }));
+            });
+            helper = await transportHelper.create({
+              targetPath: request.transportTargetPath,
+              host: handle.host,
+              port: handle.port,
+              token: session.secret,
+              runtime: request.runtime
+            });
+          }
+          return {
+            collectorId: handle.id,
+            host: handle.host,
+            port: handle.port,
+            status: handle.status,
+            ...helper === void 0 ? {} : { helperImport: helper.requiredImport, helperPath: helper.relativePath }
+          };
+        }
+      };
+      const cleanup = new CleanupService(session, {
+        collector: { close: async () => collectorServer?.close() }
+      });
+      const service = {
+        evidence,
+        runs,
+        probes,
+        process: processService,
+        collector,
+        cleanup,
+        ...collectorServer === void 0 ? {} : { collectorServer }
+      };
+      services.set(session.publicId, service);
+      return service;
+    };
+    registry = new SessionRegistry(tempBase, clock, async (session) => {
+      const result = await forSession(session).cleanup.run({
+        reason: "idle-expired",
+        finalReport: terminalReport("abandoned", "Debug session expired after inactivity")
+      });
+      services.delete(session.publicId);
+      if (result.status === "partial") {
+        await input.client.app.log({
+          body: {
+            service: "opencode-debug-mode",
+            level: "warn",
+            message: "Idle session cleanup completed with partial failures"
+          }
+        });
+      }
+    });
+    const tools = createDebugTools({
+      registry,
+      runFor: (session) => forSession(session).runs,
+      processFor: (session) => forSession(session).process,
+      collectorFor: (session) => forSession(session).collector,
+      probesFor: (session) => forSession(session).probes,
+      evidenceFor: (session) => forSession(session).evidence,
+      cleanupFor: (session) => forSession(session).cleanup
+    });
+    const logCollision = (name) => {
+      void input.client.app.log({
+        body: { service: "opencode-debug-mode", level: "warn", message: `Replacing conflicting ${name} configuration` }
+      });
+    };
+    return {
+      config: async (config) => {
+        if (config.agent?.debug !== void 0) logCollision("agent.debug");
+        if (config.command?.debug !== void 0) logCollision("command.debug");
+        config.agent ??= {};
+        config.command ??= {};
+        config.agent.debug = {
+          mode: "primary",
+          description: "Hypothesis-driven runtime debugging",
+          prompt
+        };
+        config.command.debug = {
+          description: "Start hypothesis-driven runtime debugging",
+          agent: "debug",
+          template: "$ARGUMENTS"
+        };
+      },
+      tool: tools,
+      event: async ({ event }) => {
+        if (event.type !== "session.deleted") return;
+        const trustedId = event.properties.info.id;
+        try {
+          const session = await registry.requireOwned(trustedId);
+          await forSession(session).cleanup.run({
+            reason: "session-deleted",
+            finalReport: terminalReport("abandoned", "OpenCode session was deleted")
+          });
+          registry.forgetTrusted(trustedId);
+        } catch (error2) {
+          if (!(error2 instanceof DebugModeError && error2.code === "NO_ACTIVE_SESSION")) throw error2;
+        }
+      },
+      "experimental.session.compacting": async ({ sessionID }, output) => {
+        if (await registry.hasTrusted(sessionID)) {
+          output.context.push(
+            "An opencode-debug-mode investigation is active. Before any next action, call debug_state_read and reconcile its revision, phase, completed checks, evidence references, and nextAction. Do not repeat a conclusive check unless the checkpoint records invalidating evidence."
+          );
+        }
+      },
+      dispose: async () => {
+        for (const session of registry.listActive()) {
+          await forSession(session).cleanup.run({
+            reason: "plugin-dispose",
+            finalReport: terminalReport("abandoned", "OpenCode plugin was disposed")
+          });
+        }
+        await registry.closeAll();
+      }
+    };
+  };
+}
+var DebugModePlugin = createDebugModePlugin();
+export {
+  DebugModePlugin,
+  createDebugModePlugin
+};
+//# sourceMappingURL=index.js.map