@tangle-network/agent-eval 0.112.0 → 0.114.0

package/dist/{chunk-QQVYMBCZ.js → chunk-VHPD6AXX.js}

@@ -1,4 +1,5 @@
 import {
+  assertCodeSurfaceIdentity,
   campaignBreakdown,
   campaignMeanComposite,
   defaultProductionGate,
@@ -9,8 +10,9 @@ import {
   recoverTruncatedJson,
   renderAnalystEvidence,
   runImprovementLoop,
+  surfaceContentHash,
   surfaceHash
-} from "./chunk-RCXMWGRY.js";
+} from "./chunk-N6MTC3GK.js";
 import {
   estimateCost,
   isModelPriced
@@ -21,7 +23,7 @@ import {
   planCampaignRun,
   runCampaign,
   summarizeBackendIntegrity
-} from "./chunk-XNCF3JU3.js";
+} from "./chunk-FAOEFFRT.js";
 import {
   admitPolicyEdit,
   applyPolicyEditToSurface,
@@ -39,7 +41,7 @@ import {
   mulberry32,
   pairedBootstrap,
   weightedComposite
-} from "./chunk-VC43KQCK.js";
+} from "./chunk-PJQFMIOX.js";
 import {
   analyzeTraces
 } from "./chunk-RPDDVKI7.js";
