@zhivex-ai/harness 1.4.0 → 1.5.0

package/dist/{index-m34q25jj.js → index-ggstwr0v.js}

@@ -1,6 +1,26 @@
 import {
   HARNESS_EXECUTION_POLICY_VERSION
-} from "./index-8zjmnyw5.js";
+} from "./index-1265j7t2.js";
+import {
+  FileSizeLimitError,
+  MAX_EDIT_CHANGES,
+  MAX_EDIT_PROPOSAL_BYTES,
+  SqliteDatabase,
+  UnsafeFileTypeError,
+  assertTaskAcceptanceImport,
+  confirmTaskAcceptanceImport,
+  createEditProposal,
+  fileDigestSchema,
+  moveFileInputSchema,
+  mutationAuditEntrySchema,
+  quarantineFileInputSchema,
+  readRegularFileNoFollow,
+  restoreFileInputSchema,
+  statRegularFileNoFollow,
+  taskAcceptanceChecks,
+  validateEditProposal,
+  workspaceFilePathSchema
+} from "./index-6dxrbnxm.js";
 import {
   HarnessError,
   HarnessExecutionError,
@@ -8,517 +28,9 @@ import {
   HarnessWorkspaceError
 } from "./index-bpc596v3.js";
 
-// src/workspace/edit-contracts.ts
-import { createHash } from "node:crypto";
-import path from "node:path";
-import { z } from "zod";
-var EDIT_CONTRACT_SCHEMA_VERSION = 1;
-var EDIT_DIGEST_ALGORITHM = "sha256";
-var MAX_EDIT_CHANGES = 50;
-var MAX_EDIT_FILE_BYTES = 1024 * 1024;
-var MAX_EDIT_PROPOSAL_BYTES = 4 * 1024 * 1024;
-var SHA256_DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/;
-var fileDigestSchema = z.string().regex(SHA256_DIGEST_PATTERN, "Digest must use the format sha256:<64 lowercase hexadecimal characters>.");
-var expectedEditDigestSchema = fileDigestSchema.nullable().describe("Required. Use the inspected sha256 digest for an existing file, or explicit JSON null for a create-only target. Never omit this field.");
-var workspaceFilePathSchema = z.string().min(1).max(1024).refine((value) => !value.includes("\x00"), "Path cannot contain a NUL byte.").refine((value) => !path.isAbsolute(value) && !/^[A-Za-z]:[\\/]/.test(value), "Path must be relative.").refine((value) => {
-  const segments = value.split(/[\\/]+/);
-  return segments.every((segment) => segment !== "" && segment !== "." && segment !== "..");
-}, "Path must be normalized and cannot contain empty, dot, or parent segments.");
-var editChangeSchema = z.strictObject({
-  path: workspaceFilePathSchema,
-  expectedDigest: expectedEditDigestSchema,
-  content: z.string()
-}).superRefine((change, context) => {
-  if (Buffer.byteLength(change.content, "utf8") > MAX_EDIT_FILE_BYTES) {
-    context.addIssue({
-      code: "custom",
-      path: ["content"],
-      message: `Content exceeds the ${MAX_EDIT_FILE_BYTES}-byte per-file limit.`
-    });
-  }
-});
-var editChangesSchema = z.array(editChangeSchema).min(1).max(MAX_EDIT_CHANGES).superRefine((changes, context) => {
-  const paths = new Set;
-  let totalBytes = 0;
-  for (let index = 0;index < changes.length; index += 1) {
-    const change = changes[index];
-    if (!change) {
-      continue;
-    }
-    if (paths.has(change.path)) {
-      context.addIssue({
-        code: "custom",
-        path: [index, "path"],
-        message: `Duplicate target path: ${change.path}.`
-      });
-    }
-    paths.add(change.path);
-    totalBytes += Buffer.byteLength(change.content, "utf8");
-  }
-  if (totalBytes > MAX_EDIT_PROPOSAL_BYTES) {
-    context.addIssue({
-      code: "custom",
-      message: `Proposal exceeds the ${MAX_EDIT_PROPOSAL_BYTES}-byte aggregate limit.`
-    });
-  }
-});
-var editProposalInputSchema = z.strictObject({
-  changes: editChangesSchema
-});
-var editProposalChangeSchema = z.strictObject({
-  path: workspaceFilePathSchema,
-  expectedDigest: expectedEditDigestSchema,
-  contentDigest: fileDigestSchema,
-  bytes: z.number().int().min(0).max(MAX_EDIT_FILE_BYTES)
-});
-var editProposalSchema = z.strictObject({
-  schemaVersion: z.literal(EDIT_CONTRACT_SCHEMA_VERSION),
-  kind: z.literal("edit-proposal"),
-  proposalId: fileDigestSchema,
-  digestAlgorithm: z.literal(EDIT_DIGEST_ALGORITHM),
-  changes: z.array(editProposalChangeSchema).min(1).max(MAX_EDIT_CHANGES)
-});
-var applyEditProposalInputSchema = z.strictObject({
-  proposalId: fileDigestSchema,
-  changes: editChangesSchema
-}).superRefine((input, context) => {
-  if (!editProposalInputSchema.safeParse({ changes: input.changes }).success)
-    return;
-  if (createEditProposal({ changes: input.changes }).proposalId !== input.proposalId) {
-    context.addIssue({
-      code: "custom",
-      path: ["proposalId"],
-      message: "proposalId does not match the supplied paths, preconditions, and content. Read proposalId from the matching propose_edits result; do not invent it."
-    });
-  }
-});
-var moveFileInputSchema = z.strictObject({
-  source: workspaceFilePathSchema,
-  destination: workspaceFilePathSchema,
-  expectedDigest: fileDigestSchema
-}).refine((input) => input.source !== input.destination, {
-  path: ["destination"],
-  message: "Move destination must differ from source."
-});
-var quarantineFileInputSchema = z.strictObject({
-  path: workspaceFilePathSchema,
-  expectedDigest: fileDigestSchema
-});
-var restoreFileInputSchema = z.strictObject({
-  quarantineId: z.string().min(1).max(200).regex(/^[A-Za-z0-9._:-]+$/),
-  destination: workspaceFilePathSchema.optional(),
-  expectedDigest: fileDigestSchema.optional()
-});
-var mutationOperationSchema = z.enum(["create", "update", "move", "quarantine", "restore"]);
-var mutationAuditEntrySchema = z.strictObject({
-  id: z.string().min(1).max(200),
-  operation: mutationOperationSchema,
-  path: workspaceFilePathSchema,
-  destination: workspaceFilePathSchema.optional(),
-  beforeDigest: fileDigestSchema.optional(),
-  afterDigest: fileDigestSchema.optional(),
-  timestamp: z.iso.datetime(),
-  quarantineId: z.string().min(1).max(200).optional()
-});
-var digest = (value) => `sha256:${createHash("sha256").update(value).digest("hex")}`;
-var canonicalProposalPayload = (changes) => ({
-  schemaVersion: EDIT_CONTRACT_SCHEMA_VERSION,
-  kind: "edit-proposal",
-  digestAlgorithm: EDIT_DIGEST_ALGORITHM,
-  changes: [...changes].sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0).map((change) => ({
-    path: change.path,
-    expectedDigest: change.expectedDigest,
-    contentDigest: digest(change.content),
-    bytes: Buffer.byteLength(change.content, "utf8")
-  }))
-});
-var createEditProposal = (input) => {
-  const parsed = editProposalInputSchema.parse(input);
-  const payload = canonicalProposalPayload(parsed.changes);
-  return editProposalSchema.parse({
-    ...payload,
-    proposalId: digest(JSON.stringify(payload))
-  });
-};
-var validateEditProposal = (input) => {
-  const parsed = applyEditProposalInputSchema.parse(input);
-  const proposal = createEditProposal({ changes: parsed.changes });
-  if (proposal.proposalId !== parsed.proposalId) {
-    throw new Error("proposalId does not match the supplied paths, preconditions, and content.");
-  }
-  return parsed;
-};
-var editContractDocument = (kind, result) => ({
-  schemaVersion: EDIT_CONTRACT_SCHEMA_VERSION,
-  kind,
-  result
-});
-
-// src/persistence/persistence-secrets.ts
-var protectedValues = new Set;
-function protectPersistenceSecret(secret) {
-  if (!secret)
-    return;
-  protectedValues.add(secret);
-  protectedValues.add(JSON.stringify(secret).slice(1, -1));
-}
-function assertNoPersistenceSecret(value) {
-  if (!protectedValues.size)
-    return;
-  const seen = new WeakSet;
-  const visit = (item) => {
-    if (typeof item === "string") {
-      for (const secret of protectedValues)
-        if (item.includes(secret))
-          throw new Error("PERSISTENCE_SECRET_REJECTED");
-    } else if (item instanceof Uint8Array) {
-      const bytes = Buffer.from(item.buffer, item.byteOffset, item.byteLength);
-      for (const secret of protectedValues)
-        if (bytes.includes(Buffer.from(secret)))
-          throw new Error("PERSISTENCE_SECRET_REJECTED");
-    } else if (item && typeof item === "object" && !seen.has(item)) {
-      seen.add(item);
-      for (const [key, entry] of Object.entries(item)) {
-        visit(key);
-        visit(entry);
-      }
-    }
-  };
-  visit(value);
-}
-
-// src/persistence/sqlite-access.ts
-import { closeSync, constants, fchmodSync, fstatSync, lstatSync, openSync, realpathSync } from "node:fs";
-import path2 from "node:path";
-var O_SHLOCK = 16;
-var O_EXLOCK = 32;
-var held = new WeakMap;
-var activeDescriptors = new Set;
-function filename(databasePath) {
-  const directory = realpathSync(path2.dirname(path2.resolve(databasePath)));
-  return path2.join(directory, `.${path2.basename(databasePath)}.access-lock`);
-}
-function releaseDescriptor(state) {
-  closeSync(state.fd);
-  activeDescriptors.delete(state.fd);
-}
-function makeLease(lock, fd, exclusive) {
-  const state = { filename: lock, fd, closed: false, borrowers: 0, exclusive };
-  const lease = Object.freeze({ fd, close() {
-    if (!state.closed) {
-      state.closed = true;
-      if (state.borrowers === 0)
-        releaseDescriptor(state);
-    }
-  } });
-  held.set(lease, state);
-  activeDescriptors.add(fd);
-  return lease;
-}
-function acquireSqliteAccess(databasePath, exclusive = false) {
-  if (databasePath === ":memory:" || process.platform !== "darwin")
-    return;
-  let fd;
-  try {
-    const lock = filename(databasePath);
-    fd = openSync(lock, constants.O_RDWR | constants.O_CREAT | constants.O_NOFOLLOW | constants.O_NONBLOCK | (exclusive ? O_EXLOCK : O_SHLOCK), 384);
-    const info = fstatSync(fd);
-    const current = lstatSync(lock);
-    if (!info.isFile() || info.nlink !== 1 || info.uid !== process.getuid?.() || info.size !== 0 || current.isSymbolicLink() || current.dev !== info.dev || current.ino !== info.ino)
-      throw new Error;
-    if (info.mode & 63)
-      fchmodSync(fd, 384);
-    if (fstatSync(fd).mode & 63)
-      throw new Error;
-    return makeLease(lock, fd, exclusive);
-  } catch {
-    if (fd !== undefined)
-      closeSync(fd);
-    throw new Error("SQLITE_ACCESS_UNAVAILABLE");
-  }
-}
-function retainSqliteAccess(lease, databasePath) {
-  validateSqliteAccess(lease, databasePath);
-  const state = held.get(lease);
-  state.borrowers++;
-  let released = false;
-  return () => {
-    if (!released) {
-      released = true;
-      state.borrowers--;
-      if (state.closed && state.borrowers === 0)
-        releaseDescriptor(state);
-    }
-  };
-}
-function exclusiveSqliteAccessDescriptor(lease, databasePath) {
-  validateSqliteAccess(lease, databasePath);
-  const state = held.get(lease);
-  if (!state.exclusive || state.borrowers !== 0)
-    throw new Error("SQLITE_ACCESS_UNAVAILABLE");
-  return state.fd;
-}
-function adoptExclusiveSqliteAccess(databasePath, fd) {
-  try {
-    if (process.platform !== "darwin" || !Number.isInteger(fd) || fd < 4 || fd > 603 || activeDescriptors.has(fd))
-      throw new Error;
-    const lock = filename(databasePath), current = lstatSync(lock), owned = fstatSync(fd);
-    if (!owned.isFile() || owned.nlink !== 1 || owned.uid !== process.getuid?.() || owned.mode & 63 || owned.size !== 0 || current.isSymbolicLink() || current.dev !== owned.dev || current.ino !== owned.ino)
-      throw new Error;
-    return makeLease(lock, fd, true);
-  } catch {
-    throw new Error("SQLITE_ACCESS_UNAVAILABLE");
-  }
-}
-function validateSqliteAccess(lease, databasePath) {
-  try {
-    const state = held.get(lease);
-    if (!state || state.closed || state.filename !== filename(databasePath))
-      throw new Error;
-    const current = lstatSync(state.filename), owned = fstatSync(state.fd);
-    if (current.isSymbolicLink() || !current.isFile() || current.nlink !== 1 || current.dev !== owned.dev || current.ino !== owned.ino)
-      throw new Error;
-  } catch {
-    throw new Error("SQLITE_ACCESS_UNAVAILABLE");
-  }
-}
-
-// src/persistence/sqlite-database.ts
-import { createRequire } from "node:module";
-var require2 = createRequire(process.execPath);
-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;
-  #access;
-  #ownedAccess;
-  #releaseBorrowed;
-  #databasePath;
-  constructor(databasePath, options = {}) {
-    options.create;
-    options.strict;
-    if (options.accessLease)
-      validateSqliteAccess(options.accessLease, databasePath);
-    this.#access = options.accessLease ?? acquireSqliteAccess(databasePath);
-    this.#ownedAccess = options.accessLease === undefined;
-    this.#databasePath = databasePath;
-    this.#releaseBorrowed = options.accessLease ? retainSqliteAccess(options.accessLease, databasePath) : undefined;
-    try {
-      const DatabaseSync = loadDatabaseSync();
-      this.#database = new DatabaseSync(databasePath, {
-        ...options.readonly === undefined ? {} : { readOnly: options.readonly }
-      });
-    } catch (error) {
-      if (this.#ownedAccess)
-        this.#access?.close();
-      this.#releaseBorrowed?.();
-      throw error;
-    }
-  }
-  exec(sql) {
-    if (this.#access)
-      validateSqliteAccess(this.#access, this.#databasePath);
-    assertNoPersistenceSecret(sql);
-    this.#database.exec(sql);
-  }
-  query(sql) {
-    assertNoPersistenceSecret(sql);
-    if (this.#access)
-      validateSqliteAccess(this.#access, this.#databasePath);
-    const normalized = normalizeNumberedParameters(sql);
-    const statement = this.#database.prepare(normalized.sql);
-    const invoke = (method, parameters) => {
-      if (this.#access)
-        validateSqliteAccess(this.#access, this.#databasePath);
-      assertNoPersistenceSecret(sql);
-      assertNoPersistenceSecret(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();
-      if (this.#ownedAccess)
-        this.#access?.close();
-      this.#releaseBorrowed?.();
-    } catch (error) {
-      if (throwOnError) {
-        throw error;
-      }
-    }
-  }
-}
-
-// src/workspace/file-security.ts
-import { constants as fsConstants } from "node:fs";
-import { open } from "node:fs/promises";
-import path3 from "node:path";
-var sameOpenFile = (before, after) => before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs && before.mode === after.mode && before.nlink === after.nlink;
-
-class UnsafeFileTypeError extends Error {
-  constructor(label) {
-    super(`${label} must be a regular file and must not be a symbolic link.`);
-    this.name = "UnsafeFileTypeError";
-  }
-}
-
-class FileSizeLimitError extends Error {
-  label;
-  maxBytes;
-  constructor(label, maxBytes) {
-    super(`${label} exceeds the ${maxBytes}-byte limit.`);
-    this.label = label;
-    this.maxBytes = maxBytes;
-    this.name = "FileSizeLimitError";
-  }
-}
-
-class FileChangedWhileReadingError extends Error {
-  constructor(label) {
-    super(`${label} changed while it was being read.`);
-    this.name = "FileChangedWhileReadingError";
-  }
-}
-var invalidFileError = (label) => new UnsafeFileTypeError(label);
-var openRegularFileNoFollow = async (target, label) => {
-  try {
-    const flags = fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW | fsConstants.O_NONBLOCK;
-    let absolute = path3.resolve(target);
-    if (process.platform === "darwin") {
-      absolute = absolute.replace(/^\/(tmp|var|etc)(\/|$)/, "/private/$1$2");
-      return await open(absolute, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK | 536870912, 384);
-    }
-    if (process.platform !== "linux")
-      throw new Error("Safe descriptor-relative reads require Linux or macOS.");
-    const segments = absolute.split("/").filter(Boolean);
-    const leaf = segments.pop();
-    if (!leaf)
-      throw invalidFileError(label);
-    let directory = await open("/", fsConstants.O_RDONLY | fsConstants.O_DIRECTORY);
-    try {
-      for (const segment of segments) {
-        const next = await open(`/proc/self/fd/${directory.fd}/${segment}`, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | fsConstants.O_NOFOLLOW);
-        await directory.close();
-        directory = next;
-      }
-      return await open(`/proc/self/fd/${directory.fd}/${leaf}`, flags);
-    } finally {
-      await directory.close();
-    }
-  } catch (error) {
-    const code = error.code;
-    if (code === "ELOOP" || code === "EMLINK" || code === "ENOTDIR")
-      throw invalidFileError(label);
-    throw error;
-  }
-};
-var statRegularFileNoFollow = async (target, options) => {
-  const handle = await openRegularFileNoFollow(target, options.label);
-  try {
-    const stat = await handle.stat();
-    if (!stat.isFile() || options.requireSingleLink && stat.nlink !== 1) {
-      throw invalidFileError(options.label);
-    }
-    return stat;
-  } finally {
-    await handle.close();
-  }
-};
-var readRegularFileNoFollow = async (target, options) => {
-  const handle = await openRegularFileNoFollow(target, options.label);
-  try {
-    const before = await handle.stat();
-    if (!before.isFile() || options.requireSingleLink && before.nlink !== 1) {
-      throw invalidFileError(options.label);
-    }
-    if (!Number.isSafeInteger(before.size) || before.size < 0) {
-      throw new Error(`${options.label} has an unsupported size.`);
-    }
-    if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0) {
-      throw new Error(`${options.label} has an invalid byte limit.`);
-    }
-    if (before.size > options.maxBytes) {
-      throw new FileSizeLimitError(options.label, options.maxBytes);
-    }
-    const contents = Buffer.alloc(before.size);
-    let offset = 0;
-    while (offset < contents.byteLength) {
-      const { bytesRead } = await handle.read(contents, offset, contents.byteLength - offset, offset);
-      if (bytesRead === 0)
-        break;
-      offset += bytesRead;
-    }
-    const probe = Buffer.allocUnsafe(1);
-    const { bytesRead: extraBytes } = await handle.read(probe, 0, 1, before.size);
-    const after = await handle.stat();
-    if (offset !== before.size || extraBytes !== 0 || !sameOpenFile(before, after) || options.requireSingleLink && after.nlink !== 1) {
-      throw new FileChangedWhileReadingError(options.label);
-    }
-    return { contents, stat: after };
-  } finally {
-    await handle.close();
-  }
-};
-async function* readRegularFileChunksNoFollow(target, options) {
-  const handle = await openRegularFileNoFollow(target, options.label);
-  try {
-    const before = await handle.stat();
-    if (!before.isFile() || options.requireSingleLink && before.nlink !== 1)
-      throw invalidFileError(options.label);
-    if (options.requirePrivate && (before.mode & 63) !== 0)
-      throw new Error(`${options.label} permissions must not grant group or other access.`);
-    let offset = 0;
-    while (offset < before.size) {
-      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, before.size - offset));
-      const { bytesRead: bytesRead2 } = await handle.read(buffer, 0, buffer.length, offset);
-      if (!bytesRead2)
-        throw new FileChangedWhileReadingError(options.label);
-      offset += bytesRead2;
-      yield buffer.subarray(0, bytesRead2);
-    }
-    const probe = Buffer.allocUnsafe(1);
-    const { bytesRead } = await handle.read(probe, 0, 1, offset);
-    if (bytesRead || !sameOpenFile(before, await handle.stat()))
-      throw new FileChangedWhileReadingError(options.label);
-  } finally {
-    await handle.close();
-  }
-}
-
 // src/execution/package-manager.ts
 import { lstat } from "node:fs/promises";
-import path4 from "node:path";
+import path from "node:path";
 var HARNESS_PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
 var LOCKFILES = {
   npm: ["package-lock.json", "npm-shrinkwrap.json"],
@@ -547,7 +59,7 @@ var existingLockfiles = async (root) => {
   for (const manager of HARNESS_PACKAGE_MANAGERS) {
     for (const file of LOCKFILES[manager]) {
       try {
-        const entry = await lstat(path4.join(root, file));
+        const entry = await lstat(path.join(root, file));
         if (entry.isSymbolicLink()) {
           throw new Error(`Package-manager lockfile must not be a symbolic link: ${file}.`);
         }
@@ -793,10 +305,10 @@ var runPortableProcess = async (command, options = {}) => {
 };
 
 // src/workspace/workspace-mutation-lock.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { lstat as lstat2, mkdir, open as open2, realpath } from "node:fs/promises";
-import path5 from "node:path";
+import { lstat as lstat2, mkdir, open, realpath } from "node:fs/promises";
+import path2 from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 var ownership = new AsyncLocalStorage;
 var withWorkspaceMutation = async (root, operation) => {
@@ -808,7 +320,7 @@ var withWorkspaceMutation = async (root, operation) => {
   if (uid === undefined || !["darwin", "linux"].includes(process.platform)) {
     throw new HarnessWorkspaceError("Workspace mutation locks require Linux or macOS user identity.");
   }
-  const directory = path5.join(process.platform === "darwin" ? "/private/tmp" : "/tmp", `zhivex-harness-mutation-locks-${uid}`);
+  const directory = path2.join(process.platform === "darwin" ? "/private/tmp" : "/tmp", `zhivex-harness-mutation-locks-${uid}`);
   await mkdir(directory, { mode: 448 }).catch((error) => {
     if (error.code !== "EEXIST")
       throw error;
@@ -817,22 +329,22 @@ var withWorkspaceMutation = async (root, operation) => {
   if (!entry.isDirectory() || entry.isSymbolicLink() || entry.uid !== uid || (entry.mode & 63) !== 0 || await realpath(directory) !== directory) {
     throw new HarnessWorkspaceError("Workspace mutation lock requires a real state directory without symbolic links.");
   }
-  const filename2 = path5.join(directory, `${createHash2("sha256").update(root).digest("hex")}.sqlite`);
+  const filename = path2.join(directory, `${createHash("sha256").update(root).digest("hex")}.sqlite`);
   try {
-    const created = await open2(filename2, "wx", 384);
+    const created = await open(filename, "wx", 384);
     await created.close();
   } catch (error) {
     if (error.code !== "EEXIST")
       throw error;
   }
-  const before = await statRegularFileNoFollow(filename2, { label: "Workspace mutation lock", requireSingleLink: true });
+  const before = await statRegularFileNoFollow(filename, { label: "Workspace mutation lock", requireSingleLink: true });
   if (before.uid !== uid || (before.mode & 63) !== 0)
     throw new HarnessWorkspaceError("Workspace mutation lock must be owner-only.");
-  const database = new SqliteDatabase(filename2, { create: false });
+  const database = new SqliteDatabase(filename, { create: false });
   let acquired = false;
   const token = { active: true };
   try {
-    const after = await statRegularFileNoFollow(filename2, { label: "Workspace mutation lock", requireSingleLink: true });
+    const after = await statRegularFileNoFollow(filename, { label: "Workspace mutation lock", requireSingleLink: true });
     if (before.dev !== after.dev || before.ino !== after.ino) {
       throw new HarnessWorkspaceError("Workspace mutation lock changed while opening.");
     }
@@ -865,12 +377,12 @@ var withWorkspaceMutation = async (root, operation) => {
 };
 
 // src/workspace/replacement-edits.ts
-import { z as z2 } from "zod";
-var replacementEditSchema = z2.strictObject({
+import { z } from "zod";
+var replacementEditSchema = z.strictObject({
   path: workspaceFilePathSchema,
   expectedDigest: fileDigestSchema,
-  oldText: z2.string().min(1).max(64000),
-  newText: z2.string().max(64000)
+  oldText: z.string().min(1).max(64000),
+  newText: z.string().max(64000)
 });
 
 // src/workspace/bounded-reads.ts
@@ -887,17 +399,17 @@ async function* boundedBatches(items, operation, concurrency = 8) {
 }
 
 // src/workspace/workspace.ts
-import { createHash as createHash3, randomUUID } from "node:crypto";
-import { link, lstat as lstat3, mkdir as mkdir2, open as open3, readdir, realpath as realpath2, rename, stat, unlink } from "node:fs/promises";
-import path6 from "node:path";
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { link, lstat as lstat3, mkdir as mkdir2, open as open2, readdir, realpath as realpath2, rename, stat, unlink } from "node:fs/promises";
+import path3 from "node:path";
 
 // src/workspace/path-policy.ts
 var HARD_IGNORES = new Set([".git", ".next", ".turbo", ".zhivex-harness", "coverage", "dist", "node_modules"]);
 var isSensitiveName = (name) => {
-  const normalized = name.toLocaleLowerCase();
+  const normalized = name.toLowerCase();
   return normalized === ".env" || normalized.startsWith(".env.") && normalized !== ".env.example" || normalized === ".npmrc" || normalized === "id_rsa" || normalized === "id_ed25519" || [".key", ".pem", ".p12", ".pfx"].some((extension) => normalized.endsWith(extension));
 };
-var isHardIgnored = (relativePath) => relativePath.split("/").some((segment) => HARD_IGNORES.has(segment.toLocaleLowerCase()) || isSensitiveName(segment));
+var isHardIgnored = (relativePath) => relativePath.split("/").some((segment) => HARD_IGNORES.has(segment.toLowerCase()) || isSensitiveName(segment));
 
 // src/workspace/workspace.ts
 var IGNORE_FILES = [".gitignore", ".zhivex-harnessignore"];
@@ -925,11 +437,11 @@ var MAX_GIT_DIFF_PATHS = 2048;
 var MAX_GIT_DIFF_ARGV_CHARACTERS = 128000;
 var GIT_SAFE_PREFIX = ["git", "-c", "core.fsmonitor=false"];
 var isInside = (root, candidate) => {
-  const relative = path6.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path6.sep}`) && relative !== ".." && !path6.isAbsolute(relative);
+  const relative = path3.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path3.sep}`) && relative !== ".." && !path3.isAbsolute(relative);
 };
-var wirePath = (value) => value.split(path6.sep).join("/");
-var digestBytes = (value) => `sha256:${createHash3("sha256").update(value).digest("hex")}`;
+var wirePath = (value) => value.split(path3.sep).join("/");
+var digestBytes = (value) => `sha256:${createHash2("sha256").update(value).digest("hex")}`;
 var truncate = (value, maxLength = MAX_TOOL_OUTPUT) => value.length <= maxLength ? value : `${value.slice(0, maxLength)}
 … output truncated (${value.length - maxLength} characters omitted)`;
 var cursorEncode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
@@ -1058,7 +570,7 @@ var nulFields = (result, label) => {
 };
 var safeGitPath = (candidate) => {
   const normalized = wirePath(candidate);
-  return normalized !== "" && normalized !== "." && !path6.isAbsolute(candidate) && !normalized.startsWith("../") && !isHardIgnored(normalized);
+  return normalized !== "" && normalized !== "." && !path3.isAbsolute(candidate) && !normalized.startsWith("../") && !isHardIgnored(normalized);
 };
 var renderGitPath = (candidate) => /[\0\r\n\t]/.test(candidate) ? JSON.stringify(candidate) : candidate;
 var filteredGitStatus = (result) => {
@@ -1145,7 +657,7 @@ class Workspace {
   }
   static async open(root, options = {}) {
     try {
-      const resolved = await realpath2(path6.resolve(root));
+      const resolved = await realpath2(path3.resolve(root));
       if (!(await stat(resolved)).isDirectory()) {
         throw new HarnessWorkspaceError(`The workspace is not a directory: ${root}`);
       }
@@ -1172,12 +684,12 @@ class Workspace {
   lexicalPath(relativePath) {
     if (!relativePath || relativePath.includes("\x00"))
       throw new HarnessWorkspaceError("The path must be a valid relative path.");
-    const candidate = path6.resolve(this.root, relativePath);
+    const candidate = path3.resolve(this.root, relativePath);
     if (!isInside(this.root, candidate))
       throw new HarnessWorkspaceError(`The path escapes the workspace: ${relativePath}`);
-    const relative = wirePath(path6.relative(this.root, candidate));
+    const relative = wirePath(path3.relative(this.root, candidate));
     if (relative && isHardIgnored(relative)) {
-      const blocked = relative.split("/").find((segment) => HARD_IGNORES.has(segment.toLocaleLowerCase()) || isSensitiveName(segment));
+      const blocked = relative.split("/").find((segment) => HARD_IGNORES.has(segment.toLowerCase()) || isSensitiveName(segment));
       throw new HarnessWorkspaceError(`The path is protected by the harness policy: ${blocked}`);
     }
     return candidate;
@@ -1186,10 +698,10 @@ class Workspace {
     const candidate = this.lexicalPath(relativePath);
     if (candidate === this.root && options.requireFile)
       throw new HarnessWorkspaceError("The workspace root is not a regular file.");
-    const segments = path6.relative(this.root, candidate).split(path6.sep).filter(Boolean);
+    const segments = path3.relative(this.root, candidate).split(path3.sep).filter(Boolean);
     let current = this.root;
     for (let index = 0;index < segments.length; index += 1) {
-      current = path6.join(current, segments[index]);
+      current = path3.join(current, segments[index]);
       const leaf = index === segments.length - 1;
       if (leaf && options.skipLeafValidation)
         continue;
@@ -1223,14 +735,14 @@ class Workspace {
     if (!allowBinary && contents.includes(0))
       throw new HarnessWorkspaceError("The file appears to be binary and cannot be read as text.");
     return {
-      path: wirePath(path6.relative(this.root, safe.path)),
+      path: wirePath(path3.relative(this.root, safe.path)),
       absolutePath: safe.path,
       contents,
       digest: digestBytes(contents),
       mode: file.stat.mode & 511
     };
   }
-  fingerprint(relativePath, kind, entry, digest2) {
+  fingerprint(relativePath, kind, entry, digest) {
     return {
       path: relativePath || ".",
       kind,
@@ -1239,7 +751,7 @@ class Workspace {
       size: entry.size,
       mtimeMs: entry.mtimeMs,
       ctimeMs: entry.ctimeMs,
-      ...digest2 ? { digest: digest2 } : {}
+      ...digest ? { digest } : {}
     };
   }
   sameFingerprint(entry, fingerprint) {
@@ -1247,20 +759,20 @@ class Workspace {
   }
   async rulesForDirectory(directory, base, inherited, ignoreFiles) {
     const rules = [...inherited];
-    for (const filename2 of IGNORE_FILES) {
+    for (const filename of IGNORE_FILES) {
       try {
-        const ignorePath = path6.join(directory, filename2);
+        const ignorePath = path3.join(directory, filename);
         const inspected = await statRegularFileNoFollow(ignorePath, { label: "The ignore file" });
         if (inspected.size > MAX_FILE_BYTES) {
-          ignoreFiles.push(this.fingerprint(wirePath(path6.relative(this.root, ignorePath)), "ignore-file", inspected));
+          ignoreFiles.push(this.fingerprint(wirePath(path3.relative(this.root, ignorePath)), "ignore-file", inspected));
           continue;
         }
         const file = await readRegularFileNoFollow(ignorePath, {
           label: "The ignore file",
           maxBytes: MAX_FILE_BYTES
         });
-        const digest2 = digestBytes(file.contents);
-        ignoreFiles.push(this.fingerprint(wirePath(path6.relative(this.root, ignorePath)), "ignore-file", file.stat, digest2));
+        const digest = digestBytes(file.contents);
+        ignoreFiles.push(this.fingerprint(wirePath(path3.relative(this.root, ignorePath)), "ignore-file", file.stat, digest));
         rules.push(...parseIgnoreRules(file.contents.toString("utf8"), base));
       } catch (error) {
         if (error.code !== "ENOENT" && !(error instanceof UnsafeFileTypeError))
@@ -1291,7 +803,7 @@ class Workspace {
           if (isHardIgnored(relative) || entry.isSymbolicLink() || isIgnoredByRules(relative, entry.isDirectory(), rules))
             continue;
           if (entry.isDirectory())
-            children.push({ directory: path6.join(directory, entry.name), base: relative, inherited: rules });
+            children.push({ directory: path3.join(directory, entry.name), base: relative, inherited: rules });
           else if (entry.isFile())
             files.push({ path: relative });
         }
@@ -1309,14 +821,14 @@ class Workspace {
   async isWorkspaceIndexFresh(index) {
     try {
       for await (const batch of boundedBatches(index.directories, async (fingerprint) => {
-        const absolute = fingerprint.path === "." ? this.root : path6.join(this.root, fingerprint.path);
+        const absolute = fingerprint.path === "." ? this.root : path3.join(this.root, fingerprint.path);
         const entry = await lstat3(absolute);
         return !entry.isSymbolicLink() && entry.isDirectory() && this.sameFingerprint(entry, fingerprint);
       }))
         if (batch.some((fresh) => !fresh))
           return false;
       for await (const batch of boundedBatches(index.ignoreFiles, async (fingerprint) => {
-        const absolute = path6.join(this.root, fingerprint.path);
+        const absolute = path3.join(this.root, fingerprint.path);
         if (fingerprint.digest) {
           const file = await readRegularFileNoFollow(absolute, {
             label: "The ignore file",
@@ -1412,7 +924,7 @@ class Workspace {
     const start = await this.safePath(relativePath);
     if (!(await lstat3(start.path)).isDirectory())
       throw new HarnessWorkspaceError("list_files requires a directory.");
-    const requestPath = wirePath(path6.relative(this.root, start.path)) || ".";
+    const requestPath = wirePath(path3.relative(this.root, start.path)) || ".";
     const input = typeof options === "number" ? { limit: options } : options;
     const limit = input.limit ?? 200;
     const includeDigests = input.includeDigests ?? true;
@@ -1517,7 +1029,7 @@ class Workspace {
     }
     const ordered = requests.map((request) => ({
       ...request,
-      path: wirePath(path6.relative(this.root, this.lexicalPath(request.path)))
+      path: wirePath(path3.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));
     for (const request of ordered) {
       if (!Number.isSafeInteger(request.startLine ?? 1) || (request.startLine ?? 1) < 1 || request.endLine !== undefined && (!Number.isSafeInteger(request.endLine) || request.endLine < (request.startLine ?? 1))) {
@@ -1554,7 +1066,7 @@ class Workspace {
       throw new HarnessWorkspaceError("The search query must be between 1 and 200 characters.");
     const start = await this.safePath(relativePath);
     const isDirectory = (await lstat3(start.path)).isDirectory();
-    const requestPath = wirePath(path6.relative(this.root, start.path)) || ".";
+    const requestPath = wirePath(path3.relative(this.root, start.path)) || ".";
     const limit = options.limit ?? options.maxMatches ?? 100;
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500)
       throw new HarnessWorkspaceError("limit must be between 1 and 500.");
@@ -1679,7 +1191,7 @@ class Workspace {
     });
     const start = await this.safePath(relativePath);
     const isDirectory = (await lstat3(start.path)).isDirectory();
-    const requestPath = wirePath(path6.relative(this.root, start.path)) || ".";
+    const requestPath = wirePath(path3.relative(this.root, start.path)) || ".";
     const prefix = requestPath === "." ? "" : `${requestPath}/`;
     const index = isDirectory ? await this.getWorkspaceIndex() : undefined;
     const candidateIndex = requestPath === "." ? 0 : firstPathAtLeast(index?.files ?? [], prefix);
@@ -1773,7 +1285,7 @@ class Workspace {
     this.auditEntries.push(record);
     if (this.auditPath) {
       const temporary = `${this.auditPath}.${randomUUID()}.tmp`;
-      const handle = await open3(temporary, "wx", 384);
+      const handle = await open2(temporary, "wx", 384);
       try {
         await handle.writeFile(JSON.stringify(this.auditEntries));
         await handle.sync();
@@ -1792,14 +1304,14 @@ class Workspace {
     return this.auditEntries.map((entry) => ({ ...entry }));
   }
   async secureWorkspaceDirectory(directory, mode = 493) {
-    const resolvedInput = path6.resolve(directory);
+    const resolvedInput = path3.resolve(directory);
     if (!isInside(this.root, resolvedInput)) {
       throw new HarnessWorkspaceError("A mutation directory escapes the workspace.");
     }
-    const segments = path6.relative(this.root, resolvedInput).split(path6.sep).filter(Boolean);
+    const segments = path3.relative(this.root, resolvedInput).split(path3.sep).filter(Boolean);
     let current = this.root;
     for (const segment of segments) {
-      current = path6.join(current, segment);
+      current = path3.join(current, segment);
       try {
         const entry = await lstat3(current);
         if (entry.isSymbolicLink())
@@ -1827,9 +1339,9 @@ class Workspace {
     return canonical;
   }
   async stageFile(target, contents, mode) {
-    const directory = await this.secureWorkspaceDirectory(path6.dirname(target));
-    const temporary = path6.join(directory, `.${path6.basename(target)}.zhivex-${randomUUID()}.tmp`);
-    const handle = await open3(temporary, "wx", mode);
+    const directory = await this.secureWorkspaceDirectory(path3.dirname(target));
+    const temporary = path3.join(directory, `.${path3.basename(target)}.zhivex-${randomUUID()}.tmp`);
+    const handle = await open2(temporary, "wx", mode);
     try {
       await handle.writeFile(contents);
       await handle.chmod(mode);
@@ -2052,7 +1564,7 @@ class Workspace {
     const destination = await this.safePath(parsed.destination, { allowMissing: true });
     if (destination.exists)
       throw new HarnessWorkspaceError(`Move destination already exists: ${parsed.destination}.`);
-    await this.secureWorkspaceDirectory(path6.dirname(destination.path));
+    await this.secureWorkspaceDirectory(path3.dirname(destination.path));
     const destinationRecheck = await this.safePath(parsed.destination, { allowMissing: true });
     if (destinationRecheck.exists)
       throw new HarnessWorkspaceError(`Move destination already exists: ${parsed.destination}.`);
@@ -2080,7 +1592,7 @@ class Workspace {
     const segments = [".zhivex-harness", "quarantine"];
     let current = this.root;
     for (const segment of segments) {
-      current = path6.join(current, segment);
+      current = path3.join(current, segment);
       try {
         const entry = await lstat3(current);
         if (entry.isSymbolicLink()) {
@@ -2111,7 +1623,7 @@ class Workspace {
   }
   async writeManifest(manifest) {
     const directory = await this.secureQuarantineDirectory(true);
-    const target = path6.join(directory, `${manifest.quarantineId}.json`);
+    const target = path3.join(directory, `${manifest.quarantineId}.json`);
     const temporary = await this.stageFile(target, `${JSON.stringify(manifest, null, 2)}
 `, 384);
     await rename(temporary, target);
@@ -2130,7 +1642,7 @@ class Workspace {
       throw new HarnessWorkspaceError(`Stale quarantine rejected for ${parsed.path}.`);
     const quarantineId = `${Date.now()}-${randomUUID()}`;
     const directory = await this.secureQuarantineDirectory(true);
-    const dataPath = path6.join(directory, `${quarantineId}.data`);
+    const dataPath = path3.join(directory, `${quarantineId}.data`);
     if ((await this.readStableFile(parsed.path)).digest !== parsed.expectedDigest)
       throw new HarnessWorkspaceError(`Stale quarantine rejected for ${parsed.path}.`);
     await link(source.absolutePath, dataPath);
@@ -2153,41 +1665,76 @@ class Workspace {
       await unlink(source.absolutePath);
     } catch (error) {
       await unlink(dataPath).catch(() => {});
-      await unlink(path6.join(directory, `${quarantineId}.json`)).catch(() => {});
+      await unlink(path3.join(directory, `${quarantineId}.json`)).catch(() => {});
       throw error;
     }
     this.invalidateWorkspaceIndex();
     const audit = await this.audit({ operation: "quarantine", path: parsed.path, beforeDigest: source.digest, quarantineId });
     return { quarantineId, path: parsed.path, digest: source.digest, audit };
   }
-  async restoreQuarantined(input) {
-    return withWorkspaceMutation(this.root, () => this.restoreQuarantinedLocked(input));
-  }
-  async restoreQuarantinedLocked(input) {
-    const parsed = restoreFileInputSchema.parse(input);
-    this.checkAuditCapacity();
+  async readRestorableQuarantine(quarantineId) {
     const directory = await this.secureQuarantineDirectory(false);
     let manifest;
     try {
-      const manifestFile = await this.readInternalRegularFile(path6.join(directory, `${parsed.quarantineId}.json`), "Quarantine manifest", 64 * 1024);
+      const manifestFile = await this.readInternalRegularFile(path3.join(directory, `${quarantineId}.json`), "Quarantine manifest", 64 * 1024);
       manifest = JSON.parse(manifestFile.contents.toString("utf8"));
     } catch {
-      throw new HarnessWorkspaceError(`Quarantine entry was not found: ${parsed.quarantineId}.`);
+      throw new HarnessWorkspaceError(`Quarantine entry was not found: ${quarantineId}.`);
     }
-    if (manifest.schemaVersion !== 1 || manifest.quarantineId !== parsed.quarantineId || manifest.status !== "quarantined") {
-      throw new HarnessWorkspaceError(`Quarantine entry is not restorable: ${parsed.quarantineId}.`);
+    if (manifest.schemaVersion !== 1 || manifest.quarantineId !== quarantineId || manifest.status !== "quarantined") {
+      throw new HarnessWorkspaceError(`Quarantine entry is not restorable: ${quarantineId}.`);
     }
-    const dataPath = path6.join(directory, `${parsed.quarantineId}.data`);
+    const dataPath = path3.join(directory, `${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) {
+    const digest = digestBytes(dataFile.contents);
+    if (digest !== manifest.digest) {
+      throw new HarnessWorkspaceError(`Quarantine digest mismatch: ${quarantineId}.`);
+    }
+    return { manifest, dataPath, dataFile, digest };
+  }
+  async previewRestore(input) {
+    const parsed = restoreFileInputSchema.parse(input);
+    const quarantined = await this.readRestorableQuarantine(parsed.quarantineId);
+    if (parsed.expectedDigest !== quarantined.digest) {
       throw new HarnessWorkspaceError(`Quarantine digest mismatch: ${parsed.quarantineId}.`);
     }
-    const destinationPath = parsed.destination ?? manifest.originalPath;
+    const destination = await this.safePath(parsed.destination, { allowMissing: true });
+    if (destination.exists)
+      throw new HarnessWorkspaceError(`Restore destination already exists: ${parsed.destination}.`);
+    let after;
+    try {
+      after = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(quarantined.dataFile.contents);
+    } catch {
+      throw new HarnessWorkspaceError("Preview requires valid UTF-8 text.");
+    }
+    return {
+      proposalId: parsed.expectedDigest,
+      files: [{
+        path: parsed.destination,
+        expectedDigest: parsed.expectedDigest,
+        before: null,
+        after,
+        afterDigest: quarantined.digest,
+        operation: "restore"
+      }]
+    };
+  }
+  async restoreQuarantined(input) {
+    return withWorkspaceMutation(this.root, () => this.restoreQuarantinedLocked(input));
+  }
+  async restoreQuarantinedLocked(input) {
+    const parsed = restoreFileInputSchema.parse(input);
+    this.checkAuditCapacity();
+    const quarantined = await this.readRestorableQuarantine(parsed.quarantineId);
+    if (parsed.expectedDigest !== quarantined.digest) {
+      throw new HarnessWorkspaceError(`Quarantine digest mismatch: ${parsed.quarantineId}.`);
+    }
+    const { manifest, dataPath, dataFile, digest } = quarantined;
+    const destinationPath = parsed.destination;
     const destination = await this.safePath(destinationPath, { allowMissing: true });
     if (destination.exists)
       throw new HarnessWorkspaceError(`Restore destination already exists: ${destinationPath}.`);
-    await this.secureWorkspaceDirectory(path6.dirname(destination.path));
+    await this.secureWorkspaceDirectory(path3.dirname(destination.path));
     const destinationRecheck = await this.safePath(destinationPath, { allowMissing: true });
     if (destinationRecheck.exists)
       throw new HarnessWorkspaceError(`Restore destination already exists: ${destinationPath}.`);
@@ -2197,7 +1744,7 @@ class Workspace {
     }
     await link(dataPath, destination.path);
     const linkedDestination = await this.readInternalRegularFile(destination.path, "Restore destination", MAX_FILE_BYTES);
-    if (linkedDestination.stat.dev !== dataFile.stat.dev || linkedDestination.stat.ino !== dataFile.stat.ino || digestBytes(linkedDestination.contents) !== digest2) {
+    if (linkedDestination.stat.dev !== dataFile.stat.dev || linkedDestination.stat.ino !== dataFile.stat.ino || digestBytes(linkedDestination.contents) !== digest) {
       await unlink(destination.path).catch(() => {});
       throw new HarnessWorkspaceError("Restore destination did not match the quarantined payload.");
     }
@@ -2230,8 +1777,8 @@ class Workspace {
       throw rollbackErrors.length ? new AggregateError([error, ...rollbackErrors], "Restore failed and rollback was incomplete.") : error;
     }
     this.invalidateWorkspaceIndex();
-    const audit = await this.audit({ operation: "restore", path: destinationPath, afterDigest: digest2, quarantineId: parsed.quarantineId });
-    return { quarantineId: parsed.quarantineId, path: destinationPath, digest: digest2, audit };
+    const audit = await this.audit({ operation: "restore", path: destinationPath, afterDigest: digest, quarantineId: parsed.quarantineId });
+    return { quarantineId: parsed.quarantineId, path: destinationPath, digest, audit };
   }
   async runCheck(check, expectedScript, allowedChecks = DEFAULT_CHECKS) {
     let manifest;
@@ -2273,214 +1820,21 @@ class EnvironmentPatchDriftError extends Error {
   }
 }
 
-// src/runtime/task-acceptance-delivery.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-import { z as z4 } from "zod";
-
-// src/runtime/task-acceptance-checks.ts
-import { createHash as createHash4 } from "node:crypto";
-import { z as z3 } from "zod";
-var sha = z3.string().regex(/^sha256:[a-f0-9]{64}$/);
-var taskCheckReceiptSchema = z3.strictObject({
-  schemaVersion: z3.literal(1),
-  checkId: z3.string().max(128),
-  contractDigest: sha,
-  contractRevision: z3.number().int().positive(),
-  runId: z3.string().max(512),
-  executionIdentity: z3.string().max(512),
-  patchId: sha,
-  snapshotDigest: sha,
-  argvDigest: sha,
-  exitCode: z3.number().int(),
-  timedOut: z3.boolean(),
-  unchanged: z3.boolean(),
-  source: z3.strictObject({ id: z3.string().min(1).max(512), name: z3.string().min(1).max(128), startedAt: z3.number().finite().nonnegative().optional() }).optional()
-});
-var argvDigest = (command, args) => "sha256:" + createHash4("sha256").update(JSON.stringify([command, ...args])).digest("hex");
-function createTaskAcceptanceChecks(ledger, previous = [], journal = []) {
-  const current = ledger.revisions.at(-1);
-  const receipts = new Map;
-  const parsed = z3.array(taskCheckReceiptSchema).max(32).safeParse(previous);
-  if (parsed.success)
-    for (const receipt of parsed.data) {
-      const check = current.contract.requiredChecks.find((c) => c.id === receipt.checkId);
-      if (check && receipt.contractDigest === current.digest && receipt.contractRevision === current.revision && receipt.argvDigest === argvDigest(check.command, check.args) && reconciledReceipt(receipt, journal))
-        receipts.set(check.id, receipt);
-    }
-  return {
-    matching(command, args) {
-      return current.contract.requiredChecks.filter((check) => argvDigest(check.command, check.args) === argvDigest(command, args));
-    },
-    begin(checkIds) {
-      for (const id of checkIds)
-        receipts.delete(id);
-    },
-    record(checkId, before, after, result, source) {
-      const check = current.contract.requiredChecks.find((c) => c.id === checkId);
-      if (!check)
-        throw new Error("TASK_ACCEPTANCE_UNKNOWN_CHECK");
-      const receipt = taskCheckReceiptSchema.parse({
-        schemaVersion: 1,
-        checkId,
-        contractDigest: current.digest,
-        contractRevision: current.revision,
-        ...before,
-        ...source ? { source: { id: source.id, name: source.name, ...source.startedAt !== undefined ? { startedAt: source.startedAt } : {} } } : {},
-        argvDigest: argvDigest(check.command, check.args),
-        exitCode: result.exitCode,
-        timedOut: result.timedOut,
-        unchanged: before.runId === after.runId && before.executionIdentity === after.executionIdentity && before.patchId === after.patchId && before.snapshotDigest === after.snapshotDigest
-      });
-      receipts.set(checkId, receipt);
-      return structuredClone(receipt);
-    },
-    missing(binding) {
-      return current.contract.requiredChecks.filter((check) => {
-        const receipt = receipts.get(check.id);
-        return !receipt || receipt.exitCode !== 0 || receipt.timedOut || !receipt.unchanged || receipt.runId !== binding.runId || receipt.executionIdentity !== binding.executionIdentity || receipt.patchId !== binding.patchId || receipt.snapshotDigest !== binding.snapshotDigest;
-      }).map((check) => check.id);
-    },
-    snapshot() {
-      return [...receipts.values()].map((receipt) => structuredClone(receipt));
-    }
-  };
-}
-var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-var commandDigest = (value) => {
-  const input = object(value);
-  return typeof input?.command === "string" && Array.isArray(input.args) && input.args.every((arg) => typeof arg === "string") ? argvDigest(input.command, input.args) : undefined;
-};
-function reconciledReceipt(receipt, journal) {
-  if (!receipt.source)
-    return false;
-  const matches = journal.filter((row2) => row2.runId === receipt.runId && row2.providerToolCallId === receipt.source.id && row2.toolName === receipt.source.name);
-  if (matches.length !== 1)
-    return false;
-  const row = matches[0];
-  const startedAt = receipt.source.startedAt ?? row.startedAt;
-  if (row.status !== "completed" || !Number.isFinite(startedAt) || !Number.isFinite(row.completedAt) || row.completedAt < startedAt)
-    return false;
-  if (!["run_environment_command", "run_check", "verify_and_apply_environment_patch", "verify_and_apply_reviewed_edits"].includes(row.toolName))
-    return false;
-  const output = object(row.output), result = object(output?.verification) ?? output;
-  if (!result || result.exitCode !== receipt.exitCode || result.timedOut !== receipt.timedOut || !Array.isArray(result.command) || !result.command.every((arg) => typeof arg === "string") || typeof result.command[0] !== "string" || argvDigest(result.command[0], result.command.slice(1)) !== receipt.argvDigest)
-    return false;
-  if (row.toolName !== "run_check" && commandDigest(row.input) !== receipt.argvDigest)
-    return false;
-  for (const attempt of journal) {
-    if (attempt === row || attempt.runId !== receipt.runId)
-      continue;
-    if (attempt.status === "pending" || attempt.status === "running")
-      return false;
-    const input = object(attempt.input);
-    const sameCheck = commandDigest(input) === receipt.argvDigest || attempt.toolName === "run_check" && row.toolName === "run_check" && input?.check === object(row.input)?.check || attempt.toolName === "run_environment_batch" && Array.isArray(input?.commands) && input.commands.some((command) => commandDigest(command) === receipt.argvDigest);
-    if (sameCheck && (!Number.isFinite(attempt.completedAt) || attempt.completedAt >= startedAt))
-      return false;
-  }
-  return true;
-}
-
-// src/runtime/task-acceptance-delivery.ts
-var scopes = new AsyncLocalStorage2;
-function withTaskAcceptanceDelivery(workspace, ledger, work, previousEvidence, journal = []) {
-  const latest = ledger.revisions.at(-1);
-  const previous = z4.object({ contractDigest: z4.literal(latest.digest), contractRevision: z4.literal(latest.revision), diagnostic: z4.strictObject({
-    code: z4.literal("TASK_ACCEPTANCE_SCOPE_VIOLATION"),
-    runId: z4.string().max(512),
-    patchId: z4.string().regex(/^sha256:[a-f0-9]{64}$/),
-    paths: z4.array(z4.string().max(1024)).max(256)
-  }) }).safeParse(previousEvidence);
-  const previousDelivery = z4.object({ contractDigest: z4.literal(latest.digest), contractRevision: z4.literal(latest.revision), delivery: z4.strictObject({
-    runId: z4.string().min(1).max(512),
-    executionIdentity: z4.string().min(1).max(512),
-    patchId: z4.string().regex(/^sha256:[a-f0-9]{64}$/),
-    snapshotDigest: z4.string().regex(/^sha256:[a-f0-9]{64}$/)
-  }) }).safeParse(previousEvidence);
-  return scopes.run({
-    ...previousDelivery.success ? { previousDelivery: previousDelivery.data.delivery } : {},
-    workspace,
-    revision: latest.revision,
-    digest: latest.digest,
-    checks: createTaskAcceptanceChecks(ledger, previousEvidence && typeof previousEvidence === "object" && "checks" in previousEvidence ? previousEvidence.checks : [], journal),
-    allowed: new Set(latest.contract.allowedWritePaths),
-    protected: new Set(latest.contract.protectedFiles.map((file) => file.toLowerCase())),
-    ...previous.success ? { violation: previous.data.diagnostic } : {}
-  }, work);
-}
-function assertTaskAcceptanceImport(input) {
-  const scope = scopes.getStore();
-  if (!scope)
-    return;
-  const blocked = input.entries.filter((entry) => {
-    const candidate = entry.path.toLowerCase();
-    return input.workspace !== scope.workspace || !scope.allowed.has(entry.path) || [...scope.protected].some((file) => candidate === file || candidate.startsWith(file + "/") || file.startsWith(candidate + "/"));
-  });
-  if (blocked.length) {
-    scope.violation = { code: "TASK_ACCEPTANCE_SCOPE_VIOLATION", runId: input.runId, patchId: input.patchId, paths: blocked.map((entry) => entry.path).slice(0, 256) };
-    throw new Error("TASK_ACCEPTANCE_SCOPE_VIOLATION: the OCI patch touches files outside the task contract; no host import was performed.");
-  }
-  if (!input.executionIdentity || !input.snapshotDigest || scope.checks.missing({ runId: input.runId, patchId: input.patchId, executionIdentity: input.executionIdentity, snapshotDigest: input.snapshotDigest }).length) {
-    throw new Error("TASK_ACCEPTANCE_CHECKS_MISSING: every required check must succeed on the exact final snapshot and patch before import.");
-  }
-}
-var taskAcceptanceChecks = () => scopes.getStore()?.checks;
-function taskAcceptanceDeliveryDiagnostic(digest2, revision) {
-  const scope = scopes.getStore();
-  return scope?.digest === digest2 && scope.revision === revision && scope.violation ? structuredClone(scope.violation) : undefined;
-}
-function confirmTaskAcceptanceImport(binding, validate) {
-  const scope = scopes.getStore();
-  if (scope)
-    scope.imported = { binding: structuredClone(binding), validate };
-}
-async function evaluateTaskAcceptanceOutcome(state, ledger) {
-  const current = ledger.revisions.at(-1), scope = scopes.getStore();
-  const terminal = ["completed", "failed", "cancelled", "timed_out"].includes(state.status);
-  if (!scope || scope.digest !== current.digest || scope.revision !== current.revision) {
-    return { status: terminal ? "incomplete" : "pending", reason: "TASK_ACCEPTANCE_NO_DELIVERY_EVIDENCE" };
-  }
-  if (scope.violation)
-    return { status: "failed", reason: scope.violation.code };
-  if (state.status !== "completed")
-    return { status: state.status === "failed" ? "failed" : terminal ? "incomplete" : "pending", reason: "TASK_ACCEPTANCE_RUN_NOT_COMPLETED" };
-  if (state.finishReason !== "stop")
-    return { status: "incomplete", reason: "TASK_ACCEPTANCE_RUN_NOT_FINISHED" };
-  const imported = scope.imported;
-  if (!imported || imported.binding.runId !== state.runId)
-    return { status: "incomplete", reason: "TASK_ACCEPTANCE_IMPORT_UNCONFIRMED" };
-  const delivery = { ...imported.binding };
-  if (scope.checks.missing(delivery).length)
-    return { status: "incomplete", reason: "TASK_ACCEPTANCE_CHECKS_MISSING", delivery };
-  try {
-    if (!await imported.validate())
-      return { status: "incomplete", reason: "TASK_ACCEPTANCE_DELIVERY_DRIFT", delivery };
-  } catch {
-    return { status: "incomplete", reason: "TASK_ACCEPTANCE_DELIVERY_INSPECTION_FAILED", delivery };
-  }
-  return { status: current.contract.humanReview.length ? "pending_review" : "verified", reason: current.contract.humanReview.length ? "TASK_ACCEPTANCE_HUMAN_REVIEW_REQUIRED" : "TASK_ACCEPTANCE_VERIFIED", delivery };
-}
-async function taskAcceptanceOutcome(state, ledger) {
-  const outcome = await evaluateTaskAcceptanceOutcome(state, ledger);
-  const scope = scopes.getStore(), latest = ledger.revisions.at(-1);
-  const delivery = scope?.digest === latest.digest && scope.revision === latest.revision ? scope.imported?.binding ?? scope.previousDelivery : undefined;
-  return { ...outcome, ...delivery && delivery.runId === state.runId ? { delivery: structuredClone(delivery) } : {} };
-}
-
 // src/execution/acceptance-snapshot.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { lstat as lstat4, readdir as readdir2 } from "node:fs/promises";
-import path7 from "node:path";
+import path4 from "node:path";
 async function acceptanceSnapshotDigest(root, maxBytes) {
   const rows = [];
   let bytes = 0;
   async function visit(relative) {
-    const names = await readdir2(path7.join(root, relative));
+    const names = await readdir2(path4.join(root, relative));
     names.sort();
     for (const name of names) {
       const item = relative ? relative + "/" + name : name;
       if (rows.length >= 20000)
         throw new Error("TASK_ACCEPTANCE_SNAPSHOT_CAPACITY");
-      const absolute = path7.join(root, item), entry = await lstat4(absolute);
+      const absolute = path4.join(root, item), entry = await lstat4(absolute);
       if (entry.isSymbolicLink())
         throw new Error("TASK_ACCEPTANCE_SNAPSHOT_UNSAFE");
       if (entry.isDirectory()) {
@@ -2489,13 +1843,13 @@ async function acceptanceSnapshotDigest(root, maxBytes) {
       } else if (entry.isFile() && entry.nlink === 1) {
         const file = await readRegularFileNoFollow(absolute, { label: "Acceptance snapshot file", maxBytes: maxBytes - bytes, requireSingleLink: true });
         bytes += file.contents.byteLength;
-        rows.push([item, "file", file.stat.mode & 511, createHash5("sha256").update(file.contents).digest("hex")]);
+        rows.push([item, "file", file.stat.mode & 511, createHash3("sha256").update(file.contents).digest("hex")]);
       } else
         throw new Error("TASK_ACCEPTANCE_SNAPSHOT_UNSAFE");
     }
   }
   await visit("");
-  return "sha256:" + createHash5("sha256").update(JSON.stringify(rows)).digest("hex");
+  return "sha256:" + createHash3("sha256").update(JSON.stringify(rows)).digest("hex");
 }
 
 // src/execution/oci-observability.ts
@@ -2519,9 +1873,9 @@ async function observeOciPhase(operation, action) {
 }
 
 // src/execution/execution-environment.ts
-import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
 import { spawn as spawn2 } from "node:child_process";
-import { constants as fsConstants2 } from "node:fs";
+import { constants as fsConstants } from "node:fs";
 import {
   chmod,
   copyFile,
@@ -2533,7 +1887,7 @@ import {
   rm,
   writeFile
 } from "node:fs/promises";
-import path8 from "node:path";
+import path5 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";
@@ -2577,7 +1931,7 @@ var BUILT_IN_TOOL_NAMES = new Set([
   "verify_and_apply_reviewed_edits",
   "environment_status"
 ]);
-var digest2 = (value) => `sha256:${createHash6("sha256").update(value).digest("hex")}`;
+var digest = (value) => `sha256:${createHash4("sha256").update(value).digest("hex")}`;
 var executionScopeKey = (scope) => {
   if (scope) {
     for (const value of [scope.tenantId, scope.userId, scope.namespace]) {
@@ -2590,11 +1944,11 @@ var executionScopeKey = (scope) => {
   }
   return JSON.stringify([scope?.tenantId ?? null, scope?.userId ?? null, scope?.namespace ?? null]);
 };
-var executionIdentity = (workspace, stateDirectory, runId, scopeKey) => digest2(JSON.stringify(["scoped-oci-v2", workspace, stateDirectory, scopeKey, runId]));
-var runHash = (runId) => createHash6("sha256").update(runId).digest("hex").slice(0, 24);
+var executionIdentity = (workspace, stateDirectory, runId, scopeKey) => digest(JSON.stringify(["scoped-oci-v2", workspace, stateDirectory, scopeKey, runId]));
+var runHash = (runId) => createHash4("sha256").update(runId).digest("hex").slice(0, 24);
 var isInside2 = (root, candidate) => {
-  const relative = path8.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative);
+  const relative = path5.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path5.sep}`) && !path5.isAbsolute(relative);
 };
 var privateDirectory = async (directory) => {
   await mkdir3(directory, { recursive: true, mode: 448 });
@@ -2733,14 +2087,14 @@ var updateSnapshotMetadata = (target, kind, relative, entry) => {
 var validateSynchronizedSnapshot = async (stagedRoot, previousRoot, maxWorkspaceBytes, maxFileWriteBytes) => {
   let entries = 0;
   let totalBytes = 0;
-  const seal = createHash6("sha256");
-  const metadata = createHash6("sha256");
+  const seal = createHash4("sha256");
+  const metadata = createHash4("sha256");
   const visit = async (directory, relativeDirectory = "") => {
     const children = (await readdir3(directory, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name));
     for (const child of children) {
       const name = child.name;
       const relative = relativeDirectory ? `${relativeDirectory}/${name}` : name;
-      const absolute = path8.join(directory, name);
+      const absolute = path5.join(directory, name);
       if (!isInside2(stagedRoot, absolute) || relative.length > 1024) {
         throw new Error(`OCI workspace export contains an invalid path: ${relative}.`);
       }
@@ -2787,18 +2141,18 @@ var validateSynchronizedSnapshot = async (stagedRoot, previousRoot, maxWorkspace
       if (totalBytes > maxWorkspaceBytes) {
         throw new Error(`OCI workspace export exceeds the ${maxWorkspaceBytes}-byte workspace limit.`);
       }
-      const contentDigest = digest2(contents);
+      const contentDigest = digest(contents);
       updateSnapshotMetadata(metadata, "file", relative, entry);
       seal.update(`file\x00${relative}\x00${entry.mode & 511}\x00${entry.size}\x00${contentDigest}\x00`);
       if (entry.size > maxFileWriteBytes) {
-        const previous = path8.join(previousRoot, ...relative.split("/"));
+        const previous = path5.join(previousRoot, ...relative.split("/"));
         let unchanged = false;
         try {
           const previousFile = await readRegularFileNoFollow(previous, {
             label: `Previous OCI workspace file ${relative}`,
             maxBytes: entry.size
           });
-          unchanged = previousFile.stat.size === entry.size && digest2(previousFile.contents) === contentDigest;
+          unchanged = previousFile.stat.size === entry.size && digest(previousFile.contents) === contentDigest;
         } catch (error) {
           if (error.code !== "ENOENT")
             throw error;
@@ -2820,13 +2174,13 @@ var validateSynchronizedSnapshot = async (stagedRoot, previousRoot, maxWorkspace
 var snapshotMetadataFingerprint = async (root, maxWorkspaceBytes) => {
   let entries = 0;
   let totalBytes = 0;
-  const metadata = createHash6("sha256");
+  const metadata = createHash4("sha256");
   const visit = async (directory, relativeDirectory = "") => {
     for (const name of (await readdir3(directory)).sort()) {
       const relative = relativeDirectory ? `${relativeDirectory}/${name}` : name;
       if (relative === "node_modules")
         continue;
-      const absolute = path8.join(directory, name);
+      const absolute = path5.join(directory, name);
       if (!isInside2(root, absolute) || relative.length > 1024) {
         throw new Error(`OCI workspace snapshot contains an invalid path: ${relative}.`);
       }
@@ -2986,7 +2340,7 @@ ${result.stdout}`)) {
     }
   }
   requestFingerprint(request) {
-    return digest2(JSON.stringify({
+    return digest(JSON.stringify({
       runId: request.runId,
       snapshotRoot: request.snapshotRoot,
       dependencyRoot: request.dependencyRoot ?? null,
@@ -3105,7 +2459,7 @@ ${result.stdout}`)) {
       await this.cli([
         "cp",
         "-a",
-        `${request.snapshotRoot}${path8.sep}.`,
+        `${request.snapshotRoot}${path5.sep}.`,
         `${name}:/workspace`
       ], 60000);
       if (request.dependencyRoot) {
@@ -3237,7 +2591,7 @@ ${result.stdout}`)) {
         };
       }
       const workspaceExportStartedAt = process.hrtime.bigint();
-      const stagedRoot = path8.join(path8.dirname(request.snapshotRoot), `.workspace-sync-${randomUUID2()}`);
+      const stagedRoot = path5.join(path5.dirname(request.snapshotRoot), `.workspace-sync-${randomUUID2()}`);
       try {
         await privateDirectory(stagedRoot);
         await observeOciPhase("oci_export", () => this.cli(["cp", `${session.name}:/workspace/.`, stagedRoot], 60000));
@@ -3451,7 +2805,7 @@ var collectSnapshotInventory = async (workspace, maxWorkspaceBytes, metrics, max
     if (metrics)
       metrics.inventoryPages += 1;
     for await (const candidates of boundedBatches(page.files, async (file) => {
-      const absolute = path8.join(workspace.root, ...file.path.split("/"));
+      const absolute = path5.join(workspace.root, ...file.path.split("/"));
       if (!isInside2(workspace.root, absolute))
         throw new Error(`Snapshot file escaped its workspace: ${file.path}.`);
       if (await realpath3(absolute) !== absolute)
@@ -3472,7 +2826,7 @@ var collectSnapshotInventory = async (workspace, maxWorkspaceBytes, metrics, max
         if (stable.stat.dev !== entry.dev || stable.stat.ino !== entry.ino || stable.stat.size !== entry.size || stable.stat.mtimeMs !== entry.mtimeMs || stable.stat.ctimeMs !== entry.ctimeMs) {
           throw new Error(`Snapshot inventory file changed while being read: ${file.path}.`);
         }
-        return { path: file.path, digest: digest2(stable.contents), mode: stable.stat.mode & 511, bytes: stable.contents.byteLength };
+        return { path: file.path, digest: digest(stable.contents), mode: stable.stat.mode & 511, bytes: stable.contents.byteLength };
       }, 4))
         for (const file of batch) {
           if (files.size >= maxEntries)
@@ -3485,7 +2839,7 @@ var collectSnapshotInventory = async (workspace, maxWorkspaceBytes, metrics, max
   return files;
 };
 var readSnapshotFile = async (workspace, expected, metrics, requireSingleLink = false) => {
-  const absolute = path8.join(workspace.root, ...expected.path.split("/"));
+  const absolute = path5.join(workspace.root, ...expected.path.split("/"));
   if (!isInside2(workspace.root, absolute)) {
     throw new Error(`Snapshot file escaped its workspace: ${expected.path}.`);
   }
@@ -3498,7 +2852,7 @@ var readSnapshotFile = async (workspace, expected, metrics, requireSingleLink =
   });
   const { contents } = file;
   const entry = file.stat;
-  const actualDigest = digest2(contents);
+  const actualDigest = digest(contents);
   if (actualDigest !== expected.digest || contents.byteLength !== expected.bytes || (entry.mode & 511) !== expected.mode) {
     throw new Error(`Snapshot source changed after inventory: ${expected.path}.`);
   }
@@ -3510,7 +2864,7 @@ var readSnapshotFile = async (workspace, expected, metrics, requireSingleLink =
 };
 var copySnapshotFile = async (source, target, metrics) => {
   try {
-    await copyFile(source, target, fsConstants2.COPYFILE_FICLONE_FORCE);
+    await copyFile(source, target, fsConstants.COPYFILE_FICLONE_FORCE);
   } catch (error) {
     const code = error.code;
     if (!code || !COPY_ON_WRITE_UNSUPPORTED_CODES.has(code))
@@ -3532,11 +2886,11 @@ var copyWorkspaceSnapshot = async (source, baseRoot, snapshotRoot, maxWorkspaceB
   }
   for await (const _batch of boundedBatches([...files.values()], async (expected) => {
     const file = await readSnapshotFile(source, expected, metrics);
-    const baseTarget = path8.join(baseRoot, ...file.path.split("/"));
-    const snapshotTarget = path8.join(snapshotRoot, ...file.path.split("/"));
+    const baseTarget = path5.join(baseRoot, ...file.path.split("/"));
+    const snapshotTarget = path5.join(snapshotRoot, ...file.path.split("/"));
     await Promise.all([
-      mkdir3(path8.dirname(baseTarget), { recursive: true, mode: 448 }),
-      mkdir3(path8.dirname(snapshotTarget), { recursive: true, mode: 448 })
+      mkdir3(path5.dirname(baseTarget), { recursive: true, mode: 448 }),
+      mkdir3(path5.dirname(snapshotTarget), { recursive: true, mode: 448 })
     ]);
     await writeFile(baseTarget, file.contents, { mode: file.mode });
     await chmod(baseTarget, file.mode);
@@ -3552,7 +2906,7 @@ var copyWorkspaceSnapshot = async (source, baseRoot, snapshotRoot, maxWorkspaceB
 var deliveryPaths = (value) => {
   if (value === undefined)
     return [];
-  if (!Array.isArray(value) || value.length > MAX_SYNC_ENTRIES || value.some((item) => typeof item !== "string" || !item || item.length > 8192 || item.includes("\\") || item.includes("\x00") || path8.posix.isAbsolute(item) || item.split("/").some((segment) => !segment || segment === "." || segment === "..")) || Buffer.byteLength(JSON.stringify(value)) > 512 * 1024) {
+  if (!Array.isArray(value) || value.length > MAX_SYNC_ENTRIES || value.some((item) => typeof item !== "string" || !item || item.length > 8192 || item.includes("\\") || item.includes("\x00") || path5.posix.isAbsolute(item) || item.split("/").some((segment) => !segment || segment === "." || segment === "..")) || Buffer.byteLength(JSON.stringify(value)) > 512 * 1024) {
     throw new Error("Invalid or oversized OCI delivery path history.");
   }
   return [...new Set(value)];
@@ -3613,7 +2967,7 @@ var createEnvironmentPatch = async (runId, base, current, maxFileWriteBytes, max
     throw new Error(`Environment patch exceeds the ${MAX_EDIT_PROPOSAL_BYTES}-byte import limit.`);
   }
   const payload = patchPayload(runId, entries);
-  return { entries, totalBytes, patchId: digest2(JSON.stringify({ ...payload, executionIdentity: identity ?? null })) };
+  return { entries, totalBytes, patchId: digest(JSON.stringify({ ...payload, executionIdentity: identity ?? null })) };
 };
 var inspectHostPrecondition = async (workspace, filePath, expectedDigest, expectedMode) => {
   try {
@@ -3679,7 +3033,7 @@ var importPatch = async (runId, expectedPatchId, host, base, current, maxFileWri
     const rollbackErrors = [];
     for (const item of [...quarantined].reverse()) {
       try {
-        await host.restoreQuarantined({ quarantineId: item.quarantineId, expectedDigest: item.digest });
+        await host.restoreQuarantined({ quarantineId: item.quarantineId, destination: item.path, expectedDigest: item.digest });
       } catch (rollbackError) {
         rollbackErrors.push(rollbackError);
       }
@@ -3745,7 +3099,7 @@ var harnessExecutionSession = (context) => {
 var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
   const runtime = options.runtime ?? new CliOciRuntimeAdapter(options.config.runtime);
   const image = await runtime.inspectImage(options.config.image);
-  const workspaceIdentity = digest2(options.workspace.root);
+  const workspaceIdentity = digest(options.workspace.root);
   const manifest = {
     schemaVersion: 1,
     id: `zhivex-harness-${options.config.runtime}-oci`,
@@ -3800,7 +3154,7 @@ var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
     }
   };
   const binding = createAgentExecutionEnvironmentBinding(manifest);
-  const environmentRoot = path8.join(options.stateDirectory, "environments");
+  const environmentRoot = path5.join(options.stateDirectory, "environments");
   const reviewSnapshot = async (request, allowAbsent = false) => {
     let stateDirectory;
     try {
@@ -3812,9 +3166,9 @@ var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
     }
     const scopeKey = executionScopeKey(request.scope);
     const identity = executionIdentity(options.workspace.root, stateDirectory, request.runId, scopeKey);
-    const root = path8.join(stateDirectory, "environments");
-    const directory = path8.join(root, runHash(identity));
-    for (const candidate of [root, directory, path8.join(directory, "base"), path8.join(directory, "workspace")]) {
+    const root = path5.join(stateDirectory, "environments");
+    const directory = path5.join(root, runHash(identity));
+    for (const candidate of [root, directory, path5.join(directory, "base"), path5.join(directory, "workspace")]) {
       let entry;
       try {
         entry = await lstat5(candidate);
@@ -3827,7 +3181,7 @@ var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
         throw new Error("Unsafe execution review directory.");
       }
     }
-    const file = await readRegularFileNoFollow(path8.join(directory, "environment.json"), {
+    const file = await readRegularFileNoFollow(path5.join(directory, "environment.json"), {
       label: "Execution metadata",
       maxBytes: 1024 * 1024
     });
@@ -3835,8 +3189,8 @@ var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
     if (metadata.schemaVersion !== HARNESS_EXECUTION_ARTIFACT_SCHEMA_VERSION || metadata.runId !== request.runId || metadata.scopeKey !== scopeKey || metadata.stateDirectory !== stateDirectory || metadata.executionIdentity !== identity || metadata.hostWorkspace !== options.workspace.root || metadata.binding.fingerprint !== binding.fingerprint || metadata.binding.workspaceId !== binding.workspaceId) {
       throw Object.assign(new Error("Execution review binding changed."), { diagnosticCode: "OCI_EXECUTION_BINDING_CHANGED" });
     }
-    const base = await Workspace.open(path8.join(directory, "base"));
-    const current = await Workspace.open(path8.join(directory, "workspace"));
+    const base = await Workspace.open(path5.join(directory, "base"));
+    const current = await Workspace.open(path5.join(directory, "workspace"));
     const patch = await createEnvironmentPatch(request.runId, base, current, options.config.maxFileWriteBytes, options.config.maxWorkspaceBytes, undefined, identity);
     deliveryPaths(metadata.deliveryPaths);
     return { metadata, patch, current };
@@ -3895,11 +3249,11 @@ var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
       const stateDirectory = await realpath3(options.stateDirectory);
       const scopeKey = executionScopeKey(request.scope);
       const identity = executionIdentity(options.workspace.root, stateDirectory, request.runId, scopeKey);
-      const directory = path8.join(environmentRoot, runHash(identity));
+      const directory = path5.join(environmentRoot, runHash(identity));
       await privateDirectory(directory);
-      const metadataPath = path8.join(directory, "environment.json");
-      const baseRoot = path8.join(directory, "base");
-      const snapshotRoot = path8.join(directory, "workspace");
+      const metadataPath = path5.join(directory, "environment.json");
+      const baseRoot = path5.join(directory, "base");
+      const snapshotRoot = path5.join(directory, "workspace");
       let metadata;
       try {
         const metadataFile = await readRegularFileNoFollow(metadataPath, {
@@ -3914,7 +3268,7 @@ var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
         if (error.code !== "ENOENT")
           throw error;
         try {
-          await lstat5(path8.join(environmentRoot, runHash(request.runId)));
+          await lstat5(path5.join(environmentRoot, runHash(request.runId)));
           throw new Error("Unscoped legacy OCI artifact requires its original runtime; start a new run.");
         } catch (legacyError) {
           if (legacyError.code !== "ENOENT")
@@ -3941,9 +3295,9 @@ var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
       delete metadata.releasedAt;
       delete metadata.status;
       await atomicJson(metadataPath, metadata);
-      const workspace = await Workspace.open(snapshotRoot, { auditPath: path8.join(directory, "mutation-audit.json") });
+      const workspace = await Workspace.open(snapshotRoot, { auditPath: path5.join(directory, "mutation-audit.json") });
       const base = await Workspace.open(baseRoot);
-      const dependencyPath = path8.join(options.workspace.root, "node_modules");
+      const dependencyPath = path5.join(options.workspace.root, "node_modules");
       let dependencyRoot;
       try {
         const entry = await lstat5(dependencyPath);
@@ -4022,7 +3376,7 @@ var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
         });
         for (const check of matching)
           if (check.kind === "package-script") {
-            const file = await readRegularFileNoFollow(path8.join(workspace.root, "package.json"), { label: "Acceptance package manifest", maxBytes: 256 * 1024, requireSingleLink: true });
+            const file = await readRegularFileNoFollow(path5.join(workspace.root, "package.json"), { label: "Acceptance package manifest", maxBytes: 256 * 1024, requireSingleLink: true });
             const manifestDocument = JSON.parse(file.contents.toString("utf8"));
             const resolved = await resolvePackageCheckCommand(workspace.root, manifestDocument, check.script, check.expectedScript, [check.script]);
             if (JSON.stringify(resolved.command) !== JSON.stringify(argv))
@@ -4157,7 +3511,7 @@ var createHarnessOciExecutionEnvironmentUnsafe = async (options) => {
         async runCheck(check, expectedScript, allowedChecks, context) {
           let manifestDocument;
           try {
-            const manifestFile = await readRegularFileNoFollow(path8.join(snapshotRoot, "package.json"), {
+            const manifestFile = await readRegularFileNoFollow(path5.join(snapshotRoot, "package.json"), {
               label: "Snapshot package.json",
               maxBytes: 1024 * 1024
             });
@@ -4261,7 +3615,7 @@ var createHarnessOciExecutionEnvironment = async (options) => {
   }
 };
 var cleanupHarnessExecutionArtifacts = async (stateDirectory, before, selection) => {
-  const root = path8.join(stateDirectory, "environments");
+  const root = path5.join(stateDirectory, "environments");
   const result = { scanned: 0, deleted: 0, skipped: 0 };
   let entries;
   try {
@@ -4279,7 +3633,7 @@ var cleanupHarnessExecutionArtifacts = async (stateDirectory, before, selection)
       continue;
     }
     result.scanned += 1;
-    const directory = path8.join(root, entry.name);
+    const directory = path5.join(root, entry.name);
     try {
       const resolved = await realpath3(directory);
       if (!isInside2(root, resolved))
@@ -4288,7 +3642,7 @@ var cleanupHarnessExecutionArtifacts = async (stateDirectory, before, selection)
       if (directoryEntry.isSymbolicLink() || !directoryEntry.isDirectory()) {
         throw new Error("unsafe execution artifact directory");
       }
-      const metadataPath = path8.join(directory, "environment.json");
+      const metadataPath = path5.join(directory, "environment.json");
       const metadataFile = await readRegularFileNoFollow(metadataPath, {
         label: "Execution cleanup metadata",
         maxBytes: 1024 * 1024
@@ -4307,7 +3661,7 @@ var cleanupHarnessExecutionArtifacts = async (stateDirectory, before, selection)
         result.skipped += 1;
         continue;
       }
-      const stagedDirectory = path8.join(root, `.cleanup-${artifactName}-${randomUUID2()}`);
+      const stagedDirectory = path5.join(root, `.cleanup-${artifactName}-${randomUUID2()}`);
       let staged = false;
       try {
         await rename2(directory, stagedDirectory);
@@ -4316,7 +3670,7 @@ var cleanupHarnessExecutionArtifacts = async (stateDirectory, before, selection)
         if (movedEntry.isSymbolicLink() || !movedEntry.isDirectory() || movedEntry.dev !== directoryEntry.dev || movedEntry.ino !== directoryEntry.ino) {
           throw new Error("execution artifact directory changed before cleanup");
         }
-        const recheckedMetadata = await readRegularFileNoFollow(path8.join(stagedDirectory, "environment.json"), { label: "Execution cleanup metadata", maxBytes: 1024 * 1024 });
+        const recheckedMetadata = await readRegularFileNoFollow(path5.join(stagedDirectory, "environment.json"), { label: "Execution cleanup metadata", maxBytes: 1024 * 1024 });
         if (!recheckedMetadata.contents.equals(metadataFile.contents)) {
           throw new Error("execution artifact metadata changed before cleanup");
         }
@@ -4343,4 +3697,4 @@ var executionFingerprintInput = (execution, environment) => execution.backend ==
 };
 var describeOciCommand = (command, args) => commandDisplay([command, ...args]);
 
-export { EDIT_CONTRACT_SCHEMA_VERSION, EDIT_DIGEST_ALGORITHM, MAX_EDIT_CHANGES, MAX_EDIT_FILE_BYTES, MAX_EDIT_PROPOSAL_BYTES, fileDigestSchema, workspaceFilePathSchema, editChangeSchema, editChangesSchema, editProposalInputSchema, editProposalChangeSchema, editProposalSchema, applyEditProposalInputSchema, moveFileInputSchema, quarantineFileInputSchema, restoreFileInputSchema, mutationOperationSchema, mutationAuditEntrySchema, createEditProposal, validateEditProposal, editContractDocument, protectPersistenceSecret, acquireSqliteAccess, exclusiveSqliteAccessDescriptor, adoptExclusiveSqliteAccess, SqliteDatabase, UnsafeFileTypeError, FileSizeLimitError, FileChangedWhileReadingError, statRegularFileNoFollow, readRegularFileNoFollow, readRegularFileChunksNoFollow, withWorkspaceMutation, EnvironmentPatchDriftError, taskCheckReceiptSchema, createTaskAcceptanceChecks, withTaskAcceptanceDelivery, taskAcceptanceChecks, taskAcceptanceDeliveryDiagnostic, confirmTaskAcceptanceImport, taskAcceptanceOutcome, boundedBatches, resolvePackageManager, resolvePackageCheckCommand, replacementEditSchema, runPortableProcess, isHardIgnored, Workspace, HARNESS_EXECUTION_ARTIFACT_SCHEMA_VERSION, HARNESS_OCI_LABEL, HARNESS_OCI_LABEL_VALUE, CliOciRuntimeAdapter, collectSnapshotInventory, readSnapshotFile, harnessExecutionSession, createHarnessOciExecutionEnvironment, cleanupHarnessExecutionArtifacts, executionFingerprintInput, describeOciCommand };
+export { withWorkspaceMutation, EnvironmentPatchDriftError, boundedBatches, resolvePackageManager, resolvePackageCheckCommand, replacementEditSchema, runPortableProcess, isHardIgnored, Workspace, HARNESS_EXECUTION_ARTIFACT_SCHEMA_VERSION, HARNESS_OCI_LABEL, HARNESS_OCI_LABEL_VALUE, CliOciRuntimeAdapter, collectSnapshotInventory, readSnapshotFile, harnessExecutionSession, createHarnessOciExecutionEnvironment, cleanupHarnessExecutionArtifacts, executionFingerprintInput, describeOciCommand };