@zhivex-ai/harness 0.9.0 → 0.10.0

package/dist/zhx.js

@@ -1,24 +1,24 @@
-#!/usr/bin/env bun
-// @bun
+#!/usr/bin/env node
 
 // src/cli.ts
-import { createInterface } from "readline/promises";
-import { randomUUID as randomUUID5 } from "crypto";
-import { constants as fsConstants2 } from "fs";
-import { access, lstat as lstat7, readFile as readFile4, stat as stat4 } from "fs/promises";
-import path9 from "path";
+import { createInterface } from "node:readline/promises";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { constants as fsConstants2, realpathSync as realpathSync2 } from "node:fs";
+import { access, lstat as lstat8, readFile as readFile4, stat as stat4 } from "node:fs/promises";
+import path10 from "node:path";
+import { fileURLToPath } from "node:url";
 import { z as z5 } from "zod";
 import {
   getAgentBudgetStatus as getAgentBudgetStatus3
 } from "@zhivex-ai/agents";
 
 // src/config.ts
-import { createHash as createHash2 } from "crypto";
-import { realpathSync } from "fs";
-import path from "path";
+import { createHash as createHash2 } from "node:crypto";
+import { realpathSync } from "node:fs";
+import path from "node:path";
 
 // src/providers.ts
-import { createHash } from "crypto";
+import { createHash } from "node:crypto";
 import { createGemini } from "@zhivex-ai/gemini";
 import { createMeta } from "@zhivex-ai/meta";
 import { createOpenAI } from "@zhivex-ai/openai";
@@ -372,11 +372,11 @@ var HARNESS_CONFIG_SCHEMA_VERSION = 4;
 var HARNESS_STORE_BACKENDS = ["sqlite", "file"];
 var HARNESS_EXECUTION_BACKENDS = ["none", "oci"];
 var HARNESS_OCI_RUNTIMES = ["docker", "podman"];
