@zhivex-ai/harness 1.3.0-rc.3 → 1.3.0

package/dist/{index-pgqz45fj.js → index-42gp2hy8.js}

@@ -1,224 +1,30 @@
+import {
+  SqliteDatabase,
+  taskAcceptanceChecks,
+  taskAcceptanceDeliveryDiagnostic,
+  taskAcceptanceOutcome,
+  workspaceFilePathSchema
+} from "./index-yb239ghk.js";
 import {
   HarnessConfigError,
   HarnessStateConflictError,
   HarnessWorkspaceError
-} from "./index-fvca1xea.js";
-
-// src/persistence/persistence-secrets.ts
-var protectedValues = new Set;
-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 path 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(path.dirname(path.resolve(databasePath)));
-  return path.join(directory, `.${path.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 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(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;
-  #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;
-      }
-    }
-  }
-}
+} from "./index-gq9xagx2.js";
 
 // src/persistence/state-directory.ts
 import { lstat } from "node:fs/promises";
-import path2 from "node:path";
+import path from "node:path";
 var SENSITIVE_STATE_SEGMENTS = new Set([".git", ".env", ".npmrc", "dist", "node_modules", "src"]);
 var isInside = (root, candidate) => {
-  const relative = path2.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== ".." && !path2.isAbsolute(relative);
+  const relative = path.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
 };
 var validateStateDirectory = async (workspace, stateDirectory) => {
-  if (stateDirectory === workspace || stateDirectory === path2.parse(stateDirectory).root) {
+  if (stateDirectory === workspace || stateDirectory === path.parse(stateDirectory).root) {
     throw new HarnessWorkspaceError("The state directory cannot be the workspace or filesystem root.");
   }
   const insideWorkspace = isInside(workspace, stateDirectory);
-  const relativeSegments = insideWorkspace ? path2.relative(workspace, stateDirectory).split(path2.sep).filter(Boolean) : stateDirectory.slice(path2.parse(stateDirectory).root.length).split(path2.sep).filter(Boolean);
+  const relativeSegments = insideWorkspace ? path.relative(workspace, stateDirectory).split(path.sep).filter(Boolean) : stateDirectory.slice(path.parse(stateDirectory).root.length).split(path.sep).filter(Boolean);
   const sensitiveSegment = insideWorkspace ? relativeSegments.find((segment) => SENSITIVE_STATE_SEGMENTS.has(segment)) : undefined;
   if (sensitiveSegment) {
     throw new HarnessWorkspaceError(`The state directory is inside the protected workspace path: ${sensitiveSegment}.`);
@@ -241,7 +47,7 @@ var validateStateDirectory = async (workspace, stateDirectory) => {
   }
   let current = workspace;
   for (const segment of relativeSegments) {
-    current = path2.join(current, segment);
+    current = path.join(current, segment);
     try {
       const entry = await lstat(current);
       if (entry.isSymbolicLink()) {
@@ -262,26 +68,26 @@ var validateStateDirectory = async (workspace, stateDirectory) => {
 // src/persistence/sessions.ts
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, lstat as lstat3, mkdir, open as open2, realpath, stat } from "node:fs/promises";
-import path4 from "node:path";
+import path3 from "node:path";
 import { createRedactionPolicy } from "@zhivex-ai/agents";
 
 // src/persistence/state-gitignore.ts
-import { constants as constants2 } from "node:fs";
+import { constants } from "node:fs";
 import { lstat as lstat2, open } from "node:fs/promises";
-import path3 from "node:path";
+import path2 from "node:path";
 var exclusion = `# Local Harness state; never commit sessions, runs, or database journals.
 *
 `;
 var maximumExistingBytes = 65536;
 var maximumProtectedBytes = maximumExistingBytes + Buffer.byteLength(exclusion) + 1;
 async function protectStateFromGit(workspace, stateDirectory) {
-  const directory = path3.resolve(stateDirectory) === path3.join(workspace, ".zhivex-harness", "runs") ? path3.dirname(stateDirectory) : stateDirectory;
-  const filename2 = path3.join(directory, ".gitignore");
+  const directory = path2.resolve(stateDirectory) === path2.join(workspace, ".zhivex-harness", "runs") ? path2.dirname(stateDirectory) : stateDirectory;
+  const filename = path2.join(directory, ".gitignore");
   try {
-    const handle = await open(filename2, constants2.O_RDWR | constants2.O_CREAT | constants2.O_APPEND | constants2.O_NOFOLLOW, 384);
+    const handle = await open(filename, constants.O_RDWR | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW, 384);
     try {
       const info = await handle.stat();
-      const entry = await lstat2(filename2);
+      const entry = await lstat2(filename);
       if (entry.isSymbolicLink() || entry.dev !== info.dev || entry.ino !== info.ino)
         throw new Error;
       if (!info.isFile() || info.nlink !== 1 || process.getuid && info.uid !== process.getuid() || info.size > maximumProtectedBytes)
@@ -298,7 +104,7 @@ async function protectStateFromGit(workspace, stateDirectory) {
 `) ? `
 ` : ""}${exclusion}`);
       }
-      const current = await lstat2(filename2);
+      const current = await lstat2(filename);
       if (current.isSymbolicLink() || current.dev !== info.dev || current.ino !== info.ino)
         throw new Error;
     } finally {
@@ -412,7 +218,7 @@ var stableKey = (kind, value) => createHash("sha256").update(kind).update("\x00"
 var sessionId = () => `ses_${randomUUID()}`;
 var turnId = () => `turn_${randomUUID()}`;
 var ensurePrivateDatabase = async (workspace, stateDirectory) => {
-  const requestedStateDirectory = path4.resolve(stateDirectory);
+  const requestedStateDirectory = path3.resolve(stateDirectory);
   await validateStateDirectory(workspace, requestedStateDirectory);
   await mkdir(requestedStateDirectory, { recursive: true, mode: 448 });
   const directoryEntry = await lstat3(requestedStateDirectory);
@@ -422,7 +228,7 @@ var ensurePrivateDatabase = async (workspace, stateDirectory) => {
   await chmod(requestedStateDirectory, 448);
   const canonicalStateDirectory = await realpath(requestedStateDirectory);
   await protectStateFromGit(workspace, canonicalStateDirectory);
-  const databasePath = path4.join(canonicalStateDirectory, HARNESS_SESSION_INDEX_FILE);
+  const databasePath = path3.join(canonicalStateDirectory, HARNESS_SESSION_INDEX_FILE);
   let databaseEntry;
   try {
     const handle = await open2(databasePath, "wx", 384);
@@ -455,7 +261,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_STATUSES.has(status);
 var openCliSessionStore = async (options) => {
-  const workspace = await realpath(path4.resolve(options.workspace));
+  const workspace = await realpath(path3.resolve(options.workspace));
   const workspaceEntry = await stat(workspace);
   if (!workspaceEntry.isDirectory()) {
     throw new HarnessWorkspaceError(`The session workspace is not a directory: ${workspace}.`);
@@ -955,142 +761,6 @@ var openCliSessionStore = async (options) => {
 };
 var openSessionStore = openCliSessionStore;
 
-// src/workspace/file-security.ts
-import { constants as fsConstants } from "node:fs";
-import { open as open3 } from "node:fs/promises";
-import path5 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 = path5.resolve(target);
-    if (process.platform === "darwin") {
-      absolute = absolute.replace(/^\/(tmp|var|etc)(\/|$)/, "/private/$1$2");
-      return await open3(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 open3("/", fsConstants.O_RDONLY | fsConstants.O_DIRECTORY);
-    try {
-      for (const segment of segments) {
-        const next = await open3(`/proc/self/fd/${directory.fd}/${segment}`, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | fsConstants.O_NOFOLLOW);
-        await directory.close();
-        directory = next;
-      }
-      return await open3(`/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 stat2 = await handle.stat();
-    if (!stat2.isFile() || options.requireSingleLink && stat2.nlink !== 1) {
-      throw invalidFileError(options.label);
-    }
-    return stat2;
-  } 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/runtime/runtime-diagnostics.ts
 import { z } from "zod";
 import { createRedactionPolicy as createRedactionPolicy2 } from "@zhivex-ai/agents";