@@ -3906,7 +3908,7 @@ function compositeProposer(opts) {
             const surface = isCandidate ? proposal.surface : proposal;
             const label = isCandidate ? proposal.label : "candidate";
             const rationale = isCandidate ? proposal.rationale : "";
-            const key = typeof surface === "string" ? surface : JSON.stringify(surface);
+            const key = surfaceContentHash(surface);
             if (seen.has(key)) continue;
             seen.add(key);
             pool.push({ surface, label: `${member.kind}:${label}`, rationale });
@@ -4172,6 +4174,7 @@ function coerceCandidateSurface(surface) {
   if (surface && typeof surface === "object") {
     const obj = surface;
     if (obj.kind === "code" && typeof obj.worktreeRef === "string") {
+      assertCodeSurfaceIdentity(surface);
       return surface;
     }
     return JSON.stringify(surface, null, 2);
@@ -4179,7 +4182,7 @@ function coerceCandidateSurface(surface) {
   throw new Error("policyEditProposer: policy edit produced an unsupported surface");
 }
 function sameSurface(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
+  return surfaceContentHash(a) === surfaceContentHash(b);
 }
 
 // src/campaign/proposers/trace-analyst.ts
@@ -4338,8 +4341,36 @@ function isTransientTransportFailure(message, opts = {}) {
 
 // src/campaign/worktree/index.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import { basename, isAbsolute as isAbsolute2, join as join5 } from "path";
+import { createHash as createHash7 } from "crypto";
+import {
+  closeSync,
+  existsSync as existsSync4,
+  constants as fsConstants,
+  fstatSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  mkdtempSync as mkdtempSync2,
+  openSync,
+  readlinkSync,
+  readSync,
+  realpathSync,
+  rmSync
+} from "fs";
+import { devNull, tmpdir as tmpdir2 } from "os";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve2, sep } from "path";
+var MAX_GIT_OUTPUT_BYTES = 256 * 1024 * 1024;
+var FILE_HASH_CHUNK_BYTES = 1024 * 1024;
+var GIT_REPOSITORY_ENV = /* @__PURE__ */ new Set([
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_COMMON_DIR",
+  "GIT_DIR",
+  "GIT_INDEX_FILE",
+  "GIT_NAMESPACE",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_PREFIX",
+  "GIT_QUARANTINE_PATH",
+  "GIT_WORK_TREE"
+]);
 var WorktreeAdapterError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -4348,14 +4379,443 @@ var WorktreeAdapterError = class extends Error {
   }
   cause;
 };
-function defaultGit(args, cwd) {
+function defaultGit(args, cwd, overrides) {
   try {
-    return execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
+    const env = { ...process.env };
+    for (const key of Object.keys(env)) {
+      if (GIT_REPOSITORY_ENV.has(key) || key === "GIT_CONFIG" || key.startsWith("GIT_CONFIG_") || key.startsWith("GIT_ATTR_") || key === "GIT_DIFF_OPTS" || key === "GIT_EXTERNAL_DIFF") {
+        delete env[key];
+      }
+    }
+    Object.assign(env, overrides);
+    env.GIT_NO_REPLACE_OBJECTS = "1";
+    env.LC_ALL = "C";
+    env.LANG = "C";
+    return execFileSync("git", args, { cwd, env, maxBuffer: MAX_GIT_OUTPUT_BYTES });
   } catch (err) {
     const stderr = err && typeof err === "object" && "stderr" in err ? String(err.stderr) : "";
     throw new WorktreeAdapterError(`git ${args.join(" ")} failed: ${stderr || String(err)}`, err);
   }
 }
+function gitBytes(git, args, cwd, env) {
+  try {
+    const output = git(args, cwd, env);
+    return typeof output === "string" ? Buffer.from(output, "utf8") : Buffer.from(output);
+  } catch (err) {
+    if (err instanceof WorktreeAdapterError) throw err;
+    throw new WorktreeAdapterError(`git ${args.join(" ")} failed: ${String(err)}`, err);
+  }
+}
+function gitText(git, args, cwd, env) {
+  return gitBytes(git, args, cwd, env).toString("utf8").trim();
+}
+function sha2562(bytes) {
+  return `sha256:${createHash7("sha256").update(bytes).digest("hex")}`;
+}
+var PATCH_ARGS = [
+  // Git binary patches embed a zlib stream. Pin no-compression at command
+  // scope so repository/global config and compressor heuristics cannot change
+  // the candidate identity for the same base and final tree.
+  "-c",
+  "core.compression=0",
+  "-c",
+  `core.attributesFile=${devNull}`,
+  "-c",
+  "core.quotePath=true",
+  "-c",
+  "diff.suppressBlankEmpty=false",
+  "diff",
+  "--unified=3",
+  "--inter-hunk-context=0",
+  `-O${devNull}`,
+  "--binary",
+  "--full-index",
+  "--no-color",
+  "--no-ext-diff",
+  "--no-textconv",
+  "--no-renames",
+  "--diff-algorithm=myers",
+  "--no-indent-heuristic",
+  "--src-prefix=a/",
+  "--dst-prefix=b/"
+];
+var CANONICAL_GIT_ENV = {
+  GIT_ATTR_GLOBAL: devNull,
+  GIT_ATTR_NOSYSTEM: "1",
+  GIT_CONFIG_GLOBAL: devNull,
+  GIT_CONFIG_NOSYSTEM: "1",
+  GIT_CONFIG_SYSTEM: devNull
+};
+function patchBytes(git, cwd, baseCommit, candidateCommit) {
+  const scratch = mkdtempSync2(join5(tmpdir2(), "agent-eval-patch-"));
+  const bareRepo = join5(scratch, "repo.git");
+  const emptyTemplate = join5(scratch, "empty-template");
+  mkdirSync2(emptyTemplate);
+  try {
+    const objectFormat = gitObjectHashAlgorithm(candidateCommit);
+    const sourceObjects = realpathSync(gitText(git, ["rev-parse", "--git-path", "objects"], cwd));
+    gitText(
+      git,
+      [
+        "init",
+        "--bare",
+        "--quiet",
+        ...objectFormat === "sha256" ? ["--object-format=sha256"] : [],
+        `--template=${emptyTemplate}`,
+        bareRepo
+      ],
+      scratch,
+      CANONICAL_GIT_ENV
+    );
+    return gitBytes(
+      git,
+      [`--git-dir=${bareRepo}`, ...PATCH_ARGS, baseCommit, candidateCommit, "--"],
+      scratch,
+      {
+        ...CANONICAL_GIT_ENV,
+        GIT_ALTERNATE_OBJECT_DIRECTORIES: sourceObjects
+      }
+    );
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+function resolveCommit(git, cwd, ref) {
+  return gitText(git, ["rev-parse", "--verify", `${ref}^{commit}`], cwd);
+}
+function unresolvedWorktreePath(surface, worktreeDir) {
+  if (isAbsolute2(surface.worktreeRef)) return surface.worktreeRef;
+  if (worktreeDir) return join5(worktreeDir, basename(surface.worktreeRef));
+  return surface.worktreeRef;
+}
+function displayGitPath(path) {
+  return JSON.stringify(path);
+}
+function parseGitTreeEntries(bytes) {
+  const input = Buffer.from(bytes);
+  const entries = [];
+  let start = 0;
+  while (start < input.length) {
+    const end = input.indexOf(0, start);
+    if (end < 0) throw new WorktreeAdapterError("Git tree output was not NUL-terminated");
+    const record = input.subarray(start, end);
+    start = end + 1;
+    if (record.length === 0) continue;
+    const tab = record.indexOf(9);
+    if (tab < 0) throw new WorktreeAdapterError("Git tree entry did not contain a path");
+    const metadata = record.subarray(0, tab).toString("ascii").split(" ");
+    if (metadata.length !== 3) throw new WorktreeAdapterError("Git tree entry was malformed");
+    const mode = metadata[0];
+    const type = metadata[1];
+    const objectId = metadata[2];
+    if (!mode || !type || !objectId) {
+      throw new WorktreeAdapterError("Git tree entry was malformed");
+    }
+    const pathBytes = record.subarray(tab + 1);
+    const path = pathBytes.toString("utf8");
+    if (!Buffer.from(path, "utf8").equals(pathBytes)) {
+      throw new WorktreeAdapterError("CodeSurface paths must be valid UTF-8");
+    }
+    if (type !== "blob" && type !== "commit") {
+      throw new WorktreeAdapterError(
+        `CodeSurface contains unsupported Git object type ${type} at ${displayGitPath(path)}`
+      );
+    }
+    entries.push({ mode, objectId, path });
+  }
+  return entries;
+}
+function parseGitPathList(bytes) {
+  const input = Buffer.from(bytes);
+  const paths = [];
+  let start = 0;
+  while (start < input.length) {
+    const end = input.indexOf(0, start);
+    if (end < 0) throw new WorktreeAdapterError("Git path output was not NUL-terminated");
+    const pathBytes = input.subarray(start, end);
+    start = end + 1;
+    if (pathBytes.length === 0) continue;
+    const path = pathBytes.toString("utf8");
+    if (!Buffer.from(path, "utf8").equals(pathBytes)) {
+      throw new WorktreeAdapterError("CodeSurface paths must be valid UTF-8");
+    }
+    paths.push(path);
+  }
+  return paths;
+}
+function isWithinRoot(root, candidate) {
+  const rel = relative2(root, candidate);
+  return rel === "" || !isAbsolute2(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+function assertSafeRelativePath(root, path) {
+  if (path.length === 0 || isAbsolute2(path)) {
+    throw new WorktreeAdapterError(`CodeSurface contains unsafe path ${displayGitPath(path)}`);
+  }
+  const absolutePath = resolve2(root, path);
+  if (!isWithinRoot(root, absolutePath) || absolutePath === root) {
+    throw new WorktreeAdapterError(`CodeSurface path escapes its worktree: ${displayGitPath(path)}`);
+  }
+  const segments = path.split(/[\\/]/u);
+  let parent = root;
+  for (const segment of segments.slice(0, -1)) {
+    if (segment.length === 0 || segment === "." || segment === "..") {
+      throw new WorktreeAdapterError(`CodeSurface contains unsafe path ${displayGitPath(path)}`);
+    }
+    parent = join5(parent, segment);
+    const stat = lstatSync(parent);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+      throw new WorktreeAdapterError(
+        `CodeSurface path traverses a non-directory or symbolic link: ${displayGitPath(path)}`
+      );
+    }
+  }
+  return absolutePath;
+}
+function gitObjectHashAlgorithm(objectId) {
+  if (/^[a-f0-9]{40}$/.test(objectId)) return "sha1";
+  if (/^[a-f0-9]{64}$/.test(objectId)) return "sha256";
+  throw new WorktreeAdapterError(`Unsupported Git object id: ${objectId}`);
+}
+function hashGitBlobBytes(bytes, objectId) {
+  const hash = createHash7(gitObjectHashAlgorithm(objectId));
+  hash.update(`blob ${bytes.byteLength}\0`);
+  hash.update(bytes);
+  return hash.digest("hex");
+}
+function hashGitBlobFile(path, objectId) {
+  const before = lstatSync(path);
+  if (!before.isFile() || before.isSymbolicLink()) {
+    throw new WorktreeAdapterError(`CodeSurface expected a regular file at ${displayGitPath(path)}`);
+  }
+  const noFollow = process.platform === "win32" ? 0 : fsConstants.O_NOFOLLOW;
+  const fd = openSync(path, fsConstants.O_RDONLY | noFollow);
+  try {
+    const opened = fstatSync(fd);
+    if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino || opened.size !== before.size) {
+      throw new WorktreeAdapterError(
+        `CodeSurface file changed while it was being verified: ${displayGitPath(path)}`
+      );
+    }
+    const hash = createHash7(gitObjectHashAlgorithm(objectId));
+    hash.update(`blob ${opened.size}\0`);
+    const chunk = Buffer.allocUnsafe(FILE_HASH_CHUNK_BYTES);
+    let total = 0;
+    while (true) {
+      const count = readSync(fd, chunk, 0, chunk.length, null);
+      if (count === 0) break;
+      total += count;
+      hash.update(chunk.subarray(0, count));
+    }
+    if (total !== opened.size) {
+      throw new WorktreeAdapterError(
+        `CodeSurface file changed while it was being verified: ${displayGitPath(path)}`
+      );
+    }
+    return { hash: hash.digest("hex"), executable: (opened.mode & 73) !== 0 };
+  } finally {
+    closeSync(fd);
+  }
+}
+function assertSymlinkTargetIsBound(root, linkPath, trackedPaths) {
+  const targetBytes = readlinkSync(linkPath, { encoding: "buffer" });
+  const target = targetBytes.toString("utf8");
+  if (!Buffer.from(target, "utf8").equals(targetBytes)) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link has an unsafe target at ${displayGitPath(linkPath)}`
+    );
+  }
+  if (isAbsolute2(target)) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link escapes its worktree at ${displayGitPath(linkPath)}`
+    );
+  }
+  const lexicalTarget = resolve2(dirname2(linkPath), target);
+  if (!isWithinRoot(root, lexicalTarget)) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link escapes its worktree at ${displayGitPath(linkPath)}`
+    );
+  }
+  let resolvedTarget;
+  try {
+    resolvedTarget = realpathSync(linkPath);
+  } catch (err) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link target is missing or cyclic at ${displayGitPath(linkPath)}`,
+      err
+    );
+  }
+  if (!isWithinRoot(root, resolvedTarget)) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link escapes its worktree at ${displayGitPath(linkPath)}`
+    );
+  }
+  const targetRelative = relative2(root, resolvedTarget).split(sep).join("/");
+  const targetIsTracked = trackedPaths.has(targetRelative) || [...trackedPaths].some((trackedPath) => trackedPath.startsWith(`${targetRelative}/`));
+  if (!targetIsTracked) {
+    throw new WorktreeAdapterError(
+      `CodeSurface symbolic link resolves to untracked content at ${displayGitPath(linkPath)}`
+    );
+  }
+}
+function assertRawTreeMatchesWorktree(git, root, candidateCommit) {
+  const entries = parseGitTreeEntries(
+    gitBytes(git, ["ls-tree", "-r", "-z", "--full-tree", candidateCommit], root)
+  );
+  const trackedPaths = new Set(entries.map((entry) => entry.path));
+  for (const entry of entries) {
+    const absolutePath = assertSafeRelativePath(root, entry.path);
+    if (entry.mode === "160000" || entry.mode === "040000") {
+      throw new WorktreeAdapterError(
+        `CodeSurface contains a Git submodule whose executable bytes are not bound: ${displayGitPath(entry.path)}`
+      );
+    }
+    if (entry.mode === "120000") {
+      const stat = lstatSync(absolutePath);
+      if (!stat.isSymbolicLink()) {
+        throw new WorktreeAdapterError(
+          `CodeSurface expected a symbolic link at ${displayGitPath(entry.path)}`
+        );
+      }
+      const targetBytes = readlinkSync(absolutePath, { encoding: "buffer" });
+      const actualObjectId = hashGitBlobBytes(targetBytes, entry.objectId);
+      if (actualObjectId !== entry.objectId) {
+        throw new WorktreeAdapterError(
+          `CodeSurface raw symbolic-link bytes differ from the candidate tree at ${displayGitPath(entry.path)}`
+        );
+      }
+      assertSymlinkTargetIsBound(root, absolutePath, trackedPaths);
+      continue;
+    }
+    if (entry.mode !== "100644" && entry.mode !== "100755") {
+      throw new WorktreeAdapterError(
+        `CodeSurface contains unsupported Git mode ${entry.mode} at ${displayGitPath(entry.path)}`
+      );
+    }
+    const actual = hashGitBlobFile(absolutePath, entry.objectId);
+    if (actual.hash !== entry.objectId) {
+      throw new WorktreeAdapterError(
+        `CodeSurface raw tracked bytes differ from the candidate tree because the worktree changed after finalization at ${displayGitPath(entry.path)}`
+      );
+    }
+    if (process.platform !== "win32" && actual.executable !== (entry.mode === "100755")) {
+      throw new WorktreeAdapterError(
+        `CodeSurface executable mode differs from the candidate tree at ${displayGitPath(entry.path)}`
+      );
+    }
+  }
+}
+function verifyCodeSurfaceWithGit(surface, path, git) {
+  assertCodeSurfaceIdentity(surface);
+  if (!existsSync4(path)) {
+    throw new WorktreeAdapterError(`CodeSurface worktree does not exist: ${path}`);
+  }
+  const lexicalRoot = resolve2(path);
+  const canonicalRoot = realpathSync(path);
+  if (lstatSync(lexicalRoot).isSymbolicLink() || process.platform !== "win32" && lexicalRoot !== canonicalRoot) {
+    throw new WorktreeAdapterError(
+      `CodeSurface worktree locator must not contain a symbolic link: ${path}`
+    );
+  }
+  const repoRoot = gitText(git, ["rev-parse", "--show-toplevel"], path);
+  const canonicalRepoRoot = realpathSync(repoRoot);
+  if (canonicalRepoRoot !== canonicalRoot) {
+    throw new WorktreeAdapterError(
+      `CodeSurface worktree locator is not the repository root: expected ${repoRoot}, got ${path}`
+    );
+  }
+  const indexFlags = gitText(git, ["ls-files", "-v"], path).split("\n").filter((line) => line.length > 0 && (line.startsWith("S ") || /^[a-z]/.test(line)));
+  if (indexFlags.length > 0) {
+    throw new WorktreeAdapterError(
+      `CodeSurface worktree uses hidden index entries that cannot be verified: ${path}
+${indexFlags.join("\n")}`
+    );
+  }
+  const extraPaths = [
+    ...parseGitPathList(gitBytes(git, ["ls-files", "--others", "--exclude-standard", "-z"], path)),
+    ...parseGitPathList(
+      gitBytes(git, ["ls-files", "--others", "--ignored", "--exclude-standard", "-z"], path)
+    )
+  ];
+  if (extraPaths.length > 0) {
+    throw new WorktreeAdapterError(
+      `CodeSurface worktree changed after finalization: ${path}
+${extraPaths.join("\n")}`
+    );
+  }
+  const candidateCommit = resolveCommit(git, path, "HEAD");
+  if (candidateCommit !== surface.candidateCommit) {
+    throw new WorktreeAdapterError(
+      `CodeSurface candidate commit mismatch: expected ${surface.candidateCommit}, got ${candidateCommit}`
+    );
+  }
+  const baseCommit = resolveCommit(git, path, surface.baseCommit);
+  if (baseCommit !== surface.baseCommit) {
+    throw new WorktreeAdapterError(
+      `CodeSurface base commit mismatch: expected ${surface.baseCommit}, got ${baseCommit}`
+    );
+  }
+  const baseTree = gitText(git, ["rev-parse", "--verify", `${surface.baseCommit}^{tree}`], path);
+  if (baseTree !== surface.baseTree) {
+    throw new WorktreeAdapterError(
+      `CodeSurface base tree mismatch: expected ${surface.baseTree}, got ${baseTree}`
+    );
+  }
+  const candidateTree = gitText(
+    git,
+    ["rev-parse", "--verify", `${surface.candidateCommit}^{tree}`],
+    path
+  );
+  if (candidateTree !== surface.candidateTree) {
+    throw new WorktreeAdapterError(
+      `CodeSurface tree mismatch: expected ${surface.candidateTree}, got ${candidateTree}`
+    );
+  }
+  try {
+    gitText(
+      git,
+      [
+        "diff-index",
+        "--cached",
+        "--quiet",
+        "--no-ext-diff",
+        "--no-textconv",
+        surface.candidateCommit,
+        "--"
+      ],
+      path
+    );
+  } catch (err) {
+    throw new WorktreeAdapterError(
+      `CodeSurface index differs from finalized candidate: ${path}`,
+      err
+    );
+  }
+  try {
+    assertRawTreeMatchesWorktree(git, canonicalRepoRoot, surface.candidateCommit);
+  } catch (err) {
+    if (err instanceof WorktreeAdapterError) throw err;
+    throw new WorktreeAdapterError(`CodeSurface raw tree verification failed: ${path}`, err);
+  }
+  const mergeBase = gitText(git, ["merge-base", surface.baseCommit, surface.candidateCommit], path);
+  if (mergeBase !== surface.baseCommit) {
+    throw new WorktreeAdapterError(
+      `CodeSurface candidate ${surface.candidateCommit} does not descend from base ${surface.baseCommit}`
+    );
+  }
+  const patch = patchBytes(git, path, surface.baseCommit, surface.candidateCommit);
+  const actualPatchHash = sha2562(patch);
+  if (actualPatchHash !== surface.patch.sha256 || patch.byteLength !== surface.patch.byteLength) {
+    throw new WorktreeAdapterError(
+      `CodeSurface patch mismatch: expected ${surface.patch.sha256}/${surface.patch.byteLength} bytes, got ${actualPatchHash}/${patch.byteLength} bytes`
+    );
+  }
+  return {
+    path,
+    repoRoot: canonicalRepoRoot,
+    contentHash: surfaceContentHash(surface),
+    patchBytes: new Uint8Array(patch)
+  };
+}
 function slug2(label) {
   return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "candidate";
 }
@@ -4368,32 +4828,62 @@ function gitWorktreeAdapter(opts) {
       const id = `${slug2(label)}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
       const branch = `${branchPrefix}/${id}`;
       const path = join5(worktreeDir, id);
-      git(["worktree", "add", "-b", branch, path, baseRef], opts.repoRoot);
-      return { path, branch, baseRef };
+      const baseCommit = resolveCommit(git, opts.repoRoot, baseRef);
+      const baseTree = gitText(
+        git,
+        ["rev-parse", "--verify", `${baseCommit}^{tree}`],
+        opts.repoRoot
+      );
+      gitText(git, ["worktree", "add", "-b", branch, path, baseCommit], opts.repoRoot);
+      return { path, branch, baseRef, baseCommit, baseTree };
     },
     async finalize(worktree, summary) {
-      const status = git(["status", "--porcelain"], worktree.path);
+      const status = gitText(
+        git,
+        ["status", "--porcelain=v1", "--untracked-files=all"],
+        worktree.path
+      );
       if (status.length > 0) {
-        git(["add", "-A"], worktree.path);
-        git(["commit", "-m", summary], worktree.path);
+        gitText(git, ["add", "-A"], worktree.path);
+        gitText(git, ["commit", "-m", summary], worktree.path);
       }
-      return {
+      const candidateCommit = resolveCommit(git, worktree.path, "HEAD");
+      const candidateTree = gitText(
+        git,
+        ["rev-parse", "--verify", `${candidateCommit}^{tree}`],
+        worktree.path
+      );
+      const patch = patchBytes(git, worktree.path, worktree.baseCommit, candidateCommit);
+      const surface = {
         kind: "code",
         worktreeRef: worktree.path,
         baseRef: worktree.baseRef,
+        baseCommit: worktree.baseCommit,
+        baseTree: worktree.baseTree,
+        candidateCommit,
+        candidateTree,
+        patch: {
+          format: "git-diff-binary",
+          sha256: sha2562(patch),
+          byteLength: patch.byteLength
+        },
         summary
       };
+      verifyCodeSurfaceWithGit(surface, worktree.path, git);
+      return surface;
     },
     async discard(worktree) {
-      git(["worktree", "remove", "--force", worktree.path], opts.repoRoot);
-      git(["branch", "-D", worktree.branch], opts.repoRoot);
+      gitText(git, ["worktree", "remove", "--force", worktree.path], opts.repoRoot);
+      gitText(git, ["branch", "-D", worktree.branch], opts.repoRoot);
     }
   };
 }
+function verifyCodeSurface(surface, worktreeDir) {
+  const path = unresolvedWorktreePath(surface, worktreeDir);
+  return verifyCodeSurfaceWithGit(surface, path, defaultGit);
+}
 function resolveWorktreePath(surface, worktreeDir) {
-  if (isAbsolute2(surface.worktreeRef) && existsSync4(surface.worktreeRef)) return surface.worktreeRef;
-  if (worktreeDir) return join5(worktreeDir, basename(surface.worktreeRef));
-  return surface.worktreeRef;
+  return verifyCodeSurface(surface, worktreeDir).path;
 }
 
 export {
@@ -4473,6 +4963,7 @@ export {
   isTransientTransportFailure,
   WorktreeAdapterError,
   gitWorktreeAdapter,
+  verifyCodeSurface,
   resolveWorktreePath
 };
-//# sourceMappingURL=chunk-QQVYMBCZ.js.map
+//# sourceMappingURL=chunk-VHPD6AXX.js.map