-var HARNESS_EXECUTION_POLICY_VERSION = "2026-08-20-v2";
+var HARNESS_EXECUTION_POLICY_VERSION = "2026-08-21-v3";
 var DEFAULT_OCI_EXECUTION = {
   runtime: "docker",
-  image: "oven/bun:1.3.7-slim",
-  allowedCommands: ["bun"],
+  image: "node:24-bookworm-slim",
+  allowedCommands: ["node", "npm"],
   maxProcessRuntimeMs: 120000,
   maxProcessOutputBytes: 20000,
   maxMemoryMb: 1024,
@@ -501,8 +501,8 @@ var resolveOciAllowedCommands = (configured) => {
   if (invalid) {
     throw new Error(`Invalid OCI command name: ${invalid}. Use a bare executable name without a path.`);
   }
-  if (!commands.includes("bun")) {
-    throw new Error("ociAllowedCommands must include bun so declared package checks remain available.");
+  if (!commands.some((command) => ["npm", "pnpm", "yarn", "bun"].includes(command))) {
+    throw new Error("ociAllowedCommands must include npm, pnpm, yarn, or bun so declared package checks remain available.");
   }
   return commands;
 };
@@ -657,7 +657,7 @@ var createProviderModel = (config, env = process.env, registry = DEFAULT_PROVIDE
 var providerAvailability = (env = process.env, registry = DEFAULT_PROVIDER_REGISTRY) => registry.availability(env);
 
 // src/harness.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash7 } from "node:crypto";
 import {
   Agent,
   applySafetyPolicyToAgent as applySafetyPolicyToAgent2,
@@ -727,8 +727,8 @@ var selectHarnessModel = (candidates, required) => {
 };
 
 // src/edit-contracts.ts
-import { createHash as createHash3 } from "crypto";
-import path2 from "path";
+import { createHash as createHash3 } from "node:crypto";
+import path2 from "node:path";
 import { z } from "zod";
 var EDIT_CONTRACT_SCHEMA_VERSION = 1;
 var EDIT_DIGEST_ALGORITHM = "sha256";
@@ -862,9 +862,256 @@ var editContractDocument = (kind, result) => ({
 });
 
 // src/workspace.ts
-import { createHash as createHash4, randomUUID } from "crypto";
-import { link, lstat, mkdir, open, readFile, readdir, realpath, rename, stat, unlink } from "fs/promises";
-import path3 from "path";
+import { createHash as createHash4, randomUUID } from "node:crypto";
+import { link, lstat as lstat2, mkdir, open, readFile, readdir, realpath, rename, stat, unlink } from "node:fs/promises";
+import path4 from "node:path";
+
+// src/package-manager.ts
+import { lstat } from "node:fs/promises";
+import path3 from "node:path";
+var HARNESS_PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+var LOCKFILES = {
+  npm: ["package-lock.json", "npm-shrinkwrap.json"],
+  pnpm: ["pnpm-lock.yaml"],
+  yarn: ["yarn.lock"],
+  bun: ["bun.lock", "bun.lockb"]
+};
+var isPackageManager = (value) => HARNESS_PACKAGE_MANAGERS.includes(value);
+var parsePackageManager = (value) => {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string") {
+    throw new Error("package.json packageManager must be a string when present.");
+  }
+  const match = /^(npm|pnpm|yarn|bun)@([^\s]+)$/.exec(value.trim());
+  if (!match?.[1] || !match[2]) {
+    throw new Error("package.json packageManager must pin npm, pnpm, yarn, or bun using <manager>@<version>.");
+  }
+  if (!isPackageManager(match[1])) {
+    throw new Error(`Unsupported package manager: ${match[1]}.`);
+  }
+  return match[1];
+};
+var existingLockfiles = async (root) => {
+  const matches = [];
+  for (const manager of HARNESS_PACKAGE_MANAGERS) {
+    for (const file of LOCKFILES[manager]) {
+      try {
+        const entry = await lstat(path3.join(root, file));
+        if (entry.isSymbolicLink()) {
+          throw new Error(`Package-manager lockfile must not be a symbolic link: ${file}.`);
+        }
+        if (entry.isFile())
+          matches.push({ manager, file });
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+      }
+    }
+  }
+  return matches;
+};
+var resolvePackageManager = async (root, manifest) => {
+  const declared = parsePackageManager(manifest.packageManager);
+  if (declared) {
+    return {
+      manager: declared,
+      source: "packageManager",
+      evidence: manifest.packageManager
+    };
+  }
+  const lockfiles = await existingLockfiles(root);
+  const managers = [...new Set(lockfiles.map((entry) => entry.manager))];
+  if (managers.length > 1) {
+    throw new Error(`Ambiguous package manager: found lockfiles for ${managers.join(", ")}; declare packageManager explicitly.`);
+  }
+  const detected = managers[0];
+  if (detected) {
+    return {
+      manager: detected,
+      source: "lockfile",
+      evidence: lockfiles.filter((entry) => entry.manager === detected).map((entry) => entry.file).join(",")
+    };
+  }
+  return { manager: "npm", source: "default" };
+};
+var runCommand = (manager, check) => {
+  switch (manager) {
+    case "bun":
+      return ["bun", "--no-env-file", "run", check];
+    case "npm":
+      return ["npm", "--ignore-scripts", "run", check];
+    case "pnpm":
+      return ["pnpm", "--ignore-scripts", "run", check];
+    case "yarn":
+      return ["yarn", "run", check];
+  }
+};
+var resolvePackageCheckCommand = async (root, manifest, check, expectedScript, allowedChecks) => {
+  if (!/^[A-Za-z0-9:_-]+$/.test(check) || !allowedChecks.includes(check)) {
+    throw new Error(`The check "${check}" is not in the explicit allowlist.`);
+  }
+  const scripts = manifest.scripts && typeof manifest.scripts === "object" ? manifest.scripts : {};
+  const actual = scripts[check];
+  if (typeof actual !== "string") {
+    throw new Error(`package.json does not define the "${check}" script.`);
+  }
+  if (actual !== expectedScript) {
+    throw new Error(`The "${check}" script changed or does not match expectedScript.`);
+  }
+  for (const lifecycleName of [`pre${check}`, `post${check}`]) {
+    if (typeof scripts[lifecycleName] === "string") {
+      throw new Error(`The approved "${check}" check has an implicit ${lifecycleName} lifecycle script; approve a standalone script instead.`);
+    }
+  }
+  const resolution = await resolvePackageManager(root, manifest);
+  return { ...resolution, command: runCommand(resolution.manager, check) };
+};
+
+// src/process-runtime.ts
+import { spawn } from "node:child_process";
+var DEFAULT_MAX_OUTPUT_CHARACTERS = 20000;
+var DEFAULT_TERMINATION_GRACE_MS = 1000;
+var PORTABLE_ENVIRONMENT_KEYS = [
+  "CI",
+  "FORCE_COLOR",
+  "LANG",
+  "LC_ALL",
+  "NO_COLOR",
+  "PATH",
+  "TEMP",
+  "TERM",
+  "TMP",
+  "TMPDIR"
+];
+
+class BoundedTextCapture {
+  decoder = new TextDecoder;
+  maxCharacters;
+  output = "";
+  totalCharacters = 0;
+  constructor(maxCharacters) {
+    this.maxCharacters = maxCharacters;
+  }
+  write(chunk) {
+    this.append(this.decoder.decode(chunk, { stream: true }));
+  }
+  finish() {
+    this.append(this.decoder.decode());
+    return this.totalCharacters <= this.maxCharacters ? this.output : `${this.output}
+… output truncated (${this.totalCharacters - this.maxCharacters} characters omitted)`;
+  }
+  append(value) {
+    this.totalCharacters += value.length;
+    if (this.output.length < this.maxCharacters) {
+      this.output += value.slice(0, this.maxCharacters - this.output.length);
+    }
+  }
+}
+var processEnvironment = (additional) => {
+  const env = {};
+  for (const key of PORTABLE_ENVIRONMENT_KEYS) {
+    const value = process.env[key];
+    if (value !== undefined)
+      env[key] = value;
+  }
+  for (const [key, value] of Object.entries(additional ?? {})) {
+    if (value === undefined)
+      delete env[key];
+    else
+      env[key] = value;
+  }
+  return env;
+};
+var exitCodeForSignal = (signal) => {
+  if (signal === "SIGKILL")
+    return 137;
+  if (signal === "SIGTERM")
+    return 143;
+  return 1;
+};
+var abortReason = (signal) => signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted.", "AbortError");
+var runPortableProcess = async (command, options = {}) => {
+  if (command.length === 0 || !command[0])
+    throw new Error("The process command must not be empty.");
+  if (options.signal?.aborted)
+    throw abortReason(options.signal);
+  const maxOutputCharacters = options.maxOutputCharacters ?? DEFAULT_MAX_OUTPUT_CHARACTERS;
+  if (!Number.isSafeInteger(maxOutputCharacters) || maxOutputCharacters < 0) {
+    throw new Error("maxOutputCharacters must be a non-negative safe integer.");
+  }
+  if (options.timeoutMs !== undefined && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0)) {
+    throw new Error("timeoutMs must be a positive safe integer.");
+  }
+  const argv = [...command];
+  const stdout = new BoundedTextCapture(maxOutputCharacters);
+  const stderr = new BoundedTextCapture(maxOutputCharacters);
+  const child = spawn(argv[0], argv.slice(1), {
+    ...options.cwd ? { cwd: options.cwd } : {},
+    env: processEnvironment(options.env),
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  let timedOut = false;
+  let aborted = false;
+  let terminationTimer;
+  child.stdout.on("data", (chunk) => stdout.write(chunk));
+  child.stderr?.on("data", (chunk) => stderr.write(chunk));
+  const terminate = () => {
+    if (child.exitCode !== null || child.signalCode !== null)
+      return;
+    child.kill("SIGTERM");
+    terminationTimer = setTimeout(() => {
+      if (child.exitCode === null && child.signalCode === null)
+        child.kill("SIGKILL");
+    }, DEFAULT_TERMINATION_GRACE_MS);
+    terminationTimer.unref?.();
+  };
+  const handleAbort = () => {
+    aborted = true;
+    terminate();
+  };
+  options.signal?.addEventListener("abort", handleAbort, { once: true });
+  const timeout = options.timeoutMs === undefined ? undefined : setTimeout(() => {
+    timedOut = true;
+    terminate();
+  }, options.timeoutMs);
+  timeout?.unref?.();
+  try {
+    return await new Promise((resolve, reject) => {
+      let processError;
+      child.once("error", (error) => {
+        processError = error;
+      });
+      child.once("close", (exitCode, signal) => {
+        if (processError) {
+          reject(processError);
+          return;
+        }
+        if (aborted && options.signal) {
+          reject(abortReason(options.signal));
+          return;
+        }
+        resolve({
+          command: argv,
+          exitCode: exitCode ?? exitCodeForSignal(signal),
+          stdout: stdout.finish(),
+          stderr: options.stderr === "ignore" ? "" : stderr.finish(),
+          timedOut
+        });
+      });
+    });
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+    if (terminationTimer)
+      clearTimeout(terminationTimer);
+    options.signal?.removeEventListener("abort", handleAbort);
+  }
+};
+
+// src/workspace.ts
 var HARD_IGNORES = new Set([".git", ".next", ".turbo", ".zhivex-harness", "coverage", "dist", "node_modules"]);
 var IGNORE_FILES = [".gitignore", ".zhivex-harnessignore"];
 var DEFAULT_CHECKS = ["test", "typecheck", "lint", "build"];
@@ -880,13 +1127,13 @@ var isSensitiveName = (name) => {
 };
 var isHardIgnored = (relativePath) => relativePath.split("/").some((segment) => HARD_IGNORES.has(segment.toLocaleLowerCase()) || isSensitiveName(segment));
 var isInside = (root, candidate) => {
-  const relative = path3.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path3.sep}`) && relative !== ".." && !path3.isAbsolute(relative);
+  const relative = path4.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path4.sep}`) && relative !== ".." && !path4.isAbsolute(relative);
 };
-var wirePath = (value) => value.split(path3.sep).join("/");
+var wirePath = (value) => value.split(path4.sep).join("/");
 var digestBytes = (value) => `sha256:${createHash4("sha256").update(value).digest("hex")}`;
 var truncate = (value, maxLength = MAX_TOOL_OUTPUT) => value.length <= maxLength ? value : `${value.slice(0, maxLength)}
-\u2026 output truncated (${value.length - maxLength} characters omitted)`;
+… output truncated (${value.length - maxLength} characters omitted)`;
 var cursorEncode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
 var cursorDecode = (value) => {
   try {
@@ -987,24 +1234,7 @@ var isIgnoredByRules = (relativePath, isDirectory, rules) => {
   return ignored;
 };
 var spawnBounded = async (command, cwd, timeoutMs = 120000) => {
-  const allowed = ["CI", "FORCE_COLOR", "LANG", "LC_ALL", "NO_COLOR", "PATH", "TEMP", "TERM", "TMP", "TMPDIR"];
-  const env = Object.fromEntries(allowed.flatMap((key) => process.env[key] ? [[key, process.env[key]]] : []));
-  const child = Bun.spawn(command, { cwd, env, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
-  let timedOut = false;
-  const timeout = setTimeout(() => {
-    timedOut = true;
-    child.kill();
-  }, timeoutMs);
-  try {
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(child.stdout).text(),
-      new Response(child.stderr).text(),
-      child.exited
-    ]);
-    return { command, exitCode, stdout: truncate(stdout), stderr: truncate(stderr), timedOut };
-  } finally {
-    clearTimeout(timeout);
-  }
+  return await runPortableProcess(command, { cwd, timeoutMs });
 };
 
 class Workspace {
@@ -1019,7 +1249,7 @@ class Workspace {
     this.root = root;
   }
   static async open(root) {
-    const resolved = await realpath(path3.resolve(root));
+    const resolved = await realpath(path4.resolve(root));
     if (!(await stat(resolved)).isDirectory())
       throw new Error(`The workspace is not a directory: ${root}`);
     return new Workspace(resolved);
@@ -1027,10 +1257,10 @@ class Workspace {
   lexicalPath(relativePath) {
     if (!relativePath || relativePath.includes("\x00"))
       throw new Error("The path must be a valid relative path.");
-    const candidate = path3.resolve(this.root, relativePath);
+    const candidate = path4.resolve(this.root, relativePath);
     if (!isInside(this.root, candidate))
       throw new Error(`The path escapes the workspace: ${relativePath}`);
-    const relative = wirePath(path3.relative(this.root, candidate));
+    const relative = wirePath(path4.relative(this.root, candidate));
     if (relative && isHardIgnored(relative)) {
       const blocked = relative.split("/").find((segment) => HARD_IGNORES.has(segment.toLocaleLowerCase()) || isSensitiveName(segment));
       throw new Error(`The path is protected by the harness policy: ${blocked}`);
@@ -1041,13 +1271,13 @@ class Workspace {
     const candidate = this.lexicalPath(relativePath);
     if (candidate === this.root && options.requireFile)
       throw new Error("The workspace root is not a regular file.");
-    const segments = path3.relative(this.root, candidate).split(path3.sep).filter(Boolean);
+    const segments = path4.relative(this.root, candidate).split(path4.sep).filter(Boolean);
     let current = this.root;
     for (let index = 0;index < segments.length; index += 1) {
-      current = path3.join(current, segments[index]);
+      current = path4.join(current, segments[index]);
       let entry;
       try {
-        entry = await lstat(current);
+        entry = await lstat2(current);
       } catch (error) {
         if (options.allowMissing && error.code === "ENOENT") {
           return { path: candidate, exists: false };
@@ -1068,18 +1298,18 @@ class Workspace {
   async readStableFile(relativePath, allowBinary = true) {
     this.indexMetrics.stableFileReads += 1;
     const safe = await this.safePath(relativePath, { requireFile: true });
-    const before = await lstat(safe.path);
+    const before = await lstat2(safe.path);
     if (before.size > MAX_FILE_BYTES)
       throw new Error(`The file exceeds the ${MAX_FILE_BYTES}-byte limit.`);
     const contents = await readFile(safe.path);
-    const after = await lstat(safe.path);
+    const after = await lstat2(safe.path);
     if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
       throw new Error(`The file changed while it was being read: ${relativePath}`);
     }
     if (!allowBinary && contents.includes(0))
       throw new Error("The file appears to be binary and cannot be read as text.");
     return {
-      path: wirePath(path3.relative(this.root, safe.path)),
+      path: wirePath(path4.relative(this.root, safe.path)),
       absolutePath: safe.path,
       contents,
       digest: digestBytes(contents),
@@ -1105,21 +1335,21 @@ class Workspace {
     const rules = [...inherited];
     for (const filename of IGNORE_FILES) {
       try {
-        const ignorePath = path3.join(directory, filename);
-        const before = await lstat(ignorePath);
+        const ignorePath = path4.join(directory, filename);
+        const before = await lstat2(ignorePath);
         if (before.isSymbolicLink() || !before.isFile())
           continue;
         if (before.size <= MAX_FILE_BYTES) {
           const contents = await readFile(ignorePath);
-          const after = await lstat(ignorePath);
+          const after = await lstat2(ignorePath);
           if (after.isSymbolicLink() || !after.isFile() || !this.sameFingerprint(after, this.fingerprint("", "ignore-file", before))) {
-            throw new Error(`The ignore file changed while the workspace was being indexed: ${wirePath(path3.relative(this.root, ignorePath))}`);
+            throw new Error(`The ignore file changed while the workspace was being indexed: ${wirePath(path4.relative(this.root, ignorePath))}`);
           }
           const digest2 = digestBytes(contents);
-          ignoreFiles.push(this.fingerprint(wirePath(path3.relative(this.root, ignorePath)), "ignore-file", after, digest2));
+          ignoreFiles.push(this.fingerprint(wirePath(path4.relative(this.root, ignorePath)), "ignore-file", after, digest2));
           rules.push(...parseIgnoreRules(contents.toString("utf8"), base));
         } else {
-          ignoreFiles.push(this.fingerprint(wirePath(path3.relative(this.root, ignorePath)), "ignore-file", before));
+          ignoreFiles.push(this.fingerprint(wirePath(path4.relative(this.root, ignorePath)), "ignore-file", before));
         }
       } catch (error) {
         if (error.code !== "ENOENT")
@@ -1133,7 +1363,7 @@ class Workspace {
     const directories = [];
     const ignoreFiles = [];
     const walk = async (directory, base, inherited) => {
-      const directoryEntry = await lstat(directory);
+      const directoryEntry = await lstat2(directory);
       if (directoryEntry.isSymbolicLink() || !directoryEntry.isDirectory()) {
         throw new Error(`A workspace directory changed while it was being indexed: ${base || "."}`);
       }
@@ -1144,7 +1374,7 @@ class Workspace {
         const relative = base ? `${base}/${entry.name}` : entry.name;
         if (isHardIgnored(relative) || entry.isSymbolicLink() || isIgnoredByRules(relative, entry.isDirectory(), rules))
           continue;
-        const absolute = path3.join(directory, entry.name);
+        const absolute = path4.join(directory, entry.name);
         if (entry.isDirectory())
           await walk(absolute, relative, rules);
         else if (entry.isFile())
@@ -1158,19 +1388,19 @@ class Workspace {
   async isWorkspaceIndexFresh(index) {
     try {
       for (const fingerprint of index.directories) {
-        const absolute = fingerprint.path === "." ? this.root : path3.join(this.root, fingerprint.path);
-        const entry = await lstat(absolute);
+        const absolute = fingerprint.path === "." ? this.root : path4.join(this.root, fingerprint.path);
+        const entry = await lstat2(absolute);
         if (entry.isSymbolicLink() || !entry.isDirectory() || !this.sameFingerprint(entry, fingerprint))
           return false;
       }
       for (const fingerprint of index.ignoreFiles) {
-        const absolute = path3.join(this.root, fingerprint.path);
-        const before = await lstat(absolute);
+        const absolute = path4.join(this.root, fingerprint.path);
+        const before = await lstat2(absolute);
         if (before.isSymbolicLink() || !before.isFile() || !this.sameFingerprint(before, fingerprint))
           return false;
         if (fingerprint.digest) {
           const contents = await readFile(absolute);
-          const after = await lstat(absolute);
+          const after = await lstat2(absolute);
           if (after.isSymbolicLink() || !after.isFile() || !this.sameFingerprint(after, fingerprint) || digestBytes(contents) !== fingerprint.digest)
             return false;
         }
@@ -1244,18 +1474,19 @@ class Workspace {
   }
   async listFiles(relativePath = ".", options = {}) {
     const start = await this.safePath(relativePath);
-    if (!(await lstat(start.path)).isDirectory())
+    if (!(await lstat2(start.path)).isDirectory())
       throw new Error("list_files requires a directory.");
-    const requestPath = wirePath(path3.relative(this.root, start.path)) || ".";
+    const requestPath = wirePath(path4.relative(this.root, start.path)) || ".";
     const input = typeof options === "number" ? { limit: options } : options;
     const limit = input.limit ?? 200;
+    const includeDigests = input.includeDigests ?? true;
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 5000)
       throw new Error("limit must be between 1 and 5000.");
     let after = "";
     let cursorIndexVersion;
     if (input.cursor) {
       const parsed = cursorDecode(input.cursor);
-      if (parsed.v !== 2 || parsed.kind !== "list" || parsed.path !== requestPath || parsed.limit !== limit || typeof parsed.indexVersion !== "string" || typeof parsed.after !== "string") {
+      if (parsed.v !== 2 || parsed.kind !== "list" || parsed.path !== requestPath || parsed.limit !== limit || parsed.includeDigests !== includeDigests || typeof parsed.indexVersion !== "string" || typeof parsed.after !== "string") {
         throw new Error("The pagination cursor does not match this list request.");
       }
       after = parsed.after;
@@ -1279,16 +1510,28 @@ class Workspace {
     if (truncated)
       selected.pop();
     const files = [];
-    for (const candidate of selected) {
-      const file = await this.readStableFile(candidate.path);
-      files.push({ path: file.path, size: file.contents.byteLength, digest: file.digest });
+    if (includeDigests) {
+      for (const candidate of selected) {
+        const file = await this.readStableFile(candidate.path);
+        files.push({ path: file.path, size: file.contents.byteLength, digest: file.digest });
+      }
+    } else {
+      files.push(...selected.map(({ path: candidatePath }) => ({ path: candidatePath })));
     }
     const last = selected.at(-1);
     return {
       files,
       truncated,
       ...truncated && last ? {
-        nextCursor: cursorEncode({ v: 2, kind: "list", path: requestPath, limit, after: last.path, indexVersion: index.version })
+        nextCursor: cursorEncode({
+          v: 2,
+          kind: "list",
+          path: requestPath,
+          limit,
+          includeDigests,
+          after: last.path,
+          indexVersion: index.version
+        })
       } : {}
     };
   }
@@ -1320,7 +1563,7 @@ class Workspace {
     }
     const ordered = requests.map((request) => ({
       ...request,
-      path: wirePath(path3.relative(this.root, this.lexicalPath(request.path)))
+      path: wirePath(path4.relative(this.root, this.lexicalPath(request.path)))
     })).sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0) || (a.startLine ?? 1) - (b.startLine ?? 1) || (a.endLine ?? 0) - (b.endLine ?? 0));
     const stableFiles = new Map;
     let totalBytes = 0;
@@ -1355,9 +1598,9 @@ class Workspace {
     if (!query || query.length > 200)
       throw new Error("The search query must be between 1 and 200 characters.");
     const start = await this.safePath(relativePath);
-    if (!(await lstat(start.path)).isDirectory())
+    if (!(await lstat2(start.path)).isDirectory())
       throw new Error("search_files requires a directory.");
-    const requestPath = wirePath(path3.relative(this.root, start.path)) || ".";
+    const requestPath = wirePath(path4.relative(this.root, start.path)) || ".";
     const limit = options.limit ?? options.maxMatches ?? 100;
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500)
       throw new Error("limit must be between 1 and 500.");
@@ -1455,9 +1698,9 @@ class Workspace {
       };
     });
     const start = await this.safePath(relativePath);
-    if (!(await lstat(start.path)).isDirectory())
+    if (!(await lstat2(start.path)).isDirectory())
       throw new Error("searchMany requires a directory.");
-    const requestPath = wirePath(path3.relative(this.root, start.path)) || ".";
+    const requestPath = wirePath(path4.relative(this.root, start.path)) || ".";
     const prefix = requestPath === "." ? "" : `${requestPath}/`;
     const index = await this.getWorkspaceIndex();
     let candidateIndex = requestPath === "." ? 0 : firstPathAtLeast(index.files, prefix);
@@ -1506,16 +1749,16 @@ class Workspace {
     return this.auditEntries.map((entry) => ({ ...entry }));
   }
   async secureWorkspaceDirectory(directory, mode = 493) {
-    const resolvedInput = path3.resolve(directory);
+    const resolvedInput = path4.resolve(directory);
     if (!isInside(this.root, resolvedInput)) {
       throw new Error("A mutation directory escapes the workspace.");
     }
-    const segments = path3.relative(this.root, resolvedInput).split(path3.sep).filter(Boolean);
+    const segments = path4.relative(this.root, resolvedInput).split(path4.sep).filter(Boolean);
     let current = this.root;
     for (const segment of segments) {
-      current = path3.join(current, segment);
+      current = path4.join(current, segment);
       try {
-        const entry = await lstat(current);
+        const entry = await lstat2(current);
         if (entry.isSymbolicLink())
           throw new Error("A mutation directory must not contain a symbolic link.");
         if (!entry.isDirectory())
@@ -1528,7 +1771,7 @@ class Workspace {
         } catch (mkdirError) {
           if (mkdirError.code !== "EEXIST")
             throw mkdirError;
-          const raced = await lstat(current);
+          const raced = await lstat2(current);
           if (raced.isSymbolicLink() || !raced.isDirectory()) {
             throw new Error("A mutation directory changed during creation.");
           }
@@ -1541,8 +1784,8 @@ class Workspace {
     return canonical;
   }
   async stageFile(target, contents, mode) {
-    const directory = await this.secureWorkspaceDirectory(path3.dirname(target));
-    const temporary = path3.join(directory, `.${path3.basename(target)}.zhivex-${randomUUID()}.tmp`);
+    const directory = await this.secureWorkspaceDirectory(path4.dirname(target));
+    const temporary = path4.join(directory, `.${path4.basename(target)}.zhivex-${randomUUID()}.tmp`);
     const handle = await open(temporary, "wx", mode);
     try {
       await handle.writeFile(contents);
@@ -1701,7 +1944,7 @@ class Workspace {
     const destination = await this.safePath(parsed.destination, { allowMissing: true });
     if (destination.exists)
       throw new Error(`Move destination already exists: ${parsed.destination}.`);
-    await this.secureWorkspaceDirectory(path3.dirname(destination.path));
+    await this.secureWorkspaceDirectory(path4.dirname(destination.path));
     const destinationRecheck = await this.safePath(parsed.destination, { allowMissing: true });
     if (destinationRecheck.exists)
       throw new Error(`Move destination already exists: ${parsed.destination}.`);
@@ -1729,9 +1972,9 @@ class Workspace {
     const segments = [".zhivex-harness", "quarantine"];
     let current = this.root;
     for (const segment of segments) {
-      current = path3.join(current, segment);
+      current = path4.join(current, segment);
       try {
-        const entry = await lstat(current);
+        const entry = await lstat2(current);
         if (entry.isSymbolicLink()) {
           throw new Error("Harness quarantine must not resolve through a symbolic link.");
         }
@@ -1746,7 +1989,7 @@ class Workspace {
         } catch (mkdirError) {
           if (mkdirError.code !== "EEXIST")
             throw mkdirError;
-          const racedEntry = await lstat(current);
+          const racedEntry = await lstat2(current);
           if (racedEntry.isSymbolicLink() || !racedEntry.isDirectory()) {
             throw new Error("Harness quarantine path changed during creation.");
           }
@@ -1760,19 +2003,19 @@ class Workspace {
   }
   async writeManifest(manifest) {
     const directory = await this.secureQuarantineDirectory(true);
-    const target = path3.join(directory, `${manifest.quarantineId}.json`);
+    const target = path4.join(directory, `${manifest.quarantineId}.json`);
     const temporary = await this.stageFile(target, `${JSON.stringify(manifest, null, 2)}
 `, 384);
     await rename(temporary, target);
   }
   async readInternalRegularFile(target, label, maxBytes) {
-    const before = await lstat(target);
+    const before = await lstat2(target);
     if (before.isSymbolicLink() || !before.isFile())
       throw new Error(`${label} must be a regular non-symlink file.`);
     if (before.size > maxBytes)
       throw new Error(`${label} exceeds its size limit.`);
     const contents = await readFile(target);
-    const after = await lstat(target);
+    const after = await lstat2(target);
     if (after.isSymbolicLink() || !after.isFile() || before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
       throw new Error(`${label} changed while it was being read.`);
     }
@@ -1785,7 +2028,7 @@ class Workspace {
       throw new Error(`Stale quarantine rejected for ${parsed.path}.`);
     const quarantineId = `${Date.now()}-${randomUUID()}`;
     const directory = await this.secureQuarantineDirectory(true);
-    const dataPath = path3.join(directory, `${quarantineId}.data`);
+    const dataPath = path4.join(directory, `${quarantineId}.data`);
     if ((await this.readStableFile(parsed.path)).digest !== parsed.expectedDigest)
       throw new Error(`Stale quarantine rejected for ${parsed.path}.`);
     await link(source.absolutePath, dataPath);
@@ -1807,7 +2050,7 @@ class Workspace {
       await unlink(source.absolutePath);
     } catch (error) {
       await unlink(dataPath).catch(() => {});
-      await unlink(path3.join(directory, `${quarantineId}.json`)).catch(() => {});
+      await unlink(path4.join(directory, `${quarantineId}.json`)).catch(() => {});
       throw error;
     }
     this.invalidateWorkspaceIndex();
@@ -1819,7 +2062,7 @@ class Workspace {
     const directory = await this.secureQuarantineDirectory(false);
     let manifest;
     try {
-      const manifestFile = await this.readInternalRegularFile(path3.join(directory, `${parsed.quarantineId}.json`), "Quarantine manifest", 64 * 1024);
+      const manifestFile = await this.readInternalRegularFile(path4.join(directory, `${parsed.quarantineId}.json`), "Quarantine manifest", 64 * 1024);
       manifest = JSON.parse(manifestFile.contents.toString("utf8"));
     } catch {
       throw new Error(`Quarantine entry was not found: ${parsed.quarantineId}.`);
@@ -1827,7 +2070,7 @@ class Workspace {
     if (manifest.schemaVersion !== 1 || manifest.quarantineId !== parsed.quarantineId || manifest.status !== "quarantined") {
       throw new Error(`Quarantine entry is not restorable: ${parsed.quarantineId}.`);
     }
-    const dataPath = path3.join(directory, `${parsed.quarantineId}.data`);
+    const dataPath = path4.join(directory, `${parsed.quarantineId}.data`);
     const dataFile = await this.readInternalRegularFile(dataPath, "Quarantine payload", MAX_FILE_BYTES);
     const digest2 = digestBytes(dataFile.contents);
     if (digest2 !== manifest.digest || parsed.expectedDigest && parsed.expectedDigest !== digest2) {
@@ -1837,16 +2080,16 @@ class Workspace {
     const destination = await this.safePath(destinationPath, { allowMissing: true });
     if (destination.exists)
       throw new Error(`Restore destination already exists: ${destinationPath}.`);
-    await this.secureWorkspaceDirectory(path3.dirname(destination.path));
+    await this.secureWorkspaceDirectory(path4.dirname(destination.path));
     const destinationRecheck = await this.safePath(destinationPath, { allowMissing: true });
     if (destinationRecheck.exists)
       throw new Error(`Restore destination already exists: ${destinationPath}.`);
-    const dataRecheck = await lstat(dataPath);
+    const dataRecheck = await lstat2(dataPath);
     if (dataRecheck.isSymbolicLink() || !dataRecheck.isFile() || dataRecheck.dev !== dataFile.stat.dev || dataRecheck.ino !== dataFile.stat.ino || dataRecheck.size !== dataFile.stat.size || dataRecheck.mtimeMs !== dataFile.stat.mtimeMs) {
       throw new Error("Quarantine payload changed before restore commit.");
     }
     await link(dataPath, destination.path);
-    const linkedDestination = await lstat(destination.path);
+    const linkedDestination = await lstat2(destination.path);
     if (linkedDestination.isSymbolicLink() || !linkedDestination.isFile() || linkedDestination.dev !== dataFile.stat.dev || linkedDestination.ino !== dataFile.stat.ino || digestBytes(await readFile(destination.path)) !== digest2) {
       await unlink(destination.path).catch(() => {});
       throw new Error("Restore destination did not match the quarantined payload.");
@@ -1884,24 +2127,17 @@ class Workspace {
     return { quarantineId: parsed.quarantineId, path: destinationPath, digest: digest2, audit };
   }
   async runCheck(check, expectedScript, allowedChecks = DEFAULT_CHECKS) {
-    if (!/^[A-Za-z0-9:_-]+$/.test(check) || !allowedChecks.includes(check)) {
-      throw new Error(`The check "${check}" is not in the explicit allowlist.`);
-    }
-    let scripts = {};
+    let manifest;
     try {
-      const packageJson = JSON.parse((await this.readStableFile("package.json", false)).contents.toString("utf8"));
-      scripts = packageJson.scripts ?? {};
+      manifest = JSON.parse((await this.readStableFile("package.json", false)).contents.toString("utf8"));
     } catch (error) {
       if (error.code === "ENOENT")
         throw new Error("The workspace does not contain a package.json file.");
       throw error;
     }
-    if (!scripts[check])
-      throw new Error(`package.json does not define the "${check}" script.`);
-    if (scripts[check] !== expectedScript)
-      throw new Error(`The "${check}" script changed or does not match expectedScript.`);
+    const resolved = await resolvePackageCheckCommand(this.root, manifest, check, expectedScript, allowedChecks);
     try {
-      return await spawnBounded(["bun", "--no-env-file", "run", check], this.root);
+      return await spawnBounded(resolved.command, this.root);
     } finally {
       this.invalidateWorkspaceIndex();
     }
@@ -1917,8 +2153,8 @@ class Workspace {
 }
 
 // src/operations.ts
-import { chmod, lstat as lstat3, mkdir as mkdir2, open as open2 } from "fs/promises";
-import path5 from "path";
+import { chmod, lstat as lstat4, mkdir as mkdir2, open as open2 } from "node:fs/promises";
+import path6 from "node:path";
 import {
   cancelAgentRun,
   cancelAgentRunTree,
@@ -1935,29 +2171,95 @@ import {
   createSqliteAgentRunStore
 } from "@zhivex-ai/agents/ops";
 import { createAgentRunLedger } from "@zhivex-ai/agents/control-plane";
-import { Database } from "bun:sqlite";
+
+// src/sqlite-database.ts
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var DatabaseSyncConstructor;
+var loadDatabaseSync = () => {
+  DatabaseSyncConstructor ??= require2("node:sqlite").DatabaseSync;
+  return DatabaseSyncConstructor;
+};
+var normalizeNumberedParameters = (sql) => {
+  const indexes = new Set;
+  const normalizedSql = sql.replace(/\?([1-9]\d*)/g, (_match, rawIndex) => {
+    const index = Number(rawIndex);
+    indexes.add(index);
+    return `$__zhivex_${index}`;
+  });
+  return {
+    sql: normalizedSql,
+    indexes: [...indexes].sort((left, right) => left - right)
+  };
+};
+var numberedBindings = (indexes, parameters) => {
+  if (indexes.length === 0)
+    return;
+  const maximumIndex = indexes.at(-1);
+  if (parameters.length !== maximumIndex) {
+    throw new Error(`SQLite numbered parameters require exactly ${maximumIndex} binding${maximumIndex === 1 ? "" : "s"}; received ${parameters.length}.`);
+  }
+  return Object.fromEntries(indexes.map((index) => [`$__zhivex_${index}`, parameters[index - 1]]));
+};
+
+class SqliteDatabase {
+  #database;
+  constructor(databasePath, options = {}) {
+    options.create;
+    options.strict;
+    const DatabaseSync = loadDatabaseSync();
+    this.#database = new DatabaseSync(databasePath, {
+      ...options.readonly === undefined ? {} : { readOnly: options.readonly }
+    });
+  }
+  exec(sql) {
+    this.#database.exec(sql);
+  }
+  query(sql) {
+    const normalized = normalizeNumberedParameters(sql);
+    const statement = this.#database.prepare(normalized.sql);
+    const invoke = (method, parameters) => {
+      const bindings = numberedBindings(normalized.indexes, parameters);
+      return bindings ? method(bindings) : method(...parameters);
+    };
+    return {
+      run: (...parameters) => invoke(statement.run.bind(statement), parameters),
+      get: (...parameters) => invoke(statement.get.bind(statement), parameters),
+      all: (...parameters) => invoke(statement.all.bind(statement), parameters)
+    };
+  }
+  close(throwOnError = true) {
+    try {
+      this.#database.close();
+    } catch (error) {
+      if (throwOnError) {
+        throw error;
+      }
+    }
+  }
+}
 
 // src/state-directory.ts
-import { lstat as lstat2 } from "fs/promises";
-import path4 from "path";
+import { lstat as lstat3 } from "node:fs/promises";
+import path5 from "node:path";
 var SENSITIVE_STATE_SEGMENTS = new Set([".git", ".env", ".npmrc", "dist", "node_modules", "src"]);
 var isInside2 = (root, candidate) => {
-  const relative = path4.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path4.sep}`) && relative !== ".." && !path4.isAbsolute(relative);
+  const relative = path5.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path5.sep}`) && relative !== ".." && !path5.isAbsolute(relative);
 };
 var validateStateDirectory = async (workspace, stateDirectory) => {
-  if (stateDirectory === workspace || stateDirectory === path4.parse(stateDirectory).root) {
+  if (stateDirectory === workspace || stateDirectory === path5.parse(stateDirectory).root) {
     throw new Error("The state directory cannot be the workspace or filesystem root.");
   }
   const insideWorkspace = isInside2(workspace, stateDirectory);
-  const relativeSegments = insideWorkspace ? path4.relative(workspace, stateDirectory).split(path4.sep).filter(Boolean) : stateDirectory.slice(path4.parse(stateDirectory).root.length).split(path4.sep).filter(Boolean);
+  const relativeSegments = insideWorkspace ? path5.relative(workspace, stateDirectory).split(path5.sep).filter(Boolean) : stateDirectory.slice(path5.parse(stateDirectory).root.length).split(path5.sep).filter(Boolean);
   const sensitiveSegment = insideWorkspace ? relativeSegments.find((segment) => SENSITIVE_STATE_SEGMENTS.has(segment)) : undefined;
   if (sensitiveSegment) {
     throw new Error(`The state directory is inside the protected workspace path: ${sensitiveSegment}.`);
   }
   if (!insideWorkspace) {
     try {
-      const externalEntry = await lstat2(stateDirectory);
+      const externalEntry = await lstat3(stateDirectory);
       if (externalEntry.isSymbolicLink()) {
         throw new Error(`The state directory must not be a symbolic link: ${stateDirectory}.`);
       }
@@ -1973,9 +2275,9 @@ var validateStateDirectory = async (workspace, stateDirectory) => {
   }
   let current = workspace;
   for (const segment of relativeSegments) {
-    current = path4.join(current, segment);
+    current = path5.join(current, segment);
     try {
-      const entry = await lstat2(current);
+      const entry = await lstat3(current);
       if (entry.isSymbolicLink()) {
         throw new Error(`The state directory must not resolve through a symbolic link: ${current}.`);
       }
@@ -2162,7 +2464,7 @@ var sqliteAdapter = (database) => ({
 });
 var ensurePrivateStateDirectory = async (directory) => {
   await mkdir2(directory, { recursive: true, mode: 448 });
-  const entry = await lstat3(directory);
+  const entry = await lstat4(directory);
   if (entry.isSymbolicLink() || !entry.isDirectory()) {
     throw new Error(`The state directory must be a real directory: ${directory}.`);
   }
@@ -2218,17 +2520,17 @@ var openHarnessPersistence = async (config, options = {}) => {
       backend: "file",
       store,
       memory: createFileAgentMemoryStore({
-        directory: path5.join(config.stateDirectory, "memory"),
+        directory: path6.join(config.stateDirectory, "memory"),
         scope: config.scope
       }),
       migration,
       close() {}
     };
   }
-  const databasePath = path5.join(config.stateDirectory, HARNESS_SQLITE_FILE);
+  const databasePath = path6.join(config.stateDirectory, HARNESS_SQLITE_FILE);
   let databaseEntry;
   try {
-    databaseEntry = await lstat3(databasePath);
+    databaseEntry = await lstat4(databasePath);
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -2241,12 +2543,12 @@ var openHarnessPersistence = async (config, options = {}) => {
         throw creationError;
       }
     }
-    databaseEntry = await lstat3(databasePath);
+    databaseEntry = await lstat4(databasePath);
   }
   if (databaseEntry.isSymbolicLink() || !databaseEntry.isFile()) {
     throw new Error(`The SQLite state path must be a real file: ${databasePath}.`);
   }
-  const database = new Database(databasePath, { create: false, strict: true });
+  const database = new SqliteDatabase(databasePath, { create: false, strict: true });
   let closed = false;
   const closeDatabase = () => {
     if (!closed) {
@@ -2255,7 +2557,7 @@ var openHarnessPersistence = async (config, options = {}) => {
     }
   };
   try {
-    const openedEntry = await lstat3(databasePath);
+    const openedEntry = await lstat4(databasePath);
     if (openedEntry.isSymbolicLink() || !openedEntry.isFile() || openedEntry.dev !== databaseEntry.dev || openedEntry.ino !== databaseEntry.ino) {
       throw new Error(`The SQLite state path changed while it was being opened: ${databasePath}.`);
     }
@@ -2282,8 +2584,8 @@ var openHarnessPersistence = async (config, options = {}) => {
 };
 
 // src/mcp.ts
-import { lstat as lstat4, readFile as readFile2, realpath as realpath2 } from "fs/promises";
-import path6 from "path";
+import { lstat as lstat5, readFile as readFile2, realpath as realpath2 } from "node:fs/promises";
+import path7 from "node:path";
 import {
   createMcpToolSet,
   serializeJsonValue
@@ -2291,15 +2593,19 @@ import {
 import { z as z2 } from "zod";
 
 // src/version.ts
-import { createRequire } from "module";
-var packageMetadata = createRequire(import.meta.url)("../package.json");
+import { createRequire as createRequire2 } from "node:module";
+var packageMetadata = createRequire2(import.meta.url)("../package.json");
 if (typeof packageMetadata.version !== "string" || packageMetadata.version.length === 0) {
   throw new Error("package.json must contain a non-empty version.");
 }
+if (typeof packageMetadata.engines?.node !== "string" || packageMetadata.engines.node.length === 0) {
+  throw new Error("package.json must contain a non-empty engines.node requirement.");
+}
 if (typeof packageMetadata.engines?.bun !== "string" || packageMetadata.engines.bun.length === 0) {
   throw new Error("package.json must contain a non-empty engines.bun requirement.");
 }
 var HARNESS_VERSION = packageMetadata.version;
+var NODE_ENGINE_RANGE = packageMetadata.engines.node;
 var BUN_ENGINE_RANGE = packageMetadata.engines.bun;
 
 // src/mcp.ts
@@ -2333,8 +2639,8 @@ var configurationSchema = z2.object({
   servers: z2.array(serverSchema).max(20)
 }).strict();
 var isInsidePath = (root, candidate) => {
-  const relative = path6.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path6.sep}`) && !path6.isAbsolute(relative);
+  const relative = path7.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
 };
 var validatedHttpUrl = (value, serverName) => {
   let url;
@@ -2418,7 +2724,7 @@ var normalizeHarnessMcpConfiguration = (value) => {
   return { schemaVersion: HARNESS_MCP_CONFIG_SCHEMA_VERSION, servers };
 };
 var loadHarnessMcpConfiguration = async (workspace, configPath) => {
-  const entry = await lstat4(configPath);
+  const entry = await lstat5(configPath);
   if (entry.isSymbolicLink() || !entry.isFile()) {
     throw new Error(`MCP configuration must be a regular non-symlink file: ${configPath}.`);
   }
@@ -2673,7 +2979,7 @@ var createHarnessMcpTools = async (configuration, options = {}) => {
 var mcpConfigurationFingerprintInput = (configuration) => serializeJsonValue(configuration);
 
 // src/orchestration.ts
-import { createHash as createHash5, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
 import {
   applySafetyPolicyToAgent,
   createBudgetGuard,
@@ -2698,8 +3004,8 @@ var HARNESS_SUBAGENT_PROFILE_DESCRIPTORS = [
   {
     id: "tester",
     toolName: "delegate_tester",
-    description: "Delegate focused verification to a tester with read-only inspection and approved Bun checks.",
-    instructions: "Verify the delegated behavior with repository evidence and declared Bun checks. Do not edit files. Report exact failures and limits.",
+    description: "Delegate focused verification to a tester with read-only inspection and approved package-manager checks.",
+    instructions: "Verify the delegated behavior with repository evidence and declared package-manager checks. Do not edit files. Report exact failures and limits.",
     toolNames: ["list_files", "read_file", "read_files", "search_files", "search_many", "run_check", "git_diff"]
   },
   {
@@ -2844,12 +3150,13 @@ var runHarnessReviewGroup = async (runtime, input, profiles = ["explorer", "revi
 };
 
 // src/execution-environment.ts
-import { createHash as createHash6, randomUUID as randomUUID3 } from "crypto";
-import { constants as fsConstants } from "fs";
+import { createHash as createHash6, randomUUID as randomUUID3 } from "node:crypto";
+import { spawn as spawn2 } from "node:child_process";
+import { constants as fsConstants } from "node:fs";
 import {
   chmod as chmod2,
   copyFile,
-  lstat as lstat5,
+  lstat as lstat6,
   mkdir as mkdir3,
   readFile as readFile3,
   readdir as readdir2,
@@ -2857,12 +3164,13 @@ import {
   rename as rename2,
   rm,
   writeFile
-} from "fs/promises";
-import path7 from "path";
+} from "node:fs/promises";
+import path8 from "node:path";
 import { createAgentExecutionEnvironmentBinding } from "@zhivex-ai/agents/beta";
 var HARNESS_EXECUTION_ARTIFACT_SCHEMA_VERSION = 1;
 var HARNESS_OCI_LABEL = "com.zhivex.harness.execution";
 var HARNESS_OCI_LABEL_VALUE = "v1";
+var HARNESS_OCI_OWNER_PID_LABEL = "com.zhivex.harness.owner-pid";
 var TERMINAL_STATUSES = new Set([
   "completed",
   "failed",
@@ -2877,6 +3185,7 @@ var BUILT_IN_TOOL_NAMES = new Set([
   "search_many",
   "propose_edits",
   "apply_patch",
+  "apply_reviewed_edits",
   "move_file",
   "quarantine_file",
   "restore_file",
@@ -2884,19 +3193,22 @@ var BUILT_IN_TOOL_NAMES = new Set([
   "mutation_audit",
   "git_diff",
   "run_environment_command",
+  "run_environment_batch",
   "inspect_environment_patch",
   "apply_environment_patch",
+  "verify_and_apply_environment_patch",
+  "verify_and_apply_reviewed_edits",
   "environment_status"
 ]);
 var digest2 = (value) => `sha256:${createHash6("sha256").update(value).digest("hex")}`;
 var runHash = (runId) => createHash6("sha256").update(runId).digest("hex").slice(0, 24);
 var isInside3 = (root, candidate) => {
-  const relative = path7.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
+  const relative = path8.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative);
 };
 var privateDirectory = async (directory) => {
   await mkdir3(directory, { recursive: true, mode: 448 });
-  const entry = await lstat5(directory);
+  const entry = await lstat6(directory);
   if (entry.isSymbolicLink() || !entry.isDirectory()) {
     throw new Error(`Execution artifact directory must be a real directory: ${directory}.`);
   }
@@ -2909,14 +3221,19 @@ var atomicJson = async (target, value) => {
   await rename2(temporary, target);
 };
 var commandDisplay = (command) => command.map((value) => /^[A-Za-z0-9_./:=+-]+$/.test(value) ? value : JSON.stringify(value)).join(" ");
+var elapsedMilliseconds = (startedAt) => Number(process.hrtime.bigint() - startedAt) / 1e6;
 var spawnBounded2 = async (command, options) => {
-  const child = Bun.spawn(command, {
+  const child = spawn2(command[0], command.slice(1), {
     ...options.cwd ? { cwd: options.cwd } : {},
     env: options.env ?? {},
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe"
+    stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
   });
+  if (options.input !== undefined) {
+    child.stdin?.on("error", () => {
+      return;
+    });
+    child.stdin?.end(options.input);
+  }
   let timedOut = false;
   let cancelled = false;
   let outputLimitExceeded = false;
@@ -2944,22 +3261,19 @@ var spawnBounded2 = async (command, options) => {
     options.abortSignal?.addEventListener("abort", onAbort, { once: true });
   }
   const consume = async (stream) => {
-    const reader = stream.getReader();
     const chunks = [];
     let omittedBytes = 0;
-    for (;; ) {
-      const next = await reader.read();
-      if (next.done)
-        break;
-      totalOutputBytes += next.value.byteLength;
+    for await (const value of stream) {
+      const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+      totalOutputBytes += chunk.byteLength;
       if (retainedOutputBytes < options.maxOutputBytes) {
         const remaining = options.maxOutputBytes - retainedOutputBytes;
-        const kept = next.value.byteLength <= remaining ? next.value : next.value.slice(0, remaining);
+        const kept = chunk.byteLength <= remaining ? chunk : chunk.subarray(0, remaining);
         chunks.push(kept);
         retainedOutputBytes += kept.byteLength;
-        omittedBytes += next.value.byteLength - kept.byteLength;
+        omittedBytes += chunk.byteLength - kept.byteLength;
       } else {
-        omittedBytes += next.value.byteLength;
+        omittedBytes += chunk.byteLength;
       }
       if (totalOutputBytes > options.maxOutputBytes) {
         outputLimitExceeded = true;
@@ -2968,13 +3282,17 @@ var spawnBounded2 = async (command, options) => {
     }
     const text = new TextDecoder().decode(Buffer.concat(chunks));
     return omittedBytes > 0 ? `${text}
-\u2026 output limit exceeded (${omittedBytes} bytes omitted)` : text;
+… output limit exceeded (${omittedBytes} bytes omitted)` : text;
   };
+  const exited = new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (exitCode) => resolve(exitCode ?? 137));
+  });
   try {
     const [stdout, stderr, exitCode] = await Promise.all([
       consume(child.stdout),
       consume(child.stderr),
-      child.exited
+      exited
     ]);
     return {
       command,
@@ -2998,6 +3316,16 @@ var parseRuntimeVersion = (stdout, runtime) => {
 };
 var validContainerIds = (stdout) => stdout.split(/\r?\n/).map((value) => value.trim()).filter((value) => /^[a-f0-9]{12,64}$/.test(value));
 var validVolumeNames = (stdout) => stdout.split(/\r?\n/).map((value) => value.trim()).filter((value) => /^zhivex-harness-[A-Za-z0-9_.-]+$/.test(value));
+var hostProcessIsAlive = (pid) => {
+  if (!Number.isSafeInteger(pid) || pid < 1)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
 var MAX_SYNC_ENTRIES = 1e4;
 var updateSnapshotMetadata = (target, kind, relative, entry) => {
   target.update([
@@ -3020,7 +3348,7 @@ var validateSynchronizedSnapshot = async (stagedRoot, previousRoot, maxWorkspace
   const visit = async (directory, relativeDirectory = "") => {
     for (const name of (await readdir2(directory)).sort()) {
       const relative = relativeDirectory ? `${relativeDirectory}/${name}` : name;
-      const absolute = path7.join(directory, name);
+      const absolute = path8.join(directory, name);
       if (!isInside3(stagedRoot, absolute) || relative.length > 1024) {
         throw new Error(`OCI workspace export contains an invalid path: ${relative}.`);
       }
@@ -3032,7 +3360,7 @@ var validateSynchronizedSnapshot = async (stagedRoot, previousRoot, maxWorkspace
         await rm(absolute, { recursive: true, force: true });
         continue;
       }
-      const entry = await lstat5(absolute);
+      const entry = await lstat6(absolute);
       if (entry.isSymbolicLink()) {
         throw new Error(`OCI workspace export contains a symbolic link: ${relative}.`);
       }
@@ -3046,7 +3374,7 @@ var validateSynchronizedSnapshot = async (stagedRoot, previousRoot, maxWorkspace
         throw new Error(`OCI workspace export contains a special or linked file: ${relative}.`);
       }
       const contents = await readFile3(absolute);
-      const after = await lstat5(absolute);
+      const after = await lstat6(absolute);
       if (after.isSymbolicLink() || !after.isFile() || after.nlink !== 1 || entry.dev !== after.dev || entry.ino !== after.ino || entry.size !== after.size || entry.mtimeMs !== after.mtimeMs || entry.ctimeMs !== after.ctimeMs || (entry.mode & 511) !== (after.mode & 511)) {
         throw new Error(`OCI workspace export changed while it was being validated: ${relative}.`);
       }
@@ -3058,10 +3386,10 @@ var validateSynchronizedSnapshot = async (stagedRoot, previousRoot, maxWorkspace
       updateSnapshotMetadata(metadata, "file", relative, after);
       seal.update(`file\x00${relative}\x00${entry.mode & 511}\x00${entry.size}\x00${contentDigest}\x00`);
       if (entry.size > maxFileWriteBytes) {
-        const previous = path7.join(previousRoot, ...relative.split("/"));
+        const previous = path8.join(previousRoot, ...relative.split("/"));
         let unchanged = false;
         try {
-          const previousEntry = await lstat5(previous);
+          const previousEntry = await lstat6(previous);
           unchanged = previousEntry.isFile() && !previousEntry.isSymbolicLink() && previousEntry.size === entry.size && digest2(await readFile3(previous)) === contentDigest;
         } catch (error) {
           if (error.code !== "ENOENT")
@@ -3090,7 +3418,7 @@ var snapshotMetadataFingerprint = async (root, maxWorkspaceBytes) => {
       const relative = relativeDirectory ? `${relativeDirectory}/${name}` : name;
       if (relative === "node_modules")
         continue;
-      const absolute = path7.join(directory, name);
+      const absolute = path8.join(directory, name);
       if (!isInside3(root, absolute) || relative.length > 1024) {
         throw new Error(`OCI workspace snapshot contains an invalid path: ${relative}.`);
       }
@@ -3098,7 +3426,7 @@ var snapshotMetadataFingerprint = async (root, maxWorkspaceBytes) => {
       if (entries > MAX_SYNC_ENTRIES) {
         throw new Error(`OCI workspace snapshot exceeds the ${MAX_SYNC_ENTRIES}-entry limit.`);
       }
-      const entry = await lstat5(absolute);
+      const entry = await lstat6(absolute);
       if (entry.isSymbolicLink()) {
         throw new Error(`OCI workspace snapshot contains a symbolic link: ${relative}.`);
       }
@@ -3133,14 +3461,37 @@ var replaceSnapshot = async (snapshotRoot, stagedRoot) => {
   }
   await rm(backupRoot, { recursive: true, force: true });
 };
-var OCI_WORKSPACE_SEAL_SCRIPT = [
+var OCI_BACKGROUND_PROCESS_MARKER = "ZHIVEX_HARNESS_BACKGROUND_PROCESS";
+var OCI_COMMAND_TIMEOUT_MARKER = "ZHIVEX_HARNESS_COMMAND_TIMEOUT";
+var OCI_ATTESTATION_TIMEOUT_MS = 60000;
+var OCI_ATTESTATION_PROTOCOL_BYTES = 160;
+var OCI_ATTESTATION_PATTERN = /\nZHIVEX_HARNESS_ATTESTATION:(sha256:[a-f0-9]{64})\n$/;
+var OCI_COMMAND_RUNNER_SCRIPT = [
   "import { createHash } from 'node:crypto';",
+  "import { spawn } from 'node:child_process';",
+  "import { readFileSync } from 'node:fs';",
   "import { lstat, readFile, readdir, readlink, rm } from 'node:fs/promises';",
   "import path from 'node:path';",
+  "const request=JSON.parse(readFileSync(0,'utf8'));",
+  "if(!Array.isArray(request.commands)||request.commands.length===0||!request.commands.every((command)=>Array.isArray(command)&&command.length>0&&command.every((value)=>typeof value==='string')))throw new Error('invalid OCI command batch');",
+  "if(!Number.isSafeInteger(request.maxProcessRuntimeMs)||request.maxProcessRuntimeMs<1)throw new Error('invalid OCI command timeout');",
+  "const deadline=Date.now()+request.maxProcessRuntimeMs;",
+  "const run=async(command,timeoutMs)=>await new Promise((resolve,reject)=>{",
+  "const child=spawn(command[0],command.slice(1),{stdio:['ignore','inherit','inherit'],detached:true});",
+  "let settled=false;let timedOut=false;",
+  "const finish=(value,error)=>{if(settled)return;settled=true;clearTimeout(timer);error?reject(error):resolve(value);};",
+  "const timer=setTimeout(()=>{timedOut=true;try{process.kill(-child.pid,'SIGKILL');}catch{}},timeoutMs);",
+  "child.once('error',(error)=>finish(undefined,error));",
+  "child.once('exit',(code)=>finish({exitCode:timedOut?124:(code??137),timedOut}));",
+  "});",
+  "for(const command of request.commands){const remaining=deadline-Date.now();if(remaining<=0){console.error('ZHIVEX_HARNESS_COMMAND_TIMEOUT');process.exit(124);}const result=await run(command,remaining);if(result.timedOut){console.error('ZHIVEX_HARNESS_COMMAND_TIMEOUT');process.exit(124);}if(result.exitCode!==0)process.exit(result.exitCode);}",
+  "const unexpectedProcesses=async()=>(await readdir('/proc')).filter((name)=>/^\\d+$/.test(name)).map(Number).filter((pid)=>pid!==1&&pid!==process.pid);",
+  "if((await unexpectedProcesses()).length>0){console.error('ZHIVEX_HARNESS_BACKGROUND_PROCESS');process.exit(126);}",
   "const root='/workspace';",
   "const seal=createHash('sha256');",
   "const modules=path.join(root,'node_modules');",
-  "if(process.env.ZHIVEX_HARNESS_HAS_DEPENDENCIES==='1'){const entry=await lstat(modules);if(!entry.isSymbolicLink()||(await readlink(modules))!=='/dependencies')throw new Error('read-only dependency mount was replaced');}else{await rm(modules,{recursive:true,force:true});}",
+  "try{",
+  "if(request.hasDependencies===true){const entry=await lstat(modules);if(!entry.isSymbolicLink()||(await readlink(modules))!=='/dependencies')throw new Error('read-only dependency mount was replaced');}else{await rm(modules,{recursive:true,force:true});}",
   "const digest=(value)=>`sha256:${createHash('sha256').update(value).digest('hex')}`;",
   "const same=(before,after)=>before.dev===after.dev&&before.ino===after.ino&&before.size===after.size&&before.mtimeMs===after.mtimeMs&&before.ctimeMs===after.ctimeMs&&(before.mode&0o777)===(after.mode&0o777);",
   "const visit=async(directory,base='')=>{",
@@ -3159,8 +3510,10 @@ var OCI_WORKSPACE_SEAL_SCRIPT = [
   "}",
   "};",
   "await visit(root);",
+  "if((await unexpectedProcesses()).length>0){console.error('ZHIVEX_HARNESS_BACKGROUND_PROCESS');process.exit(126);}",
   "for(const name of await readdir('/tmp'))await rm(path.join('/tmp',name),{recursive:true,force:true});",
-  "console.log(`sha256:${seal.digest('hex')}`);"
+  "process.stdout.write(`\\nZHIVEX_HARNESS_ATTESTATION:sha256:${seal.digest('hex')}\\n`);",
+  "}catch(error){console.error(`ZHIVEX_HARNESS_ATTESTATION_FAILURE:${error instanceof Error?error.message:String(error)}`);process.exit(127);}"
 ].join("");
 var OCI_SESSION_CONTROLLER_SCRIPT = "setInterval(()=>{},2147483647);";
 
@@ -3277,6 +3630,8 @@ ${result.stdout}`)) {
       `${HARNESS_OCI_LABEL}=${HARNESS_OCI_LABEL_VALUE}`,
       "--label",
       `com.zhivex.harness.run=${runHash(request.runId)}`,
+      "--label",
+      `${HARNESS_OCI_OWNER_PID_LABEL}=${process.pid}`,
       volumeName
     ];
     const args = [
@@ -3311,15 +3666,16 @@ ${result.stdout}`)) {
       "--env",
       "TMPDIR=/tmp",
       "--env",
-      "BUN_INSTALL_CACHE_DIR=/tmp/bun-cache",
+      "NPM_CONFIG_CACHE=/tmp/npm-cache",
       "--env",
       "CI=1",
       ...request.dependencyRoot ? ["--volume", `${request.dependencyRoot}:/dependencies:ro`] : [],
       "--workdir",
       "/workspace",
       "--entrypoint",
-      "bun",
+      "node",
       request.imageId,
+      "--input-type=module",
       "-e",
       OCI_SESSION_CONTROLLER_SCRIPT
     ];
@@ -3332,7 +3688,7 @@ ${result.stdout}`)) {
       await this.cli([
         "cp",
         "-a",
-        `${request.snapshotRoot}${path7.sep}.`,
+        `${request.snapshotRoot}${path8.sep}.`,
         `${name}:/workspace`
       ], 60000);
       if (request.dependencyRoot) {
@@ -3343,20 +3699,19 @@ ${result.stdout}`)) {
           "--user",
           `${uid}:${gid}`,
           name,
-          "bun",
+          "node",
+          "--input-type=module",
           "-e",
           "import { symlink } from 'node:fs/promises'; await symlink('/dependencies', '/workspace/node_modules', 'dir')"
         ]);
       }
-      await this.cli(["pause", name]);
       const session = {
         key: runHash(request.runId),
         requestFingerprint,
         name,
         volumeName,
         snapshotSeal,
-        hostFingerprint,
-        paused: true
+        hostFingerprint
       };
       this.sessions.set(session.key, session);
       return session;
@@ -3369,109 +3724,100 @@ ${result.stdout}`)) {
       throw error;
     }
   }
-  async onlyControllerProcessRemains(session) {
-    const result = await this.cli(this.runtime === "podman" ? ["top", session.name, "pid"] : ["top", session.name, "-eo", "pid"]);
-    const processIds = result.stdout.split(/\r?\n/).filter((line) => /^\s*\d+\s*$/.test(line));
-    return processIds.length === 1;
-  }
-  async containerWorkspaceSeal(session, uid, gid, hasDependencies) {
-    if (session.paused) {
-      await this.cli(["unpause", session.name]);
-      session.paused = false;
-    }
-    try {
-      const result = await this.cli([
-        "exec",
-        "--workdir",
-        "/workspace",
-        "--user",
-        `${uid}:${gid}`,
-        "--env",
-        `ZHIVEX_HARNESS_HAS_DEPENDENCIES=${hasDependencies ? "1" : "0"}`,
-        session.name,
-        "bun",
-        "-e",
-        OCI_WORKSPACE_SEAL_SCRIPT
-      ], 60000, 20000);
-      const seal = result.stdout.trim();
-      if (!/^sha256:[a-f0-9]{64}$/.test(seal)) {
-        throw new Error("OCI workspace seal helper returned an invalid digest.");
-      }
-      return seal;
-    } finally {
-      if (!session.paused) {
-        await this.cli(["pause", session.name]);
-        session.paused = true;
-      }
-    }
-  }
   async runInSession(request, session, sessionReused) {
+    const totalStartedAt = process.hrtime.bigint();
     const uid = process.getuid?.() ?? 65532;
     const gid = process.getgid?.() ?? 65532;
-    if (session.paused) {
-      await this.cli(["unpause", session.name]);
-      session.paused = false;
-    }
     let forcedRemoval;
     const forceRemove = () => {
       forcedRemoval ??= this.forceRemove(session.name);
     };
+    const commandStartedAt = process.hrtime.bigint();
     const result = await spawnBounded2([
       this.runtime,
       "exec",
+      "-i",
       "--workdir",
       "/workspace",
       "--user",
       `${uid}:${gid}`,
       session.name,
-      ...request.command
+      "node",
+      "--input-type=module",
+      "-e",
+      OCI_COMMAND_RUNNER_SCRIPT
     ], {
       env: this.hostEnvironment,
-      timeoutMs: request.limits.maxProcessRuntimeMs,
-      maxOutputBytes: request.limits.maxProcessOutputBytes,
+      timeoutMs: request.limits.maxProcessRuntimeMs + OCI_ATTESTATION_TIMEOUT_MS,
+      maxOutputBytes: request.limits.maxProcessOutputBytes + OCI_ATTESTATION_PROTOCOL_BYTES,
+      input: JSON.stringify({
+        commands: request.commands,
+        maxProcessRuntimeMs: request.limits.maxProcessRuntimeMs,
+        hasDependencies: Boolean(request.dependencyRoot)
+      }),
       ...request.abortSignal ? { abortSignal: request.abortSignal } : {},
       onStop: forceRemove
     });
-    if (result.exitCode !== 0 || result.timedOut || result.cancelled || result.outputLimitExceeded) {
+    const commandAndAttestationMs = elapsedMilliseconds(commandStartedAt);
+    const attestationMatch = result.exitCode === 0 ? result.stdout.match(OCI_ATTESTATION_PATTERN) : null;
+    const commandResult = attestationMatch ? { ...result, stdout: result.stdout.slice(0, -attestationMatch[0].length) } : result;
+    if (Buffer.byteLength(commandResult.stdout) + Buffer.byteLength(commandResult.stderr) > request.limits.maxProcessOutputBytes) {
+      commandResult.outputLimitExceeded = true;
+    }
+    const command = request.commands.length === 1 ? request.commands[0] : ["<oci-batch>", String(request.commands.length)];
+    const backgroundProcess = commandResult.exitCode === 126 && commandResult.stderr.includes(OCI_BACKGROUND_PROCESS_MARKER);
+    const commandTimedOut = commandResult.exitCode === 124 && commandResult.stderr.includes(OCI_COMMAND_TIMEOUT_MARKER);
+    const attestationFailure = commandResult.exitCode === 127 ? commandResult.stderr.match(/ZHIVEX_HARNESS_ATTESTATION_FAILURE:([^\r\n]*)/) : null;
+    if (commandResult.exitCode !== 0 || commandResult.timedOut || commandResult.cancelled || commandResult.outputLimitExceeded) {
       forceRemove();
       await forcedRemoval;
       await this.destroySession(session);
+      if (attestationFailure) {
+        throw new Error(`OCI workspace attestation failed: ${attestationFailure[1] ?? "unknown failure"}.`);
+      }
       return {
-        ...result,
-        command: request.command,
+        ...commandResult,
+        command,
+        commands: request.commands,
+        ...commandTimedOut ? { timedOut: true, exitCode: 124 } : {},
+        ...backgroundProcess ? {
+          exitCode: 126,
+          stderr: [
+            commandResult.stderr.replace(OCI_BACKGROUND_PROCESS_MARKER, "").trim(),
+            "OCI command left background processes running; its workspace changes were discarded."
+          ].filter(Boolean).join(`
+`)
+        } : {},
         sessionReused,
         workspacePublished: false,
-        workspaceExported: false
+        workspaceExported: false,
+        phaseLatencies: {
+          commandAndAttestationMs,
+          totalMs: elapsedMilliseconds(totalStartedAt)
+        }
       };
     }
     try {
-      if (!await this.onlyControllerProcessRemains(session)) {
-        await this.destroySession(session);
-        return {
-          ...result,
-          command: request.command,
-          exitCode: 126,
-          stderr: [
-            result.stderr,
-            "OCI command left background processes running; its workspace changes were discarded."
-          ].filter(Boolean).join(`
-`),
-          sessionReused,
-          workspacePublished: false,
-          workspaceExported: false
-        };
+      if (!attestationMatch) {
+        throw new Error("OCI command attestation returned an invalid workspace seal.");
       }
-      const workspaceSeal = await this.containerWorkspaceSeal(session, uid, gid, Boolean(request.dependencyRoot));
+      const workspaceSeal = attestationMatch[1];
       if (workspaceSeal === session.snapshotSeal) {
         return {
-          ...result,
-          command: request.command,
+          ...commandResult,
+          command,
+          commands: request.commands,
           sessionReused,
           workspacePublished: true,
-          workspaceExported: false
+          workspaceExported: false,
+          phaseLatencies: {
+            commandAndAttestationMs,
+            totalMs: elapsedMilliseconds(totalStartedAt)
+          }
         };
       }
-      const stagedRoot = path7.join(path7.dirname(request.snapshotRoot), `.workspace-sync-${randomUUID3()}`);
+      const workspaceExportStartedAt = process.hrtime.bigint();
+      const stagedRoot = path8.join(path8.dirname(request.snapshotRoot), `.workspace-sync-${randomUUID3()}`);
       try {
         await privateDirectory(stagedRoot);
         await this.cli(["cp", `${session.name}:/workspace/.`, stagedRoot], 60000);
@@ -3483,37 +3829,62 @@ ${result.stdout}`)) {
         await rm(stagedRoot, { recursive: true, force: true });
       }
       return {
-        ...result,
-        command: request.command,
+        ...commandResult,
+        command,
+        commands: request.commands,
         sessionReused,
         workspacePublished: true,
-        workspaceExported: true
+        workspaceExported: true,
+        phaseLatencies: {
+          commandAndAttestationMs,
+          workspaceExportMs: elapsedMilliseconds(workspaceExportStartedAt),
+          totalMs: elapsedMilliseconds(totalStartedAt)
+        }
       };
     } catch (error) {
       await this.destroySession(session);
       throw error;
     }
   }
-  async runLocked(request) {
+  async runBatchLocked(request) {
+    if (request.commands.length === 0 || request.commands.some((command) => command.length === 0)) {
+      throw new Error("OCI command batch must contain at least one non-empty argv command.");
+    }
+    const totalStartedAt = process.hrtime.bigint();
     const key = runHash(request.runId);
     const requestFingerprint = this.requestFingerprint(request);
     let session = this.sessions.get(key);
     let sessionReused = Boolean(session);
     let validated;
+    let hostSynchronizationMs;
+    let sessionCreationMs;
     if (session) {
+      const synchronizationStartedAt = process.hrtime.bigint();
       const hostFingerprint = await snapshotMetadataFingerprint(request.snapshotRoot, request.limits.maxWorkspaceBytes);
       if (session.requestFingerprint !== requestFingerprint || session.hostFingerprint !== hostFingerprint) {
         await this.destroySession(session);
         session = undefined;
         sessionReused = false;
       }
+      hostSynchronizationMs = elapsedMilliseconds(synchronizationStartedAt);
     }
     if (!session) {
+      const creationStartedAt = process.hrtime.bigint();
       validated = await validateSynchronizedSnapshot(request.snapshotRoot, request.snapshotRoot, request.limits.maxWorkspaceBytes, request.limits.maxFileWriteBytes);
       session = await this.createSession(request, requestFingerprint, validated.seal, validated.metadataFingerprint);
+      sessionCreationMs = elapsedMilliseconds(creationStartedAt);
     }
     try {
-      return await this.runInSession(request, session, sessionReused);
+      const result = await this.runInSession(request, session, sessionReused);
+      return {
+        ...result,
+        phaseLatencies: {
+          ...result.phaseLatencies,
+          ...hostSynchronizationMs !== undefined ? { hostSynchronizationMs } : {},
+          ...sessionCreationMs !== undefined ? { sessionCreationMs } : {},
+          totalMs: elapsedMilliseconds(totalStartedAt)
+        }
+      };
     } catch (error) {
       if (this.sessions.get(key) === session)
         await this.destroySession(session).catch(() => {
@@ -3523,7 +3894,12 @@ ${result.stdout}`)) {
     }
   }
   async run(request) {
-    return this.withRunLock(request.runId, () => this.runLocked(request));
+    const { command, ...shared } = request;
+    const result = await this.runBatch({ ...shared, commands: [command] });
+    return { ...result, command };
+  }
+  async runBatch(request) {
+    return this.withRunLock(request.runId, () => this.runBatchLocked(request));
   }
   async removeByFilters(filters) {
     const listed = await spawnBounded2([this.runtime, "ps", "-aq", ...filters.flatMap((filter) => ["--filter", filter])], {
@@ -3569,6 +3945,39 @@ ${result.stdout}`)) {
     }
     return removed;
   }
+  async removeRunningOrphans() {
+    const listed = await spawnBounded2([
+      this.runtime,
+      "ps",
+      "-q",
+      "--filter",
+      `label=${HARNESS_OCI_LABEL}=${HARNESS_OCI_LABEL_VALUE}`,
+      "--filter",
+      "status=running"
+    ], {
+      env: this.hostEnvironment,
+      timeoutMs: 30000,
+      maxOutputBytes: 1024 * 1024
+    });
+    if (listed.exitCode !== 0)
+      return 0;
+    let removed = 0;
+    for (const id of validContainerIds(listed.stdout)) {
+      const inspected = await this.cli([
+        "inspect",
+        id,
+        "--format",
+        "{{json .Config.Labels}}"
+      ], 30000, 20000);
+      const labels = JSON.parse(inspected.stdout);
+      const ownerPid = Number(labels[HARNESS_OCI_OWNER_PID_LABEL]);
+      if (hostProcessIsAlive(ownerPid))
+        continue;
+      await this.forceRemove(id);
+      removed += 1;
+    }
+    return removed;
+  }
   async removeRunContainers(runId) {
     const key = runHash(runId);
     const session = this.sessions.get(key);
@@ -3586,14 +3995,19 @@ ${result.stdout}`)) {
     return cachedResources + containers + volumes;
   }
   async cleanupOrphans() {
-    this.sessions.clear();
     let removed = 0;
+    for (const session of [...this.sessions.values()]) {
+      await this.destroySession(session);
+      removed += 2;
+    }
+    this.sessions.clear();
     for (const status of ["created", "exited", "dead", "paused"]) {
       removed += await this.removeByFilters([
         `label=${HARNESS_OCI_LABEL}=${HARNESS_OCI_LABEL_VALUE}`,
         `status=${status}`
       ]);
     }
+    removed += await this.removeRunningOrphans();
     removed += await this.removeVolumesByFilters([
       `label=${HARNESS_OCI_LABEL}=${HARNESS_OCI_LABEL_VALUE}`
     ]);
@@ -3615,10 +4029,10 @@ var collectSnapshotInventory = async (workspace, metrics) => {
     if (metrics)
       metrics.inventoryPages += 1;
     for (const file of page.files) {
-      const absolute = path7.join(workspace.root, ...file.path.split("/"));
+      const absolute = path8.join(workspace.root, ...file.path.split("/"));
       if (!isInside3(workspace.root, absolute))
         throw new Error(`Snapshot file escaped its workspace: ${file.path}.`);
-      const entry = await lstat5(absolute);
+      const entry = await lstat6(absolute);
       if (entry.isSymbolicLink() || !entry.isFile()) {
         throw new Error(`Snapshot source is not a regular file: ${file.path}.`);
       }
@@ -3637,16 +4051,16 @@ var collectSnapshotInventory = async (workspace, metrics) => {
   return files;
 };
 var readSnapshotFile = async (workspace, expected, metrics) => {
-  const absolute = path7.join(workspace.root, ...expected.path.split("/"));
+  const absolute = path8.join(workspace.root, ...expected.path.split("/"));
   if (!isInside3(workspace.root, absolute)) {
     throw new Error(`Snapshot file escaped its workspace: ${expected.path}.`);
   }
-  const before = await lstat5(absolute);
+  const before = await lstat6(absolute);
   if (before.isSymbolicLink() || !before.isFile()) {
     throw new Error(`Snapshot source is not a regular file: ${expected.path}.`);
   }
   const contents = await readFile3(absolute);
-  const after = await lstat5(absolute);
+  const after = await lstat6(absolute);
   if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || (before.mode & 511) !== (after.mode & 511)) {
     throw new Error(`Snapshot source changed while reading: ${expected.path}.`);
   }
@@ -3684,11 +4098,11 @@ var copyWorkspaceSnapshot = async (source, baseRoot, snapshotRoot, maxWorkspaceB
   }
   for (const expected of files.values()) {
     const file = await readSnapshotFile(source, expected, metrics);
-    const baseTarget = path7.join(baseRoot, ...file.path.split("/"));
-    const snapshotTarget = path7.join(snapshotRoot, ...file.path.split("/"));
+    const baseTarget = path8.join(baseRoot, ...file.path.split("/"));
+    const snapshotTarget = path8.join(snapshotRoot, ...file.path.split("/"));
     await Promise.all([
-      mkdir3(path7.dirname(baseTarget), { recursive: true, mode: 448 }),
-      mkdir3(path7.dirname(snapshotTarget), { recursive: true, mode: 448 })
+      mkdir3(path8.dirname(baseTarget), { recursive: true, mode: 448 }),
+      mkdir3(path8.dirname(snapshotTarget), { recursive: true, mode: 448 })
     ]);
     await writeFile(baseTarget, file.contents, { mode: file.mode });
     await chmod2(baseTarget, file.mode);
@@ -3911,7 +4325,7 @@ var createHarnessOciExecutionEnvironment = async (options) => {
     }
   };
   const binding = createAgentExecutionEnvironmentBinding(manifest);
-  const environmentRoot = path7.join(options.stateDirectory, "environments");
+  const environmentRoot = path8.join(options.stateDirectory, "environments");
   return {
     manifest,
     image,
@@ -3931,14 +4345,14 @@ var createHarnessOciExecutionEnvironment = async (options) => {
         workspaceExports: 0
       };
       await privateDirectory(environmentRoot);
-      const directory = path7.join(environmentRoot, runHash(request.runId));
+      const directory = path8.join(environmentRoot, runHash(request.runId));
       await privateDirectory(directory);
-      const metadataPath = path7.join(directory, "environment.json");
-      const baseRoot = path7.join(directory, "base");
-      const snapshotRoot = path7.join(directory, "workspace");
+      const metadataPath = path8.join(directory, "environment.json");
+      const baseRoot = path8.join(directory, "base");
+      const snapshotRoot = path8.join(directory, "workspace");
       let metadata;
       try {
-        const entry = await lstat5(metadataPath);
+        const entry = await lstat6(metadataPath);
         if (entry.isSymbolicLink() || !entry.isFile())
           throw new Error("Execution metadata must be a regular file.");
         metadata = JSON.parse(await readFile3(metadataPath, "utf8"));
@@ -3967,10 +4381,10 @@ var createHarnessOciExecutionEnvironment = async (options) => {
       await atomicJson(metadataPath, metadata);
       const workspace = await Workspace.open(snapshotRoot);
       const base = await Workspace.open(baseRoot);
-      const dependencyPath = path7.join(options.workspace.root, "node_modules");
+      const dependencyPath = path8.join(options.workspace.root, "node_modules");
       let dependencyRoot;
       try {
-        const entry = await lstat5(dependencyPath);
+        const entry = await lstat6(dependencyPath);
         if (entry.isSymbolicLink() || !entry.isDirectory()) {
           throw new Error("node_modules must be a real directory before it can be mounted read-only.");
         }
@@ -3980,31 +4394,33 @@ var createHarnessOciExecutionEnvironment = async (options) => {
           throw error;
         }
       }
-      const runCommand = async (command, args, context) => {
+      const validateCommand = (command, args) => {
         if (!options.config.allowedCommands.includes(command)) {
           throw new Error(`The OCI command "${command}" is not in the explicit allowlist.`);
         }
         if (args.length > 256 || args.some((value) => value.length > 8192 || value.includes("\x00"))) {
           throw new Error("OCI command arguments exceed the bounded argument contract.");
         }
-        const result = await runtime.run({
-          runId: request.runId,
-          snapshotRoot,
-          ...dependencyRoot ? { dependencyRoot } : {},
-          command: [command, ...args],
-          imageId: image.imageId,
-          limits: {
-            maxProcessRuntimeMs: options.config.maxProcessRuntimeMs,
-            maxProcessOutputBytes: options.config.maxProcessOutputBytes,
-            maxMemoryMb: options.config.maxMemoryMb,
-            maxPids: options.config.maxPids,
-            maxCpus: options.config.maxCpus,
-            maxWorkspaceBytes: options.config.maxWorkspaceBytes,
-            maxFileWriteBytes: options.config.maxFileWriteBytes,
-            tmpfsMb: options.config.tmpfsMb
-          },
-          ...context?.abortSignal ?? request.abortSignal ? { abortSignal: context?.abortSignal ?? request.abortSignal } : {}
-        });
+        return [command, ...args];
+      };
+      const sharedRunRequest = (context) => ({
+        runId: request.runId,
+        snapshotRoot,
+        ...dependencyRoot ? { dependencyRoot } : {},
+        imageId: image.imageId,
+        limits: {
+          maxProcessRuntimeMs: options.config.maxProcessRuntimeMs,
+          maxProcessOutputBytes: options.config.maxProcessOutputBytes,
+          maxMemoryMb: options.config.maxMemoryMb,
+          maxPids: options.config.maxPids,
+          maxCpus: options.config.maxCpus,
+          maxWorkspaceBytes: options.config.maxWorkspaceBytes,
+          maxFileWriteBytes: options.config.maxFileWriteBytes,
+          tmpfsMb: options.config.tmpfsMb
+        },
+        ...context?.abortSignal ?? request.abortSignal ? { abortSignal: context?.abortSignal ?? request.abortSignal } : {}
+      });
+      const normalizeResult = (result) => {
         if (result.sessionReused === false)
           ioMetrics.containerStarts += 1;
         if (result.sessionReused === true)
@@ -4025,7 +4441,45 @@ var createHarnessOciExecutionEnvironment = async (options) => {
             ...result.outputLimitExceeded ? ["OCI command exceeded the output limit."] : []
           ].filter(Boolean).join(`
 `),
-          timedOut: result.timedOut
+          timedOut: result.timedOut,
+          ...result.phaseLatencies ? { phaseLatencies: result.phaseLatencies } : {},
+          ...result.sessionReused !== undefined ? { sessionReused: result.sessionReused } : {},
+          ...result.workspacePublished !== undefined ? { workspacePublished: result.workspacePublished } : {},
+          ...result.workspaceExported !== undefined ? { workspaceExported: result.workspaceExported } : {}
+        };
+      };
+      const runCommand2 = async (command, args, context) => normalizeResult(await runtime.run({
+        ...sharedRunRequest(context),
+        command: validateCommand(command, args)
+      }));
+      const runCommandBatch = async (commands, context) => {
+        if (commands.length === 0 || commands.length > 32) {
+          throw new Error("OCI command batch must contain between 1 and 32 commands.");
+        }
+        if (commands.reduce((total, item) => total + item.args.length, 0) > 256) {
+          throw new Error("OCI command batch exceeds the bounded argument-count contract.");
+        }
+        const argvCommands = commands.map(({ command, args }) => validateCommand(command, args));
+        if (runtime.runBatch) {
+          return normalizeResult(await runtime.runBatch({
+            ...sharedRunRequest(context),
+            commands: argvCommands
+          }));
+        }
+        const results = [];
+        for (const argv of argvCommands) {
+          const result = await runCommand2(argv[0], argv.slice(1), context);
+          results.push(result);
+          if (result.exitCode !== 0)
+            break;
+        }
+        return {
+          command: ["<oci-batch>", String(commands.length)],
+          exitCode: results.at(-1)?.exitCode ?? 1,
+          stdout: results.map((result) => result.stdout).filter(Boolean).join(""),
+          stderr: results.map((result) => result.stderr).filter(Boolean).join(`
+`),
+          timedOut: results.some((result) => result.timedOut)
         };
       };
       const session = {
@@ -4045,6 +4499,22 @@ var createHarnessOciExecutionEnvironment = async (options) => {
               return { decision: "deny", reason: "The requested OCI executable is not allowlisted." };
             }
           }
+          if (name === "verify_and_apply_environment_patch" || name === "verify_and_apply_reviewed_edits") {
+            const input = authorization.input;
+            const validBoundInput = name === "verify_and_apply_environment_patch" ? typeof input.patchId === "string" : Array.isArray(input.changes) && input.changes.length > 0;
+            if (!validBoundInput || typeof input.command !== "string" || !options.config.allowedCommands.includes(input.command) || !Array.isArray(input.args)) {
+              return { decision: "deny", reason: "The verified OCI transaction is invalid or contains a non-allowlisted executable." };
+            }
+          }
+          if (name === "run_environment_batch") {
+            const input = authorization.input;
+            if (!Array.isArray(input.commands) || input.commands.length < 1 || input.commands.length > 32 || input.commands.some((item) => {
+              const candidate = item;
+              return typeof candidate.command !== "string" || !options.config.allowedCommands.includes(candidate.command) || !Array.isArray(candidate.args);
+            })) {
+              return { decision: "deny", reason: "The requested OCI command batch is invalid or contains a non-allowlisted executable." };
+            }
+          }
           return {
             decision: "allow",
             metadata: {
@@ -4077,26 +4547,20 @@ var createHarnessOciExecutionEnvironment = async (options) => {
             io: { ...ioMetrics }
           };
         },
-        runCommand,
+        runCommand: runCommand2,
+        runCommandBatch,
         async runCheck(check, expectedScript, allowedChecks, context) {
-          if (!/^[A-Za-z0-9:_-]+$/.test(check) || !allowedChecks.includes(check)) {
-            throw new Error(`The check "${check}" is not in the explicit allowlist.`);
-          }
           let manifestDocument;
           try {
-            manifestDocument = JSON.parse(await readFile3(path7.join(snapshotRoot, "package.json"), "utf8"));
+            manifestDocument = JSON.parse(await readFile3(path8.join(snapshotRoot, "package.json"), "utf8"));
           } catch (error) {
             if (error.code === "ENOENT") {
               throw new Error("The environment snapshot does not contain package.json.");
             }
             throw error;
           }
-          const actual = manifestDocument.scripts?.[check];
-          if (!actual)
-            throw new Error(`package.json does not define the "${check}" script.`);
-          if (actual !== expectedScript)
-            throw new Error(`The "${check}" script changed or does not match expectedScript.`);
-          return runCommand("bun", ["--no-env-file", "run", check], context);
+          const resolved = await resolvePackageCheckCommand(snapshotRoot, manifestDocument, check, expectedScript, allowedChecks);
+          return runCommand2(resolved.command[0], resolved.command.slice(1), context);
         },
         async inspectPatch() {
           const patch = await createEnvironmentPatch(request.runId, base, workspace, options.config.maxFileWriteBytes, ioMetrics);
@@ -4122,7 +4586,7 @@ var createHarnessOciExecutionEnvironment = async (options) => {
   };
 };
 var cleanupHarnessExecutionArtifacts = async (stateDirectory, before) => {
-  const root = path7.join(stateDirectory, "environments");
+  const root = path8.join(stateDirectory, "environments");
   const result = { scanned: 0, deleted: 0, skipped: 0 };
   let entries;
   try {
@@ -4138,15 +4602,15 @@ var cleanupHarnessExecutionArtifacts = async (stateDirectory, before) => {
       continue;
     }
     result.scanned += 1;
-    const directory = path7.join(root, entry.name);
+    const directory = path8.join(root, entry.name);
     const resolved = await realpath3(directory);
     if (!isInside3(root, resolved)) {
       result.skipped += 1;
       continue;
     }
     try {
-      const metadataPath = path7.join(directory, "environment.json");
-      const metadataEntry = await lstat5(metadataPath);
+      const metadataPath = path8.join(directory, "environment.json");
+      const metadataEntry = await lstat6(metadataPath);
       if (metadataEntry.isSymbolicLink() || !metadataEntry.isFile())
         throw new Error("unsafe metadata");
       const metadata = JSON.parse(await readFile3(metadataPath, "utf8"));
@@ -4172,7 +4636,7 @@ var describeOciCommand = (command, args) => commandDisplay([command, ...args]);
 
 // src/harness.ts
 var APPROVAL_VERSION = "2026-08-17-v5";
-var TOOL_CONTRACT_VERSION = "workspace-batch-v2";
+var TOOL_CONTRACT_VERSION = "workspace-verified-transaction-v3";
 var createHarnessBinding = (config, mcpConfiguration, model, subagentModels, providerTransportFingerprint, executionEnvironment) => ({
   schemaVersion: 1,
   id: "zhivex-harness",
@@ -4202,14 +4666,17 @@ var HARNESS_INSTRUCTIONS = `You are Zhivex Harness, a provider-portable coding a
 
 Rules:
 - Match the user's language.
-- Inspect the repository before proposing changes. Prefer search_many and read_files for independent lookups, then use search_files or read_file when pagination or one focused read is clearer.
+- Inspect the repository before proposing changes. Use list_files with includeDigests=false for fast topology discovery, then prefer search_many and read_files for independent lookups. Omit cursor on the first paginated call and only reuse an exact nextCursor returned by the immediately preceding matching request. Read the exact digest before proposing any edit.
 - Use only workspace-relative paths. Never request or expose secrets.
 - Make the smallest coherent change that fully addresses the task.
 - For every file edit, first read its digest and call propose_edits. Apply exactly that reviewed proposal with apply_patch.
 - apply_patch, move_file, quarantine_file, restore_file, and run_check require explicit approval from the operator.
+- apply_reviewed_edits is the one-step equivalent of propose_edits plus apply_patch: its complete digest-bound changes are the approval payload and are applied atomically only after approval.
+- verify_and_apply_reviewed_edits requests one approval for complete digest-bound edits plus exact verifier argv, applies them to a clean OCI snapshot, rejects verifier-created drift, and imports only after exit code 0.
 - Calling an approval-gated tool is how you request that approval: call the tool with its complete reviewed arguments, then let the runtime pause before execution. Never replace the tool call with a textual approval request.
 - With enforced OCI execution enabled, workspace tools operate on an ephemeral snapshot. Use inspect_environment_patch and obtain a separate approval through apply_environment_patch before changing the host workspace.
-- run_environment_command executes one allowlisted argv command without a host shell. Network, privileges, resources, environment variables, and output are bounded by the OCI policy.
+- run_environment_command executes one allowlisted argv command without a host shell. Prefer run_environment_batch for a reviewed sequence that can share one final workspace attestation. Network, privileges, resources, environment variables, and output are bounded by the OCI policy.
+- verify_and_apply_environment_patch binds one reviewed patch and verifier argv, runs that verifier inside OCI, rejects any verifier-created patch drift, and imports only after exit code 0.
 - Never overwrite stale content. If an expected digest no longer matches, inspect the file again and create a new proposal.
 - Deletions are recoverable: use quarantine_file, never permanent deletion. Use restore_file to recover quarantined content.
 - Never claim a check passed unless run_check returned exitCode 0.
@@ -4248,20 +4715,29 @@ var mutationApproval = {
   approvalVersion: APPROVAL_VERSION,
   metadata: toolMetadata(["filesystem", "write"], "high")
 };
+var verifierCommandSchema = z3.strictObject({
+  command: z3.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._+-]*$/),
+  args: z3.array(z3.string().max(8192)).max(256).default([])
+});
+var verifiedReviewedEditsInputSchema = editProposalInputSchema.extend({
+  command: verifierCommandSchema.shape.command,
+  args: verifierCommandSchema.shape.args
+});
 var createWorkspaceTools = (workspace, allowedChecks) => ({
   list_files: tool({
     name: "list_files",
-    description: "List regular files with content digests using a stable cursor. Build artifacts, dependencies, Git internals, and harness state are ignored.",
+    description: "List regular files using a stable cursor. Omit cursor on the first call; on later pages pass only the exact nextCursor returned by the preceding matching request. Set includeDigests=false for fast path-only topology discovery; keep it true when size and content digests are required. Build artifacts, dependencies, Git internals, and harness state are ignored.",
     schema: z3.object({
       path: z3.string().min(1).default("."),
       limit: z3.number().int().min(1).max(500).default(200),
-      cursor: z3.string().min(1).max(2000).optional()
+      includeDigests: z3.boolean().default(true),
+      cursor: z3.string().min(1).max(2000).optional().describe("Omit on the first page. For a later page, pass only the exact nextCursor returned by the preceding matching list_files result.")
     }),
     metadata: readOnlyMetadata,
-    execute: async ({ path: path8, limit, cursor }, context) => serializeJsonValue2(await (harnessExecutionSession(context)?.workspace ?? workspace).listFiles(path8, {
-      limit,
-      ...cursor ? { cursor } : {}
-    }))
+    execute: async ({ path: path9, limit, includeDigests, cursor }, context) => {
+      const selectedWorkspace = harnessExecutionSession(context)?.workspace ?? workspace;
+      return serializeJsonValue2(await (includeDigests ? selectedWorkspace.listFiles(path9, { limit, includeDigests: true, ...cursor ? { cursor } : {} }) : selectedWorkspace.listFiles(path9, { limit, includeDigests: false, ...cursor ? { cursor } : {} })));
+    }
   }),
   read_file: tool({
     name: "read_file",
@@ -4272,7 +4748,7 @@ var createWorkspaceTools = (workspace, allowedChecks) => ({
       endLine: z3.number().int().min(1).optional()
     }),
     metadata: readOnlyMetadata,
-    execute: async ({ path: path8, startLine, endLine }, context) => serializeJsonValue2(await (harnessExecutionSession(context)?.workspace ?? workspace).readFile(path8, startLine, endLine))
+    execute: async ({ path: path9, startLine, endLine }, context) => serializeJsonValue2(await (harnessExecutionSession(context)?.workspace ?? workspace).readFile(path9, startLine, endLine))
   }),
   read_files: tool({
     name: "read_files",
@@ -4285,8 +4761,8 @@ var createWorkspaceTools = (workspace, allowedChecks) => ({
       })).min(1).max(20)
     }),
     metadata: readOnlyMetadata,
-    execute: async ({ files }, context) => serializeJsonValue2(await (harnessExecutionSession(context)?.workspace ?? workspace).readFiles(files.map(({ path: path8, startLine, endLine }) => ({
-      path: path8,
+    execute: async ({ files }, context) => serializeJsonValue2(await (harnessExecutionSession(context)?.workspace ?? workspace).readFiles(files.map(({ path: path9, startLine, endLine }) => ({
+      path: path9,
       startLine,
       ...endLine !== undefined ? { endLine } : {}
     }))))
@@ -4302,7 +4778,7 @@ var createWorkspaceTools = (workspace, allowedChecks) => ({
       cursor: z3.string().min(1).max(2000).optional()
     }),
     metadata: readOnlyMetadata,
-    execute: async ({ query, path: path8, caseSensitive, limit, cursor }, context) => serializeJsonValue2(await (harnessExecutionSession(context)?.workspace ?? workspace).searchFiles(query, path8, {
+    execute: async ({ query, path: path9, caseSensitive, limit, cursor }, context) => serializeJsonValue2(await (harnessExecutionSession(context)?.workspace ?? workspace).searchFiles(query, path9, {
       caseSensitive,
       limit,
       ...cursor ? { cursor } : {}
@@ -4328,7 +4804,7 @@ var createWorkspaceTools = (workspace, allowedChecks) => ({
       }
     }),
     metadata: readOnlyMetadata,
-    execute: async ({ queries, path: path8, limitPerQuery }, context) => serializeJsonValue2(await (harnessExecutionSession(context)?.workspace ?? workspace).searchMany(queries, path8, { limitPerQuery }))
+    execute: async ({ queries, path: path9, limitPerQuery }, context) => serializeJsonValue2(await (harnessExecutionSession(context)?.workspace ?? workspace).searchMany(queries, path9, { limitPerQuery }))
   }),
   propose_edits: tool({
     name: "propose_edits",
@@ -4350,6 +4826,19 @@ var createWorkspaceTools = (workspace, allowedChecks) => ({
       return serializeJsonValue2(editContractDocument("patch-result", await (harnessExecutionSession(context)?.workspace ?? workspace).applyPatch(proposal)));
     }
   }),
+  apply_reviewed_edits: tool({
+    name: "apply_reviewed_edits",
+    description: "Request approval for complete digest-bound changes and atomically apply them without copying a separate proposalId between model turns. The exact paths, expected digests, and contents are the approval payload.",
+    schema: editProposalInputSchema,
+    ...mutationApproval,
+    execute: async ({ changes }, context) => {
+      const proposal = createEditProposal({ changes });
+      return serializeJsonValue2(editContractDocument("patch-result", await (harnessExecutionSession(context)?.workspace ?? workspace).applyPatch({
+        proposalId: proposal.proposalId,
+        changes
+      })));
+    }
+  }),
   move_file: tool({
     name: "move_file",
     description: "Move one regular file without overwriting the destination. The source must still match expectedDigest.",
@@ -4373,7 +4862,7 @@ var createWorkspaceTools = (workspace, allowedChecks) => ({
   }),
   run_check: tool({
     name: "run_check",
-    description: `Run one explicitly allowed package.json script through Bun (${allowedChecks.join(", ")}). Read package.json first and pass its exact script text as expectedScript so the operator can review the command. No arbitrary shell or .env loading is exposed.`,
+    description: `Run one explicitly allowed package.json script through the repository package manager (${allowedChecks.join(", ")}). Read package.json first and pass its exact script text as expectedScript so the operator can review the command. No arbitrary shell or implicit lifecycle hook is exposed.`,
     schema: z3.object({
       check: z3.string().min(1).max(100).regex(/^[A-Za-z0-9:_-]+$/),
       expectedScript: z3.string().min(1).max(2000)
@@ -4425,6 +4914,29 @@ var createExecutionEnvironmentTools = (workspace) => ({
     metadata: toolMetadata(["code-execution", "filesystem"], "high"),
     execute: async ({ command, args }, context) => serializeJsonValue2(await requireExecutionSession(context).runCommand(command, args, context))
   }),
+  run_environment_batch: tool({
+    name: "run_environment_batch",
+    description: "Run 1 to 32 reviewed allowlisted argv commands sequentially inside one enforced OCI cycle. Execution stops on the first failure and the workspace is attested and published only after the batch succeeds; no host shell or network is exposed.",
+    schema: z3.strictObject({
+      commands: z3.array(z3.strictObject({
+        command: z3.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._+-]*$/),
+        args: z3.array(z3.string().max(8192)).max(256).default([])
+      })).min(1).max(32)
+    }).superRefine((input, context) => {
+      if (input.commands.reduce((total, command) => total + command.args.length, 0) > 256) {
+        context.addIssue({
+          code: "custom",
+          path: ["commands"],
+          message: "run_environment_batch allows at most 256 aggregate arguments."
+        });
+      }
+    }),
+    requiresApproval: true,
+    approvalMode: "interrupt",
+    approvalVersion: APPROVAL_VERSION,
+    metadata: toolMetadata(["code-execution", "filesystem"], "high"),
+    execute: async ({ commands }, context) => serializeJsonValue2(await requireExecutionSession(context).runCommandBatch(commands, context))
+  }),
   environment_status: tool({
     name: "environment_status",
     description: "Inspect the immutable image binding and enforced policy for the active run without exposing host paths or environment variables.",
@@ -4445,6 +4957,83 @@ var createExecutionEnvironmentTools = (workspace) => ({
     schema: z3.strictObject({ patchId: fileDigestSchema }),
     ...mutationApproval,
     execute: async ({ patchId }, context) => serializeJsonValue2(await requireExecutionSession(context).importPatch(workspace, patchId))
+  }),
+  verify_and_apply_environment_patch: tool({
+    name: "verify_and_apply_environment_patch",
+    description: "Request one approval to verify an already inspected content-bound OCI patch with exact allowlisted argv and import it only when verification succeeds without changing the reviewed patch.",
+    schema: z3.strictObject({
+      patchId: fileDigestSchema,
+      command: z3.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._+-]*$/),
+      args: z3.array(z3.string().max(8192)).max(256).default([])
+    }),
+    requiresApproval: true,
+    approvalMode: "interrupt",
+    approvalVersion: "2026-08-21-verify-and-apply-v1",
+    metadata: toolMetadata(["code-execution", "filesystem"], "high"),
+    execute: async ({ patchId, command, args }, context) => {
+      const session = requireExecutionSession(context);
+      const beforeVerification = await session.inspectPatch();
+      if (beforeVerification.patchId !== patchId) {
+        throw new Error("The OCI patch changed after review; inspect it again before verification and import.");
+      }
+      const verification = await session.runCommand(command, args, context);
+      if (verification.exitCode !== 0) {
+        throw new Error(`The approved verifier failed with exit code ${verification.exitCode}; the host workspace was not changed.`);
+      }
+      const afterVerification = await session.inspectPatch();
+      if (afterVerification.patchId !== patchId) {
+        throw new Error("The verifier changed the reviewed OCI patch; the host workspace was not changed.");
+      }
+      const imported = await session.importPatch(workspace, patchId);
+      return serializeJsonValue2({
+        schemaVersion: 1,
+        kind: "verified-environment-patch-import",
+        patchId,
+        verification,
+        imported
+      });
+    }
+  }),
+  verify_and_apply_reviewed_edits: tool({
+    name: "verify_and_apply_reviewed_edits",
+    description: "Request one approval for complete digest-bound edits and exact verifier argv. The transaction requires a clean OCI snapshot, applies the edits atomically, rejects verifier-created drift, and imports the reviewed patch only after exit code 0.",
+    schema: verifiedReviewedEditsInputSchema,
+    requiresApproval: true,
+    approvalMode: "interrupt",
+    approvalVersion: "2026-08-21-verify-reviewed-edits-v1",
+    metadata: toolMetadata(["code-execution", "filesystem", "write"], "high"),
+    execute: async ({ changes, command, args }, context) => {
+      const session = requireExecutionSession(context);
+      const initialPatch = await session.inspectPatch();
+      if (initialPatch.entries.length !== 0) {
+        throw new Error("The verified edit transaction requires a clean OCI snapshot; the host workspace was not changed.");
+      }
+      const proposal = createEditProposal({ changes });
+      await session.workspace.applyPatch({ proposalId: proposal.proposalId, changes });
+      const reviewedPatch = await session.inspectPatch();
+      const approvedPaths = [...new Set(changes.map((change) => change.path))].sort();
+      const reviewedPaths = reviewedPatch.entries.map((entry) => entry.path).sort();
+      if (JSON.stringify(reviewedPaths) !== JSON.stringify(approvedPaths)) {
+        throw new Error("The OCI patch does not match the approved edit paths; the host workspace was not changed.");
+      }
+      const verification = await session.runCommand(command, args, context);
+      if (verification.exitCode !== 0) {
+        throw new Error(`The approved verifier failed with exit code ${verification.exitCode}; the host workspace was not changed.`);
+      }
+      const afterVerification = await session.inspectPatch();
+      if (afterVerification.patchId !== reviewedPatch.patchId) {
+        throw new Error("The verifier changed the reviewed OCI patch; the host workspace was not changed.");
+      }
+      const imported = await session.importPatch(workspace, reviewedPatch.patchId);
+      return serializeJsonValue2({
+        schemaVersion: 1,
+        kind: "verified-reviewed-edit-import",
+        proposalId: proposal.proposalId,
+        patchId: reviewedPatch.patchId,
+        verification,
+        imported
+      });
+    }
   })
 });
 var estimateMessageTokens = (messages) => Math.max(1, Math.ceil(JSON.stringify(messages).length / 4));
@@ -4455,7 +5044,7 @@ var summarizeHarnessMessages = (messages) => {
     const parts = (record.parts ?? []).map((part) => {
       if (part.type === "text" && typeof part.text === "string") {
         const text = redaction.redactText(part.text).replace(/\bBearer\s+\S+/gi, "Bearer [REDACTED]").replace(/\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)|api[_-]?key|access[_-]?token|password)\s*([=:])\s*(?:"[^"]*"|'[^']*'|\S+)/gi, "$1$2[REDACTED]").replace(/\b(?:sk|ghp|gho|github_pat)-[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]").replace(/\s+/g, " ").trim();
-        return text.length > 160 ? `${text.slice(0, 160)}\u2026` : text;
+        return text.length > 160 ? `${text.slice(0, 160)}…` : text;
       }
       if (part.type === "tool-call") {
         const call = part.toolCall;
@@ -4471,7 +5060,7 @@ var summarizeHarnessMessages = (messages) => {
   });
   const summary = summaries.join(`
 `);
-  return summary.length > 4000 ? `${summary.slice(0, 4000)}\u2026` : summary;
+  return summary.length > 4000 ? `${summary.slice(0, 4000)}…` : summary;
 };
 var compactHarnessMessages = (messages) => {
   if (messages.length === 0)
@@ -4676,6 +5265,272 @@ Available bounded delegations: ${config.orchestration.profiles.map((profile) =>
     }
   };
 };
+var canonicalJson = (value) => {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+};
+var localApprovalResolutionPayload = (inputDigest, approve, reason) => JSON.stringify({ inputDigest, approve, reason: reason ?? null });
+var terminalToolCallId = (runId, step, providerToolCallId, toolName2, input) => `tool_${createHash7("sha256").update(`${runId}\x00${step}\x00${providerToolCallId}\x00${toolName2}\x00${canonicalJson(input)}`).digest("hex")}`;
+var recoverableTerminalStaleDigest = (toolName2, message) => toolName2 === "verify_and_apply_reviewed_edits" && /^Stale patch rejected for .+\.$/.test(message);
+var executeTerminalReceiptTool = async (harness, waiting, approval, response) => {
+  if (approval.kind !== "local-tool" || response.provider !== approval.provider || response.approvalRequestId !== approval.id || !response.approve || !approval.toolCallId || approval.step === undefined) {
+    throw new Error("Terminal receipt finalization requires one matching approved local-tool request.");
+  }
+  const candidate = harness.agent.tools?.[approval.name];
+  if (!candidate || !("execute" in candidate)) {
+    throw new Error(`Approved terminal tool ${approval.name} is not locally callable.`);
+  }
+  const definition = candidate;
+  const parsedInput = definition.schema.parse(JSON.parse(approval.arguments));
+  const serializedInput = serializeJsonValue2(parsedInput);
+  const session = await harness.executionEnvironment?.acquire({
+    runId: waiting.state.runId,
+    ...waiting.state.agentId ? { agentId: waiting.state.agentId } : {},
+    ...waiting.state.scope ? { scope: waiting.state.scope } : {},
+    ...waiting.state.metadata ? { metadata: waiting.state.metadata } : {}
+  });
+  if (!session)
+    throw new Error("Terminal receipt finalization requires an active execution environment.");
+  const toolVersion = [
+    definition.approvalVersion,
+    `environment:${session.binding.fingerprint}`
+  ].filter(Boolean).join("|") || "1";
+  const inputDigest = createHash7("sha256").update(canonicalJson({
+    runId: waiting.state.runId,
+    step: approval.step,
+    toolCallId: approval.toolCallId,
+    toolName: approval.name,
+    input: serializedInput,
+    toolVersion
+  })).digest("hex");
+  if (approval.id !== `approval_${inputDigest}` || approval.inputDigest !== inputDigest || approval.toolVersion !== toolVersion || approval.arguments !== canonicalJson(serializedInput)) {
+    await session.release?.({ status: "failed", error: { message: "Approval binding mismatch." } });
+    throw new Error("The terminal tool approval is stale or does not match the current runtime binding.");
+  }
+  if (harness.agent.toolApprovalSigner) {
+    if (!approval.signature) {
+      await session.release?.({ status: "failed", error: { message: "Missing approval signature." } });
+      throw new Error("The terminal tool approval is missing its required signature.");
+    }
+    const valid = harness.agent.toolApprovalSigner.verify ? await harness.agent.toolApprovalSigner.verify(inputDigest, approval.signature) : await harness.agent.toolApprovalSigner.sign(inputDigest) === approval.signature;
+    if (!valid) {
+      await session.release?.({ status: "failed", error: { message: "Invalid approval signature." } });
+      throw new Error("The terminal tool approval signature is invalid.");
+    }
+  }
+  const toolCall = { id: approval.toolCallId, name: approval.name, input: serializedInput };
+  const context = {
+    runId: waiting.state.runId,
+    ...waiting.state.agentId ? { agentId: waiting.state.agentId } : {},
+    ...harness.agent.name ? { agentName: harness.agent.name } : {},
+    ...waiting.state.scope ? { scope: waiting.state.scope } : {},
+    ...waiting.state.metadata ? { metadata: waiting.state.metadata } : {},
+    executionEnvironment: session,
+    toolCall,
+    step: approval.step,
+    model: harness.agent.model,
+    idempotencyKey: `${waiting.state.runId}:${approval.toolCallId}`
+  };
+  const authorization = {
+    manifest: session.manifest,
+    binding: session.binding,
+    tool: definition,
+    toolCall,
+    input: parsedInput,
+    context,
+    phase: "execute"
+  };
+  const decision = await session.authorize(authorization);
+  if (decision.decision === "deny") {
+    await session.release?.({ status: "failed", error: { message: decision.reason } });
+    throw new Error(`Terminal tool execution was denied by the execution environment: ${decision.reason}`);
+  }
+  const resolutionSignature = harness.agent.toolApprovalSigner ? await harness.agent.toolApprovalSigner.sign(localApprovalResolutionPayload(inputDigest, response.approve, response.reason)) : undefined;
+  const durableId = terminalToolCallId(waiting.state.runId, approval.step, approval.toolCallId, approval.name, serializedInput);
+  const idempotencyKey = `${waiting.state.runId}:${durableId}`;
+  const journalCandidate = {
+    runId: waiting.state.runId,
+    ...waiting.state.scope ? { scope: waiting.state.scope } : {},
+    toolCallId: durableId,
+    toolName: approval.name,
+    status: "pending",
+    idempotencyKey,
+    revision: 0,
+    input: serializedInput,
+    updatedAt: Date.now()
+  };
+  const journal = harness.store.claimToolExecution ? await harness.store.claimToolExecution(journalCandidate) : undefined;
+  let output;
+  try {
+    if (journal && !journal.claimed) {
+      if (journal.entry.status === "completed") {
+        output = journal.entry.output ?? null;
+      } else if (journal.entry.status === "failed") {
+        throw new Error(journal.entry.error?.message ?? `Tool "${approval.name}" previously failed.`);
+      } else {
+        throw new Error(`Tool "${approval.name}" has an indeterminate durable execution.`);
+      }
+    } else {
+      output = serializeJsonValue2(await session.execute(authorization, () => definition.execute(parsedInput, { ...context, idempotencyKey })));
+      if (journal?.claimed && harness.store.completeToolExecution) {
+        await harness.store.completeToolExecution({
+          ...journal.entry,
+          status: "completed",
+          output,
+          completedAt: Date.now(),
+          updatedAt: Date.now()
+        }, { expectedRevision: journal.entry.revision });
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (journal?.claimed && harness.store.completeToolExecution) {
+      await Promise.resolve(harness.store.completeToolExecution({
+        ...journal.entry,
+        status: "failed",
+        error: { message },
+        completedAt: Date.now(),
+        updatedAt: Date.now()
+      }, { expectedRevision: journal.entry.revision })).catch(() => {
+        return;
+      });
+    }
+    await session.release?.({
+      status: "failed",
+      error: { message }
+    });
+    if (!recoverableTerminalStaleDigest(approval.name, message))
+      throw error;
+    const now2 = Date.now();
+    const toolResult2 = {
+      toolCallId: approval.toolCallId,
+      toolName: approval.name,
+      error: { message },
+      isError: true
+    };
+    const messages2 = [
+      ...waiting.messages,
+      { role: "tool", parts: [{ type: "tool-result", toolResult: toolResult2 }] }
+    ];
+    const steps2 = waiting.steps.map((step) => step.index === approval.step ? {
+      ...step,
+      status: "completed",
+      finishedAt: now2,
+      toolResults: [...step.toolResults, toolResult2]
+    } : step);
+    const previousRevision2 = waiting.state.revision ?? 0;
+    const {
+      finalOutput: _finalOutput,
+      finishReason: _finishReason,
+      providerFinishReason: _providerFinishReason,
+      error: _stateError,
+      ...resumableState
+    } = waiting.state;
+    const state2 = {
+      ...resumableState,
+      revision: previousRevision2 + 1,
+      status: "running",
+      messages: messages2,
+      steps: steps2,
+      toolResults: [...waiting.toolResults, toolResult2],
+      pendingApprovals: [],
+      approvalHistory: [
+        ...waiting.state.approvalHistory ?? [],
+        {
+          requestId: approval.id,
+          kind: "local-tool",
+          provider: approval.provider,
+          approve: true,
+          ...response.reason ? { reason: response.reason } : {},
+          toolCallId: approval.toolCallId,
+          step: approval.step,
+          inputDigest,
+          toolVersion,
+          ...resolutionSignature ? { signature: resolutionSignature } : {},
+          resolvedAt: now2
+        }
+      ],
+      updatedAt: now2
+    };
+    await harness.store.save(state2, { expectedRevision: previousRevision2 });
+    return {
+      status: "running",
+      outputText: state2.outputText,
+      ...waiting.usage ? { usage: waiting.usage } : {},
+      messages: messages2,
+      steps: steps2,
+      toolResults: state2.toolResults,
+      state: state2
+    };
+  }
+  const now = Date.now();
+  const toolResult = {
+    toolCallId: approval.toolCallId,
+    toolName: approval.name,
+    output,
+    isError: false
+  };
+  const messages = [
+    ...waiting.messages,
+    { role: "tool", parts: [{ type: "tool-result", toolResult }] }
+  ];
+  const steps = waiting.steps.map((step) => step.index === approval.step ? {
+    ...step,
+    status: "completed",
+    finishedAt: now,
+    toolResults: [...step.toolResults, toolResult]
+  } : step);
+  const outputText = canonicalJson(output);
+  const previousRevision = waiting.state.revision ?? 0;
+  const state = {
+    ...waiting.state,
+    revision: previousRevision + 1,
+    status: "completed",
+    messages,
+    steps,
+    toolResults: [...waiting.toolResults, toolResult],
+    outputText,
+    finalOutput: output,
+    finishReason: "stop",
+    providerFinishReason: "terminal-tool-receipt",
+    pendingApprovals: [],
+    approvalHistory: [
+      ...waiting.state.approvalHistory ?? [],
+      {
+        requestId: approval.id,
+        kind: "local-tool",
+        provider: approval.provider,
+        approve: true,
+        ...response.reason ? { reason: response.reason } : {},
+        toolCallId: approval.toolCallId,
+        step: approval.step,
+        inputDigest,
+        toolVersion,
+        ...resolutionSignature ? { signature: resolutionSignature } : {},
+        resolvedAt: now
+      }
+    ],
+    updatedAt: now
+  };
+  await harness.store.save(state, { expectedRevision: previousRevision });
+  await session.release?.({ status: "completed" });
+  return {
+    status: "completed",
+    outputText,
+    finalOutput: output,
+    finishReason: "stop",
+    providerFinishReason: "terminal-tool-receipt",
+    ...waiting.usage ? { usage: waiting.usage } : {},
+    messages,
+    steps,
+    toolResults: state.toolResults,
+    state
+  };
+};
 var runHarness = async (harness, input, options = {}) => {
   let nextInput = input;
   const continuationOptions = {
@@ -4716,6 +5571,17 @@ var runHarness = async (harness, input, options = {}) => {
     if (!approvals) {
       return result;
     }
+    const terminalTools = new Set(options.terminalReceiptTools ?? []);
+    if (result.state.pendingApprovals.length === 1 && approvals.length === 1 && approvals[0]?.approve === true && terminalTools.has(result.state.pendingApprovals[0].name)) {
+      const terminalResult = await executeTerminalReceiptTool(harness, result, result.state.pendingApprovals[0], approvals[0]);
+      if (terminalResult.status === "completed")
+        return terminalResult;
+      nextInput = {
+        ...continuationOptions,
+        state: terminalResult.state
+      };
+      continue;
+    }
     nextInput = {
       ...continuationOptions,
       state: result.state,
@@ -4903,11 +5769,10 @@ var streamResultDocument = (result, sequence = 0) => {
 var serializeStreamResult = (result, sequence = 0) => JSON.stringify(streamResultDocument(result, sequence));
 
 // src/sessions.ts
-import { createHash as createHash8, randomUUID as randomUUID4 } from "crypto";
-import { chmod as chmod3, lstat as lstat6, mkdir as mkdir4, open as open3, realpath as realpath4, stat as stat3 } from "fs/promises";
-import path8 from "path";
+import { createHash as createHash8, randomUUID as randomUUID4 } from "node:crypto";
+import { chmod as chmod3, lstat as lstat7, mkdir as mkdir4, open as open3, realpath as realpath4, stat as stat3 } from "node:fs/promises";
+import path9 from "node:path";
 import { createRedactionPolicy as createRedactionPolicy3 } from "@zhivex-ai/agents";
-import { Database as Database2 } from "bun:sqlite";
 var HARNESS_SESSION_INDEX_FILE = "operations.sqlite";
 var HARNESS_SESSION_SCHEMA_VERSION = 1;
 var SESSION_RUN_STATUSES = [
@@ -5011,19 +5876,19 @@ var sessionId = () => `ses_${randomUUID4()}`;
 var turnId = () => `turn_${randomUUID4()}`;
 var isMissing = (error) => error.code === "ENOENT";
 var ensurePrivateDatabase = async (workspace, stateDirectory) => {
-  const requestedStateDirectory = path8.resolve(stateDirectory);
+  const requestedStateDirectory = path9.resolve(stateDirectory);
   await validateStateDirectory(workspace, requestedStateDirectory);
   await mkdir4(requestedStateDirectory, { recursive: true, mode: 448 });
-  const directoryEntry = await lstat6(requestedStateDirectory);
+  const directoryEntry = await lstat7(requestedStateDirectory);
   if (directoryEntry.isSymbolicLink() || !directoryEntry.isDirectory()) {
     throw new Error(`The session state directory must be a real directory: ${requestedStateDirectory}.`);
   }
   await chmod3(requestedStateDirectory, 448);
   const canonicalStateDirectory2 = await realpath4(requestedStateDirectory);
-  const databasePath = path8.join(canonicalStateDirectory2, HARNESS_SESSION_INDEX_FILE);
+  const databasePath = path9.join(canonicalStateDirectory2, HARNESS_SESSION_INDEX_FILE);
   let databaseEntry;
   try {
-    databaseEntry = await lstat6(databasePath);
+    databaseEntry = await lstat7(databasePath);
   } catch (error) {
     if (!isMissing(error)) {
       throw error;
@@ -5036,7 +5901,7 @@ var ensurePrivateDatabase = async (workspace, stateDirectory) => {
         throw creationError;
       }
     }
-    databaseEntry = await lstat6(databasePath);
+    databaseEntry = await lstat7(databasePath);
   }
   if (databaseEntry.isSymbolicLink() || !databaseEntry.isFile()) {
     throw new Error(`The session SQLite path must be a real file: ${databasePath}.`);
@@ -5060,7 +5925,7 @@ var toRunReference = (row) => ({
 var metadataSize = (input) => Object.values(input).reduce((total, value) => total + (typeof value === "string" ? byteLength(value) : 0), 0);
 var isTerminal = (status) => TERMINAL_STATUSES2.has(status);
 var openCliSessionStore = async (options) => {
-  const workspace = await realpath4(path8.resolve(options.workspace));
+  const workspace = await realpath4(path9.resolve(options.workspace));
   const workspaceEntry = await stat3(workspace);
   if (!workspaceEntry.isDirectory()) {
     throw new Error(`The session workspace is not a directory: ${workspace}.`);
@@ -5075,7 +5940,7 @@ var openCliSessionStore = async (options) => {
   const maxIndexBytes = boundedInteger("maxIndexBytes", options.maxIndexBytes, DEFAULT_MAX_INDEX_BYTES, 1024);
   const now = options.now ?? Date.now;
   const { databasePath, databaseEntry } = await ensurePrivateDatabase(workspace, options.stateDirectory);
-  const database = new Database2(databasePath, { create: false, strict: true });
+  const database = new SqliteDatabase(databasePath, { create: false, strict: true });
   let closed = false;
   const assertOpen = () => {
     if (closed) {
@@ -5195,7 +6060,7 @@ var openCliSessionStore = async (options) => {
     `).run(candidateTurnId, sourceTurnId ?? null, candidateSessionId, sequence, runId, provider, model, role, status, createdAt, isTerminal(status) ? createdAt : null, entryBytes);
   };
   try {
-    const openedEntry = await lstat6(databasePath);
+    const openedEntry = await lstat7(databasePath);
     if (openedEntry.isSymbolicLink() || !openedEntry.isFile() || openedEntry.dev !== databaseEntry.dev || openedEntry.ino !== databaseEntry.ino) {
       throw new Error(`The session SQLite path changed while it was being opened: ${databasePath}.`);
     }
@@ -5554,7 +6419,7 @@ var openCliSessionStore = async (options) => {
 var openSessionStore = openCliSessionStore;
 
 // src/change-envelope.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { z as z4 } from "zod";
 var CHANGE_ENVELOPE_SCHEMA_VERSION = 1;
 var CHANGE_ENVELOPE_DIGEST_ALGORITHM = "sha256";
@@ -5567,7 +6432,7 @@ var boundedIdentifierSchema = z4.string().min(1).max(200).regex(/^[A-Za-z0-9][A-
 var approvalScopeSchema = z4.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:/*-]*$/, "Approval scope must contain only bounded token characters.");
 var attestationFormatSchema = z4.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9.+_-]*$/);
 var mediaTypeSchema = z4.string().min(3).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*\/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*$/);
-var addDuplicateIssues = (values, key, context, path9) => {
+var addDuplicateIssues = (values, key, context, path10) => {
   const seen = new Set;
   for (let index = 0;index < values.length; index += 1) {
     const value = values[index];
@@ -5577,22 +6442,22 @@ var addDuplicateIssues = (values, key, context, path9) => {
     if (seen.has(identifier2)) {
       context.addIssue({
         code: "custom",
-        path: [index, path9],
-        message: `Duplicate ${path9}: ${identifier2}.`
+        path: [index, path10],
+        message: `Duplicate ${path10}: ${identifier2}.`
       });
     }
     seen.add(identifier2);
   }
 };
-var addCanonicalOrderIssue = (values, key, context, path9) => {
+var addCanonicalOrderIssue = (values, key, context, path10) => {
   for (let index = 1;index < values.length; index += 1) {
     const previous = values[index - 1];
     const current = values[index];
     if (previous !== undefined && current !== undefined && key(previous) >= key(current)) {
       context.addIssue({
         code: "custom",
-        path: [index, path9],
-        message: `${path9} entries must be unique and in canonical ascending order.`
+        path: [index, path10],
+        message: `${path10} entries must be unique and in canonical ascending order.`
       });
     }
   }
@@ -5760,7 +6625,7 @@ var changeEnvelopeSchema = z4.strictObject({
     }
   }
 });
-var canonicalJson = (value) => {
+var canonicalJson2 = (value) => {
   if (value === null || typeof value === "boolean" || typeof value === "string") {
     return JSON.stringify(value);
   }
@@ -5770,15 +6635,15 @@ var canonicalJson = (value) => {
     return JSON.stringify(Object.is(value, -0) ? 0 : value);
   }
   if (Array.isArray(value)) {
-    return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+    return `[${value.map((entry) => canonicalJson2(entry)).join(",")}]`;
   }
   if (typeof value === "object") {
     const record = value;
-    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(record[key])}`).join(",")}}`;
   }
   throw new TypeError(`Canonical JSON cannot encode ${typeof value}.`);
 };
-var digestCanonical = (value) => `sha256:${createHash9("sha256").update(canonicalJson(value)).digest("hex")}`;
+var digestCanonical = (value) => `sha256:${createHash9("sha256").update(canonicalJson2(value)).digest("hex")}`;
 var digestChangeEnvelopeArtifact = (value) => `sha256:${createHash9("sha256").update(value).digest("hex")}`;
 var evidencePayload = (checks) => ({
   schemaVersion: CHANGE_ENVELOPE_SCHEMA_VERSION,
@@ -5826,7 +6691,7 @@ var createChangeEnvelope = (input) => {
     envelopeId: digestCanonical(payload)
   });
 };
-var canonicalizeChangeEnvelope = (input) => canonicalJson(changeEnvelopeSchema.parse(input));
+var canonicalizeChangeEnvelope = (input) => canonicalJson2(changeEnvelopeSchema.parse(input));
 var computeChangeEnvelopeDigest = (input) => {
   const parsed = changeEnvelopeSchema.parse(input);
   return digestCanonical(envelopePayload(parsed));
@@ -5960,11 +6825,11 @@ var verifyChangeEnvelope = (input, options = {}) => {
     });
   }
   const preconditions = parsedOptions.preconditions;
-  const comparePrecondition = (field, expected, actual, path9) => {
+  const comparePrecondition = (field, expected, actual, path10) => {
     if (expected !== undefined && expected !== actual) {
       issues.push({
         code: "precondition-mismatch",
-        path: path9,
+        path: path10,
         message: `Change envelope precondition does not match: ${field}.`,
         expected,
         actual
@@ -6715,7 +7580,7 @@ Options:
   --execution <none|oci>         Enforced execution backend (default: none)
   --oci-runtime <docker|podman>  Local OCI runtime (default: docker)
   --oci-image <reference>        Preloaded immutable-capable OCI image
-  --oci-allow-command <name>     Allow one argv executable in OCI; repeatable, must include bun
+  --oci-allow-command <name>     Allow one argv executable in OCI; repeatable, include a package manager
   --oci-max-process-runtime-ms <n> Per-command timeout (default: 120000)
   --oci-max-process-output-bytes <n> Combined output ceiling (default: 20000)
   --oci-max-memory-mb <n>        Container memory ceiling (default: 1024)
@@ -6767,7 +7632,7 @@ Credentials:
   Gemini: GEMINI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY`;
 var summarizeApproval = (approval) => {
   const mustShowCompleteProposal = approval.name === "apply_patch";
-  const argumentsText = !mustShowCompleteProposal && approval.arguments.length > 1200 ? `${approval.arguments.slice(0, 1200)}\u2026` : approval.arguments;
+  const argumentsText = !mustShowCompleteProposal && approval.arguments.length > 1200 ? `${approval.arguments.slice(0, 1200)}…` : approval.arguments;
   return `[${approval.kind ?? "provider"}] ${approval.name}
 ${argumentsText}`;
 };
@@ -6889,7 +7754,7 @@ var printTerminalResult = (result, harness, output, tracker) => {
 `);
   }
   process.stderr.write(`
-run ${result.state.runId} \xB7 ${result.state.provider}/${result.state.modelId} \xB7 ${result.status} \xB7 ${result.steps.length} steps \xB7 ${harness.workspace.mutationAudit().length} mutations
+run ${result.state.runId} · ${result.state.provider}/${result.state.modelId} · ${result.status} · ${result.steps.length} steps · ${harness.workspace.mutationAudit().length} mutations
 `);
   if (result.status === "waiting_approval") {
     for (const approval of result.state.pendingApprovals) {
@@ -6919,11 +7784,11 @@ var orchestrationObserver = (json) => async (event) => {
     return;
   if (event.type === "subagent-start") {
     process.stderr.write(`
-subagent start \xB7 ${event.childAgentId ?? event.toolName}
+subagent start · ${event.childAgentId ?? event.toolName}
 `);
   } else if (event.type === "subagent-finish") {
     process.stderr.write(`
-subagent finish \xB7 ${event.childRun.agentId ?? event.childRun.toolName} \xB7 ${event.childRun.status}
+subagent finish · ${event.childRun.agentId ?? event.childRun.toolName} · ${event.childRun.status}
 `);
   }
 };
@@ -7189,9 +8054,9 @@ var chat = async (options) => {
     const current = await refreshSession();
     const latest = current.runs.at(-1);
     const routeText = routes.size === 0 ? "default" : [...routes.values()].map((route) => `${route.profile}=${route.provider}:${route.model}`).join(", ");
-    return `session ${current.sessionId} \xB7 ${harness.config.provider}/${harness.config.model}` + ` \xB7 ${messages.length} messages \xB7 routes ${routeText}` + `${latest ? ` \xB7 last ${latest.runId} (${latest.status})` : ""}`;
+    return `session ${current.sessionId} · ${harness.config.provider}/${harness.config.model}` + ` · ${messages.length} messages · routes ${routeText}` + `${latest ? ` · last ${latest.runId} (${latest.status})` : ""}`;
   };
-  process.stderr.write(`Zhivex Harness ${HARNESS_VERSION} \xB7 ${harness.config.provider}/${harness.config.model}
+  process.stderr.write(`Zhivex Harness ${HARNESS_VERSION} · ${harness.config.provider}/${harness.config.model}
 ` + `session ${session.sessionId}
 ` + `Type /help for console commands.
 `);
@@ -7206,9 +8071,9 @@ var chat = async (options) => {
         break;
       }
       if (prompt === "/help") {
-        process.stderr.write(`/provider [id] \xB7 /model [id] \xB7 /route [role=provider[:model]] \xB7 /status
-` + `/diff \xB7 /review <task> \xB7 /resume <last|sessionId> \xB7 /compact
-` + `/new [title] \xB7 /rename <title> \xB7 /clear \xB7 /exit
+        process.stderr.write(`/provider [id] · /model [id] · /route [role=provider[:model]] · /status
+` + `/diff · /review <task> · /resume <last|sessionId> · /compact
+` + `/new [title] · /rename <title> · /clear · /exit
 `);
         continue;
       }
@@ -7487,7 +8352,7 @@ var parseNumericVersion = (version) => {
   const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
   return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : undefined;
 };
-var satisfiesBunEngine = (version, range) => {
+var satisfiesEngine = (version, range) => {
   const minimumMatch = /^>=(\d+\.\d+\.\d+)$/.exec(range.trim());
   const actual = parseNumericVersion(version);
   const minimum = minimumMatch ? parseNumericVersion(minimumMatch[1] ?? "") : undefined;
@@ -7519,36 +8384,28 @@ var inspectWorkspace = async (workspace) => {
 };
 var inspectGit = async (workspace) => {
   try {
-    const versionProcess = Bun.spawn(["git", "--version"], {
-      stdin: "ignore",
-      stdout: "pipe",
+    const versionProcess = await runPortableProcess(["git", "--version"], {
+      timeoutMs: 15000,
+      maxOutputCharacters: 4096,
       stderr: "ignore"
     });
-    const [versionOutput, versionExitCode] = await Promise.all([
-      new Response(versionProcess.stdout).text(),
-      versionProcess.exited
-    ]);
-    if (versionExitCode !== 0) {
+    if (versionProcess.exitCode !== 0) {
       return diagnostic("git", "warn", "Git is unavailable.", { installed: false });
     }
-    const repositoryProcess = Bun.spawn(["git", "-C", workspace, "rev-parse", "--is-inside-work-tree"], {
-      env: { PATH: process.env.PATH ?? "", GIT_TERMINAL_PROMPT: "0" },
-      stdin: "ignore",
-      stdout: "pipe",
+    const repositoryProcess = await runPortableProcess(["git", "-C", workspace, "rev-parse", "--is-inside-work-tree"], {
+      env: { GIT_TERMINAL_PROMPT: "0" },
+      timeoutMs: 15000,
+      maxOutputCharacters: 4096,
       stderr: "ignore"
     });
-    const [repositoryOutput, repositoryExitCode] = await Promise.all([
-      new Response(repositoryProcess.stdout).text(),
-      repositoryProcess.exited
-    ]);
-    const repository = repositoryExitCode === 0 && repositoryOutput.trim() === "true";
-    return diagnostic("git", repository ? "pass" : "warn", repository ? "Git is installed and the workspace is a repository." : "Git is installed, but the workspace is not a repository.", { installed: true, repository, version: versionOutput.trim() });
+    const repository = repositoryProcess.exitCode === 0 && repositoryProcess.stdout.trim() === "true";
+    return diagnostic("git", repository ? "pass" : "warn", repository ? "Git is installed and the workspace is a repository." : "Git is installed, but the workspace is not a repository.", { installed: true, repository, version: versionProcess.stdout.trim() });
   } catch {
     return diagnostic("git", "warn", "Git is unavailable.", { installed: false });
   }
 };
 var inspectScripts = async (workspace, allowedChecks) => {
-  const packagePath = path9.join(workspace, "package.json");
+  const packagePath = path10.join(workspace, "package.json");
   try {
     const packageStat = await stat4(packagePath);
     if (!packageStat.isFile() || packageStat.size > 1024 * 1024) {
@@ -7561,7 +8418,15 @@ var inspectScripts = async (workspace, allowedChecks) => {
     const scripts = packageJson.scripts && typeof packageJson.scripts === "object" ? packageJson.scripts : {};
     const available = allowedChecks.filter((name) => typeof scripts[name] === "string");
     const missing = allowedChecks.filter((name) => typeof scripts[name] !== "string");
-    return diagnostic("scripts", available.length > 0 ? "pass" : "warn", available.length > 0 ? "Supported Bun check scripts were found." : "No supported Bun check scripts were found.", { packageJson: true, available, missing });
+    const packageManager = await resolvePackageManager(workspace, packageJson);
+    return diagnostic("scripts", available.length > 0 ? "pass" : "warn", available.length > 0 ? `Supported ${packageManager.manager} check scripts were found.` : `No supported ${packageManager.manager} check scripts were found.`, {
+      packageJson: true,
+      packageManager: packageManager.manager,
+      packageManagerSource: packageManager.source,
+      ...packageManager.evidence ? { packageManagerEvidence: packageManager.evidence } : {},
+      available,
+      missing
+    });
   } catch (error) {
     const code = error instanceof SyntaxError ? "INVALID_JSON" : error.code ?? "UNKNOWN";
     return diagnostic("scripts", "warn", "package.json could not be inspected.", {
@@ -7572,17 +8437,17 @@ var inspectScripts = async (workspace, allowedChecks) => {
   }
 };
 var isInsidePath2 = (root, candidate) => {
-  const relative = path9.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path9.sep}`) && relative !== ".." && !path9.isAbsolute(relative);
+  const relative = path10.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path10.sep}`) && relative !== ".." && !path10.isAbsolute(relative);
 };
 var containsSymlink = async (candidate, trustedPrefix) => {
-  const parsed = path9.parse(candidate);
-  const parts = trustedPrefix ? path9.relative(trustedPrefix, candidate).split(path9.sep).filter(Boolean) : candidate.slice(parsed.root.length).split(path9.sep).filter(Boolean).slice(1);
-  let current = trustedPrefix ?? path9.join(parsed.root, candidate.slice(parsed.root.length).split(path9.sep).filter(Boolean)[0] ?? "");
+  const parsed = path10.parse(candidate);
+  const parts = trustedPrefix ? path10.relative(trustedPrefix, candidate).split(path10.sep).filter(Boolean) : candidate.slice(parsed.root.length).split(path10.sep).filter(Boolean).slice(1);
+  let current = trustedPrefix ?? path10.join(parsed.root, candidate.slice(parsed.root.length).split(path10.sep).filter(Boolean)[0] ?? "");
   for (const part of parts) {
-    current = path9.join(current, part);
+    current = path10.join(current, part);
     try {
-      if ((await lstat7(current)).isSymbolicLink()) {
+      if ((await lstat8(current)).isSymbolicLink()) {
         return true;
       }
     } catch (error) {
@@ -7603,7 +8468,7 @@ var nearestExistingPath = async (candidate) => {
       if (error.code !== "ENOENT") {
         throw error;
       }
-      const parent = path9.dirname(current);
+      const parent = path10.dirname(current);
       if (parent === current) {
         throw error;
       }
@@ -7619,7 +8484,7 @@ var inspectStateDirectory = async (workspace, stateDirectory) => {
     });
   }
   if (isInsidePath2(workspace, stateDirectory)) {
-    const segments = path9.relative(workspace, stateDirectory).split(path9.sep).filter(Boolean);
+    const segments = path10.relative(workspace, stateDirectory).split(path10.sep).filter(Boolean);
     const sensitiveSegment = segments.find(isSensitiveStateSegment);
     if (sensitiveSegment) {
       return diagnostic("state-directory", "fail", "State directory is inside a sensitive workspace path.", {
@@ -7666,9 +8531,9 @@ var inspectOperationsStore = async (stateDirectory, storeBackend) => {
       migrationAvailable: true
     });
   }
-  const databasePath = path9.join(stateDirectory, "operations.sqlite");
+  const databasePath = path10.join(stateDirectory, "operations.sqlite");
   try {
-    const entry = await lstat7(databasePath);
+    const entry = await lstat8(databasePath);
     if (entry.isSymbolicLink() || !entry.isFile()) {
       return diagnostic("operations-store", "fail", "SQLite state path is not a regular file.", {
         backend: storeBackend,
@@ -7796,11 +8661,11 @@ var createDoctorReport = async (options = {}, context = {}) => {
     ...env.ZHIVEX_HARNESS_MCP_CONFIG ? { mcpConfigPath: env.ZHIVEX_HARNESS_MCP_CONFIG } : {},
     ...options
   });
-  const bunVersion = context.bunVersion ?? Bun.version;
+  const runtime = context.nodeVersion ? { name: "node", version: context.nodeVersion, required: NODE_ENGINE_RANGE } : context.bunVersion ? { name: "bun", version: context.bunVersion, required: BUN_ENGINE_RANGE } : process.versions.bun ? { name: "bun", version: process.versions.bun, required: BUN_ENGINE_RANGE } : { name: "node", version: process.versions.node, required: NODE_ENGINE_RANGE };
   const providers = providerAvailability(env);
   const selectedProvider = providers.find((provider) => provider.id === config.provider);
   const checks = [];
-  checks.push(diagnostic("bun", satisfiesBunEngine(bunVersion, BUN_ENGINE_RANGE) ? "pass" : "fail", satisfiesBunEngine(bunVersion, BUN_ENGINE_RANGE) ? "Bun satisfies the package engine requirement." : "Bun does not satisfy the package engine requirement.", { version: bunVersion, required: BUN_ENGINE_RANGE }));
+  checks.push(diagnostic(runtime.name, satisfiesEngine(runtime.version, runtime.required) ? "pass" : "fail", satisfiesEngine(runtime.version, runtime.required) ? `${runtime.name === "node" ? "Node.js" : "Bun"} satisfies the package engine requirement.` : `${runtime.name === "node" ? "Node.js" : "Bun"} does not satisfy the package engine requirement.`, { version: runtime.version, required: runtime.required, primary: runtime.name === "node" }));
   checks.push(await inspectWorkspace(config.workspace));
   checks.push(await inspectGit(config.workspace));
   checks.push(await inspectScripts(config.workspace, config.allowedChecks));
@@ -7860,7 +8725,7 @@ var createDoctorReport = async (options = {}, context = {}) => {
   };
 };
 var formatDoctorReport = (report) => {
-  const symbols = { pass: "\u2713", warn: "!", fail: "\u2717" };
+  const symbols = { pass: "✓", warn: "!", fail: "✗" };
   const lines = [
     `Zhivex Harness doctor v${report.harnessVersion}`,
     ...report.checks.map((check) => `${symbols[check.status]} ${check.id}: ${check.message}`),
@@ -7898,7 +8763,7 @@ var printRunsDocument = (document, json) => {
   }
   if (record.kind === "run-inspection") {
     const run = record.run;
-    process.stdout.write(`${String(run.runId)} \xB7 ${String(run.status)} \xB7 ${String(run.provider)}/${String(run.model)} \xB7 ${String(run.steps)} steps \xB7 ${String(run.toolCalls)} tools
+    process.stdout.write(`${String(run.runId)} · ${String(run.status)} · ${String(run.provider)}/${String(run.model)} · ${String(run.steps)} steps · ${String(run.toolCalls)} tools
 `);
     return;
   }
@@ -7971,14 +8836,14 @@ var printSessionDocument = (document, json) => {
   if (record.kind === "session-list") {
     for (const session2 of record.sessions ?? []) {
       const latest = session2.runs.at(-1);
-      process.stdout.write(`${session2.sessionId} ${session2.title ?? "(untitled)"} \xB7 ${session2.runs.length} runs` + `${latest ? ` \xB7 ${latest.provider}/${latest.model} \xB7 ${latest.status}` : ""}
+      process.stdout.write(`${session2.sessionId} ${session2.title ?? "(untitled)"} · ${session2.runs.length} runs` + `${latest ? ` · ${latest.provider}/${latest.model} · ${latest.status}` : ""}
 `);
     }
     return;
   }
   const session = record.session;
   if (session) {
-    process.stdout.write(`${session.sessionId} \xB7 ${session.title ?? "(untitled)"} \xB7 ${session.runs.length} runs` + `${session.archivedAt ? " \xB7 archived" : ""}
+    process.stdout.write(`${session.sessionId} · ${session.title ?? "(untitled)"} · ${session.runs.length} runs` + `${session.archivedAt ? " · archived" : ""}
 `);
     return;
   }
@@ -8049,9 +8914,9 @@ var cliExitCodeForError = (error) => error instanceof CliUsageError ? CLI_EXIT_C
 var MAX_CHANGE_ENVELOPE_JSON_BYTES = 4 * 1024 * 1024;
 var MAX_CHANGE_ARTIFACT_BYTES = 64 * 1024 * 1024;
 var readStableCliArtifact = async (filePath, maxBytes) => {
-  const absolute = path9.resolve(process.cwd(), filePath);
+  const absolute = path10.resolve(process.cwd(), filePath);
   try {
-    const before = await lstat7(absolute);
+    const before = await lstat8(absolute);
     if (before.isSymbolicLink() || !before.isFile()) {
       throw new CliUsageError(`Change artifact must be a regular non-symlink file: ${filePath}`);
     }
@@ -8059,7 +8924,7 @@ var readStableCliArtifact = async (filePath, maxBytes) => {
       throw new CliUsageError(`Change artifact exceeds the ${maxBytes}-byte limit: ${filePath}`);
     }
     const contents = await readFile4(absolute);
-    const after = await lstat7(absolute);
+    const after = await lstat8(absolute);
     if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
       throw new CliUsageError(`Change artifact changed while it was being read: ${filePath}`);
     }
@@ -8173,7 +9038,16 @@ var main = async (argv = process.argv.slice(2)) => {
       await reviewOnce(options);
   }
 };
-if (import.meta.main) {
+var isMainModule = (() => {
+  if (!process.argv[1])
+    return false;
+  try {
+    return realpathSync2(process.argv[1]) === realpathSync2(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+})();
+if (isMainModule) {
   main().catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     process.stderr.write(`Error: ${message}
@@ -8182,22 +9056,22 @@ if (import.meta.main) {
   });
 }
 export {
-  withTemporaryHarnessProfiles,
-  summarizeApproval,
-  runResultDocument,
-  resumeCommand,
-  readHarnessResumeRoutes,
-  readHarnessResumeConfig,
-  providersDocument,
-  parseCliArgs,
-  main,
-  formatDoctorReport,
-  createHarnessResumeMetadata,
-  createDoctorReport,
-  cliExitCodeForError,
-  HARNESS_RESUME_METADATA_SCHEMA_VERSION,
-  HARNESS_RESUME_METADATA_KEY,
-  CliUsageError,
+  CLI_EXIT_CODES,
   CLI_JSON_SCHEMA_VERSION,
-  CLI_EXIT_CODES
+  CliUsageError,
+  HARNESS_RESUME_METADATA_KEY,
+  HARNESS_RESUME_METADATA_SCHEMA_VERSION,
+  cliExitCodeForError,
+  createDoctorReport,
+  createHarnessResumeMetadata,
+  formatDoctorReport,
+  main,
+  parseCliArgs,
+  providersDocument,
+  readHarnessResumeConfig,
+  readHarnessResumeRoutes,
+  resumeCommand,
+  runResultDocument,
+  summarizeApproval,
+  withTemporaryHarnessProfiles
 };