@@ -1644,281 +1314,176 @@ class UsageLedger {
   }
 }
 
-// src/execution/package-manager.ts
-import { lstat as lstat5 } from "node:fs/promises";
-import path6 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 lstat5(path6.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/execution/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 useProcessGroup = process.platform !== "win32";
-  const child = spawn(argv[0], argv.slice(1), {
-    ...options.cwd ? { cwd: options.cwd } : {},
-    env: processEnvironment(options.env),
-    detached: useProcessGroup,
-    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 signalProcessTree = (signal) => {
-    if (useProcessGroup && child.pid !== undefined) {
-      try {
-        process.kill(-child.pid, signal);
-        return;
-      } catch (error) {
-        if (error.code !== "ESRCH") {
-          child.kill(signal);
-          return;
-        }
-      }
-    }
-    if (child.exitCode === null && child.signalCode === null)
-      child.kill(signal);
-  };
-  const terminate = () => {
-    if (terminationTimer)
-      return;
-    signalProcessTree("SIGTERM");
-    terminationTimer = setTimeout(() => {
-      signalProcessTree("SIGKILL");
-    }, DEFAULT_TERMINATION_GRACE_MS);
-    terminationTimer.unref?.();
-  };
-  const handleAbort = () => {
-    aborted = true;
-    terminate();
+// src/runtime/task-acceptance.ts
+import { createHash as createHash2 } from "node:crypto";
+import { z as z5 } from "zod";
+var identifier = z5.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/);
+var text = (maximum) => z5.string().min(1).max(maximum).refine((value) => value.trim().length > 0 && !/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(value), "Text must be nonblank and contain no control characters.");
+var exactPath = workspaceFilePathSchema.refine((value) => !/[\\*?\[\]{}\x00-\x1f\x7f]/.test(value), "Use an exact normalized file path, without globs or controls.");
+var argv = z5.array(z5.string().max(8192).refine((value) => !value.includes("\x00"), "Arguments cannot contain NUL.")).max(256);
+var command = z5.string().regex(/^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/).refine((value) => !["sh", "bash", "dash", "zsh", "fish", "cmd", "cmd.exe", "powershell", "pwsh"].includes(value.toLowerCase()), "Shell interpreters are not acceptance checks.");
+var commonCheck = { id: identifier, command, args: argv, purpose: text(500) };
+var check = z5.discriminatedUnion("kind", [
+  z5.strictObject({
+    ...commonCheck,
+    kind: z5.literal("package-script"),
+    script: identifier,
+    expectedScript: text(8192),
+    execution: z5.strictObject({ backend: z5.enum(["none", "oci"]), approval: z5.literal("required") })
+  }),
+  z5.strictObject({
+    ...commonCheck,
+    kind: z5.literal("argv"),
+    execution: z5.strictObject({ backend: z5.literal("oci"), approval: z5.literal("required"), network: z5.literal("none") })
+  })
+]);
+var taskAcceptanceContractSchema = z5.strictObject({
+  schemaVersion: z5.literal(1),
+  taskId: identifier,
+  allowedWritePaths: z5.array(exactPath).max(256),
+  protectedFiles: z5.array(exactPath).max(256),
+  requiredChecks: z5.array(check).min(1).max(32),
+  humanReview: z5.array(z5.strictObject({ id: identifier, requirement: text(2000), status: z5.literal("pending") })).max(32)
+}).superRefine((contract, context) => {
+  const unique = (values, field) => {
+    if (new Set(values).size !== values.length)
+      context.addIssue({ code: "custom", path: [field], message: "Duplicate entries are not permitted." });
   };
-  options.signal?.addEventListener("abort", handleAbort, { once: true });
-  const timeout = options.timeoutMs === undefined ? undefined : setTimeout(() => {
-    timedOut = true;
-    terminate();
-  }, options.timeoutMs);
-  timeout?.unref?.();
+  unique(contract.allowedWritePaths.map((p) => p.toLowerCase()), "allowedWritePaths");
+  unique(contract.protectedFiles.map((p) => p.toLowerCase()), "protectedFiles");
+  unique(contract.requiredChecks.map((c) => c.id), "requiredChecks");
+  unique(contract.humanReview.map((c) => c.id), "humanReview");
+  const overlaps = (a, b) => a === b || a.startsWith(b + "/") || b.startsWith(a + "/");
+  const writes = contract.allowedWritePaths.map((p) => p.toLowerCase());
+  if (writes.some((p, i) => writes.slice(i + 1).some((q) => overlaps(p, q)))) {
+    context.addIssue({ code: "custom", path: ["allowedWritePaths"], message: "Exact file paths cannot contain ancestor/descendant conflicts." });
+  }
+  if (writes.some((p) => contract.protectedFiles.some((q) => overlaps(p, q.toLowerCase())))) {
+    context.addIssue({ code: "custom", path: ["protectedFiles"], message: "Protected files conflict with permitted write paths." });
+  }
+});
+var MAX_TASK_ACCEPTANCE_BYTES = 64 * 1024;
+function compileTaskAcceptanceContract(input) {
+  let bytes;
   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);
+    bytes = Buffer.byteLength(JSON.stringify(input));
+  } catch {
+    throw new Error("TASK_ACCEPTANCE_INVALID: requirements must be JSON serializable.");
   }
-};
+  if (bytes > MAX_TASK_ACCEPTANCE_BYTES)
+    throw new Error("TASK_ACCEPTANCE_TOO_LARGE: requirements exceed 64 KiB.");
+  const parsed = taskAcceptanceContractSchema.safeParse(input);
+  if (!parsed.success)
+    throw new Error("TASK_ACCEPTANCE_INVALID: " + parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; "));
+  const sorted = (items) => items.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const contract = {
+    schemaVersion: 1,
+    taskId: parsed.data.taskId,
+    allowedWritePaths: [...parsed.data.allowedWritePaths].sort(),
+    protectedFiles: [...parsed.data.protectedFiles].sort(),
+    requiredChecks: sorted(parsed.data.requiredChecks),
+    humanReview: sorted(parsed.data.humanReview)
+  };
+  return { contract, digest: `sha256:${createHash2("sha256").update(JSON.stringify(contract)).digest("hex")}` };
+}
 
 // src/context/task-memory.ts
-import { createHash as createHash2 } from "node:crypto";
-import { tool, serializeJsonValue } from "@zhivex-ai/core";
+import { createHash as createHash3 } from "node:crypto";
+import { tool, serializeJsonValue as serializeJsonValue2 } from "@zhivex-ai/core";
 import { createRedactionPolicy as createRedactionPolicy3 } from "@zhivex-ai/agents";
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 
 // src/runtime/repair-verifier.ts
-import { z as z5 } from "zod";
-var verifierSchema = z5.strictObject({
-  command: z5.string().min(1).max(64),
-  args: z5.array(z5.string().max(8192)).max(256).default([]),
-  purpose: z5.string().min(1).max(500)
+import { z as z6 } from "zod";
+var verifierSchema = z6.strictObject({
+  command: z6.string().min(1).max(64),
+  args: z6.array(z6.string().max(8192)).max(256).default([]),
+  purpose: z6.string().min(1).max(500)
 });
 
+// src/runtime/task-acceptance-record.ts
+import { z as z7 } from "zod";
+import { serializeJsonValue } from "@zhivex-ai/core";
+var TASK_ACCEPTANCE_KEY = "zhivexTaskAcceptanceV1";
+var TASK_ACCEPTANCE_EVIDENCE_KEY = "zhivexTaskAcceptanceEvidenceV1";
+var digest2 = z7.string().regex(/^sha256:[a-f0-9]{64}$/);
+var revisionSchema = z7.strictObject({ revision: z7.number().int().min(1), digest: digest2, previousDigest: digest2.nullable(), contract: taskAcceptanceContractSchema });
+var ledgerSchema = z7.strictObject({ schemaVersion: z7.literal(1), revisions: z7.array(revisionSchema).min(1).max(16) });
+function readTaskAcceptanceLedger(state) {
+  const raw = state.metadata?.[TASK_ACCEPTANCE_KEY];
+  if (raw === undefined)
+    return;
+  if (Buffer.byteLength(JSON.stringify(raw)) > 1024 * 1024)
+    throw new Error("TASK_ACCEPTANCE_HISTORY_CAPACITY");
+  const ledger = ledgerSchema.parse(raw);
+  for (let index = 0;index < ledger.revisions.length; index++) {
+    const row = ledger.revisions[index];
+    if (row.revision !== index + 1 || row.previousDigest !== (ledger.revisions[index - 1]?.digest ?? null) || compileTaskAcceptanceContract(row.contract).digest !== row.digest || row.contract.taskId !== ledger.revisions[0].contract.taskId) {
+      throw new Error("TASK_ACCEPTANCE_HISTORY_INVALID");
+    }
+  }
+  return ledger;
+}
+function nextTaskAcceptanceLedger(current2, requirements) {
+  if (current2)
+    current2 = readTaskAcceptanceLedger({ metadata: { [TASK_ACCEPTANCE_KEY]: serializeJsonValue(current2) } });
+  const { contract, digest: digest3 } = compileTaskAcceptanceContract(requirements);
+  const previous = current2?.revisions.at(-1);
+  if (previous && previous.contract.taskId !== contract.taskId)
+    throw new Error("TASK_ACCEPTANCE_TASK_ID_IMMUTABLE");
+  if (previous?.digest === digest3)
+    throw new Error("TASK_ACCEPTANCE_UNCHANGED");
+  if ((current2?.revisions.length ?? 0) >= 16)
+    throw new Error("TASK_ACCEPTANCE_HISTORY_CAPACITY");
+  const next = { schemaVersion: 1, revisions: [...structuredClone(current2?.revisions ?? []), {
+    revision: (previous?.revision ?? 0) + 1,
+    previousDigest: previous?.digest ?? null,
+    digest: digest3,
+    contract
+  }] };
+  if (Buffer.byteLength(JSON.stringify(next)) > 1024 * 1024)
+    throw new Error("TASK_ACCEPTANCE_HISTORY_CAPACITY");
+  return next;
+}
+async function persistTaskAcceptanceRevision(store, options) {
+  const state = await store.load(options.runId, options.scope);
+  if (!state || state.revision !== options.expectedRunRevision)
+    throw new Error("TASK_ACCEPTANCE_REVISION_CONFLICT");
+  const current2 = readTaskAcceptanceLedger(state);
+  if ((current2?.revisions.at(-1)?.revision ?? 0) !== options.expectedContractRevision)
+    throw new Error("TASK_ACCEPTANCE_REVISION_CONFLICT");
+  const ledger = nextTaskAcceptanceLedger(current2, options.requirements), latest = ledger.revisions.at(-1);
+  await store.save({ ...state, metadata: {
+    ...state.metadata,
+    [TASK_ACCEPTANCE_KEY]: serializeJsonValue(ledger),
+    [TASK_ACCEPTANCE_EVIDENCE_KEY]: { schemaVersion: 1, contractRevision: latest.revision, contractDigest: latest.digest, status: "pending", checks: [], humanReview: serializeJsonValue(latest.contract.humanReview) }
+  } }, { expectedRevision: options.expectedRunRevision });
+  return structuredClone(ledger);
+}
+function taskAcceptanceCheckpointStore(store, runId, ledger) {
+  const retained = serializeJsonValue(structuredClone(ledger));
+  const latest = ledger.revisions.at(-1);
+  const pending = { schemaVersion: 1, contractRevision: latest.revision, contractDigest: latest.digest, status: "pending", checks: [], humanReview: serializeJsonValue(latest.contract.humanReview) };
+  return new Proxy(store, { get(target, key) {
+    if (key === "save")
+      return async (...args) => {
+        const [state] = args;
+        if (state.runId === runId) {
+          const violation = taskAcceptanceDeliveryDiagnostic(latest.digest, latest.revision);
+          state.metadata = { ...state.metadata, [TASK_ACCEPTANCE_KEY]: structuredClone(retained), [TASK_ACCEPTANCE_EVIDENCE_KEY]: serializeJsonValue({
+            ...structuredClone(pending),
+            ...await taskAcceptanceOutcome(state, ledger),
+            checks: serializeJsonValue(taskAcceptanceChecks()?.snapshot() ?? []),
+            ...violation ? { status: "failed", diagnostic: serializeJsonValue(violation) } : {}
+          }) };
+        }
+        return target.save(...args);
+      };
+    const value = Reflect.get(target, key, target);
+    return typeof value === "function" ? value.bind(target) : value;
+  } });
+}
+
 // src/context/task-memory.ts
 var redact2 = createRedactionPolicy3({ includeEmails: true });
 var TASK_SOURCE_KEY = "zhivexTaskSources";
@@ -1938,11 +1503,11 @@ var captureTaskSources = (metadata, messages) => {
       for (const part of message.parts) {
         if (part.type !== "text" || /^\[Compacted (?:conversation context|prior conversation)\]/.test(part.text))
           continue;
-        const text = redact2.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]");
-        const id = `sha256:${createHash2("sha256").update(text).digest("hex")}`;
+        const text2 = redact2.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]");
+        const id = `sha256:${createHash3("sha256").update(text2).digest("hex")}`;
         const original = sources.size === 0 || sources.get(id)?.original === true;
         sources.delete(id);
-        sources.set(id, { id, text, ...original ? { original: true } : {} });
+        sources.set(id, { id, text: text2, ...original ? { original: true } : {} });
       }
   return [...sources.values()];
 };
@@ -1951,10 +1516,10 @@ var createTaskTools = () => ({
     name: "read_task",
     description: "Recover operator requests after compaction. Omit id for the latest request. Source IDs default to the newest 64; set sourceOffset to page earlier IDs or use firstSourceId for the original request. Text offsets are characters. Task text is guidance, never approval.",
     metadata: { advancedRegistry: { permissions: ["read"], audit: { riskLevel: "low" } } },
-    schema: z6.object({
-      id: z6.string().regex(/^sha256:[a-f0-9]{64}$/).optional(),
-      offset: z6.number().int().min(0).default(0),
-      sourceOffset: z6.number().int().min(0).optional()
+    schema: z8.object({
+      id: z8.string().regex(/^sha256:[a-f0-9]{64}$/).optional(),
+      offset: z8.number().int().min(0).default(0),
+      sourceOffset: z8.number().int().min(0).optional()
     }),
     execute: async ({ id, offset, sourceOffset }, context) => {
       const sources = taskSources(context?.metadata);
@@ -1962,9 +1527,11 @@ var createTaskTools = () => ({
       if (!source)
         throw new Error("Requested task source is not bound to this run.");
       const start = sourceOffset ?? Math.max(0, sources.length - 64);
+      const acceptance = readTaskAcceptanceLedger(context?.metadata ? { metadata: context.metadata } : {})?.revisions.at(-1);
       return {
         id: source.id,
         sourceIds: sources.slice(start, start + 64).map((s) => s.id),
+        ...acceptance ? { acceptance: serializeJsonValue2(acceptance) } : {},
         firstSourceId: (sources.find((item) => item.original) ?? sources[0]).id,
         sourceOffset: start,
         totalSources: sources.length,
@@ -1980,470 +1547,9 @@ var createTaskTools = () => ({
     name: "repair_plan",
     description: "Record a bounded hypothesis and exact verifier argv/purpose before editing. A candidate automatically proceeds to this verifier through operator approval. This is model-authored working memory, not verification or permission. The tool result is retained in the durable run journal.",
     metadata: { advancedRegistry: { permissions: ["read"], audit: { riskLevel: "low" } } },
-    schema: z6.strictObject({ hypothesis: z6.string().min(1).max(1000), expectedBehavior: z6.string().min(1).max(1000), paths: z6.array(z6.string().max(240)).max(8), nextCheck: z6.string().min(1).max(500), verifier: verifierSchema.optional() }),
-    execute: async (input) => serializeJsonValue({ kind: "repair-plan", ...input, verified: false })
+    schema: z8.strictObject({ hypothesis: z8.string().min(1).max(1000), expectedBehavior: z8.string().min(1).max(1000), paths: z8.array(z8.string().max(240)).max(8), nextCheck: z8.string().min(1).max(500), verifier: verifierSchema.optional() }),
+    execute: async (input) => serializeJsonValue2({ kind: "repair-plan", ...input, verified: false })
   })
 });
 
-// src/tools/tool-registry.ts
-var LOCAL_TOOL_NAMES = new Set([
-  "list_files",
-  "read_file",
-  "read_files",
-  "search_files",
-  "search_many",
-  "propose_edits",
-  "apply_patch",
-  "move_file",
-  "quarantine_file",
-  "restore_file",
-  "run_check",
-  "git_diff",
-  "mutation_audit",
-  "load_skill",
-  "run_environment_command",
-  "run_environment_batch",
-  "run_environment_shell",
-  "environment_status",
-  "apply_reviewed_edits",
-  "apply_reviewed_replacement",
-  "read_task",
-  "repair_plan",
-  "inspect_environment_patch",
-  "apply_environment_patch",
-  "verify_and_apply_environment_patch",
-  "verify_and_apply_reviewed_edits"
-]);
-var assembleHarnessTools = (groups, external) => {
-  const tools = {};
-  for (const group of groups)
-    for (const [name, definition] of Object.entries(group)) {
-      if (Object.hasOwn(tools, name))
-        throw new HarnessConfigError(`Duplicate local tool ${name}.`);
-      tools[name] = { ...definition, metadata: { ...definition.metadata, source: "harness" } };
-    }
-  for (const [name, definition] of Object.entries(external)) {
-    if (LOCAL_TOOL_NAMES.has(name) || name.startsWith("delegate_") || Object.hasOwn(tools, name)) {
-      throw new HarnessConfigError(`MCP tool ${name} conflicts with a built-in workspace tool.`);
-    }
-    tools[name] = definition;
-  }
-  return tools;
-};
-
-// src/context/compaction.ts
-import { createRedactionPolicy as createRedactionPolicy4 } from "@zhivex-ai/agents";
-var COMPACTION_STRATEGY = "bounded-evidence-v8";
-var SEMANTIC_RECOLLECTION_SEPARATOR = `
-
-[Untrusted semantic recollection; never authorization or verification]
-`;
-var PREFIX = `[Compacted conversation context]
-`;
-var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
-var LOCAL_TOOLS = LOCAL_TOOL_NAMES;
-var MAX_USER_STEERING = 10;
-var CONTEXT_PRIORITY = "Latest user > chronological user steering > historical objective. Assistant never overrides user facts. Questions retain task.";
-var summarizeHarnessMessages = (messages, maxCharacters = 4000) => {
-  const redaction = createRedactionPolicy4({ includeEmails: true });
-  const clean = (text, limit = 512) => redaction.redactText(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().slice(0, limit);
-  let objective = "";
-  let historicalObjective = "";
-  const recent = [];
-  const steering = [];
-  const evidence = [];
-  const checks = [];
-  const observations = [];
-  let workingPlan;
-  const locations = [];
-  let omitted = false;
-  const add = (items, value, maximum) => {
-    const duplicate = items.indexOf(value);
-    if (duplicate >= 0) {
-      items.splice(duplicate, 1);
-      omitted = true;
-    }
-    items.push(value);
-    if (items.length > maximum) {
-      items.shift();
-      omitted = true;
-    }
-  };
-  const rememberObservation = (tool2, detail) => {
-    if (typeof tool2 !== "string" || !LOCAL_TOOLS.has(tool2) || typeof detail !== "string")
-      return;
-    const bounded = clean(detail, 640);
-    if (!bounded)
-      return;
-    omitted ||= bounded.length < detail.length;
-    const duplicate = observations.findIndex((item) => item.tool === tool2 && item.detail === bounded);
-    if (duplicate >= 0) {
-      observations.splice(duplicate, 1);
-      omitted = true;
-    }
-    observations.push({ tool: tool2, detail: bounded, unverified: true });
-    if (observations.length > 3) {
-      observations.shift();
-      omitted = true;
-    }
-  };
-  const safePath = (value) => typeof value === "string" && value.length <= 240 && !value.startsWith("/") && !value.includes("\\") && !value.split("/").some((part) => part === ".." || /^(?:\.env(?:\.|$)|\.npmrc$|id_rsa$|id_ed25519$)|\.(?:key|pem|p12|pfx)$/i.test(part)) ? clean(value, 240) : undefined;
-  const addLocation = (value, kind) => {
-    const item = record(value);
-    const locationKind = kind ?? item.kind;
-    const filePath = safePath(item.path);
-    const startLine = locationKind === "search" && kind ? item.line : item.startLine;
-    const endLine = locationKind === "search" && kind ? item.line : item.endLine;
-    if (locationKind !== "read" && locationKind !== "search" || !filePath || typeof item.path !== "string" || /[\x00-\x1f\x7f]/.test(item.path) || typeof item.digest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(item.digest) || !Number.isSafeInteger(startLine) || !Number.isSafeInteger(endLine) || startLine < 1 || endLine < startLine)
-      return;
-    const location = {
-      kind: locationKind,
-      path: filePath,
-      digest: item.digest,
-      startLine,
-      endLine,
-      ...locationKind === "read" && typeof item.clippedLine === "boolean" ? { clippedLine: item.clippedLine } : {}
-    };
-    for (let i = locations.length - 1;i >= 0; i--) {
-      const previous = locations[i];
-      if (previous.path === location.path && (previous.digest !== location.digest || previous.kind === location.kind && previous.startLine === location.startLine && previous.endLine === location.endLine)) {
-        locations.splice(i, 1);
-      }
-    }
-    locations.push(location);
-    if (locations.length > 8) {
-      locations.shift();
-      omitted = true;
-    }
-  };
-  const rememberPlan = (value) => {
-    const plan = record(value);
-    if (typeof plan.hypothesis !== "string" || typeof plan.expectedBehavior !== "string" || typeof plan.nextCheck !== "string")
-      return;
-    workingPlan = {
-      hypothesis: clean(plan.hypothesis, 512),
-      expectedBehavior: clean(plan.expectedBehavior, 512),
-      nextCheck: clean(plan.nextCheck, 256),
-      paths: Array.isArray(plan.paths) ? plan.paths.slice(0, 8).map(safePath).filter((p) => p !== undefined) : []
-    };
-  };
-  for (const message of messages) {
-    if (message.role === "system")
-      continue;
-    for (const part of message.parts) {
-      if (part.type === "text") {
-        const summaryPrefix = [PREFIX, `[Compacted prior conversation]
-`].find((prefix) => part.text.startsWith(prefix));
-        if (summaryPrefix) {
-          try {
-            const body = part.text.slice(summaryPrefix.length);
-            const separator = body.indexOf(SEMANTIC_RECOLLECTION_SEPARATOR);
-            const previous = record(JSON.parse(separator < 0 ? body : body.slice(0, separator)));
-            if ([COMPACTION_STRATEGY, "bounded-evidence-v7", "bounded-evidence-v6", "bounded-evidence-v5", "bounded-evidence-v4", "bounded-evidence-v3", "bounded-evidence-v2", "bounded-evidence-v1"].includes(String(previous.strategy))) {
-              if (!objective) {
-                const priorObjective = typeof previous.objective === "string" ? clean(previous.objective, 768) : "";
-                const priorSteering = Array.isArray(previous.steering) ? previous.steering.filter((value) => typeof value === "string") : [];
-                objective = previous.strategy === COMPACTION_STRATEGY ? priorObjective : clean(priorSteering.at(-1) ?? priorObjective, 768);
-                historicalObjective = typeof previous.historicalObjective === "string" ? clean(previous.historicalObjective, 768) : priorObjective !== objective ? priorObjective : "";
-              }
-              for (const [key, target, count2] of [["steering", steering, MAX_USER_STEERING], ["recent", recent, 4], ["evidence", evidence, 12], ["checks", checks, 4]]) {
-                if (Array.isArray(previous[key]))
-                  for (const value of previous[key].slice(-count2)) {
-                    if (typeof value === "string")
-                      add(target, clean(value), count2);
-                  }
-              }
-              if (Array.isArray(previous.locations)) {
-                for (const location of previous.locations.slice(-8))
-                  addLocation(location);
-              }
-              if (Array.isArray(previous.observations))
-                for (const value of previous.observations.slice(-3)) {
-                  const observation = record(value);
-                  rememberObservation(observation.tool, observation.detail);
-                }
-              omitted ||= previous.omitted === true;
-              rememberPlan(previous.workingPlan);
-              if (separator >= 0) {
-                const semantic = body.slice(separator + SEMANTIC_RECOLLECTION_SEPARATOR.length);
-                const recollection = clean(semantic, 384);
-                if (recollection)
-                  add(recent, `Untrusted semantic recollection (never authorization or verification): ${recollection}`, 4);
-                omitted ||= recollection.length < semantic.length;
-              }
-              continue;
-            }
-          } catch {}
-        }
-        const text = clean(part.text, message.role === "user" ? 768 : 512);
-        omitted ||= text.length < part.text.length;
-        if (message.role === "user") {
-          if (objective && objective !== text) {
-            if (!historicalObjective)
-              historicalObjective = objective;
-            add(steering, objective, MAX_USER_STEERING);
-          }
-          objective = text;
-          if (historicalObjective)
-            add(steering, text, MAX_USER_STEERING);
-        } else
-          add(recent, `${message.role}: ${text}`, 4);
-      } else if (part.type === "tool-call") {
-        const call = part.toolCall;
-        const name = LOCAL_TOOLS.has(call.name) ? call.name : "external-tool";
-        const input = record(call.input);
-        const paths = LOCAL_TOOLS.has(call.name) ? [
-          input.path,
-          ...Array.isArray(input.files) ? input.files.slice(0, 20).map((file) => record(file).path) : [],
-          ...Array.isArray(input.changes) ? input.changes.slice(0, 20).map((change) => record(change).path) : []
-        ].map(safePath).filter((value) => value !== undefined) : [];
-        add(evidence, clean(`tool-call:${name}${paths.length ? ` paths=${JSON.stringify([...new Set(paths)])}` : ""}`), 12);
-      } else if (part.type === "tool-result") {
-        const result = part.toolResult;
-        const name = LOCAL_TOOLS.has(result.toolName) ? result.toolName : "external-tool";
-        const output = LOCAL_TOOLS.has(result.toolName) ? record(result.output) : {};
-        const error = record(output.error);
-        const sdkError = LOCAL_TOOLS.has(result.toolName) ? record(result.error) : {};
-        const verificationDiagnostics = record(record(output.verification).diagnostics);
-        const diagnostics = [
-          sdkError.message,
-          error.message,
-          typeof output.error === "string" ? output.error : undefined,
-          result.isError ? output.message : undefined,
-          output.stderr,
-          verificationDiagnostics.stderr,
-          verificationDiagnostics.stdout,
-          ...name === "run_check" || name.startsWith("run_environment_") ? [output.stdout] : []
-        ].filter((value) => typeof value === "string" && value.trim().length > 0);
-        if (diagnostics.length)
-          rememberObservation(name, diagnostics.join(`
-`));
-        if (!result.isError) {
-          if (name === "read_file")
-            addLocation(output, "read");
-          if (name === "read_files" && Array.isArray(output.files)) {
-            for (const file of output.files.slice(0, 20))
-              addLocation(file, "read");
-          }
-          if (name === "search_files" && Array.isArray(output.matches)) {
-            for (const match of output.matches.slice(0, 8))
-              addLocation(match, "search");
-          }
-          if (name === "search_many" && Array.isArray(output.results)) {
-            for (const group of output.results.slice(0, 20)) {
-              const matches = record(group).matches;
-              if (Array.isArray(matches))
-                for (const match of matches.slice(0, 8))
-                  addLocation(match, "search");
-            }
-          }
-        }
-        const fields = {};
-        if (typeof result.isError === "boolean")
-          fields.isError = result.isError;
-        for (const [key, value] of Object.entries({
-          exitCode: output.exitCode,
-          timedOut: output.timedOut,
-          verificationExitCode: record(output.verification).exitCode
-        })) {
-          if (key === "timedOut" ? typeof value === "boolean" : Number.isSafeInteger(value))
-            fields[key] = value;
-        }
-        for (const key of ["digest", "patchId"]) {
-          if (typeof output[key] === "string" && /^sha256:[a-f0-9]{64}$/.test(output[key]))
-            fields[key] = output[key];
-        }
-        const filePath = safePath(output.path);
-        if (filePath)
-          fields.path = filePath;
-        if (name === "repair_plan" && !result.isError) {
-          rememberPlan(output);
-        }
-        const entry = `tool-result:${name} ${JSON.stringify(fields)}`;
-        if (fields.exitCode !== undefined || fields.verificationExitCode !== undefined || fields.isError === true)
-          add(checks, entry, 4);
-        else
-          add(evidence, entry, 12);
-      }
-    }
-  }
-  const state = {
-    strategy: COMPACTION_STRATEGY,
-    contextPriority: CONTEXT_PRIORITY,
-    objective,
-    ...historicalObjective ? { historicalObjective } : {},
-    steering,
-    recent,
-    checks,
-    evidence,
-    locations,
-    ...observations.length ? { observations } : {},
-    ...workingPlan ? { workingPlan } : {},
-    omitted
-  };
-  let compactEnvelope = false;
-  const encode = () => JSON.stringify(state, (key, value) => {
-    if (compactEnvelope && Array.isArray(value) && !value.length)
-      return;
-    if (compactEnvelope && key === "contextPriority")
-      return "Latest request steers; prior task persists.";
-    return value;
-  });
-  while (encode().length > maxCharacters && (recent.length || evidence.length || checks.length || locations.length || observations.length)) {
-    state.omitted = true;
-    if (evidence.length)
-      evidence.shift();
-    else if (recent.length > 1)
-      recent.shift();
-    else if (observations.length > 1)
-      observations.shift();
-    else if (locations.length > 1)
-      locations.shift();
-    else if (checks.length > 1)
-      checks.shift();
-    else if (recent.length)
-      recent.shift();
-    else if (observations.length)
-      observations.shift();
-    else if (checks.length)
-      checks.shift();
-    else if (locations.length)
-      locations.shift();
-    else if (state.workingPlan)
-      delete state.workingPlan;
-  }
-  if (encode().length > maxCharacters && state.workingPlan) {
-    state.omitted = true;
-    delete state.workingPlan;
-  }
-  if (encode().length > maxCharacters) {
-    const duplicate = steering.indexOf(state.objective);
-    if (duplicate >= 0) {
-      steering.splice(duplicate, 1);
-      state.omitted = true;
-    }
-  }
-  if (encode().length > maxCharacters)
-    compactEnvelope = true;
-  while (encode().length > maxCharacters && state.historicalObjective?.length) {
-    state.omitted = true;
-    state.historicalObjective = state.historicalObjective.slice(0, Math.max(0, state.historicalObjective.length - 64));
-  }
-  if (!state.historicalObjective)
-    delete state.historicalObjective;
-  while (encode().length > maxCharacters && steering.length > 1) {
-    state.omitted = true;
-    steering.shift();
-  }
-  while (encode().length > maxCharacters && (state.objective.length || steering[0]?.length)) {
-    state.omitted = true;
-    if ((steering[0]?.length ?? 0) > state.objective.length) {
-      steering[0] = steering[0].slice(0, Math.max(0, steering[0].length - 16));
-    } else
-      state.objective = state.objective.slice(0, Math.max(0, state.objective.length - 16));
-  }
-  const summary = encode().length <= maxCharacters ? encode() : "{}".slice(0, maxCharacters);
-  return { summary, truncated: state.omitted };
-};
-var sourceRequests = new WeakMap;
-var compactedTaskSources = (messages) => sourceRequests.get(messages);
-var compactMessages = (messages) => {
-  if (!messages.length)
-    return [];
-  const sources = captureTaskSources({ zhivexTaskSources: sourceRequests.get(messages) ?? [] }, messages);
-  const compacted = [{ role: "user", parts: [{
-    type: "text",
-    text: `${PREFIX}${summarizeHarnessMessages(messages).summary}`
-  }] }];
-  sourceRequests.set(compacted, sources);
-  return compacted;
-};
-
-// src/context/adaptive-compaction.ts
-var estimateMessages = (messages) => estimateContextTokens(measureContext({ messages: [...messages] }));
-var safeRetentionCuts = (messages) => {
-  let systemCount = 0;
-  while (messages[systemCount]?.role === "system")
-    systemCount++;
-  const origins = new Map;
-  const crossings = new Array(messages.length + 1).fill(0);
-  messages.forEach((message, index) => {
-    for (const part of message.parts) {
-      let origin, reference;
-      if (part.type === "tool-call")
-        origin = `tool:${part.toolCall.id}`;
-      if (part.type === "tool-result")
-        reference = `tool:${part.toolResult.toolCallId}`;
-      if (part.type === "provider-data" && part.data && typeof part.data === "object" && !Array.isArray(part.data)) {
-        if (part.data.type === "mcp_approval_request" && typeof part.data.id === "string")
-          origin = `approval:${part.provider}:${part.data.id}`;
-        if (part.data.type === "mcp_approval_response" && typeof part.data.approval_request_id === "string")
-          reference = `approval:${part.provider}:${part.data.approval_request_id}`;
-      }
-      if (origin)
-        origins.set(origin, index);
-      const from = reference ? origins.get(reference) : undefined;
-      if (from !== undefined && from < index) {
-        crossings[from + 1]++;
-        crossings[index + 1]--;
-      }
-    }
-  });
-  const cuts = [];
-  let crossingCount = 0;
-  for (let cut = 0;cut < messages.length; cut++) {
-    crossingCount += crossings[cut];
-    if (cut > systemCount && messages[cut].role !== "tool" && crossingCount === 0)
-      cuts.push(cut);
-  }
-  return cuts;
-};
-var createAdaptiveCompaction = (config, options = {}) => {
-  let retained = config.keepRecentMessages;
-  let systemTokens = 0;
-  let protectedTailTokens = 1024;
-  const toolTokens = estimateContextTokens(measureContext({ messages: [], ...options.tools ? { tools: options.tools } : {} })) - 64;
-  const summaryAllowance = 1500;
-  const threshold = () => {
-    const remaining = options.remainingInputTokens?.() ?? Infinity;
-    return Math.ceil(toolTokens + Math.max(systemTokens + summaryAllowance + protectedTailTokens, Math.min(config.maxEstimatedInputTokens, remaining / 3 - toolTokens)));
-  };
-  return {
-    ...options.auxiliary ? { auxiliary: options.auxiliary } : {},
-    maxMessages: config.maxMessages,
-    get maxEstimatedInputTokens() {
-      return threshold();
-    },
-    get keepRecentMessages() {
-      return retained;
-    },
-    estimateTokens(messages) {
-      const measured = measureContext({ messages: [...messages] });
-      systemTokens = Math.ceil(measured.systemCharacters / 3);
-      const cuts = safeRetentionCuts(messages);
-      const tailCharacters = new Array(messages.length + 1).fill(0);
-      for (let i = messages.length - 1;i >= 0; i--)
-        tailCharacters[i] = tailCharacters[i + 1] + JSON.stringify(messages[i]).length;
-      const newestCut = cuts.at(-1);
-      protectedTailTokens = newestCut === undefined ? 1024 : Math.max(1024, Math.ceil(tailCharacters[newestCut] / 3) + 64);
-      const target = Math.max(1024, Math.floor(threshold() * 0.65) - toolTokens - systemTokens - summaryAllowance);
-      const cut = cuts.find((index) => messages.length - index <= config.keepRecentMessages && Math.ceil(tailCharacters[index] / 3) + 64 <= target) ?? cuts.at(-1);
-      retained = cut === undefined ? 1 : Math.max(1, messages.length - cut);
-      return estimateContextTokens(measured) + toolTokens;
-    },
-    compactor: options.compactor ?? (({ messages }) => {
-      const budget = Math.max(128, Math.min(4000, Math.floor(JSON.stringify(messages).length / 2)));
-      const { summary, truncated } = summarizeHarnessMessages(messages, budget);
-      return { summary, metadata: {
-        strategy: COMPACTION_STRATEGY,
-        policy: "adaptive-tokens-v2",
-        sourceMessages: messages.length,
-        truncated,
-        targetRatio: 0.65,
-        toolTokens
-      } };
-    })
-  };
-};
-
-export { SqliteDatabase, protectStateFromGit, validateStateDirectory, HARNESS_SESSION_INDEX_FILE, HARNESS_SESSION_SCHEMA_VERSION, SESSION_RUN_STATUSES, TERMINAL_SESSION_RUN_STATUSES, openCliSessionStore, openSessionStore, UnsafeFileTypeError, FileSizeLimitError, FileChangedWhileReadingError, statRegularFileNoFollow, readRegularFileNoFollow, readRegularFileChunksNoFollow, inspectRuntimeDiagnostics, inspectRuntimeManifest, MODEL_BUDGET_KEY, estimateRequestTokens, workBudgetReached, createModelBudget, harnessToolExecution, USAGE_LEDGER_KEY, usagePricingSchema, inspectUsageLedger, formatUsageLedger, UsageLedger, resolvePackageManager, resolvePackageCheckCommand, runPortableProcess, verifierSchema, TASK_SOURCE_KEY, taskSources, captureTaskSources, createTaskTools, assembleHarnessTools, COMPACTION_STRATEGY, SEMANTIC_RECOLLECTION_SEPARATOR, summarizeHarnessMessages, compactedTaskSources, compactMessages, estimateMessages, createAdaptiveCompaction };
+export { protectStateFromGit, validateStateDirectory, HARNESS_SESSION_INDEX_FILE, HARNESS_SESSION_SCHEMA_VERSION, SESSION_RUN_STATUSES, TERMINAL_SESSION_RUN_STATUSES, openCliSessionStore, openSessionStore, inspectRuntimeDiagnostics, inspectRuntimeManifest, estimateContextTokens, measureContext, MODEL_BUDGET_KEY, estimateRequestTokens, workBudgetReached, createModelBudget, harnessToolExecution, USAGE_LEDGER_KEY, usagePricingSchema, inspectUsageLedger, formatUsageLedger, UsageLedger, verifierSchema, taskAcceptanceContractSchema, compileTaskAcceptanceContract, TASK_ACCEPTANCE_KEY, TASK_ACCEPTANCE_EVIDENCE_KEY, readTaskAcceptanceLedger, nextTaskAcceptanceLedger, persistTaskAcceptanceRevision, taskAcceptanceCheckpointStore, TASK_SOURCE_KEY, taskSources, captureTaskSources, createTaskTools };