@nimiplatform/nimi-coding 0.4.0 → 0.6.0

package/cli/lib/authority/git-snapshot.mjs

@@ -6,7 +6,7 @@ import { lstat, mkdir, mkdtemp, open, readdir, realpath, rm, writeFile } from "n
 import os from "node:os";
 import path from "node:path";
 
-import { compareText, makeDiagnostic } from "./diagnostics.mjs";
+import { compareText, isPathWithin, makeDiagnostic } from "./diagnostics.mjs";
 
 const SNAPSHOT_IDENTITY_FORMAT = "nimicoding.authority-snapshot-content/v1";
 const SPEC_ROOT = ".nimi/spec";
@@ -285,11 +285,6 @@ function sameObject(left, right) {
   return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode;
 }
 
-function contained(root, candidate) {
-  const relative = path.relative(root, candidate);
-  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
-
 function filesystemFailure(error, initial, entryPath = SPEC_ROOT) {
   if (error instanceof AuthorityReviewRefusal) return error;
   if (!initial && ["ENOENT", "ENOTDIR", "ELOOP"].includes(error?.code)) {
@@ -303,13 +298,13 @@ async function securedDirectory(absolute, containmentRoot, entryPath, initial) {
     const before = await lstat(absolute, { bigint: true });
     if (before.isSymbolicLink() || !before.isDirectory()) throw refusal("AUTH_REVIEW_WORKTREE_ENTRY_INVALID", `worktree authority entry is not a regular directory: ${entryPath}`, entryPath);
     const beforeReal = await realpath(absolute);
-    if (!contained(containmentRoot, beforeReal)) throw refusal("AUTH_REVIEW_WORKTREE_ENTRY_INVALID", `worktree authority directory escapes .nimi/spec: ${entryPath}`, entryPath);
+    if (!isPathWithin(containmentRoot, beforeReal)) throw refusal("AUTH_REVIEW_WORKTREE_ENTRY_INVALID", `worktree authority directory escapes .nimi/spec: ${entryPath}`, entryPath);
     const handle = await open(absolute, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | fsConstants.O_NOFOLLOW);
     try {
       const held = await handle.stat({ bigint: true });
       const current = await lstat(absolute, { bigint: true });
       const currentReal = await realpath(absolute);
-      if (!held.isDirectory() || !sameObject(before, held) || !sameObject(held, current) || !contained(containmentRoot, currentReal)) {
+      if (!held.isDirectory() || !sameObject(before, held) || !sameObject(held, current) || !isPathWithin(containmentRoot, currentReal)) {
         throw refusal("AUTH_REVIEW_CAPTURE_CHANGED", `worktree authority directory changed during capture: ${entryPath}`, entryPath);
       }
       return { handle, token: statToken(held) };
@@ -327,13 +322,13 @@ async function openSecuredFile(absolute, containmentRoot, entryPath, initial) {
     const before = await lstat(absolute, { bigint: true });
     if (before.isSymbolicLink() || !before.isFile()) throw refusal("AUTH_REVIEW_WORKTREE_ENTRY_INVALID", `worktree authority entry is not a regular non-symlink file: ${entryPath}`, entryPath);
     const beforeReal = await realpath(absolute);
-    if (containmentRoot !== null && !contained(containmentRoot, beforeReal)) throw refusal("AUTH_REVIEW_WORKTREE_ENTRY_INVALID", `worktree authority file escapes .nimi/spec: ${entryPath}`, entryPath);
+    if (containmentRoot !== null && !isPathWithin(containmentRoot, beforeReal)) throw refusal("AUTH_REVIEW_WORKTREE_ENTRY_INVALID", `worktree authority file escapes .nimi/spec: ${entryPath}`, entryPath);
     const handle = await open(absolute, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
     try {
       const held = await handle.stat({ bigint: true });
       const current = await lstat(absolute, { bigint: true });
       const currentReal = await realpath(absolute);
-      if (!held.isFile() || !sameObject(before, held) || !sameObject(held, current) || (containmentRoot !== null && !contained(containmentRoot, currentReal))) {
+      if (!held.isFile() || !sameObject(before, held) || !sameObject(held, current) || (containmentRoot !== null && !isPathWithin(containmentRoot, currentReal))) {
         throw refusal("AUTH_REVIEW_CAPTURE_CHANGED", `worktree authority file changed before capture: ${entryPath}`, entryPath);
       }
       return { handle, token: statToken(held) };
@@ -371,7 +366,7 @@ async function readSecuredFile(secured, absolute, containmentRoot, entryPath, in
     const heldBefore = await secured.handle.stat({ bigint: true });
     const currentBefore = await lstat(absolute, { bigint: true });
     const currentReal = await realpath(absolute);
-    if (!heldBefore.isFile() || statToken(heldBefore) !== secured.token || !sameObject(heldBefore, currentBefore) || (containmentRoot !== null && !contained(containmentRoot, currentReal))) {
+    if (!heldBefore.isFile() || statToken(heldBefore) !== secured.token || !sameObject(heldBefore, currentBefore) || (containmentRoot !== null && !isPathWithin(containmentRoot, currentReal))) {
       throw refusal("AUTH_REVIEW_CAPTURE_CHANGED", `worktree authority file changed before bytes were captured: ${entryPath}`, entryPath);
     }
     if (budget !== null) budget.reserve(heldBefore.size, entryPath);
@@ -465,7 +460,7 @@ async function scanWorktree(repository, initial, { retainHandles = false, budget
       const current = await lstat(absolute, { bigint: true });
       const currentReal = await realpath(absolute);
       const held = await secured.handle.stat({ bigint: true });
-      if (statToken(held) !== secured.token || !sameObject(held, current) || !contained(specReal, currentReal)) {
+      if (statToken(held) !== secured.token || !sameObject(held, current) || !isPathWithin(specReal, currentReal)) {
         throw refusal("AUTH_REVIEW_CAPTURE_CHANGED", `worktree authority directory changed during traversal: ${entryPath}`, entryPath);
       }
     } finally {
@@ -497,7 +492,7 @@ async function verifyHeldEntries(heldEntries) {
       const held = await entry.handle.stat({ bigint: true });
       const current = await lstat(entry.absolute, { bigint: true });
       const currentReal = await realpath(entry.absolute);
-      if (!held.isDirectory() || statToken(held) !== entry.token || !sameObject(held, current) || !contained(entry.containmentRoot, currentReal)) {
+      if (!held.isDirectory() || statToken(held) !== entry.token || !sameObject(held, current) || !isPathWithin(entry.containmentRoot, currentReal)) {
         throw refusal("AUTH_REVIEW_CAPTURE_CHANGED", `worktree authority directory changed before capture commit: ${entry.path}`, entry.path);
       }
     } catch (error) {
@@ -594,7 +589,7 @@ function stableRegularFileBudget(maxBytes, label) {
   return {
     reserve(size) {
       if (size > BigInt(maxBytes)) {
-        throw refusal("AUTH_EVIDENCE_INPUT_BUDGET", `evidence input requires ${size} bytes but maxInputBytes is ${maxBytes}: ${label}`, label);
+        throw refusal("AUTH_REVIEW_INPUT_BUDGET", `review input requires ${size} bytes but maxBytes is ${maxBytes}: ${label}`, label);
       }
     },
   };
@@ -618,204 +613,6 @@ export async function captureStableRegularFile(file, label, containmentRoot = nu
   }
 }
 
-function evidenceRefusal(code, reason, file = ".") {
-  return refusal(code, reason, file);
-}
-
-function mapEvidenceRefusal(error, fallbackCode, fallbackFile = ".") {
-  if (!(error instanceof AuthorityReviewRefusal)) return error;
-  if (error.code === "AUTH_REVIEW_CAPTURE_CHANGED" || error.code === "AUTH_EVIDENCE_CAPTURE_CHANGED") {
-    return evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", error.message, error.file ?? fallbackFile);
-  }
-  if (error.code.startsWith("AUTH_EVIDENCE_")) return error;
-  return evidenceRefusal(fallbackCode, error.message, error.file ?? fallbackFile);
-}
-
-function validEvidencePath(value) {
-  return typeof value === "string"
-    && validateRelativePath(value)
-    && value === value.normalize("NFC")
-    && !value.includes("\0")
-    && !value.includes("\n")
-    && !value.includes("\r")
-    && value.split("/").every((part) => part.toLowerCase() !== ".git");
-}
-
-function evidenceInputBudget(maxInputBytes) {
-  if (!Number.isSafeInteger(maxInputBytes) || maxInputBytes <= 0) {
-    throw evidenceRefusal("AUTH_EVIDENCE_INPUT_BUDGET", "maxInputBytes must be one positive safe integer");
-  }
-  let captured = 0;
-  return {
-    reserve(size, entryPath) {
-      if (size < 0n || size > BigInt(Number.MAX_SAFE_INTEGER)) {
-        throw evidenceRefusal("AUTH_EVIDENCE_INPUT_BUDGET", `evidence input is too large to capture exactly: ${entryPath}`, entryPath);
-      }
-      const required = BigInt(captured) + size;
-      if (required > BigInt(maxInputBytes)) {
-        throw evidenceRefusal(
-          "AUTH_EVIDENCE_INPUT_BUDGET",
-          `complete evidence snapshot requires at least ${required} input bytes but maxInputBytes is ${maxInputBytes}`,
-          entryPath,
-        );
-      }
-      captured = Number(required);
-    },
-    get captured() {
-      return captured;
-    },
-  };
-}
-
-async function trackedRegularIndexRecord(repository, bindingPath) {
-  const result = await runGit(repository, ["ls-files", "--stage", "-z", "--error-unmatch", "--", bindingPath]);
-  if (result.signal !== null) throw new Error(`Git process terminated by signal ${result.signal}`);
-  if (result.status !== 0) {
-    throw evidenceRefusal("AUTH_EVIDENCE_BINDING_INVALID", "evidence binding must be one tracked regular repository path", bindingPath);
-  }
-  const records = splitNullRecords(result.stdout);
-  if (records.length !== 1) {
-    throw evidenceRefusal("AUTH_EVIDENCE_BINDING_INVALID", "evidence binding must resolve to exactly one non-conflicted index entry", bindingPath);
-  }
-  const tab = records[0].indexOf(9);
-  if (tab <= 0 || tab === records[0].length - 1) {
-    throw evidenceRefusal("AUTH_EVIDENCE_BINDING_INVALID", "tracked evidence binding index entry is malformed", bindingPath);
-  }
-  const metadata = decodeUtf8(records[0].subarray(0, tab), "tracked evidence binding metadata", "AUTH_EVIDENCE_BINDING_INVALID");
-  const indexedPath = decodeUtf8(records[0].subarray(tab + 1), "tracked evidence binding path", "AUTH_EVIDENCE_BINDING_INVALID");
-  if (!/^(?:100644|100755) (?:[0-9a-f]{40}|[0-9a-f]{64}) 0$/.test(metadata) || indexedPath !== bindingPath) {
-    throw evidenceRefusal("AUTH_EVIDENCE_BINDING_INVALID", "evidence binding must be one exact stage-zero regular Git entry", bindingPath);
-  }
-  return Buffer.from(records[0]);
-}
-
-async function captureEvidenceInput(repository, descriptor, budget, retainHandles) {
-  const heldEntries = [];
-  const pathTokens = [];
-  const parts = descriptor.path.split("/");
-  let absolute = repository;
-  let retained = false;
-
-  async function retainDirectory(directory, entryPath) {
-    const secured = await securedDirectory(directory, repository, entryPath, true);
-    pathTokens.push({ path: entryPath, token: secured.token });
-    if (retainHandles) heldEntries.push({ path: entryPath, type: "directory", absolute: directory, containmentRoot: repository, ...secured });
-    else await secured.handle.close();
-  }
-
-  function missing(missingAbsolute, missingPath) {
-    if (!descriptor.allowMissing) {
-      throw evidenceRefusal(descriptor.invalidCode, `${descriptor.role} input is missing: ${descriptor.path}`, descriptor.path);
-    }
-    retained = retainHandles;
-    return {
-      role: descriptor.role,
-      path: descriptor.path,
-      type: "missing",
-      bytes: null,
-      token: null,
-      pathTokens,
-      heldEntries,
-      missingAbsolute,
-      missingPath,
-    };
-  }
-
-  try {
-    await retainDirectory(repository, ".");
-    for (let index = 0; index < parts.length - 1; index += 1) {
-      absolute = path.join(absolute, parts[index]);
-      const entryPath = parts.slice(0, index + 1).join("/");
-      try {
-        const info = await lstat(absolute, { bigint: true });
-        if (info.isSymbolicLink() || !info.isDirectory()) {
-          throw evidenceRefusal(descriptor.invalidCode, `${descriptor.role} ancestor is not one regular non-symlink directory: ${entryPath}`, entryPath);
-        }
-      } catch (error) {
-        if (error?.code === "ENOENT") return missing(absolute, entryPath);
-        throw error;
-      }
-      await retainDirectory(absolute, entryPath);
-    }
-
-    const target = path.join(repository, ...parts);
-    try {
-      const info = await lstat(target, { bigint: true });
-      if (info.isSymbolicLink() || !info.isFile()) {
-        throw evidenceRefusal(descriptor.invalidCode, `${descriptor.role} input is not one regular non-symlink file: ${descriptor.path}`, descriptor.path);
-      }
-    } catch (error) {
-      if (error?.code === "ENOENT") return missing(target, descriptor.path);
-      throw error;
-    }
-    const captured = await securedFile(target, repository, descriptor.path, true, retainHandles, budget);
-    if (retainHandles) heldEntries.push({ path: descriptor.path, type: "regular-file", absolute: target, containmentRoot: repository, ...captured });
-    retained = retainHandles;
-    return {
-      role: descriptor.role,
-      path: descriptor.path,
-      type: "regular-file",
-      bytes: captured.bytes,
-      token: captured.token,
-      pathTokens,
-      heldEntries,
-      missingAbsolute: null,
-      missingPath: null,
-    };
-  } catch (error) {
-    throw mapEvidenceRefusal(error, descriptor.invalidCode, descriptor.path);
-  } finally {
-    if (!retained) await closeHeldEntries(heldEntries);
-  }
-}
-
-function sameEvidenceInput(left, right) {
-  if (left.role !== right.role
-    || left.path !== right.path
-    || left.type !== right.type
-    || left.token !== right.token
-    || left.pathTokens.length !== right.pathTokens.length) return false;
-  for (let index = 0; index < left.pathTokens.length; index += 1) {
-    if (left.pathTokens[index].path !== right.pathTokens[index].path
-      || left.pathTokens[index].token !== right.pathTokens[index].token) return false;
-  }
-  return left.type === "missing" || left.bytes.equals(right.bytes);
-}
-
-async function verifyEvidenceInput(entry) {
-  try {
-    await verifyHeldEntries(entry.heldEntries);
-  } catch (error) {
-    throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", `${entry.role} changed before evidence capture commit: ${entry.path}; ${error.message}`, entry.path);
-  }
-  if (entry.type !== "missing") return;
-  try {
-    await lstat(entry.missingAbsolute, { bigint: true });
-    throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", `missing locator appeared during capture: ${entry.path}`, entry.path);
-  } catch (error) {
-    if (error?.code === "ENOENT") return;
-    throw mapEvidenceRefusal(error, "AUTH_EVIDENCE_CAPTURE_CHANGED", entry.path);
-  }
-}
-
-function semanticEvidenceInput(entry) {
-  return {
-    role: entry.role,
-    path: entry.path,
-    type: entry.type,
-    bytes: entry.bytes,
-  };
-}
-
-function evidenceInputMetadata(entries) {
-  return entries.map((entry) => ({
-    role: entry.role,
-    path: entry.path,
-    type: entry.type,
-    bytes: entry.bytes?.length ?? 0,
-  }));
-}
-
 async function createTemporaryRoot(protectedRoots, prefix = "nimicoding-authority-review-") {
   let base;
   try {
@@ -825,14 +622,14 @@ async function createTemporaryRoot(protectedRoots, prefix = "nimicoding-authorit
   } catch {
     throw refusal("AUTH_REVIEW_TEMPORARY_INVALID", "system temporary directory is not one readable physical directory");
   }
-  if (protectedRoots.some((protectedRoot) => contained(protectedRoot, base))) {
+  if (protectedRoots.some((protectedRoot) => isPathWithin(protectedRoot, base))) {
     throw refusal("AUTH_REVIEW_TEMPORARY_INVALID", "system temporary directory must be outside the reviewed worktree and Git administration directories");
   }
   const created = await mkdtemp(path.join(base, prefix));
   try {
     const temporaryRoot = await realpath(created);
     const info = await lstat(temporaryRoot);
-    if (!info.isDirectory() || protectedRoots.some((protectedRoot) => contained(protectedRoot, temporaryRoot) || contained(temporaryRoot, protectedRoot))) {
+    if (!info.isDirectory() || protectedRoots.some((protectedRoot) => isPathWithin(protectedRoot, temporaryRoot) || isPathWithin(temporaryRoot, protectedRoot))) {
       throw refusal("AUTH_REVIEW_TEMPORARY_INVALID", "authority snapshots require one isolated temporary directory outside the reviewed repository");
     }
     return temporaryRoot;
@@ -842,188 +639,46 @@ async function createTemporaryRoot(protectedRoots, prefix = "nimicoding-authorit
   }
 }
 
-function evidenceDescriptors(bindingPath, probeResultsPath, locatorPaths) {
-  if (!validEvidencePath(bindingPath) || !bindingPath.startsWith(".nimi/config/")) {
-    throw evidenceRefusal("AUTH_EVIDENCE_BINDING_INVALID", "bindingPath must be one repository-relative path nested under .nimi/config", String(bindingPath ?? "."));
-  }
-  if (probeResultsPath !== null && probeResultsPath !== undefined && !validEvidencePath(probeResultsPath)) {
-    throw evidenceRefusal("AUTH_EVIDENCE_INPUT_INVALID", "probeResultsPath must be one safe repository-relative regular-file path", String(probeResultsPath));
-  }
-  if (!Array.isArray(locatorPaths) || locatorPaths.some((entry) => !validEvidencePath(entry))) {
-    throw evidenceRefusal("AUTH_EVIDENCE_LOCATOR_INVALID", "locatorPaths must be one list of safe repository-relative paths");
-  }
-  const orderedLocators = [...locatorPaths].sort(compareText);
-  if (new Set(orderedLocators.map((entry) => entry.toLowerCase())).size !== orderedLocators.length) {
-    throw evidenceRefusal("AUTH_EVIDENCE_LOCATOR_INVALID", "locatorPaths must not contain duplicate or portable-colliding paths");
-  }
-  const allPaths = [bindingPath, ...(probeResultsPath === null || probeResultsPath === undefined ? [] : [probeResultsPath]), ...orderedLocators];
-  if (new Set(allPaths.map((entry) => entry.toLowerCase())).size !== allPaths.length) {
-    throw evidenceRefusal("AUTH_EVIDENCE_INPUT_INVALID", "binding, probe results, and locator paths must be logically distinct without portable collisions");
-  }
-  return [
-    { role: "binding", path: bindingPath, allowMissing: false, invalidCode: "AUTH_EVIDENCE_BINDING_INVALID" },
-    ...(probeResultsPath === null || probeResultsPath === undefined ? [] : [{ role: "probe-results", path: probeResultsPath, allowMissing: false, invalidCode: "AUTH_EVIDENCE_INPUT_INVALID" }]),
-    ...orderedLocators.map((entryPath) => ({ role: "locator", path: entryPath, allowMissing: true, invalidCode: "AUTH_EVIDENCE_LOCATOR_INVALID" })),
-  ];
-}
-
-export async function withGitEvidenceSnapshot({
-  repositoryPath,
-  bindingPath,
-  probeResultsPath = null,
-  locatorPaths,
-  maxInputBytes,
-  hooks = null,
-}, callback) {
-  if (typeof callback !== "function") throw evidenceRefusal("AUTH_EVIDENCE_INPUT_INVALID", "evidence snapshot requires one callback");
-  const budget = evidenceInputBudget(maxInputBytes);
-  const descriptors = evidenceDescriptors(bindingPath, probeResultsPath, locatorPaths);
-  let resolved;
-  try {
-    resolved = await resolveRepository(repositoryPath);
-  } catch (error) {
-    throw mapEvidenceRefusal(error, "AUTH_EVIDENCE_REPOSITORY_INVALID");
-  }
-  const { repository, protectedRoots } = resolved;
-  let headOid;
-  try {
-    headOid = await resolveBaseOid(repository, "HEAD");
-  } catch (error) {
-    throw mapEvidenceRefusal(error, "AUTH_EVIDENCE_HEAD_INVALID");
-  }
-  if (hooks?.afterHeadResolved) await hooks.afterHeadResolved({ repository, headOid });
-
-  let trackedBinding;
-  try {
-    trackedBinding = await trackedRegularIndexRecord(repository, bindingPath);
-  } catch (error) {
-    throw mapEvidenceRefusal(error, "AUTH_EVIDENCE_BINDING_INVALID", bindingPath);
-  }
-
-  let authorityEntries;
-  let semanticInputs;
-  let authorityHeld = [];
-  const capturedInputs = [];
-  try {
-    let firstAuthority;
-    try {
-      const captured = await scanWorktree(repository, true, { retainHandles: true, budget });
-      firstAuthority = captured.entries;
-      authorityHeld = captured.heldEntries;
-    } catch (error) {
-      throw mapEvidenceRefusal(error, "AUTH_EVIDENCE_AUTHORITY_INVALID", SPEC_ROOT);
-    }
-    if (hooks?.afterAuthorityCapture) {
-      await hooks.afterAuthorityCapture({
-        repository,
-        headOid,
-        authority: semanticEntries(firstAuthority).map((entry) => ({ path: entry.path, type: entry.type, bytes: entry.bytes?.length ?? 0 })),
-      });
-    }
-    for (const descriptor of descriptors) capturedInputs.push(await captureEvidenceInput(repository, descriptor, budget, true));
-    if (hooks?.afterInitialCapture) {
-      await hooks.afterInitialCapture({ repository, headOid, inputs: evidenceInputMetadata(capturedInputs) });
-    }
-
-    const recaptureBudget = evidenceInputBudget(maxInputBytes);
-    let secondAuthority;
-    try {
-      secondAuthority = (await scanWorktree(repository, false, { budget: recaptureBudget })).entries;
-    } catch (error) {
-      throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", `authority inventory changed during evidence capture: ${error.message}`, SPEC_ROOT);
-    }
-    if (!compareCapturedEntries(firstAuthority, secondAuthority, true)) {
-      throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", "authority paths, types, metadata, or bytes changed during evidence capture", SPEC_ROOT);
-    }
-    for (let index = 0; index < descriptors.length; index += 1) {
-      let second;
-      try {
-        second = await captureEvidenceInput(repository, descriptors[index], recaptureBudget, false);
-      } catch (error) {
-        throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", `${descriptors[index].role} input changed during evidence capture: ${descriptors[index].path}; ${error.message}`, descriptors[index].path);
-      }
-      if (!sameEvidenceInput(capturedInputs[index], second)) {
-        throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", `${descriptors[index].role} path, type, metadata, or bytes changed during evidence capture: ${descriptors[index].path}`, descriptors[index].path);
-      }
-    }
-    const secondTrackedBinding = await trackedRegularIndexRecord(repository, bindingPath).catch((error) => {
-      throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", `evidence binding tracking state changed during capture: ${error.message}`, bindingPath);
-    });
-    if (!trackedBinding.equals(secondTrackedBinding)) {
-      throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", "evidence binding index identity changed during capture", bindingPath);
-    }
-    if (hooks?.beforeCaptureCommit) {
-      await hooks.beforeCaptureCommit({ repository, headOid, inputs: evidenceInputMetadata(capturedInputs) });
-    }
-    await verifyHeldEntries(authorityHeld).catch((error) => {
-      throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", `authority changed before evidence capture commit: ${error.message}`, SPEC_ROOT);
-    });
-    for (const entry of capturedInputs) await verifyEvidenceInput(entry);
-    const committedTrackedBinding = await trackedRegularIndexRecord(repository, bindingPath).catch((error) => {
-      throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", `evidence binding tracking state changed before capture commit: ${error.message}`, bindingPath);
-    });
-    if (!trackedBinding.equals(committedTrackedBinding)) {
-      throw evidenceRefusal("AUTH_EVIDENCE_CAPTURE_CHANGED", "evidence binding index identity changed before capture commit", bindingPath);
-    }
-    authorityEntries = semanticEntries(firstAuthority);
-    semanticInputs = capturedInputs.map(semanticEvidenceInput);
-  } finally {
-    await closeHeldEntries(authorityHeld);
-    await Promise.all(capturedInputs.map((entry) => closeHeldEntries(entry.heldEntries)));
-  }
-
-  let temporaryRoot;
-  try {
-    temporaryRoot = await createTemporaryRoot(protectedRoots, "nimicoding-authority-evidence-");
-  } catch (error) {
-    throw mapEvidenceRefusal(error, "AUTH_EVIDENCE_TEMPORARY_INVALID");
-  }
-  const authorityRoot = path.join(temporaryRoot, "authority");
-  try {
-    await mkdir(authorityRoot, { mode: 0o700 });
-    try {
-      await materializeEntries(authorityRoot, authorityEntries, "AUTH_EVIDENCE_AUTHORITY_INVALID");
-    } catch (error) {
-      throw mapEvidenceRefusal(error, "AUTH_EVIDENCE_AUTHORITY_INVALID", SPEC_ROOT);
-    }
-    const counts = snapshotCounts(authorityEntries);
-    return await callback({
-      repository,
-      headOid,
-      temporaryRoot,
-      authority: {
-        root: authorityRoot,
-        contentIdentity: authoritySnapshotContentIdentity(authorityEntries),
-        ...counts,
-      },
-      inputs: semanticInputs,
-      capturedInputBytes: budget.captured,
-    });
-  } finally {
-    await rm(temporaryRoot, { recursive: true, force: true });
-  }
-}
-
 export async function listGitTrackedFiles(repositoryPath) {
   const { repository } = await resolveRepository(repositoryPath);
   const bytes = await checkedGit(
     repository,
-    ["ls-files", "--cached", "--full-name", "-z"],
+    ["ls-files", "--stage", "--full-name", "-z"],
     "AUTH_REVIEW_GIT_INDEX_INVALID",
     "Git tracked-file inventory cannot be read",
   );
   const files = [];
+  const gitlinks = [];
   let offset = 0;
   while (offset < bytes.length) {
     const end = bytes.indexOf(0, offset);
     if (end < 0) throw refusal("AUTH_REVIEW_GIT_INDEX_INVALID", "Git tracked-file inventory is not NUL-terminated");
     if (end === offset) throw refusal("AUTH_REVIEW_GIT_INDEX_INVALID", "Git tracked-file inventory contains an empty path");
-    const file = decodeUtf8(bytes.subarray(offset, end), "Git tracked-file path", "AUTH_REVIEW_GIT_INDEX_INVALID");
+    const record = bytes.subarray(offset, end);
+    const tab = record.indexOf(9);
+    if (tab <= 0 || tab === record.length - 1) {
+      throw refusal("AUTH_REVIEW_GIT_INDEX_INVALID", "Git tracked-file inventory contains a malformed index entry");
+    }
+    const metadata = decodeUtf8(
+      record.subarray(0, tab),
+      "Git tracked-file metadata",
+      "AUTH_REVIEW_GIT_INDEX_INVALID",
+    );
+    const match = /^(100644|100755|120000|160000) (?:[0-9a-f]{40}|[0-9a-f]{64}) ([0-3])$/.exec(metadata);
+    if (match === null) {
+      throw refusal("AUTH_REVIEW_GIT_INDEX_INVALID", "Git tracked-file inventory contains an unsupported index entry");
+    }
+    const file = decodeUtf8(record.subarray(tab + 1), "Git tracked-file path", "AUTH_REVIEW_GIT_INDEX_INVALID");
     if (!validateRelativePath(file)) throw refusal("AUTH_REVIEW_GIT_INDEX_INVALID", "Git tracked-file inventory contains an unsafe path");
     files.push(file);
+    if (match[1] === "160000") gitlinks.push(file);
     offset = end + 1;
   }
-  return { repository, files: [...new Set(files)].sort(compareText) };
+  return {
+    repository,
+    files: [...new Set(files)].sort(compareText),
+    gitlinks: [...new Set(gitlinks)].sort(compareText),
+  };
 }
 
 export async function withGitAuthoritySnapshots({ repositoryPath, baseRef, hooks = null }, callback) {

package/cli/lib/authority/graph.mjs

@@ -164,14 +164,14 @@ function finish(compiled, graph, location, root, traversal) {
     compiled,
     location,
     root.unit.id,
-    `complete graph proof requires ${traversal.units} units but max-units is ${maxUnits}`,
+    `complete graph traversal requires ${traversal.units} units but max-units is ${maxUnits}`,
     root.idMap,
   );
   if (traversal.edges > maxEdges) return budgetFailure(
     compiled,
     location,
     root.unit.id,
-    `complete graph proof requires ${traversal.edges} authored edges but max-edges is ${maxEdges}`,
+    `complete graph traversal requires ${traversal.edges} authored edges but max-edges is ${maxEdges}`,
     root.idMap,
   );
   const graphBytes = Buffer.byteLength(JSON.stringify(graph), "utf8");
@@ -245,7 +245,7 @@ export async function pathAuthorityPath(inputPath, fromId, toId, { traversal: tr
   const { compiled, location, snapshot } = admitted;
   const root = snapshot.byId.get(fromId);
   const visitedDepth = new Map([[fromId, 0]]);
-  const proofEdges = new Set();
+  const traversedEdges = new Set();
   let layer = new Map([[fromId, []]]);
   let witness = fromId === toId ? [] : null;
   let exhausted = false;
@@ -255,7 +255,7 @@ export async function pathAuthorityPath(inputPath, fromId, toId, { traversal: tr
     for (const id of [...layer.keys()].sort(compareText)) {
       const prefix = layer.get(id);
       for (const value of pathAdjacency(snapshot, id, traversalMode)) {
-        proofEdges.add(edgeKey(value.edge));
+        traversedEdges.add(edgeKey(value.edge));
         const priorDepth = visitedDepth.get(value.next);
         if (priorDepth !== undefined && priorDepth < depth + 1) continue;
         const candidate = [...prefix, { source: value.edge.source, type: value.edge.type, target: value.edge.target, traversal: value.traversal }];
@@ -273,7 +273,7 @@ export async function pathAuthorityPath(inputPath, fromId, toId, { traversal: tr
     let unchecked = false;
     for (const id of [...layer.keys()].sort(compareText)) {
       for (const value of pathAdjacency(snapshot, id, traversalMode)) {
-        proofEdges.add(edgeKey(value.edge));
+        traversedEdges.add(edgeKey(value.edge));
         if (!visitedDepth.has(value.next)) unchecked = true;
       }
     }
@@ -293,7 +293,7 @@ export async function pathAuthorityPath(inputPath, fromId, toId, { traversal: tr
     ? [fromId, ...(witness ?? []).map((step) => step.traversal === "forward" ? step.target : step.source)]
     : [fromId, toId];
   const nodes = [...new Set(pathNodeIds)].map((id) => snapshot.byId.get(id).node);
-  const traversal = { units: new Set([...visitedDepth.keys(), toId]).size, edges: proofEdges.size };
+  const traversal = { units: new Set([...visitedDepth.keys(), toId]).size, edges: traversedEdges.size };
   const budgets = { maxHops, maxUnits, maxEdges, maxBytes };
   const graph = graphBase("path", { fromId, toId, traversal: traversalMode, relations }, nodes, edges, {
     edgeRepresentation: "canonical_authored_source_to_target",
@@ -315,13 +315,13 @@ export async function subgraphAuthorityPath(inputPath, id, { direction, relation
   const { compiled, location, snapshot } = admitted;
   const root = snapshot.byId.get(id);
   const distances = new Map([[id, 0]]);
-  const proofEdges = new Set();
+  const traversedEdges = new Set();
   let layer = [id];
   for (let currentDepth = 0; currentDepth < depth && layer.length > 0; currentDepth += 1) {
     const next = new Set();
     for (const current of [...layer].sort(compareText)) {
       for (const value of adjacent(snapshot, current, direction)) {
-        proofEdges.add(edgeKey(value.edge));
+        traversedEdges.add(edgeKey(value.edge));
         if (!distances.has(value.next)) {
           distances.set(value.next, currentDepth + 1);
           next.add(value.next);
@@ -332,9 +332,9 @@ export async function subgraphAuthorityPath(inputPath, id, { direction, relation
   }
   const nodeIds = new Set(distances.keys());
   const edges = snapshot.edges.filter((edge) => nodeIds.has(edge.source) && nodeIds.has(edge.target));
-  for (const edge of edges) proofEdges.add(edgeKey(edge));
+  for (const edge of edges) traversedEdges.add(edgeKey(edge));
   const nodes = [...nodeIds].map((nodeId) => snapshot.byId.get(nodeId).node);
-  const traversal = { units: nodes.length, edges: proofEdges.size };
+  const traversal = { units: nodes.length, edges: traversedEdges.size };
   const budgets = { depth, maxUnits, maxEdges, maxBytes };
   const graph = graphBase("subgraph", { id, direction, relations, depth }, nodes, edges, {
     edgeRepresentation: "canonical_authored_source_to_target",