@maximtop/opencode-debug-mode 0.1.0

package/dist/process-supervisor.js

@@ -0,0 +1,276 @@
+// src/process/supervisor-entry.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/process/protocol.ts
+import { z } from "zod";
+var MAX_MESSAGE_BYTES = 64 * 1024;
+var BoundedString = z.string().max(8192);
+var StartMessageSchema = z.object({
+  type: z.literal("start"),
+  executable: BoundedString.min(1),
+  args: z.array(BoundedString).max(256),
+  cwd: BoundedString.min(1),
+  env: z.record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), BoundedString).refine((value) => Object.keys(value).length <= 256),
+  timeoutMs: z.number().int().min(1).max(3e5),
+  ownerNonce: z.string().min(32).max(128).regex(/^[A-Za-z0-9_-]+$/)
+}).strict();
+var TerminateMessageSchema = z.object({ type: z.literal("terminate"), reason: BoundedString }).strict();
+var ParentMessageSchema = z.discriminatedUnion("type", [StartMessageSchema, TerminateMessageSchema]);
+var ChildMessageSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("ready") }).strict(),
+  z.object({ type: z.literal("started"), targetPid: z.number().int().positive() }).strict(),
+  z.object({
+    type: z.literal("result"),
+    targetPid: z.number().int().positive(),
+    exitCode: z.number().int().nullable(),
+    signal: z.string().max(64).nullable(),
+    timedOut: z.boolean(),
+    termination: z.object({
+      graceful: z.boolean(),
+      forced: z.boolean(),
+      remaining: z.boolean(),
+      durationMs: z.number().nonnegative(),
+      errors: z.array(z.string().max(256)).max(20)
+    }).strict().optional()
+  }).strict(),
+  z.object({ type: z.literal("failure"), code: z.string().max(128), message: z.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 parseParentMessage(value) {
+  assertSize(value);
+  return ParentMessageSchema.parse(value);
+}
+function parseChildMessage(value) {
+  assertSize(value);
+  return ChildMessageSchema.parse(value);
+}
+
+// src/process/tree.ts
+import { spawn } from "child_process";
+import { performance } from "perf_hooks";
+
+// src/core/constants.ts
+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 (error) {
+    return error.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(error) {
+  const code = error.code;
+  return typeof code === "string" ? code.slice(0, 64) : "termination-failed";
+}
+async function terminateTree(targetPid, options = {}) {
+  const started2 = 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() - started2,
+      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 (error) {
+      errors.push(safeError(error));
+    }
+    await waitForExit(targetPid, gracefulMs);
+    try {
+      const result = await execute("taskkill", ["/PID", String(targetPid), "/T", "/F"]);
+      forced = result.exitCode === 0;
+    } catch (error) {
+      errors.push(safeError(error));
+    }
+    await waitForExit(targetPid, forceMs);
+  } else {
+    try {
+      process.kill(-targetPid, "SIGTERM");
+      graceful = true;
+    } catch (error) {
+      if (error.code === "ESRCH") {
+        return { graceful: false, forced: false, remaining: false, durationMs: performance.now() - started2, errors };
+      }
+      errors.push(safeError(error));
+    }
+    if (!await waitForExit(targetPid, gracefulMs)) {
+      try {
+        process.kill(-targetPid, "SIGKILL");
+        forced = true;
+      } catch (error) {
+        if (error.code !== "ESRCH") errors.push(safeError(error));
+      }
+      await waitForExit(targetPid, forceMs);
+    }
+  }
+  return {
+    graceful,
+    forced,
+    remaining: isAlive(targetPid),
+    durationMs: performance.now() - started2,
+    errors
+  };
+}
+
+// src/process/supervisor-entry.ts
+var target;
+var started = false;
+var finishing = false;
+var timedOut = false;
+var timeout;
+var targetResult;
+function safeSend(message) {
+  const parsed = parseChildMessage(message);
+  if (process.connected && process.send !== void 0) process.send(parsed);
+}
+function fail(code, message) {
+  safeSend({ type: "failure", code: code.slice(0, 128), message: message.slice(0, 512) });
+}
+async function finish(termination) {
+  if (finishing) return;
+  finishing = true;
+  if (timeout !== void 0) clearTimeout(timeout);
+  if (target === void 0 || target.pid === void 0 || targetResult === void 0) {
+    process.exitCode = 1;
+    return;
+  }
+  const result = await targetResult;
+  safeSend({
+    type: "result",
+    targetPid: target.pid,
+    exitCode: result.exitCode,
+    signal: result.signal,
+    timedOut,
+    ...termination === void 0 ? {} : { termination }
+  });
+  process.exit(0);
+}
+async function terminate(reason) {
+  if (finishing) return;
+  if (target === void 0 || target.pid === void 0) {
+    fail("NO_TARGET", reason);
+    process.exit(1);
+  }
+  const result = await terminateTree(target.pid);
+  await finish(result);
+}
+function startTarget(message) {
+  if (started) {
+    fail("SECOND_START", "The supervisor accepts exactly one start message");
+    void terminate("second-start");
+    return;
+  }
+  started = true;
+  try {
+    const child = spawn2(message.executable, message.args, {
+      cwd: message.cwd,
+      env: { ...process.env, ...message.env },
+      detached: true,
+      shell: false,
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    target = child;
+    child.stdout?.on("data", (chunk) => process.stdout.write(chunk));
+    child.stderr?.on("data", (chunk) => process.stderr.write(chunk));
+    targetResult = new Promise((resolve) => {
+      child.once("exit", (exitCode, signal) => resolve({ exitCode, signal }));
+    });
+    child.once("error", () => {
+      fail("TARGET_ERROR", "Target process emitted an error");
+      void terminate("target-error");
+    });
+    if (child.pid === void 0) {
+      fail("SPAWN_FAILED", "Target process did not receive a PID");
+      process.exit(1);
+    }
+    safeSend({ type: "started", targetPid: child.pid });
+  } catch {
+    fail("SPAWN_FAILED", "Target process could not be started");
+    process.exit(1);
+  }
+  timeout = setTimeout(() => {
+    timedOut = true;
+    void terminate("timeout");
+  }, message.timeoutMs);
+  timeout.unref();
+  void targetResult.then(() => finish());
+}
+if (process.send === void 0) {
+  process.exitCode = 1;
+} else {
+  safeSend({ type: "ready" });
+  const startDeadline = setTimeout(() => {
+    fail("START_TIMEOUT", "No start message arrived within two seconds");
+    process.exit(1);
+  }, 2e3);
+  startDeadline.unref();
+  process.on("message", (value) => {
+    try {
+      const message = parseParentMessage(value);
+      if (message.type === "start") {
+        clearTimeout(startDeadline);
+        startTarget(message);
+      } else {
+        void terminate(message.reason);
+      }
+    } catch {
+      fail("INVALID_MESSAGE", "Supervisor message was invalid");
+      void terminate("invalid-message");
+    }
+  });
+  process.once("disconnect", () => void terminate("parent-disconnect"));
+  process.once("SIGTERM", () => void terminate("supervisor-sigterm"));
+  process.once("uncaughtException", () => void terminate("uncaught-exception"));
+  process.once("unhandledRejection", () => void terminate("unhandled-rejection"));
+}
+//# sourceMappingURL=process-supervisor.js.map

package/dist/process-supervisor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/process/supervisor-entry.ts","../src/process/protocol.ts","../src/process/tree.ts","../src/core/constants.ts"],"sourcesContent":["import { type ChildProcess, spawn } from \"node:child_process\"\nimport { type ChildMessage, type ParentMessage, parseChildMessage, parseParentMessage } from \"./protocol.js\"\nimport { type TerminationResult, terminateTree } from \"./tree.js\"\n\nlet target: ChildProcess | undefined\nlet started = false\nlet finishing = false\nlet timedOut = false\nlet timeout: NodeJS.Timeout | undefined\nlet targetResult: Promise<{ exitCode: number | null; signal: NodeJS.Signals | null }> | undefined\n\nfunction safeSend(message: ChildMessage): void {\n  const parsed = parseChildMessage(message)\n  if (process.connected && process.send !== undefined) process.send(parsed)\n}\n\nfunction fail(code: string, message: string): void {\n  safeSend({ type: \"failure\", code: code.slice(0, 128), message: message.slice(0, 512) })\n}\n\nasync function finish(termination?: TerminationResult): Promise<void> {\n  if (finishing) return\n  finishing = true\n  if (timeout !== undefined) clearTimeout(timeout)\n  if (target === undefined || target.pid === undefined || targetResult === undefined) {\n    process.exitCode = 1\n    return\n  }\n  const result = await targetResult\n  safeSend({\n    type: \"result\",\n    targetPid: target.pid,\n    exitCode: result.exitCode,\n    signal: result.signal,\n    timedOut,\n    ...(termination === undefined ? {} : { termination }),\n  })\n  process.exit(0)\n}\n\nasync function terminate(reason: string): Promise<void> {\n  if (finishing) return\n  if (target === undefined || target.pid === undefined) {\n    fail(\"NO_TARGET\", reason)\n    process.exit(1)\n  }\n  const result = await terminateTree(target.pid)\n  await finish(result)\n}\n\nfunction startTarget(message: Extract<ParentMessage, { type: \"start\" }>): void {\n  if (started) {\n    fail(\"SECOND_START\", \"The supervisor accepts exactly one start message\")\n    void terminate(\"second-start\")\n    return\n  }\n  started = true\n  try {\n    const child = spawn(message.executable, message.args, {\n      cwd: message.cwd,\n      env: { ...process.env, ...message.env },\n      detached: true,\n      shell: false,\n      windowsHide: true,\n      stdio: [\"ignore\", \"pipe\", \"pipe\"],\n    })\n    target = child\n    child.stdout?.on(\"data\", (chunk: Buffer) => process.stdout.write(chunk))\n    child.stderr?.on(\"data\", (chunk: Buffer) => process.stderr.write(chunk))\n    targetResult = new Promise((resolve) => {\n      child.once(\"exit\", (exitCode, signal) => resolve({ exitCode, signal }))\n    })\n    child.once(\"error\", () => {\n      fail(\"TARGET_ERROR\", \"Target process emitted an error\")\n      void terminate(\"target-error\")\n    })\n    if (child.pid === undefined) {\n      fail(\"SPAWN_FAILED\", \"Target process did not receive a PID\")\n      process.exit(1)\n    }\n    safeSend({ type: \"started\", targetPid: child.pid })\n  } catch {\n    fail(\"SPAWN_FAILED\", \"Target process could not be started\")\n    process.exit(1)\n  }\n  timeout = setTimeout(() => {\n    timedOut = true\n    void terminate(\"timeout\")\n  }, message.timeoutMs)\n  timeout.unref()\n  void targetResult.then(() => finish())\n}\n\nif (process.send === undefined) {\n  process.exitCode = 1\n} else {\n  safeSend({ type: \"ready\" })\n  const startDeadline = setTimeout(() => {\n    fail(\"START_TIMEOUT\", \"No start message arrived within two seconds\")\n    process.exit(1)\n  }, 2_000)\n  startDeadline.unref()\n\n  process.on(\"message\", (value: unknown) => {\n    try {\n      const message = parseParentMessage(value)\n      if (message.type === \"start\") {\n        clearTimeout(startDeadline)\n        startTarget(message)\n      } else {\n        void terminate(message.reason)\n      }\n    } catch {\n      fail(\"INVALID_MESSAGE\", \"Supervisor message was invalid\")\n      void terminate(\"invalid-message\")\n    }\n  })\n  process.once(\"disconnect\", () => void terminate(\"parent-disconnect\"))\n  process.once(\"SIGTERM\", () => void terminate(\"supervisor-sigterm\"))\n  process.once(\"uncaughtException\", () => void terminate(\"uncaught-exception\"))\n  process.once(\"unhandledRejection\", () => void terminate(\"unhandled-rejection\"))\n}\n","import { z } from \"zod\"\n\nconst MAX_MESSAGE_BYTES = 64 * 1024\nconst BoundedString = z.string().max(8_192)\n\nconst StartMessageSchema = z\n  .object({\n    type: z.literal(\"start\"),\n    executable: BoundedString.min(1),\n    args: z.array(BoundedString).max(256),\n    cwd: BoundedString.min(1),\n    env: z\n      .record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), BoundedString)\n      .refine((value) => Object.keys(value).length <= 256),\n    timeoutMs: z.number().int().min(1).max(300_000),\n    ownerNonce: z\n      .string()\n      .min(32)\n      .max(128)\n      .regex(/^[A-Za-z0-9_-]+$/),\n  })\n  .strict()\n\nconst TerminateMessageSchema = z.object({ type: z.literal(\"terminate\"), reason: BoundedString }).strict()\n\nexport const ParentMessageSchema = z.discriminatedUnion(\"type\", [StartMessageSchema, TerminateMessageSchema])\n\nexport const ChildMessageSchema = z.discriminatedUnion(\"type\", [\n  z.object({ type: z.literal(\"ready\") }).strict(),\n  z.object({ type: z.literal(\"started\"), targetPid: z.number().int().positive() }).strict(),\n  z\n    .object({\n      type: z.literal(\"result\"),\n      targetPid: z.number().int().positive(),\n      exitCode: z.number().int().nullable(),\n      signal: z.string().max(64).nullable(),\n      timedOut: z.boolean(),\n      termination: z\n        .object({\n          graceful: z.boolean(),\n          forced: z.boolean(),\n          remaining: z.boolean(),\n          durationMs: z.number().nonnegative(),\n          errors: z.array(z.string().max(256)).max(20),\n        })\n        .strict()\n        .optional(),\n    })\n    .strict(),\n  z.object({ type: z.literal(\"failure\"), code: z.string().max(128), message: z.string().max(512) }).strict(),\n])\n\nexport type ParentMessage = z.infer<typeof ParentMessageSchema>\nexport type ChildMessage = z.infer<typeof ChildMessageSchema>\n\nfunction assertSize(value: unknown): void {\n  let serialized: string\n  try {\n    serialized = JSON.stringify(value)\n  } catch {\n    throw new Error(\"IPC message is not serializable\")\n  }\n  if (Buffer.byteLength(serialized) > MAX_MESSAGE_BYTES) throw new Error(\"IPC message exceeds 64 KiB\")\n}\n\nexport function parseParentMessage(value: unknown): ParentMessage {\n  assertSize(value)\n  return ParentMessageSchema.parse(value)\n}\n\nexport function parseChildMessage(value: unknown): ChildMessage {\n  assertSize(value)\n  return ChildMessageSchema.parse(value)\n}\n","import { spawn } from \"node:child_process\"\nimport { performance } from \"node:perf_hooks\"\nimport { LIMITS } from \"../core/constants.js\"\n\nexport type Execute = (executable: string, args: string[]) => Promise<{ exitCode: number | null }>\n\nexport type TerminationResult = Readonly<{\n  graceful: boolean\n  forced: boolean\n  remaining: boolean\n  durationMs: number\n  errors: string[]\n}>\n\nconst defaultExecute: Execute = (executable, args) =>\n  new Promise((resolve, reject) => {\n    const child = spawn(executable, args, { shell: false, windowsHide: true, stdio: \"ignore\" })\n    child.once(\"error\", reject)\n    child.once(\"exit\", (exitCode) => resolve({ exitCode }))\n  })\n\nfunction isAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0)\n    return true\n  } catch (error) {\n    return (error as NodeJS.ErrnoException).code !== \"ESRCH\"\n  }\n}\n\nasync function waitForExit(pid: number, milliseconds: number): Promise<boolean> {\n  const deadline = performance.now() + milliseconds\n  while (performance.now() < deadline) {\n    if (!isAlive(pid)) return true\n    await new Promise<void>((resolve) => setTimeout(resolve, 20))\n  }\n  return !isAlive(pid)\n}\n\nfunction safeError(error: unknown): string {\n  const code = (error as NodeJS.ErrnoException).code\n  return typeof code === \"string\" ? code.slice(0, 64) : \"termination-failed\"\n}\n\nexport async function terminateTree(\n  targetPid: number,\n  options: {\n    platform?: NodeJS.Platform\n    execute?: Execute\n    gracefulMs?: number\n    forceMs?: number\n  } = {},\n): Promise<TerminationResult> {\n  const started = performance.now()\n  const errors: string[] = []\n  let graceful = false\n  let forced = false\n  const platform = options.platform ?? process.platform\n  const gracefulMs = options.gracefulMs ?? LIMITS.gracefulKillMs\n  const forceMs = options.forceMs ?? LIMITS.forcedKillMs\n\n  if (!Number.isInteger(targetPid) || targetPid <= 0) {\n    return {\n      graceful: false,\n      forced: false,\n      remaining: false,\n      durationMs: performance.now() - started,\n      errors: [\"invalid-pid\"],\n    }\n  }\n\n  if (platform === \"win32\") {\n    const execute = options.execute ?? defaultExecute\n    try {\n      const result = await execute(\"taskkill\", [\"/PID\", String(targetPid), \"/T\"])\n      graceful = result.exitCode === 0\n    } catch (error) {\n      errors.push(safeError(error))\n    }\n    await waitForExit(targetPid, gracefulMs)\n    try {\n      const result = await execute(\"taskkill\", [\"/PID\", String(targetPid), \"/T\", \"/F\"])\n      forced = result.exitCode === 0\n    } catch (error) {\n      errors.push(safeError(error))\n    }\n    await waitForExit(targetPid, forceMs)\n  } else {\n    try {\n      process.kill(-targetPid, \"SIGTERM\")\n      graceful = true\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code === \"ESRCH\") {\n        return { graceful: false, forced: false, remaining: false, durationMs: performance.now() - started, errors }\n      }\n      errors.push(safeError(error))\n    }\n    if (!(await waitForExit(targetPid, gracefulMs))) {\n      try {\n        process.kill(-targetPid, \"SIGKILL\")\n        forced = true\n      } catch (error) {\n        if ((error as NodeJS.ErrnoException).code !== \"ESRCH\") errors.push(safeError(error))\n      }\n      await waitForExit(targetPid, forceMs)\n    }\n  }\n\n  return {\n    graceful,\n    forced,\n    remaining: isAlive(targetPid),\n    durationMs: performance.now() - started,\n    errors,\n  }\n}\n","export const PACKAGE_ID = \"opencode-debug-mode\" as const\nexport const MANIFEST_SCHEMA_VERSION = 1 as const\nexport const STATE_SCHEMA_VERSION = 1 as const\nexport const EVENT_SCHEMA_VERSION = 1 as const\nexport const TEMP_BASE_NAME = \"opencode-debug-mode-v1\" as const\nexport const PROCESS_EVENT_PREFIX = \"__OPENCODE_DEBUG_EVENT_V1__\" as const\n\nexport const LIMITS = Object.freeze({\n  requestBytes: 64 * 1024,\n  scalarBytes: 8 * 1024,\n  events: 25_000,\n  evidenceBytes: 25 * 1024 * 1024,\n  checkpointBytes: 256 * 1024,\n  eventsPerBatch: 100,\n  idleMs: 30 * 60 * 1000,\n  collectorReadyMs: 2_000,\n  cleanupMs: 5_000,\n  gracefulKillMs: 750,\n  forcedKillMs: 1_500,\n  noSignalIterations: 3,\n})\n"],"mappings":"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","names":["spawn","started","spawn"]}

package/dist/run/service.d.ts

@@ -0,0 +1,21 @@
+import type { Clock } from "../core/clock.js";
+import type { CleanupManifest, ManifestRun } from "../session/types.js";
+export interface RunPersistence {
+    read(): Promise<CleanupManifest>;
+    update(expectedRevision: number, mutate: (value: CleanupManifest) => CleanupManifest): Promise<CleanupManifest>;
+}
+export type LeaseFactory = (kind: "process" | "waiting") => Promise<() => void> | (() => void);
+export declare class RunService {
+    private readonly persistence;
+    private readonly clock;
+    private readonly acquireLease?;
+    private readonly waitingReleases;
+    constructor(persistence: RunPersistence, clock?: Clock, acquireLease?: LeaseFactory | undefined);
+    start(input: {
+        label: "pre-fix" | "post-fix";
+        reproduction: string;
+        waitingForUser: boolean;
+    }): Promise<ManifestRun>;
+    require(runId: string): Promise<ManifestRun>;
+    complete(runId: string, status: "completed" | "failed" | "timed_out" | "cancelled"): Promise<ManifestRun>;
+}

package/dist/session/atomic-json.d.ts

@@ -0,0 +1 @@
+export declare function atomicWriteJson(filename: string, value: unknown, maximumBytes: number): Promise<number>;

package/dist/session/manifest-store.d.ts

@@ -0,0 +1,22 @@
+import { type CleanupManifest } from "./types.js";
+export declare function createInitialManifest(input: {
+    sessionId: string;
+    trustedSessionHash: string;
+    projectRoot: string;
+    sessionDir: string;
+    now: string;
+    keepArtifacts?: boolean;
+    retentionDestination?: string;
+}): CleanupManifest;
+export declare class ManifestStore {
+    private readonly filename;
+    private tail;
+    constructor(filename: string);
+    create(value: CleanupManifest): Promise<CleanupManifest>;
+    read(): Promise<CleanupManifest>;
+    update(expectedRevision: number, mutate: (value: CleanupManifest) => CleanupManifest): Promise<CleanupManifest>;
+    modify(mutate: (value: CleanupManifest) => CleanupManifest): Promise<CleanupManifest>;
+    private writeNext;
+    private verifyPaths;
+    private exclusive;
+}

package/dist/session/orphan-recovery.d.ts

@@ -0,0 +1,16 @@
+import type { DebugSession } from "./registry.js";
+import type { CleanupManifest } from "./types.js";
+export type OrphanRecoveryOptions = Readonly<{
+    tempBase: string;
+    now?: Date;
+    activeSessionDirs?: Set<string>;
+    cleanup?: (session: DebugSession, manifest: CleanupManifest) => Promise<void>;
+}>;
+export declare function recoverOrphans(options: OrphanRecoveryOptions): Promise<{
+    cleaned: string[];
+    ignored: string[];
+    errors: Array<{
+        directory: string;
+        reason: string;
+    }>;
+}>;

package/dist/session/paths.d.ts

@@ -0,0 +1,11 @@
+export type SessionPaths = Readonly<{
+    baseDir: string;
+    sessionDir: string;
+    projectRoot: string;
+    manifestFile: string;
+    secretFile: string;
+    stateFile: string;
+    evidenceFile: string;
+}>;
+export declare function isContained(parent: string, child: string): boolean;
+export declare function createSessionPaths(tempBase: string, projectRoot: string): Promise<SessionPaths>;

package/dist/session/registry.d.ts

@@ -0,0 +1,48 @@
+import type { Clock } from "../core/clock.js";
+import { InvestigationStore } from "../investigation/store.js";
+import { ManifestStore } from "./manifest-store.js";
+import { type SessionPaths } from "./paths.js";
+import { SecretStore } from "./secret-store.js";
+export declare function trustedSessionHash(openCodeSessionId: string): string;
+export type ProjectContext = Readonly<{
+    directory: string;
+    worktree: string;
+}>;
+export type DebugSession = Readonly<{
+    publicId: string;
+    trustedHash: string;
+    projectRoot: string;
+    directory: string;
+    paths: SessionPaths;
+    manifestStore: ManifestStore;
+    investigationStore: InvestigationStore;
+    secretStore: SecretStore;
+    secret: string;
+}>;
+export type RegistryCleanup = (session: DebugSession, reason: "idle-expired") => Promise<void>;
+export declare class SessionRegistry {
+    private readonly tempBase;
+    private readonly clock;
+    private readonly cleanup?;
+    private readonly sessions;
+    private readonly timer;
+    private closed;
+    constructor(tempBase: string, clock?: Clock, cleanup?: RegistryCleanup | undefined);
+    start(trustedId: string, context: ProjectContext, options?: {
+        keepArtifacts?: boolean;
+        retentionDestination?: string;
+    }): Promise<DebugSession>;
+    requireOwned(trustedId: string): Promise<DebugSession>;
+    hasTrusted(trustedId: string): Promise<boolean>;
+    touch(trustedId: string): Promise<void>;
+    touchSession(sessionValue: DebugSession): Promise<void>;
+    acquireLease(trustedId: string, kind: "process" | "waiting"): Promise<() => void>;
+    acquireLeaseForSession(sessionValue: DebugSession, kind: "process" | "waiting"): () => void;
+    sweep(): Promise<void>;
+    listActive(): DebugSession[];
+    forgetTrusted(trustedId: string): void;
+    closeAll(): Promise<void>;
+    private findPersisted;
+    private pathsFromManifest;
+    private assertOpen;
+}

package/dist/session/secret-store.d.ts

@@ -0,0 +1,7 @@
+export declare class SecretStore {
+    private readonly filename;
+    constructor(filename: string);
+    create(): Promise<string>;
+    read(): Promise<string>;
+    remove(): Promise<"success" | "already-clean">;
+}