mason-context 0.17.3 → 0.18.0

package/dist/mason-mcp.js

@@ -31,6 +31,32 @@ var init_profile = __esm({
   }
 });
 
+// src/utils/git-read.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+function execGit(args, options) {
+  const command = args.find((arg) => !arg.startsWith("-")) ?? "other";
+  return profilePhase("git." + (commands.has(command) ? command : "other"), async () => {
+    const { input, ...processOptions } = options;
+    const operation = execute("git", args, processOptions);
+    if (input !== void 0) {
+      operation.child.stdin.on("error", () => {
+      });
+      operation.child.stdin.end(input);
+    }
+    return operation;
+  });
+}
+var execute, commands;
+var init_git_read = __esm({
+  "src/utils/git-read.ts"() {
+    "use strict";
+    init_profile();
+    execute = promisify(execFile);
+    commands = /* @__PURE__ */ new Set(["rev-parse", "symbolic-ref", "for-each-ref", "ls-files", "check-ignore", "status", "log", "diff", "ls-tree", "show", "merge-base"]);
+  }
+});
+
 // src/audit/commands.ts
 import path from "path";
 function splitCommands(line) {
@@ -255,14 +281,14 @@ function extractClaims(content2) {
   const ignored = computeIgnoredLines(lines);
   const paths = /* @__PURE__ */ new Map();
   const counts = [];
-  const commands = /* @__PURE__ */ new Map();
+  const commands2 = /* @__PURE__ */ new Map();
   const addPath = (claim) => {
     const key = [claim.relativeTo ?? "scope", claim.path].join(":");
     if (!paths.has(key)) paths.set(key, claim);
   };
   const addCommand = (claim) => {
     const key = JSON.stringify([claim.scriptName, claim.directory, claim.scopeUnknown]);
-    if (!commands.has(key)) commands.set(key, claim);
+    if (!commands2.has(key)) commands2.set(key, claim);
   };
   const parsed = markdown.parse(lines.map((line, i) => ignored[i] ? "" : line).join("\n"), {});
   for (const token of parsed) {
@@ -364,7 +390,7 @@ function extractClaims(content2) {
   return {
     paths: [...paths.values()],
     counts,
-    commands: [...commands.values()]
+    commands: [...commands2.values()]
   };
 }
 var ROOT_FILE_NAMES, SHELL_FENCE_INFOS, markdown, COUNT_RE, COUNT_DENYLIST_RE, IGNORE_LINE, IGNORE_START, IGNORE_END;
@@ -414,97 +440,6 @@ var init_claims = __esm({
   }
 });
 
-// src/audit/git.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-function parseCommitLine(line) {
-  const parts = line.split("	");
-  if (parts.length < 3 || !parts[0]) return null;
-  return { hash: parts[0], date: parts[1], subject: parts.slice(2).join("	") };
-}
-async function lastCommitOf(resolvedRoot, relPath) {
-  try {
-    const { stdout } = await exec(
-      "git",
-      ["log", "-1", `--format=${COMMIT_FORMAT}`, "--", `:(literal)${relPath}`],
-      { cwd: resolvedRoot }
-    );
-    const line = stdout.trim().split("\n")[0];
-    return line ? parseCommitLine(line) : null;
-  } catch {
-    return null;
-  }
-}
-async function deletingCommitOf(resolvedRoot, relPath) {
-  try {
-    const { stdout } = await exec(
-      "git",
-      [
-        "log",
-        "-1",
-        "--diff-filter=D",
-        `--format=${COMMIT_FORMAT}`,
-        "--",
-        `:(literal)${relPath}`
-      ],
-      { cwd: resolvedRoot }
-    );
-    const line = stdout.trim().split("\n")[0];
-    return line ? parseCommitLine(line) : null;
-  } catch {
-    return null;
-  }
-}
-async function firstCommitOf(resolvedRoot, relPath) {
-  try {
-    const { stdout } = await exec(
-      "git",
-      ["log", "--reverse", `--format=${COMMIT_FORMAT}`, "--", `:(literal)${relPath}`],
-      { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }
-    );
-    const line = stdout.trim().split("\n")[0];
-    return line ? parseCommitLine(line) : null;
-  } catch {
-    return null;
-  }
-}
-async function commitsTouchingSince(resolvedRoot, fromHash, pathspecs) {
-  if (!fromHash || fromHash === "unknown") return null;
-  try {
-    const { stdout } = await exec(
-      "git",
-      [
-        "log",
-        `${fromHash}..HEAD`,
-        `--format=%x01${COMMIT_FORMAT}`,
-        "--name-only",
-        "--",
-        ...pathspecs
-      ],
-      { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }
-    );
-    const commits = [];
-    for (const block of stdout.split("
")) {
-      if (!block.trim()) continue;
-      const lines = block.split("\n").filter((l) => l.trim().length > 0);
-      const ref = parseCommitLine(lines[0]);
-      if (!ref) continue;
-      commits.push({ ...ref, files: lines.slice(1).map((l) => l.trim()) });
-    }
-    return { commits, total: commits.length };
-  } catch {
-    return null;
-  }
-}
-var exec, COMMIT_FORMAT;
-var init_git = __esm({
-  "src/audit/git.ts"() {
-    "use strict";
-    exec = promisify(execFile);
-    COMMIT_FORMAT = "%H%x09%cI%x09%s";
-  }
-});
-
 // src/utils/paths.ts
 import path2 from "path";
 function normalizeRepoPath(value) {
@@ -539,8 +474,6 @@ var init_paths = __esm({
 import fs from "fs/promises";
 import { constants } from "fs";
 import path3 from "path";
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
 import fg from "fast-glob";
 function isSensitiveFile(file) {
   return file.split(/[\\/]/).some(
@@ -594,12 +527,12 @@ async function createFileAccess(rootDir) {
   const ignore = [...SOURCE_IGNORE, ...config.ignore ?? []];
   let gitFiles = null;
   try {
-    const { stdout } = await exec2("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: root, maxBuffer: 50 * 1024 * 1024 });
+    const { stdout } = await execGit(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: root, maxBuffer: 50 * 1024 * 1024 });
     gitFiles = new Set(stdout.split("\0").filter(Boolean));
   } catch {
     let inGit = false;
     try {
-      await exec2("git", ["rev-parse", "--git-dir"], { cwd: root });
+      await execGit(["rev-parse", "--git-dir"], { cwd: root });
       inGit = true;
     } catch {
     }
@@ -642,12 +575,12 @@ async function createFileAccess(rootDir) {
   }
   return { root, config, list, read };
 }
-var exec2, SOURCE_EXTENSIONS, SOURCE_GLOB, SOURCE_IGNORE, MAX_SOURCE_BYTES;
+var SOURCE_EXTENSIONS, SOURCE_GLOB, SOURCE_IGNORE, MAX_SOURCE_BYTES;
 var init_files = __esm({
   "src/utils/files.ts"() {
     "use strict";
+    init_git_read();
     init_paths();
-    exec2 = promisify2(execFile2);
     SOURCE_EXTENSIONS = ["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs", "vue", "svelte", "kt", "kts", "java", "py", "go", "rs", "swift", "rb", "cs", "cpp", "c", "h", "hpp", "dart", "php"];
     SOURCE_GLOB = `**/*.{${SOURCE_EXTENSIONS.join(",")}}`;
     SOURCE_IGNORE = [
@@ -677,9 +610,140 @@ var init_files = __esm({
   }
 });
 
+// src/audit/inspection.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import path4 from "path";
+function withRepositoryInspection(root, run) {
+  return inspections.run({ root: path4.resolve(root), reads: /* @__PURE__ */ new Map() }, run);
+}
+function inspectionRead(root, key, read) {
+  const inspection = inspections.getStore();
+  if (!inspection || inspection.root !== path4.resolve(root)) return read();
+  if (!inspection.reads.has(key)) {
+    const pending = read();
+    inspection.reads.set(key, pending);
+    void pending.catch(() => {
+      if (inspection.reads.get(key) === pending) inspection.reads.delete(key);
+    });
+  }
+  return inspection.reads.get(key);
+}
+function inspectionGit(args, options) {
+  return inspectionRead(options.cwd, "git:" + JSON.stringify([args, options]), () => execGit(args, options));
+}
+async function auditGitPaths(root, kind) {
+  const shared = inspections.getStore()?.root === path4.resolve(root);
+  const specs = shared ? [...docSpecs, ...sourceSpecs] : kind === "documents" ? docSpecs : sourceSpecs;
+  const limit = kind === "documents" ? 16 * 1024 * 1024 : 32 * 1024 * 1024;
+  const { stdout } = await inspectionGit(
+    ["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...specs],
+    { cwd: root, maxBuffer: shared ? 48 * 1024 * 1024 : limit, timeout: 1e4 }
+  );
+  const paths = [...new Set(stdout.split("\0").filter(Boolean))].filter((file) => kind === "documents" ? /^(readme|agents|claude)\.md$/i.test(path4.posix.basename(file)) : sourceSuffixes.has(file.slice(file.lastIndexOf("."))));
+  if (Buffer.byteLength(paths.join("\0")) > limit) throw new Error("Git " + kind + " inventory exceeds its bounded read limit.");
+  return paths.sort();
+}
+var inspections, sourceSpecs, docSpecs, sourceSuffixes;
+var init_inspection = __esm({
+  "src/audit/inspection.ts"() {
+    "use strict";
+    init_git_read();
+    init_files();
+    inspections = new AsyncLocalStorage2();
+    sourceSpecs = SOURCE_EXTENSIONS.map((extension) => `:(glob)**/*.${extension}`);
+    docSpecs = [":(icase,glob)**/readme.md", ":(icase,glob)**/agents.md", ":(icase,glob)**/claude.md"];
+    sourceSuffixes = new Set(SOURCE_EXTENSIONS.map((extension) => "." + extension));
+  }
+});
+
+// src/audit/git.ts
+function parseCommitLine(line) {
+  const parts = line.split("	");
+  if (parts.length < 3 || !parts[0]) return null;
+  return { hash: parts[0], date: parts[1], subject: parts.slice(2).join("	") };
+}
+async function lastCommitOf(resolvedRoot, relPath) {
+  try {
+    const { stdout } = await inspectionGit(
+      ["log", "-1", `--format=${COMMIT_FORMAT}`, "--", `:(literal)${relPath}`],
+      { cwd: resolvedRoot }
+    );
+    const line = stdout.trim().split("\n")[0];
+    return line ? parseCommitLine(line) : null;
+  } catch {
+    return null;
+  }
+}
+async function deletingCommitOf(resolvedRoot, relPath) {
+  try {
+    const { stdout } = await inspectionGit(
+      [
+        "log",
+        "-1",
+        "--diff-filter=D",
+        `--format=${COMMIT_FORMAT}`,
+        "--",
+        `:(literal)${relPath}`
+      ],
+      { cwd: resolvedRoot }
+    );
+    const line = stdout.trim().split("\n")[0];
+    return line ? parseCommitLine(line) : null;
+  } catch {
+    return null;
+  }
+}
+async function firstCommitOf(resolvedRoot, relPath) {
+  try {
+    const { stdout } = await inspectionGit(
+      ["log", "--reverse", `--format=${COMMIT_FORMAT}`, "--", `:(literal)${relPath}`],
+      { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }
+    );
+    const line = stdout.trim().split("\n")[0];
+    return line ? parseCommitLine(line) : null;
+  } catch {
+    return null;
+  }
+}
+async function commitsTouchingSince(resolvedRoot, fromHash, pathspecs) {
+  if (!fromHash || fromHash === "unknown") return null;
+  try {
+    const { stdout } = await inspectionGit(
+      [
+        "log",
+        `${fromHash}..HEAD`,
+        `--format=%x01${COMMIT_FORMAT}`,
+        "--name-only",
+        "--",
+        ...pathspecs
+      ],
+      { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }
+    );
+    const commits = [];
+    for (const block of stdout.split("
")) {
+      if (!block.trim()) continue;
+      const lines = block.split("\n").filter((l) => l.trim().length > 0);
+      const ref = parseCommitLine(lines[0]);
+      if (!ref) continue;
+      commits.push({ ...ref, files: lines.slice(1).map((l) => l.trim()) });
+    }
+    return { commits, total: commits.length };
+  } catch {
+    return null;
+  }
+}
+var COMMIT_FORMAT;
+var init_git = __esm({
+  "src/audit/git.ts"() {
+    "use strict";
+    init_inspection();
+    COMMIT_FORMAT = "%H%x09%cI%x09%s";
+  }
+});
+
 // src/utils/storage.ts
 import fs2 from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 import { randomUUID } from "crypto";
 async function storePath(root, relative, createParents = false) {
   const normalized = normalizeRepoPath(relative);
@@ -687,7 +751,7 @@ async function storePath(root, relative, createParents = false) {
   let current = await fs2.realpath(root);
   const parts = normalized.split("/");
   for (let i = 0; i < parts.length; i++) {
-    current = path4.join(current, parts[i]);
+    current = path5.join(current, parts[i]);
     let stat;
     try {
       stat = await fs2.lstat(current);
@@ -725,7 +789,7 @@ async function writeStoreJson(root, relative, value) {
     throw new Error(`Mason store ${relative} exceeds 10 MiB`);
   }
   const file = await storePath(root, relative, true);
-  const temporary = path4.join(path4.dirname(file), `.${path4.basename(file)}.${randomUUID()}.tmp`);
+  const temporary = path5.join(path5.dirname(file), `.${path5.basename(file)}.${randomUUID()}.tmp`);
   try {
     const handle = await fs2.open(temporary, "wx", 384);
     try {
@@ -750,9 +814,7 @@ var init_storage = __esm({
 // src/audit/inputs.ts
 import fs3 from "fs/promises";
 import * as nativeFs from "fs";
-import path5 from "path";
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
+import path6 from "path";
 import fg2 from "fast-glob";
 async function auditInputPath(root, file) {
   if (file === ".") return fs3.realpath(root);
@@ -779,7 +841,7 @@ async function auditGlob(root, patterns, options) {
   if (Array.isArray(patterns) && !patterns.length) return [];
   const directories = /* @__PURE__ */ new Set();
   const readdir2 = ((directory, opts, callback) => {
-    const relative = path5.relative(root, directory).split(path5.sep).join("/") || ".";
+    const relative = path6.relative(root, directory).split(path6.sep).join("/") || ".";
     directories.add(relative);
     if (directories.size > MAX_INPUTS) {
       callback(new Error(`${options.label} exceeds ${MAX_INPUTS.toLocaleString("en-US")} directories while inspecting ${relative}. Narrow this check's inputs.`));
@@ -790,7 +852,7 @@ async function auditGlob(root, patterns, options) {
     }, callback);
   });
   const lstat2 = ((file, callback) => {
-    const relative = path5.relative(root, file).split(path5.sep).join("/") || ".";
+    const relative = path6.relative(root, file).split(path6.sep).join("/") || ".";
     auditInputPath(root, relative).then(() => nativeFs.lstat(file, callback), callback);
   });
   const stream = fg2.stream(patterns, {
@@ -827,62 +889,48 @@ async function auditGlob(root, patterns, options) {
   return matches.sort();
 }
 async function gitSourcePaths(root) {
-  const { stdout } = await execute(
-    "git",
-    [
-      "ls-files",
-      "-z",
-      "--cached",
-      "--others",
-      "--exclude-standard",
-      "--",
-      ...SOURCE_EXTENSIONS.map((extension) => `:(glob)**/*.${extension}`)
-    ],
-    { cwd: root, maxBuffer: 32 * 1024 * 1024, timeout: 1e4 }
-  );
-  return [...new Set(stdout.split("\0").filter(Boolean))].sort();
+  return auditGitPaths(root, "sources");
 }
 async function gitIgnoredPaths(root, files) {
   if (!files.length) return /* @__PURE__ */ new Set();
-  const operation = execute(
-    "git",
-    ["check-ignore", "-z", "--stdin"],
-    { cwd: root, maxBuffer: 4 * 1024 * 1024, timeout: 1e4 }
-  );
-  operation.child.stdin.on("error", () => {
-  });
-  operation.child.stdin.end(files.join("\0") + "\0");
-  try {
-    return new Set((await operation).stdout.split("\0").filter(Boolean));
-  } catch (error) {
-    if (error.code === 1) return /* @__PURE__ */ new Set();
-    throw error;
+  const ignored = /* @__PURE__ */ new Set();
+  for (let offset = 0; offset < files.length; offset += 1e3) {
+    try {
+      const { stdout } = await execGit(["check-ignore", "-z", "--stdin"], {
+        cwd: root,
+        maxBuffer: 4 * 1024 * 1024,
+        timeout: 1e4,
+        input: files.slice(offset, offset + 1e3).join("\0") + "\0"
+      });
+      for (const file of stdout.split("\0").filter(Boolean)) ignored.add(file);
+    } catch (error) {
+      if (error.code !== 1) throw error;
+    }
   }
+  return ignored;
 }
-var execute, MAX_INPUTS;
+var MAX_INPUTS;
 var init_inputs = __esm({
   "src/audit/inputs.ts"() {
     "use strict";
     init_files();
     init_storage();
-    execute = promisify3(execFile3);
+    init_git_read();
+    init_inspection();
     MAX_INPUTS = 1e5;
   }
 });
 
 // src/audit/docs.ts
 import fs4 from "fs/promises";
-import path6 from "path";
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
+import path7 from "path";
 import fg3 from "fast-glob";
 async function dirtyDocs(resolvedRoot, files) {
   if (!files.length) return /* @__PURE__ */ new Set();
   try {
     const dirty = /* @__PURE__ */ new Set();
     for (let offset = 0; offset < files.length; offset += 256) {
-      const { stdout } = await exec3(
-        "git",
+      const { stdout } = await execGit(
         ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ...files.slice(offset, offset + 256).map((file) => `:(literal)${file}`)],
         { cwd: resolvedRoot, maxBuffer: 16 * 1024 * 1024, timeout: 1e4 }
       );
@@ -902,25 +950,10 @@ async function dirtyDocs(resolvedRoot, files) {
 async function discoverDocPaths(root) {
   let candidates = [];
   try {
-    const { stdout } = await exec3(
-      "git",
-      [
-        "ls-files",
-        "-z",
-        "--cached",
-        "--others",
-        "--exclude-standard",
-        "--",
-        ":(icase,glob)**/readme.md",
-        ":(icase,glob)**/agents.md",
-        ":(icase,glob)**/claude.md"
-      ],
-      { cwd: root, maxBuffer: 16 * 1024 * 1024, timeout: 1e4 }
-    );
-    candidates = stdout.split("\0").filter(Boolean);
+    candidates = await auditGitPaths(root, "documents");
   } catch (error) {
     try {
-      await exec3("git", ["rev-parse", "--git-dir"], { cwd: root });
+      await execGit(["rev-parse", "--git-dir"], { cwd: root });
     } catch {
       return localDocPaths(root);
     }
@@ -967,14 +1000,14 @@ async function localDocPaths(root) {
       throw error;
     }
     for (const entry of entries) if (/^(?:agents|claude|readme)\.md$/i.test(entry.name)) {
-      paths.push(path6.posix.join(dir, entry.name));
+      paths.push(path7.posix.join(dir, entry.name));
     }
   }
   return paths;
 }
 function documentScope(file) {
-  const parent = path6.posix.dirname(file);
-  return path6.posix.basename(parent).toLowerCase() === ".claude" ? path6.posix.dirname(parent) : parent;
+  const parent = path7.posix.dirname(file);
+  return path7.posix.basename(parent).toLowerCase() === ".claude" ? path7.posix.dirname(parent) : parent;
 }
 async function discoverDocs(resolvedRoot) {
   return profilePhase("audit.documents", () => readDocs(resolvedRoot));
@@ -994,7 +1027,7 @@ async function readDocs(resolvedRoot) {
         path: candidate,
         content: content2,
         scope: documentScope(candidate),
-        kind: /^readme\.md$/i.test(path6.posix.basename(candidate)) ? "readme" : "instructions",
+        kind: /^readme\.md$/i.test(path7.posix.basename(candidate)) ? "readme" : "instructions",
         lineCount: content2.split("\n").length,
         lastCommit,
         dirty: dirty.has(candidate),
@@ -1004,16 +1037,17 @@ async function readDocs(resolvedRoot) {
   }
   return docs;
 }
-var exec3, DOC_CANDIDATES;
+var DOC_CANDIDATES;
 var init_docs = __esm({
   "src/audit/docs.ts"() {
     "use strict";
+    init_git_read();
     init_profile();
     init_claims();
     init_git();
     init_inputs();
     init_files();
-    exec3 = promisify4(execFile4);
+    init_inspection();
     DOC_CANDIDATES = [
       "AGENTS.md",
       "CLAUDE.md",
@@ -1024,14 +1058,14 @@ var init_docs = __esm({
 
 // src/audit/scope.ts
 import fs5 from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 function scopedPath(directory, value) {
-  if (path7.posix.isAbsolute(value) || value.includes("\\") || /[\x00-\x1f]/.test(value)) return null;
-  const resolved = path7.posix.normalize(path7.posix.join(directory, value));
+  if (path8.posix.isAbsolute(value) || value.includes("\\") || /[\x00-\x1f]/.test(value)) return null;
+  const resolved = path8.posix.normalize(path8.posix.join(directory, value));
   return resolved === ".." || resolved.startsWith("../") ? null : resolved;
 }
 function pathClaimScope(doc, claim) {
-  const directory = claim.relativeTo === "document" ? path7.posix.dirname(doc) : documentScope(doc);
+  const directory = claim.relativeTo === "document" ? path8.posix.dirname(doc) : documentScope(doc);
   const local = scopedPath(directory, claim.path);
   if (!local) return null;
   const candidates = claim.relativeTo === "document" || directory === "." ? [local] : [...new Set([local, scopedPath(".", claim.path)].filter((p) => p !== null))];
@@ -1064,14 +1098,113 @@ var init_scope = __esm({
   }
 });
 
+// src/utils/store-lock.ts
+import fs6 from "fs/promises";
+import os from "os";
+async function lockDiagnostic(file) {
+  let reason2;
+  try {
+    const owner = JSON.parse(await fs6.readFile(file, "utf8"));
+    if (!owner || typeof owner.host !== "string" || !Number.isInteger(owner.pid) || owner.pid <= 0) {
+      reason2 = "Lock owner data is incomplete or malformed.";
+    } else if (owner.host !== os.hostname()) {
+      reason2 = "The lock belongs to another host; its process cannot be checked locally.";
+    } else {
+      try {
+        process.kill(owner.pid, 0);
+        reason2 = `Local owner PID ${owner.pid} is still running.`;
+      } catch (error) {
+        reason2 = error.code === "ESRCH" ? `Local owner PID ${owner.pid} has exited, but lock recovery has not completed.` : `Local owner PID ${owner.pid} could not be checked.`;
+      }
+    }
+  } catch (error) {
+    reason2 = error instanceof SyntaxError ? "Lock owner data is incomplete or malformed." : "Lock owner data could not be read; the lock may have changed.";
+  }
+  if (await fs6.lstat(file + ".reclaim").then(() => true, () => false)) {
+    reason2 += " A recovery guard also needs inspection: " + file + ".reclaim.";
+  }
+  return reason2 + " Retry if a writer is active. For manual recovery, stop all Mason writers for this checkout, confirm they have exited (including other hosts), then remove only confirmed abandoned lock and lock.reclaim files. See docs/reference.md#snapshot-repairs-and-verification.";
+}
+async function withStoreLock(root, directory, run, waitMs = 5e3, label = "Mason store") {
+  const file = await storePath(root, directory + "/lock", true);
+  const deadline = Date.now() + waitMs;
+  let handle;
+  while (!handle) {
+    try {
+      handle = await fs6.open(file, "wx", 384);
+      try {
+        await handle.writeFile(JSON.stringify({ pid: process.pid, host: os.hostname() }));
+      } catch (error) {
+        await handle.close().catch(() => {
+        });
+        handle = void 0;
+        await fs6.rm(file, { force: true }).catch(() => {
+        });
+        throw error;
+      }
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      try {
+        const owner = JSON.parse(await fs6.readFile(file, "utf8"));
+        if (owner.host === os.hostname() && Number.isInteger(owner.pid) && owner.pid > 0) {
+          try {
+            process.kill(owner.pid, 0);
+          } catch (probe) {
+            if (probe.code === "ESRCH") {
+              const reclaim = file + ".reclaim";
+              let guard;
+              try {
+                guard = await fs6.open(reclaim, "wx", 384);
+                const current = JSON.parse(await fs6.readFile(file, "utf8"));
+                if (current.pid === owner.pid && current.host === owner.host) await fs6.unlink(file);
+              } finally {
+                if (guard) {
+                  await guard.close();
+                  await fs6.rm(reclaim, { force: true });
+                }
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      if (Date.now() >= deadline) throw new Error(label + " is busy or its lock needs inspection: " + file + ". " + await lockDiagnostic(file));
+      await new Promise((resolve2) => setTimeout(resolve2, 40));
+    }
+  }
+  try {
+    return await run();
+  } finally {
+    await handle.close();
+    await fs6.unlink(file);
+  }
+}
+var init_store_lock = __esm({
+  "src/utils/store-lock.ts"() {
+    "use strict";
+    init_storage();
+  }
+});
+
+// src/snapshot/lock.ts
+function withSnapshotWrite(root, run, waitMs = 5e3) {
+  return withStoreLock(root, ".mason/local/snapshot-write", run, waitMs, "Snapshot store");
+}
+var init_lock = __esm({
+  "src/snapshot/lock.ts"() {
+    "use strict";
+    init_store_lock();
+  }
+});
+
 // src/test-map.ts
 var test_map_exports = {};
 __export(test_map_exports, {
   buildTestMap: () => buildTestMap
 });
-import path8 from "path";
+import path9 from "path";
 async function buildTestMap(dir) {
-  const rootDir = path8.resolve(dir);
+  const rootDir = path9.resolve(dir);
   const access = await createFileAccess(rootDir);
   const testPatterns = [
     "**/*.test.*",
@@ -1092,7 +1225,7 @@ async function buildTestMap(dir) {
   const sourceByBaseName = /* @__PURE__ */ new Map();
   for (const file of sourceFiles) {
     if (testFiles.includes(file)) continue;
-    const baseName = path8.basename(file).replace(/\.[^.]+$/, "");
+    const baseName = path9.basename(file).replace(/\.[^.]+$/, "");
     const existing = sourceByBaseName.get(baseName) ?? [];
     existing.push(file);
     sourceByBaseName.set(baseName, existing);
@@ -1100,7 +1233,7 @@ async function buildTestMap(dir) {
   const paired = [];
   const unmatched = [];
   for (const testFile of testFiles) {
-    const testBaseName = path8.basename(testFile).replace(/\.[^.]+$/, "");
+    const testBaseName = path9.basename(testFile).replace(/\.[^.]+$/, "");
     const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
     if (!sourceName) {
       unmatched.push(testFile);
@@ -1108,10 +1241,10 @@ async function buildTestMap(dir) {
     }
     const candidates = sourceByBaseName.get(sourceName);
     if (candidates && candidates.length > 0) {
-      const testDir = path8.dirname(testFile);
+      const testDir = path9.dirname(testFile);
       const bestMatch = candidates.reduce((best, candidate) => {
-        const candidateDir = path8.dirname(candidate);
-        const bestDir = path8.dirname(best);
+        const candidateDir = path9.dirname(candidate);
+        const bestDir = path9.dirname(best);
         const candidateOverlap = commonSegments(testDir, candidateDir);
         const bestOverlap = commonSegments(testDir, bestDir);
         return candidateOverlap > bestOverlap ? candidate : best;
@@ -1145,9 +1278,7 @@ var init_test_map = __esm({
 });
 
 // src/snapshot/snapshot.ts
-import path9 from "path";
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify5 } from "util";
+import path10 from "path";
 import { z } from "zod";
 function normalizeFeatureType(value) {
   return value === "infrastructure" ? "infrastructure" : "capability";
@@ -1171,12 +1302,19 @@ async function inspectSnapshot(rootDir) {
     }] };
   }
 }
-async function saveSnapshot(rootDir, snapshot) {
-  await writeStoreJson(rootDir, ".mason/snapshot.json", snapshotSchema.parse(snapshot));
+async function updateSnapshot(rootDir, update) {
+  return withSnapshotWrite(rootDir, async () => {
+    const change = await update(await loadSnapshot(rootDir));
+    if (change.snapshot) {
+      await writeStoreJson(rootDir, ".mason/snapshot.json", snapshotSchema.parse(change.snapshot));
+      await change.afterSave?.();
+    }
+    return change.result;
+  });
 }
 async function getCurrentGitHash(rootDir) {
   try {
-    const { stdout } = await exec4("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await execGit(["rev-parse", "HEAD"], {
       cwd: rootDir
     });
     return stdout.trim();
@@ -1188,7 +1326,7 @@ async function listSourceFiles(resolvedRoot) {
   return (await createFileAccess(resolvedRoot)).list();
 }
 async function prepareSnapshotBatch(rootDir, offset, batchSize = DEFAULT_BATCH_SIZE, scopeFiles) {
-  const resolvedRoot = path9.resolve(rootDir);
+  const resolvedRoot = path10.resolve(rootDir);
   const access = await createFileAccess(resolvedRoot);
   let allFiles = await access.list();
   if (scopeFiles) {
@@ -1237,21 +1375,23 @@ async function prepareSnapshotBatch(rootDir, offset, batchSize = DEFAULT_BATCH_S
     testPairs
   };
 }
-var exec4, repoPath, verificationFields, featureSchema, flowSchema, snapshotSchema, DEFAULT_BATCH_SIZE, SKELETON_CHARS, DEEP_SAMPLE_CHARS, DEEP_SAMPLES_PER_BATCH;
+var repoPath, verificationFields, featureSchema, flowSchema, snapshotSchema, DEFAULT_BATCH_SIZE, SKELETON_CHARS, DEEP_SAMPLE_CHARS, DEEP_SAMPLES_PER_BATCH;
 var init_snapshot = __esm({
   "src/snapshot/snapshot.ts"() {
     "use strict";
+    init_git_read();
     init_files();
     init_files();
     init_storage();
+    init_lock();
     init_paths();
     init_test_map();
-    exec4 = promisify5(execFile5);
     repoPath = z.string().refine((value) => normalizeRepoPath(value) !== null, "Expected a relative repository path");
     verificationFields = {
       refreshedHash: z.string().optional(),
       verifiedAt: z.string().optional(),
       verifiedHash: z.string().optional(),
+      verificationToken: z.string().optional(),
       verificationFailed: z.boolean().optional(),
       verificationNote: z.string().optional()
     };
@@ -1279,10 +1419,8 @@ var init_snapshot = __esm({
 });
 
 // src/drift/drift.ts
-import fs6 from "fs/promises";
-import path10 from "path";
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify6 } from "util";
+import fs7 from "fs/promises";
+import path11 from "path";
 function parseChanges(output) {
   const fields = output.split("\0");
   const changes = [];
@@ -1303,7 +1441,7 @@ function touchedPaths(changes) {
 async function getChangesWithStatus(resolvedRoot, fromHash, toHash = "HEAD") {
   if (!fromHash || fromHash === "unknown" || fromHash.startsWith("-") || !toHash || toHash === "unknown" || toHash.startsWith("-")) return null;
   try {
-    const { stdout } = await exec5("git", ["diff", "--name-status", "-z", "-M", fromHash, toHash, "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 });
+    const { stdout } = await execGit(["diff", "--name-status", "-z", "-M", fromHash, toHash, "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 });
     return parseChanges(stdout);
   } catch {
     return null;
@@ -1312,8 +1450,8 @@ async function getChangesWithStatus(resolvedRoot, fromHash, toHash = "HEAD") {
 async function getWorkingTree(resolvedRoot) {
   try {
     const [diff, untracked] = await Promise.all([
-      exec5("git", ["diff", "--name-status", "-z", "-M", "HEAD", "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }),
-      exec5("git", ["ls-files", "-z", "--others", "--exclude-standard"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 })
+      execGit(["diff", "--name-status", "-z", "-M", "HEAD", "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }),
+      execGit(["ls-files", "-z", "--others", "--exclude-standard"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 })
     ]);
     const untrackedFiles = untracked.stdout.split("\0").filter((f) => f && !f.startsWith(".mason/"));
     return { available: true, changedFiles: [.../* @__PURE__ */ new Set([...touchedPaths(parseChanges(diff.stdout)), ...untrackedFiles])].sort(), untrackedFiles };
@@ -1324,8 +1462,7 @@ async function getWorkingTree(resolvedRoot) {
 async function countCommitsBehind(resolvedRoot, fromHash) {
   if (!fromHash || fromHash === "unknown" || fromHash.startsWith("-")) return null;
   try {
-    const { stdout } = await exec5(
-      "git",
+    const { stdout } = await execGit(
       ["rev-list", "--count", `${fromHash}..HEAD`],
       { cwd: resolvedRoot }
     );
@@ -1350,7 +1487,7 @@ async function findGhostFiles(resolvedRoot, mappedFiles) {
   const ghosts = [];
   for (const file of mappedFiles) {
     try {
-      await fs6.access(path10.join(resolvedRoot, file));
+      await fs7.access(path11.join(resolvedRoot, file));
     } catch {
       ghosts.push(file);
     }
@@ -1358,7 +1495,7 @@ async function findGhostFiles(resolvedRoot, mappedFiles) {
   return ghosts.sort();
 }
 async function computeDrift(rootDir) {
-  const root = path10.resolve(rootDir);
+  const root = path11.resolve(rootDir);
   const snapshot = await loadSnapshot(root);
   if (!snapshot) return null;
   const [headHash, workingTree] = await Promise.all([getCurrentGitHash(root), getWorkingTree(root)]);
@@ -1415,7 +1552,7 @@ async function computeDrift(rootDir) {
   const sourceFiles = new Set(await listSourceFiles(root));
   let committedFiles = /* @__PURE__ */ new Set();
   try {
-    const { stdout } = await exec5("git", ["ls-tree", "-r", "--name-only", "-z", "HEAD"], { cwd: root, maxBuffer: 50 * 1024 * 1024 });
+    const { stdout } = await execGit(["ls-tree", "-r", "--name-only", "-z", "HEAD"], { cwd: root, maxBuffer: 50 * 1024 * 1024 });
     committedFiles = new Set(stdout.split("\0").filter(Boolean));
   } catch {
     report.historyAvailable = false;
@@ -1435,13 +1572,13 @@ async function computeDrift(rootDir) {
   else report.recommendation = changedMapped.size >= FULL_REBUILD_MIN_CHANGED_MAPPED_FILES && changedMapped.size / Math.max(1, mappedFiles.size) > FULL_REBUILD_FRACTION ? "full-rebuild" : "incremental";
   return report;
 }
-var exec5, FULL_REBUILD_FRACTION, FULL_REBUILD_MIN_CHANGED_MAPPED_FILES;
+var FULL_REBUILD_FRACTION, FULL_REBUILD_MIN_CHANGED_MAPPED_FILES;
 var init_drift = __esm({
   "src/drift/drift.ts"() {
     "use strict";
+    init_git_read();
     init_snapshot();
     init_paths();
-    exec5 = promisify6(execFile6);
     FULL_REBUILD_FRACTION = 0.4;
     FULL_REBUILD_MIN_CHANGED_MAPPED_FILES = 10;
   }
@@ -1464,7 +1601,7 @@ var init_types = __esm({
 });
 
 // src/audit/checks/deleted-reference.ts
-import path11 from "path";
+import path12 from "path";
 async function checkDeletedReferences(ctx) {
   const result = emptyResult();
   for (const doc of ctx.docs) {
@@ -1493,7 +1630,7 @@ async function checkDeletedReferences(ctx) {
       const candidates = await Promise.all(scope.candidates.map(async (file) => ({
         file,
         tracked: await lastCommitOf(ctx.root, file),
-        parent: await pathExists(ctx.root, path11.posix.dirname(file))
+        parent: await pathExists(ctx.root, path12.posix.dirname(file))
       })));
       const candidate = candidates.find((c) => c.tracked || renames.has(c.file)) ?? candidates.find((c) => c.parent);
       if (!candidate && claim.relativeTo !== "document") continue;
@@ -1532,8 +1669,8 @@ var init_deleted_reference = __esm({
 
 // src/audit/checks/new-module.ts
 import fg4 from "fast-glob";
-import fs7 from "fs/promises";
-import path12 from "path";
+import fs8 from "fs/promises";
+import path13 from "path";
 function escapeRegExp(text2) {
   return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -1571,23 +1708,36 @@ async function checkNewModules(ctx) {
   return result;
 }
 function moduleDocumentation(docs) {
-  return docs.map((doc) => doc.content + "\n" + (path12.posix.dirname(doc.path) === "." ? "" : path12.posix.dirname(doc.path) + "/")).join("\n");
+  return docs.map((doc) => doc.content + "\n" + (path13.posix.dirname(doc.path) === "." ? "" : path13.posix.dirname(doc.path) + "/")).join("\n");
 }
-async function moduleCandidates(root, combinedDocs) {
+function moduleCandidates(root, combinedDocs) {
+  return inspectionRead(root, "modules:" + combinedDocs, () => collectModuleCandidates(root, combinedDocs));
+}
+async function collectModuleCandidates(root, combinedDocs) {
   const [config, sourcePaths] = await Promise.all([loadProjectConfig(root), gitSourcePaths(root)]);
   const ignore = [...SOURCE_IGNORE, ...config.ignore ?? []];
   const sources = sourcePaths.filter((file) => !file.split("/").some((part) => part.startsWith(".")));
-  const listSubdirs = async (dir) => {
-    const entries = await fs7.readdir(await auditInputPath(root, dir), { withFileTypes: true });
-    const dirs = entries.filter((entry) => (entry.isDirectory() || entry.isSymbolicLink() && sources.some((file) => file.startsWith(path12.posix.join(dir, entry.name) + "/"))) && !entry.name.startsWith(".") && !DIR_DENYLIST.has(entry.name)).map((entry) => path12.posix.join(dir, entry.name));
-    const ignored = await gitIgnoredPaths(root, dirs);
-    const visible = new Set(dirs.filter((dir2) => !ignored.has(dir2) || sources.some((file) => file.startsWith(dir2 + "/"))));
-    return (await auditGlob(root, dir === "." ? "*" : `${fg4.escapePath(dir)}/*`, {
-      ignore,
-      onlyDirectories: true,
-      label: "Module directory discovery",
-      select: (file) => visible.has(file)
-    })).map((file) => path12.posix.basename(file));
+  const listSubdirs = async (parents) => {
+    const byParent = /* @__PURE__ */ new Map();
+    for (let offset = 0; offset < parents.length; offset += 16) {
+      await Promise.all(parents.slice(offset, offset + 16).map(async (dir) => {
+        const entries = await fs8.readdir(await auditInputPath(root, dir), { withFileTypes: true });
+        const dirs = entries.filter((entry) => (entry.isDirectory() || entry.isSymbolicLink() && sources.some((file) => file.startsWith(path13.posix.join(dir, entry.name) + "/"))) && !entry.name.startsWith(".") && !DIR_DENYLIST.has(entry.name)).map((entry) => path13.posix.join(dir, entry.name));
+        byParent.set(dir, dirs);
+      }));
+    }
+    const ignored = await gitIgnoredPaths(root, [...byParent.values()].flat());
+    const result = /* @__PURE__ */ new Map();
+    for (const dir of parents) {
+      const visible = new Set(byParent.get(dir).filter((candidate) => !ignored.has(candidate) || sources.some((file) => file.startsWith(candidate + "/"))));
+      result.set(dir, (await auditGlob(root, dir === "." ? "*" : `${fg4.escapePath(dir)}/*`, {
+        ignore,
+        onlyDirectories: true,
+        label: "Module directory discovery",
+        select: (file) => visible.has(file)
+      })).map((file) => path13.posix.basename(file)));
+    }
+    return result;
   };
   const countSourceFiles = async (dir) => {
     const files = sources.filter((file) => file.startsWith(dir + "/"));
@@ -1603,14 +1753,16 @@ async function moduleCandidates(root, combinedDocs) {
     return count4;
   };
   const candidates = [];
-  for (const topDir of await listSubdirs(".")) {
+  const topDirs = (await listSubdirs(["."])).get(".");
+  const nested = await listSubdirs(topDirs.filter((dir) => isMentioned(combinedDocs, dir)));
+  for (const topDir of topDirs) {
     const topMentioned = isMentioned(combinedDocs, topDir);
     if (!topMentioned) {
       const count4 = await countSourceFiles(topDir);
       if (count4 >= 1) candidates.push({ dir: topDir, sourceFileCount: count4 });
       continue;
     }
-    const subdirs = await listSubdirs(topDir);
+    const subdirs = nested.get(topDir);
     const mentioned = subdirs.filter((s) => isMentioned(combinedDocs, s));
     if (mentioned.length < ENUMERATION_THRESHOLD) continue;
     for (const sub of subdirs) {
@@ -1627,6 +1779,7 @@ var DIR_DENYLIST, SECOND_LEVEL_MIN_SOURCE_FILES, ENUMERATION_THRESHOLD;
 var init_new_module = __esm({
   "src/audit/checks/new-module.ts"() {
     "use strict";
+    init_inspection();
     init_files();
     init_inputs();
     init_git();
@@ -1656,7 +1809,7 @@ var init_new_module = __esm({
 });
 
 // src/audit/checks/stale-count.ts
-import path13 from "path";
+import path14 from "path";
 async function countGradleModules(root) {
   for (const name of ["settings.gradle.kts", "settings.gradle"]) {
     const content2 = await readAuditInput(root, name);
@@ -1690,7 +1843,7 @@ async function countNpmWorkspaces(root) {
       return {
         actual: matched.length,
         countedFrom: "package.json workspaces",
-        members: matched.map((m) => path13.dirname(m)).sort()
+        members: matched.map((m) => path14.dirname(m)).sort()
       };
     }
   }
@@ -1721,7 +1874,7 @@ async function countNpmWorkspaces(root) {
       return {
         actual: matched.length,
         countedFrom: "pnpm-workspace.yaml",
-        members: matched.map((m) => path13.dirname(m)).sort()
+        members: matched.map((m) => path14.dirname(m)).sort()
       };
     }
   }
@@ -1743,8 +1896,8 @@ async function countCargoCrates(root) {
         ignore: ["**/target/**"],
         label: "Cargo workspace discovery"
       });
-      for (const m of matched) members.add(path13.dirname(m));
-    } else if (await readAuditInput(root, path13.posix.join(entry, "Cargo.toml")) !== null) {
+      for (const m of matched) members.add(path14.dirname(m));
+    } else if (await readAuditInput(root, path14.posix.join(entry, "Cargo.toml")) !== null) {
       members.add(entry);
     }
   }
@@ -1764,7 +1917,7 @@ async function resolveCountSource(root, claim) {
 }
 async function resolveDocCountSource(root, doc, claim) {
   const scope = documentScope(doc);
-  const source = await resolveCountSource(path13.join(root, scope), claim);
+  const source = await resolveCountSource(path14.join(root, scope), claim);
   if (!source || scope === ".") return source;
   return {
     ...source,
@@ -1816,7 +1969,7 @@ var init_stale_count = __esm({
 });
 
 // src/audit/checks/dead-command.ts
-import path14 from "path";
+import path15 from "path";
 function scriptsOf(raw) {
   try {
     const pkg = JSON.parse(raw);
@@ -1852,7 +2005,7 @@ async function commandInputs(root, docs) {
     }
     let cursor = directory;
     while (true) {
-      const manifest = path14.posix.join(cursor, "package.json");
+      const manifest = path15.posix.join(cursor, "package.json");
       scope.candidates.push(manifest);
       const raw = await read(manifest);
       if (raw !== null) {
@@ -1863,7 +2016,7 @@ async function commandInputs(root, docs) {
         break;
       }
       if (claim.directory !== void 0 || cursor === ".") break;
-      cursor = path14.posix.dirname(cursor);
+      cursor = path15.posix.dirname(cursor);
     }
     if (!resolution.manifest && !resolution.problem) {
       resolution.problem = `No package.json for the command's scope (${directory}).`;
@@ -1926,10 +2079,8 @@ var init_dead_command = __esm({
 });
 
 // src/audit/release-metadata.ts
-import { execFile as execFile7 } from "child_process";
-import { promisify as promisify7 } from "util";
 async function git(root, args) {
-  return (await exec6("git", args, { cwd: root, timeout: 1e4, maxBuffer: 2 * 1024 * 1024 })).stdout;
+  return (await execGit(args, { cwd: root, timeout: 1e4, maxBuffer: 2 * 1024 * 1024 })).stdout;
 }
 function withoutAndroidReleaseValues(text2) {
   if (/\/\*|"""|'''/.test(text2) || !/id\s*\(?\s*["']com\.android\.(application|library)["']/.test(text2)) return null;
@@ -1975,11 +2126,10 @@ async function releaseMetadataOnly(root, commit) {
     return false;
   }
 }
-var exec6;
 var init_release_metadata = __esm({
   "src/audit/release-metadata.ts"() {
     "use strict";
-    exec6 = promisify7(execFile7);
+    init_git_read();
   }
 });
 
@@ -2075,7 +2225,7 @@ var init_deps_changed = __esm({
 });
 
 // src/context/lexical.ts
-import path15 from "path";
+import path16 from "path";
 function tokenize(text2) {
   return text2.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2 && !STOPWORDS.has(t));
 }
@@ -2088,7 +2238,7 @@ function tokenSet(text2) {
 function scoreEntry(taskTokens, entry) {
   const nameTokens = tokenSet(entry.name);
   const descTokens = tokenSet(entry.description);
-  const fileTokens = tokenSet(entry.files.map((f) => path15.basename(f)).join(" "));
+  const fileTokens = tokenSet(entry.files.map((f) => path16.basename(f)).join(" "));
   let score = 0;
   for (const token of taskTokens) {
     if (nameTokens.has(token)) score += 3;
@@ -2194,7 +2344,9 @@ function assessTrust(entry, freshness) {
 }
 function trustHint(states) {
   const parts = [];
-  if (states.some((s) => s.verification === "failed")) parts.push("Verification failed for returned entries; do not rely on those descriptions until corrected.");
+  if (states.some((s) => s.verification === "failed" || s.recordedVerdict === "failed")) parts.push("Verification failed for returned entries; do not rely on those descriptions until corrected.");
+  if (states.some((s) => s.verification === "stale")) parts.push("Recorded verification evidence changed; use verify_snapshot and review the current evidence before reusing those verdicts.");
+  if (states.some((s) => s.verification === "unknown")) parts.push("Recorded verification evidence cannot be confirmed; inspect the files and obtain a fresh review before relying on those verdicts.");
   if (states.some((s) => s.freshness === "unknown")) parts.push("Freshness is unknown for some returned entries; inspect their files before relying on them.");
   if (states.some((s) => s.freshness === "changed")) parts.push("Some returned entries have changed files, including possible local edits; verify against the current code.");
   if (!parts.length) parts.push("No changes detected in the returned anchors. This does not prove the descriptions are correct.");
@@ -2419,8 +2571,8 @@ __export(decisions_exports, {
   upsertDecision: () => upsertDecision,
   withDecisionWrite: () => withDecisionWrite
 });
-import fs8 from "fs/promises";
-import path16 from "path";
+import fs9 from "fs/promises";
+import path17 from "path";
 import { createHash } from "crypto";
 import { z as z3 } from "zod";
 async function loadDecisionStore(rootDir) {
@@ -2428,7 +2580,7 @@ async function loadDecisionStore(rootDir) {
   const diagnostics = [];
   let entries;
   try {
-    entries = await fs8.readdir(await storePath(rootDir, ".mason/decisions"));
+    entries = await fs9.readdir(await storePath(rootDir, ".mason/decisions"));
   } catch (error) {
     if (error.code !== "ENOENT") diagnostics.push({ path: ".mason/decisions", message: String(error) });
     return { records, diagnostics };
@@ -2487,7 +2639,7 @@ async function withDecisionWrite(root, operation) {
   const lockPath = await storePath(root, ".mason/decisions/.write-lock", true);
   let lock;
   try {
-    lock = await fs8.open(lockPath, "wx", 384);
+    lock = await fs9.open(lockPath, "wx", 384);
   } catch (error) {
     if (error.code === "EEXIST") return { status: "error", error: "Decision store is locked by another write. Retry after it finishes; an abandoned .mason/decisions/.write-lock must be removed only after confirming no writer is running." };
     throw error;
@@ -2496,7 +2648,7 @@ async function withDecisionWrite(root, operation) {
     return await operation();
   } finally {
     await lock.close();
-    await fs8.unlink(lockPath);
+    await fs9.unlink(lockPath);
   }
 }
 async function upsertDecision(rootDir, input) {
@@ -2518,7 +2670,7 @@ async function upsertDecision(rootDir, input) {
     if (input.files && files.length < input.files.length) warnings.push("some anchor paths were outside the repo or duplicated and were dropped");
     for (const file of files) {
       try {
-        await fs8.access(path16.join(rootDir, file));
+        await fs9.access(path17.join(rootDir, file));
       } catch {
         warnings.push(`anchor file does not exist on disk: ${file}`);
       }
@@ -2643,9 +2795,9 @@ var init_decisions = __esm({
 });
 
 // src/decisions/drift.ts
-import path17 from "path";
+import path18 from "path";
 async function computeDecisionDrift(rootDir, decisions) {
-  const resolvedRoot = path17.resolve(rootDir);
+  const resolvedRoot = path18.resolve(rootDir);
   const store = decisions ? { records: decisions, diagnostics: [] } : await loadDecisionStore(resolvedRoot);
   const report = { historyAvailable: true, totalDecisions: store.records.length, staleDecisions: {}, freshness: {}, diagnostics: store.diagnostics };
   const [head, workingTree] = await Promise.all([getCurrentGitHash(resolvedRoot), getWorkingTree(resolvedRoot)]);
@@ -2868,8 +3020,6 @@ var init_findings = __esm({
 });
 
 // src/automation/store.ts
-import fs9 from "fs/promises";
-import os from "os";
 import { z as z5 } from "zod";
 function parseState(raw) {
   try {
@@ -2878,65 +3028,14 @@ function parseState(raw) {
     throw new Error("Invalid automation state; original evidence was retained.", { cause: error });
   }
 }
-async function withLock(root, directory, run, waitMs = 5e3) {
-  const file = await storePath(root, directory + "/lock", true);
-  const deadline = Date.now() + waitMs;
-  let handle;
-  while (!handle) {
-    try {
-      handle = await fs9.open(file, "wx", 384);
-      try {
-        await handle.writeFile(JSON.stringify({ pid: process.pid, host: os.hostname() }));
-      } catch (error) {
-        await handle.close().catch(() => {
-        });
-        handle = void 0;
-        await fs9.rm(file, { force: true }).catch(() => {
-        });
-        throw error;
-      }
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      try {
-        const owner = JSON.parse(await fs9.readFile(file, "utf8"));
-        if (owner.host === os.hostname() && Number.isInteger(owner.pid) && owner.pid > 0) {
-          try {
-            process.kill(owner.pid, 0);
-          } catch (probe) {
-            if (probe.code === "ESRCH") {
-              const reclaim = file + ".reclaim";
-              let guard;
-              try {
-                guard = await fs9.open(reclaim, "wx", 384);
-                const current = JSON.parse(await fs9.readFile(file, "utf8"));
-                if (current.pid === owner.pid && current.host === owner.host) await fs9.unlink(file);
-              } finally {
-                if (guard) {
-                  await guard.close();
-                  await fs9.rm(reclaim, { force: true });
-                }
-              }
-            }
-          }
-        }
-      } catch {
-      }
-      if (Date.now() >= deadline) throw new Error("Automation is busy or its lock needs inspection: " + file);
-      await new Promise((resolve2) => setTimeout(resolve2, 40));
-    }
-  }
-  try {
-    return await run();
-  } finally {
-    await handle.close();
-    await fs9.unlink(file);
-  }
+function withLock(root, directory, run, waitMs = 5e3) {
+  return withStoreLock(root, directory, run, waitMs, "Automation");
 }
 var hostSchema, events, stateSchema;
 var init_store = __esm({
   "src/automation/store.ts"() {
     "use strict";
-    init_storage();
+    init_store_lock();
     hostSchema = z5.enum(["claude", "codex"]);
     events = ["session_start", "turn_start", "before_tool", "after_tool", "task_end"];
     stateSchema = z5.object({
@@ -2967,8 +3066,6 @@ var init_store = __esm({
 
 // src/audit/advisory-review.ts
 import fs10 from "fs/promises";
-import { execFile as execFile8 } from "child_process";
-import { promisify as promisify8 } from "util";
 import { z as z6 } from "zod";
 async function readRecord(root, id) {
   const raw = await readStoreJson(root, recordPath(id));
@@ -3163,10 +3260,12 @@ async function reviewAdvisory(rootDir, input) {
     };
   });
 }
-var execute2, git2, hashSchema, commitSchema2, evidenceSchema2, eventSchema2, recordSchema, reviewSummarySchema, advisoryReviewRequest, recordPath;
+var git2, hashSchema, commitSchema2, evidenceSchema2, eventSchema2, recordSchema, reviewSummarySchema, advisoryReviewRequest, recordPath;
 var init_advisory_review = __esm({
   "src/audit/advisory-review.ts"() {
     "use strict";
+    init_inspection();
+    init_git_read();
     init_findings();
     init_deps_changed();
     init_inputs();
@@ -3176,8 +3275,7 @@ var init_advisory_review = __esm({
     init_store();
     init_decisions();
     init_drift2();
-    execute2 = promisify8(execFile8);
-    git2 = async (root, ...args) => (await execute2("git", args, { cwd: root, timeout: 1e4, maxBuffer: 8 * 1024 * 1024 })).stdout;
+    git2 = async (root, ...args) => (await (["log", "ls-tree", "ls-files", "merge-base"].includes(args[0]) ? inspectionGit : execGit)(args, { cwd: root, timeout: 1e4, maxBuffer: 8 * 1024 * 1024 })).stdout;
     hashSchema = z6.string().regex(/^[a-f0-9]{64}$/);
     commitSchema2 = z6.string().regex(/^[a-f0-9]{40,64}$/);
     evidenceSchema2 = z6.object({
@@ -3221,12 +3319,12 @@ var init_advisory_review = __esm({
 
 // src/audit/audit.ts
 import fs11 from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 async function computeAudit(rootDir, options = {}) {
   return profilePhase("audit.current", () => auditCurrent(rootDir, options));
 }
 async function auditCurrent(rootDir, options) {
-  const resolvedRoot = path18.resolve(rootDir);
+  const resolvedRoot = path19.resolve(rootDir);
   const [docs, headHash] = await Promise.all([discoverDocs(resolvedRoot), getCurrentGitHash(resolvedRoot)]);
   if (docs.length === 0) return null;
   const report = {
@@ -3260,7 +3358,7 @@ async function auditCurrent(rootDir, options) {
   }
   let decisionsPresent = false;
   try {
-    await fs11.access(path18.join(resolvedRoot, ".mason", "decisions"));
+    await fs11.access(path19.join(resolvedRoot, ".mason", "decisions"));
     decisionsPresent = true;
   } catch {
   }
@@ -3315,7 +3413,7 @@ __export(repair_exports, {
   withRepairSession: () => withRepairSession
 });
 import fs12 from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 import { z as z7 } from "zod";
 function recheckable(finding) {
@@ -3353,8 +3451,8 @@ async function readStableAudit(root, checks, options) {
 async function prepareRepair(rootDir, checks = ALL_CHECKS, options = {}) {
   return prepareOriginal(rootDir, checks, options);
 }
-async function withRepairSession(root, options, run, cachedAudit) {
-  const before = await Promise.all([getCurrentGitHash(root), docState(root), advisoryReviewInventory(root).then(digest)]);
+async function withRepairSession(root, options, run, validate, cachedAudit) {
+  const head = await getCurrentGitHash(root);
   const audits = /* @__PURE__ */ new Map();
   const documents = /* @__PURE__ */ new Map();
   const history = /* @__PURE__ */ new Map();
@@ -3365,9 +3463,9 @@ async function withRepairSession(root, options, run, cachedAudit) {
   };
   const session = {
     audit: (checks) => memo(audits, [...checks].sort().join(","), async () => {
-      if (cachedAudit && cachedAudit.headHash === before[0] && cachedAudit.root === root && digest([...checks].sort()) === digest([...cachedAudit.checksRun ?? []].sort())) {
+      if (cachedAudit && cachedAudit.headHash === head && cachedAudit.root === root && digest([...checks].sort()) === digest([...cachedAudit.checksRun ?? []].sort())) {
         const current = structuredClone(cachedAudit);
-        const reviews = (await Promise.all(allFindings(current).map((f) => assessAdvisory(root, f, before[0])))).filter((r) => r !== null);
+        const reviews = (await Promise.all(allFindings(current).map((f) => assessAdvisory(root, f, head)))).filter((r) => r !== null);
         delete current.advisoryReviews;
         if (reviews.length) current.advisoryReviews = reviews;
         return current;
@@ -3375,16 +3473,15 @@ async function withRepairSession(root, options, run, cachedAudit) {
       return computeAudit(root, { ...options, checks });
     }),
     document: (file) => memo(documents, file, async () => readBoundedFile(await storePath(root, file), 10 * 1024 * 1024)),
-    history: (head) => memo(history, head, () => getChangesWithStatus(root, head)),
-    assessment: (dir, finding, head) => memo(assessments, digest([dir, finding, head]), () => assessAdvisory(dir, finding, head))
+    history: (head2) => memo(history, head2, () => getChangesWithStatus(root, head2)),
+    assessment: (dir, finding, head2) => memo(assessments, digest([dir, finding, head2]), () => assessAdvisory(dir, finding, head2))
   };
   const result = await run({
     prepare: () => prepareOriginal(root, ALL_CHECKS, options, session),
     verify: (baseline) => profilePhase("repair.verify", () => verifyOriginal(root, baseline, options, session)),
     currentAudit: () => session.audit(ALL_CHECKS)
   });
-  const after = await Promise.all([getCurrentGitHash(root), docState(root), advisoryReviewInventory(root).then(digest)]);
-  if (digest(before) !== digest(after)) throw new Error("HEAD, context files or advisory review records changed during verification; retry against stable evidence.");
+  await validate();
   return result;
 }
 async function prepareOriginal(rootDir, checks, options, session) {
@@ -3406,8 +3503,8 @@ async function prepareOriginal(rootDir, checks, options, session) {
 }
 async function loadRepairBaseline(rootDir, baselinePath) {
   const root = await fs12.realpath(rootDir);
-  const declaredRoot = path19.resolve(rootDir);
-  const relative = path19.isAbsolute(baselinePath) ? path19.relative(isWithinRoot(declaredRoot, baselinePath) ? declaredRoot : root, baselinePath) : baselinePath;
+  const declaredRoot = path20.resolve(rootDir);
+  const relative = path20.isAbsolute(baselinePath) ? path20.relative(isWithinRoot(declaredRoot, baselinePath) ? declaredRoot : root, baselinePath) : baselinePath;
   const stored = baselineSchema.parse(await readStoreJson(root, relative));
   const { digest: savedDigest, ...payload } = stored;
   if (digest(payload) !== savedDigest) throw new Error("Repair baseline was modified; use the original baseline.");
@@ -3582,14 +3679,12 @@ var init_repair = __esm({
 
 // src/automation/evidence.ts
 import fs13 from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 import { createHash as createHash3 } from "crypto";
-import { execFile as execFile9 } from "child_process";
-import { promisify as promisify9 } from "util";
 import fg5 from "fast-glob";
 import { z as z8 } from "zod";
 async function git3(root, ...args) {
-  return profilePhase("automation.git", async () => (await exec7("git", args, { cwd: root, maxBuffer: 16 * 1024 * 1024, timeout: 1e4 })).stdout);
+  return profilePhase("automation.git", async () => (await execGit(args, { cwd: root, maxBuffer: 16 * 1024 * 1024, timeout: 1e4 })).stdout);
 }
 async function workspace(dir) {
   const root = await fs13.realpath((await git3(dir, "rev-parse", "--show-toplevel")).trim());
@@ -3613,7 +3708,7 @@ async function collectInputs(root) {
   const head = headText.trim();
   let shallow = null;
   try {
-    shallow = await fs13.readFile(path20.resolve(root, shallowPath.trim()), "utf8");
+    shallow = await fs13.readFile(path21.resolve(root, shallowPath.trim()), "utf8");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
@@ -3637,7 +3732,7 @@ async function collectInputs(root) {
       if (scope?.candidates.some(gitMetadataPath)) continue;
       for (const candidate of scope?.candidates ?? []) {
         if (optionalMasonPath(candidate)) continue;
-        const [filePresent, parentPresent] = await Promise.all([exists(candidate), exists(path20.posix.dirname(candidate))]);
+        const [filePresent, parentPresent] = await Promise.all([exists(candidate), exists(path21.posix.dirname(candidate))]);
         claims.push([candidate, filePresent, parentPresent]);
       }
     }
@@ -3649,7 +3744,7 @@ async function collectInputs(root) {
     if (error.code === "ENOENT") return "absent";
     throw error;
   });
-  const [modules, counts, commands, decisionFiles] = await Promise.all([
+  const [modules, counts, commands2, decisionFiles] = await Promise.all([
     combinedDocs ? moduleCandidates(root, combinedDocs) : [],
     Promise.all(countClaims.map(({ doc, claim }) => resolveDocCountSource(root, doc, claim))),
     commandInputs(root, parsedDocs),
@@ -3668,7 +3763,7 @@ async function collectInputs(root) {
     "deleted-reference": hash([common, claims, docStatus]),
     "new-module": hash([common, modules]),
     "stale-count": hash([common, counts]),
-    "dead-command": hash([common, commands]),
+    "dead-command": hash([common, commands2]),
     "deps-changed": hash([common, docStatus]),
     "decision-anchor-drift": hash([common, decisionPresence, decisions, status, index2])
   };
@@ -3706,10 +3801,11 @@ function checkCache(raw, inputs) {
     }
   };
 }
-var exec7, engineVersion, hash, content, cacheSchema;
+var engineVersion, hash, content, cacheSchema;
 var init_evidence = __esm({
   "src/automation/evidence.ts"() {
     "use strict";
+    init_git_read();
     init_profile();
     init_docs();
     init_scope();
@@ -3722,8 +3818,7 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     init_advisory_review();
-    exec7 = promisify9(execFile9);
-    engineVersion = true ? "0.17.3" : "development";
+    engineVersion = true ? "0.18.0" : "development";
     hash = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
     cacheSchema = z8.object({ version: z8.literal(1), entries: z8.record(z8.object({ key: z8.string(), result: checkResultSchema })), digest: z8.string() });
@@ -3783,8 +3878,8 @@ var init_model = __esm({
 });
 
 // src/setup/launcher.ts
-import { execFile as execFile10 } from "child_process";
-import { promisify as promisify10 } from "util";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
 import fs14 from "fs/promises";
 function globalCommand(args, platform = process.platform) {
   return platform === "win32" ? { command: "cmd.exe", args: ["/d", "/s", "/c", "mason", ...args] } : { command: "mason", args };
@@ -3792,7 +3887,7 @@ function globalCommand(args, platform = process.platform) {
 async function installedCommand() {
   const invocation = globalCommand(["internal-integration-version"]);
   try {
-    const { stdout } = await promisify10(execFile10)(
+    const { stdout } = await promisify2(execFile2)(
       invocation.command,
       invocation.args,
       { timeout: 5e3, maxBuffer: 8192, windowsHide: true }
@@ -3815,12 +3910,124 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.17.3" : "development";
+    executingVersion = () => true ? "0.18.0" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host} auto`;
   }
 });
 
+// src/snapshot/review.ts
+import { createHash as createHash5 } from "crypto";
+function snapshotEntryContent(entry) {
+  return {
+    description: entry.description,
+    files: "files" in entry ? entry.files : void 0,
+    chain: "chain" in entry ? entry.chain : void 0,
+    tests: "files" in entry ? entry.tests : void 0,
+    type: "files" in entry ? normalizeFeatureType(entry.type) : void 0
+  };
+}
+function reviewToken(kind, name, entry, evidence) {
+  return createHash5("sha256").update(JSON.stringify({
+    version: 1,
+    kind,
+    name,
+    entry: snapshotEntryContent(entry),
+    evidence
+  })).digest("hex");
+}
+async function prepareSnapshotReview(access, kind, name, entry) {
+  const files = "files" in entry ? entry.files : entry.chain;
+  const evidence = [];
+  const skeletons = [];
+  for (const file of files.slice(0, VERIFY_MAX_FILES_PER_ENTRY)) {
+    const full = await access.read(file);
+    evidence.push({ path: file, hash: full ? sourceHash(full.content) : null });
+    skeletons.push(full ? { path: full.path, content: full.content.slice(0, VERIFY_SKELETON_CHARS) } : { path: file, missing: true });
+  }
+  return { reviewToken: reviewToken(kind, name, entry, evidence), skeletons, truncated: files.length > VERIFY_MAX_FILES_PER_ENTRY };
+}
+function createSnapshotEvidenceReader(access) {
+  const hashes = /* @__PURE__ */ new Map();
+  return async (kind, name, entry) => {
+    const files = "files" in entry ? entry.files : entry.chain;
+    const evidence = [];
+    for (const file of files.slice(0, VERIFY_MAX_FILES_PER_ENTRY)) {
+      let hash2 = hashes.get(file);
+      if (!hash2) {
+        hash2 = access.read(file).then((full) => full ? sourceHash(full.content) : null);
+        hashes.set(file, hash2);
+      }
+      evidence.push({ path: file, hash: await hash2 });
+    }
+    return {
+      reviewToken: reviewToken(kind, name, entry, evidence),
+      evidenceAvailable: evidence.length > 0 && evidence.every((file) => file.hash !== null)
+    };
+  };
+}
+var VERIFY_MAX_FILES_PER_ENTRY, VERIFY_SKELETON_CHARS, sourceHash;
+var init_review = __esm({
+  "src/snapshot/review.ts"() {
+    "use strict";
+    init_snapshot();
+    VERIFY_MAX_FILES_PER_ENTRY = 8;
+    VERIFY_SKELETON_CHARS = 500;
+    sourceHash = (content2) => createHash5("sha256").update(content2).digest("hex");
+  }
+});
+
+// src/snapshot/trust.ts
+function createSnapshotTrustReader(root) {
+  let reader;
+  return async (kind, name, entry, freshness) => {
+    const trust = assessTrust(entry, freshness);
+    const verdict = entry.verificationFailed ? "failed" : entry.verifiedAt ? "passed" : void 0;
+    if (!verdict) return trust;
+    trust.recordedVerdict = verdict;
+    const unknown = (reason2) => {
+      trust.verification = "unknown";
+      trust.reasons.push(reason2);
+      return trust;
+    };
+    if (!entry.verificationToken || !/^[a-f0-9]{64}$/.test(entry.verificationToken)) return unknown("The recorded verdict has no supported evidence token; obtain a fresh verify_snapshot review.");
+    try {
+      reader ??= createFileAccess(root).then(createSnapshotEvidenceReader).catch(() => null);
+      const readReview = await reader;
+      if (!readReview) return unknown("Verification source evidence could not be read under the current file policy.");
+      const review = await readReview(kind, name, entry);
+      if (!review.evidenceAvailable) {
+        return unknown("Verification source evidence is missing, excluded, unreadable, or empty; the recorded verdict cannot be confirmed.");
+      }
+      if (review.reviewToken !== entry.verificationToken) {
+        trust.verification = "stale";
+        trust.reasons.push("The entry or sampled source contents differ from the recorded verification evidence; obtain a fresh review.");
+      }
+      return trust;
+    } catch {
+      return unknown("Verification source evidence could not be read under the current file policy.");
+    }
+  };
+}
+async function readSnapshotTrustIndex(readTrust, snapshot, drift) {
+  const features = /* @__PURE__ */ Object.create(null), flows = /* @__PURE__ */ Object.create(null);
+  for (const [name, entry] of Object.entries(snapshot.features)) {
+    features[name] = await readTrust("feature", name, entry, drift?.featureFreshness?.[name] ?? "unknown");
+  }
+  for (const [name, entry] of Object.entries(snapshot.flows)) {
+    flows[name] = await readTrust("flow", name, entry, drift?.flowFreshness?.[name] ?? "unknown");
+  }
+  return { features, flows };
+}
+var init_trust2 = __esm({
+  "src/snapshot/trust.ts"() {
+    "use strict";
+    init_trust();
+    init_files();
+    init_review();
+  }
+});
+
 // src/setup/files.ts
 var files_exports = {};
 __export(files_exports, {
@@ -3829,7 +4036,7 @@ __export(files_exports, {
   readText: () => readText
 });
 import fs17 from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function readText(root, file) {
   try {
@@ -3862,7 +4069,7 @@ async function applyEdit(root, edit) {
     return true;
   }
   const file = await storePath(root, edit.path, true);
-  const temporary = path24.join(path24.dirname(file), ".mason-setup-" + randomUUID3() + ".tmp");
+  const temporary = path25.join(path25.dirname(file), ".mason-setup-" + randomUUID3() + ".tmp");
   try {
     const mode = await fs17.stat(file).then((s) => s.mode & 511, () => 384);
     const handle = await fs17.open(temporary, "wx", mode);
@@ -4164,12 +4371,12 @@ async function matchingAnalysis(ws, state, inputs) {
   return { analysis: a };
 }
 async function verifyInputs(ws, inputs) {
-  return profilePhase("automation.revalidate", async () => {
+  return profilePhase("automation.revalidate", () => withRepositoryInspection(ws.root, async () => {
     const [after, currentWs] = await Promise.all([readInputs(ws.root), workspace(ws.root)]);
     if (after.fingerprint !== inputs.fingerprint || currentWs.directory !== ws.directory) {
       throw new Error("Repository inputs or branch changed during automation; no current verification was recorded. Retry on a stable checkout.");
     }
-  });
+  }));
 }
 async function computeAnalysis(ws, state, inputs, event, previousAudit, cacheDiagnostic) {
   const baselines = [...state.baselines];
@@ -4189,7 +4396,10 @@ async function computeAnalysis(ws, state, inputs, event, previousAudit, cacheDia
     capture: "unknown",
     scope: SCOPE
   };
-  if (!baselines.length && Object.values(inputs.docs).every((value) => value === null)) return { baselines, report: empty, cache: null };
+  if (!baselines.length && Object.values(inputs.docs).every((value) => value === null)) {
+    await verifyInputs(ws, inputs);
+    return { baselines, report: empty, cache: null };
+  }
   if (ws.branch === "detached" && state.latest) {
     const previous = await readStoreJson(ws.root, state.latest);
     if (!previous?.head || !/^[a-f0-9]{40,64}$/.test(previous.head)) throw new Error("The previous detached checkout evidence is unavailable.");
@@ -4227,7 +4437,7 @@ async function computeAnalysis(ws, state, inputs, event, previousAudit, cacheDia
     }
     currentAudit = await repairs.currentAudit();
     return verifications2;
-  }, cachedAudit);
+  }, () => verifyInputs(ws, inputs), cachedAudit);
   const merged = /* @__PURE__ */ new Map();
   for (const verification of verifications) {
     for (const finding of verification.findings) {
@@ -4262,7 +4472,6 @@ async function analyze(ws, inputs, event, startedAt) {
     if (previous && previous.completedAt >= startedAt) return { analysis: previous, shared: true };
     const originalDigest = await baselineDigest(ws, before);
     const computed = await computeAnalysis(ws, before, inputs, event, previous?.currentAudit, diagnostic);
-    await verifyInputs(ws, inputs);
     if (originalDigest !== await baselineDigest(ws, before)) throw new Error("Repair baseline was modified during automation; original evidence must be inspected.");
     const id = randomUUID5();
     const analysis = analysisSchema.parse({
@@ -4291,7 +4500,7 @@ async function analyze(ws, inputs, event, startedAt) {
 async function automate(dir, event) {
   const startedAt = Date.now();
   const ws = await profilePhase("automation.workspace", () => workspace(dir));
-  return recordExecution(ws.root, ws.directory, event.event, async () => {
+  return recordExecution(ws.root, ws.directory, event.event, () => withRepositoryInspection(ws.root, async () => {
     const inputs = await readInputs(ws.root);
     const result = await profilePhase("automation.analysis", () => analyze(ws, inputs, event, startedAt));
     if (result.shared) {
@@ -4364,7 +4573,7 @@ async function automate(dir, event) {
       await writeStoreJson(ws.root, ws.directory + "/state.json", state);
       return { report, message: notify ? summarize(report) : null, continueOnce };
     }));
-  });
+  }));
 }
 async function automationStatus(dir) {
   const ws = await profilePhase("automation.workspace", () => workspace(dir));
@@ -4402,6 +4611,7 @@ var init_runtime = __esm({
   "src/automation/runtime.ts"() {
     "use strict";
     init_profile();
+    init_inspection();
     init_execution();
     init_repair();
     init_types();
@@ -4447,7 +4657,7 @@ var init_runtime = __esm({
 
 // src/automation/hook-root.ts
 import fs19 from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 var init_hook_root = __esm({
   "src/automation/hook-root.ts"() {
     "use strict";
@@ -4852,7 +5062,7 @@ Mason provides recorded decisions and file impact over MCP. A concept map is opt
 - Before editing a file \u2192 \`get_impact\` to check references, tests, and historical change partners.
 - Investigation or correction reveals a reusable project lesson \u2192 \`save_decision\` before finishing. Capture only the lasting constraint and reason, with anchors and known sources, owner, and recorder. This creates a proposal; never infer approval. Preserve uncertain causes and unknown attribution. Route project lessons here; keep personal preferences in agent memory. Skip code summaries, current checkout status, temporary task permissions, session trivia, and secrets. No qualifying lesson means no record.
 - Before saving, compare the lesson with matching \`get_context\` records and any pending proposal. If new evidence changes the same lesson's assumptions, scope, or recommended action, revise it with \`save_decision(id: existingId)\`, including when it is accepted. Preserve supported rationale and sources, replace obsolete instructions, and add the new evidence. Create a separate record for a genuinely distinct lesson; skip unchanged restatements. Revision preserves history and leaves the accepted version operative until authorized review.
-- Consult trust metadata before relying on entries: unknown or changed freshness requires inspection, and failed verification means the description must be corrected. Check approval too: proposals are suggestions, legacy records are unreviewed, and accepted decisions are recorded constraints subject to freshness checks. An accepted revision remains operative while a pending proposal is reviewed; keep both versions and their freshness distinct.
+- Consult trust metadata before relying on entries: unknown or changed freshness requires inspection, stale or unknown map verification requires a fresh evidence review, and a recorded failed verdict means the description must be corrected. Check approval too: proposals are suggestions, legacy records are unreviewed, and accepted decisions are recorded constraints subject to freshness checks. An accepted revision remains operative while a pending proposal is reviewed; keep both versions and their freshness distinct.
 - Asked to review or re-verify a decision \u2192 \`review_decision\` first to inspect content, sources, history, and code changes. Record acceptance, reaffirmation, or retirement only when authorized by the user or a cited team review, with the actual reviewer and reason. Never infer approval from unchanged code. Review and commit the local record through the normal project workflow.
 - For an architectural overview, use \`get_snapshot\` if a map is available. If \`map.status\` is missing or invalid, use available decisions and source evidence; do not start building a map unless requested.
 - \`mason_init\` returns documentation audit and committed-diff review results, plus a short setup guide. Pass \`evidence\` with local CI manifest paths to include test and analysis results; the CLI equivalent is \`mason-review --evidence <manifest>\`. State skipped, unavailable, stale, or unknown checks explicitly. Related accepted decisions identify review context, not proven violations.
@@ -4916,13 +5126,13 @@ If a build is interrupted, its partials remain in \`.mason/partial-snapshots/\`.
 });
 
 // src/review/cochange.ts
-import { execFile as execFile15 } from "child_process";
-import { promisify as promisify15 } from "util";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
 async function buildMatrix(resolvedRoot) {
   try {
-    const { stdout: shallow } = await exec12("git", ["rev-parse", "--is-shallow-repository"], { cwd: resolvedRoot });
+    const { stdout: shallow } = await exec4("git", ["rev-parse", "--is-shallow-repository"], { cwd: resolvedRoot });
     if (shallow.trim() === "true") return null;
-    const { stdout } = await exec12(
+    const { stdout } = await exec4(
       "git",
       ["log", `-n${HISTORY_COMMITS}`, "--format=%x01", "--name-only", "-M"],
       { cwd: resolvedRoot, maxBuffer: 100 * 1024 * 1024 }
@@ -4978,11 +5188,11 @@ async function findMissingPartners(resolvedRoot, changedFiles, existsOnDisk, all
   findings.sort((a, b) => b.rate - a.rate || b.sharedCommits - a.sharedCommits);
   return findings;
 }
-var exec12, HISTORY_COMMITS, MIN_FILE_COMMITS, MIN_SHARED_COMMITS, MIN_COCHANGE_RATE, MAX_COMMIT_FILES;
+var exec4, HISTORY_COMMITS, MIN_FILE_COMMITS, MIN_SHARED_COMMITS, MIN_COCHANGE_RATE, MAX_COMMIT_FILES;
 var init_cochange = __esm({
   "src/review/cochange.ts"() {
     "use strict";
-    exec12 = promisify15(execFile15);
+    exec4 = promisify6(execFile6);
     HISTORY_COMMITS = 1500;
     MIN_FILE_COMMITS = 5;
     MIN_SHARED_COMMITS = 4;
@@ -5290,10 +5500,10 @@ var init_check = __esm({
 });
 
 // src/review/evidence.ts
-import path26 from "path";
+import path27 from "path";
 import { z as z22 } from "zod";
 function relativeArtifact(root, file) {
-  const relative = path26.isAbsolute(file) ? path26.relative(root, file) : file;
+  const relative = path27.isAbsolute(file) ? path27.relative(root, file) : file;
   const normalized = normalizeRepoPath(relative);
   if (!normalized) throw new Error(`Evidence artifact must be inside the repository: ${file}`);
   return normalized;
@@ -5390,7 +5600,7 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
         const report = await readStoreJson(root, file);
         if (report === null) throw new Error(`Report artifact is missing: ${file}`);
         const sourceRoot = check.sourceRoot ?? root;
-        if (!path26.posix.isAbsolute(sourceRoot) && !/^[A-Za-z]:[\\/]/.test(sourceRoot)) throw new Error("sourceRoot must identify the absolute checkout root on the check runner.");
+        if (!path27.posix.isAbsolute(sourceRoot) && !/^[A-Za-z]:[\\/]/.test(sourceRoot)) throw new Error("sourceRoot must identify the absolute checkout root on the check runner.");
         const parsed = check.report.format === "vitest-json" ? parseVitest(report, sourceRoot) : check.report.format === "mason-check-json" ? parseCheck(report, sourceRoot) : parseSarif(report, sourceRoot);
         result.outcome = parsed.outcome;
         result.counts = parsed.counts;
@@ -5512,12 +5722,12 @@ var init_evidence2 = __esm({
 
 // src/review/review.ts
 import fs20 from "fs/promises";
-import path27 from "path";
-import { execFile as execFile16 } from "child_process";
-import { promisify as promisify16 } from "util";
+import path28 from "path";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
 async function resolveMergeBase(resolvedRoot, base, head) {
   try {
-    const { stdout } = await exec13("git", ["merge-base", base, head], {
+    const { stdout } = await exec5("git", ["merge-base", base, head], {
       cwd: resolvedRoot
     });
     return stdout.trim() || null;
@@ -5528,7 +5738,7 @@ async function resolveMergeBase(resolvedRoot, base, head) {
 async function defaultBase(resolvedRoot) {
   for (const ref of ["origin/HEAD", "origin/main", "origin/master", "main"]) {
     try {
-      await exec13("git", ["rev-parse", "--verify", "--quiet", ref], {
+      await exec5("git", ["rev-parse", "--verify", "--quiet", ref], {
         cwd: resolvedRoot
       });
       return ref;
@@ -5541,7 +5751,7 @@ function anchorsTouched(record, changedFiles) {
   return matchingPaths(record.files, changedFiles);
 }
 async function computeReview(rootDir, base, options = {}) {
-  const resolvedRoot = path27.resolve(rootDir);
+  const resolvedRoot = path28.resolve(rootDir);
   const head = await getCurrentGitHash(resolvedRoot);
   if (head === "unknown") return null;
   const mergeBase = await resolveMergeBase(resolvedRoot, base, head);
@@ -5591,7 +5801,7 @@ async function computeReview(rootDir, base, options = {}) {
     analyzed,
     async (relPath) => {
       try {
-        await fs20.access(path27.join(resolvedRoot, relPath));
+        await fs20.access(path28.join(resolvedRoot, relPath));
         return true;
       } catch {
         return false;
@@ -5624,8 +5834,8 @@ async function computeReview(rootDir, base, options = {}) {
   }
   return finalize();
 }
-var exec13, MAX_ANALYZED_FILES;
-var init_review = __esm({
+var exec5, MAX_ANALYZED_FILES;
+var init_review2 = __esm({
   "src/review/review.ts"() {
     "use strict";
     init_drift();
@@ -5636,7 +5846,7 @@ var init_review = __esm({
     init_cochange();
     init_evidence2();
     init_snapshot();
-    exec13 = promisify16(execFile16);
+    exec5 = promisify7(execFile7);
     MAX_ANALYZED_FILES = 50;
   }
 });
@@ -5714,7 +5924,7 @@ var init_onboarding = __esm({
   "src/mcp/onboarding.ts"() {
     "use strict";
     init_audit();
-    init_review();
+    init_review2();
     init_drift();
     init_snapshot();
     init_provenance();
@@ -5726,7 +5936,7 @@ var init_onboarding = __esm({
 });
 
 // src/impact/references.ts
-import path28 from "path";
+import path29 from "path";
 function templateEnd(content2, start) {
   let i = start + 1, interpolation = 0;
   while (i < content2.length) {
@@ -5852,10 +6062,10 @@ function jvmImports(content2) {
 }
 function resolveImport(file, specifier, available) {
   if (!specifier.startsWith("./") && !specifier.startsWith("../")) return null;
-  const relative = path28.posix.normalize(path28.posix.join(path28.posix.dirname(file), specifier));
+  const relative = path29.posix.normalize(path29.posix.join(path29.posix.dirname(file), specifier));
   if (relative.startsWith("../")) return null;
   if (available.has(relative)) return relative;
-  const ext = path28.posix.extname(relative);
+  const ext = path29.posix.extname(relative);
   const replacements = { ".js": [".ts", ".tsx"], ".mjs": [".mts"], ".cjs": [".cts"] };
   const candidates = ext ? (replacements[ext] ?? []).map((e) => relative.slice(0, -ext.length) + e) : jsExtensions.flatMap((e) => [relative + e, relative + "/index" + e]);
   const found = candidates.filter((f) => available.has(f));
@@ -5867,13 +6077,13 @@ function mentionsPath(content2, target) {
 function createReferenceMatcher(targets, available, targetContents = /* @__PURE__ */ new Map()) {
   const counts = /* @__PURE__ */ new Map();
   for (const file of available) {
-    const name = path28.posix.basename(file, path28.posix.extname(file));
+    const name = path29.posix.basename(file, path29.posix.extname(file));
     counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   const jvmTargets = new Map([...targetContents].filter(([file]) => /\.(?:kt|kts|java)$/.test(file)).map(([file, content2]) => [file, declaredSymbols(content2)]));
   return (source) => {
     if (targets.includes(source.path)) return [];
-    const resolved = new Set(jsExtensions.includes(path28.posix.extname(source.path)) ? imports(source.content).map((s) => resolveImport(source.path, s, available)).filter(Boolean) : []);
+    const resolved = new Set(jsExtensions.includes(path29.posix.extname(source.path)) ? imports(source.content).map((s) => resolveImport(source.path, s, available)).filter(Boolean) : []);
     if (/\.(?:kt|kts|java)$/.test(source.path)) {
       const imported = jvmImports(source.content);
       for (const [target, symbols] of jvmTargets) if (symbols.some((symbol) => imported.some((name) => name === symbol || name.startsWith(symbol + ".")))) resolved.add(target);
@@ -5889,7 +6099,7 @@ function createReferenceMatcher(targets, available, targetContents = /* @__PURE_
         add("explicit-path", target);
         continue;
       }
-      const ext = path28.posix.extname(target), name = path28.posix.basename(target, ext);
+      const ext = path29.posix.extname(target), name = path29.posix.basename(target, ext);
       if (!/\.(?:[cm]?[jt]sx?|py|kt|java|go|rs|swift|rb|cs|cpp|c|h|hpp|dart|php)$/.test(ext) || name.startsWith(".") || name.length < 3 || genericNames.has(name.toLowerCase()) || counts.get(name) !== 1) continue;
       if (word(name).test(source.content)) {
         add("name-candidate", name);
@@ -5918,11 +6128,11 @@ var impact_exports = {};
 __export(impact_exports, {
   analyzeImpact: () => analyzeImpact
 });
-import path29 from "path";
-import { execFile as execFile17 } from "child_process";
-import { promisify as promisify17 } from "util";
+import path30 from "path";
+import { execFile as execFile8 } from "child_process";
+import { promisify as promisify8 } from "util";
 async function analyzeImpact(rootDir, targetFiles) {
-  const resolvedRoot = path29.resolve(rootDir);
+  const resolvedRoot = path30.resolve(rootDir);
   const resolvedTargets = await resolveTargetFiles(resolvedRoot, targetFiles);
   const [cochange, references, tests] = await Promise.all([
     getCochangeFiles(resolvedRoot, resolvedTargets),
@@ -5965,7 +6175,7 @@ async function getCochangeFiles(rootDir, targetFiles) {
   let totalTargetCommits = 0;
   for (const targetFile of targetFiles) {
     try {
-      const { stdout: commitLog } = await exec14(
+      const { stdout: commitLog } = await exec6(
         "git",
         ["log", "--format=%H", "-n", "500", "--", targetFile],
         { cwd: rootDir, maxBuffer: 5e6 }
@@ -5975,7 +6185,7 @@ async function getCochangeFiles(rootDir, targetFiles) {
       if (commits.length === 0) continue;
       for (const commit of commits) {
         try {
-          const { stdout: filesInCommit } = await exec14(
+          const { stdout: filesInCommit } = await exec6(
             "git",
             ["diff-tree", "--no-commit-id", "--name-only", "-r", commit],
             { cwd: rootDir }
@@ -6036,9 +6246,9 @@ async function getRelatedTests(rootDir, targetFiles) {
   const testFiles = await (await createFileAccess(rootDir)).list(testPatterns);
   const results = [];
   for (const target of targetFiles) {
-    const targetBaseName = path29.basename(target).replace(/\.[^.]+$/, "");
+    const targetBaseName = path30.basename(target).replace(/\.[^.]+$/, "");
     for (const testFile of testFiles) {
-      const testBaseName = path29.basename(testFile).replace(/\.[^.]+$/, "");
+      const testBaseName = path30.basename(testFile).replace(/\.[^.]+$/, "");
       const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
       if (sourceName === targetBaseName) {
         results.push({
@@ -6050,14 +6260,14 @@ async function getRelatedTests(rootDir, targetFiles) {
   }
   return results;
 }
-var exec14;
+var exec6;
 var init_impact = __esm({
   "src/impact/impact.ts"() {
     "use strict";
     init_files();
     init_paths();
     init_references();
-    exec14 = promisify17(execFile17);
+    exec6 = promisify8(execFile8);
   }
 });
 
@@ -6066,13 +6276,13 @@ var assemble_exports = {};
 __export(assemble_exports, {
   assembleContext: () => assembleContext
 });
-import path30 from "path";
+import path31 from "path";
 import fs21 from "fs/promises";
 async function collectImpact(root, candidates) {
   const targets = /* @__PURE__ */ new Set();
   let sourceFiles;
   for (const candidate of sanitizeRepoPaths(candidates)) {
-    const stat = await fs21.stat(path30.join(root, candidate)).catch(() => null);
+    const stat = await fs21.stat(path31.join(root, candidate)).catch(() => null);
     if (stat?.isDirectory()) {
       sourceFiles ??= await (await createFileAccess(root)).list();
       for (const file of sourceFiles) {
@@ -6098,7 +6308,7 @@ async function collectImpact(root, candidates) {
   };
 }
 async function assembleContext(rootDir, task, files) {
-  const resolvedRoot = path30.resolve(rootDir);
+  const resolvedRoot = path31.resolve(rootDir);
   const mapState = await inspectSnapshot(resolvedRoot);
   const snapshot = mapState.snapshot;
   const store = await loadDecisionStore(resolvedRoot);
@@ -6130,6 +6340,7 @@ async function assembleContext(rootDir, task, files) {
     };
   }
   const drift = await computeDrift(resolvedRoot);
+  const readTrust = createSnapshotTrustReader(resolvedRoot);
   const featureScores = Object.entries(snapshot.features).map(([name, feat]) => ({
     name,
     feat,
@@ -6156,14 +6367,7 @@ async function assembleContext(rootDir, task, files) {
     Object.assign(bundle, await collectImpact(resolvedRoot, [...anchorFiles, ...Object.values(decisions).flatMap((d) => [...d.files, ...d.pendingProposal?.files ?? []])]));
     bundle.diagnostics = store.diagnostics;
     bundle.freshness = drift;
-    bundle.trust = {
-      features: Object.fromEntries(Object.entries(snapshot.features).map(
-        ([name, entry]) => [name, assessTrust(entry, drift?.featureFreshness?.[name] ?? "unknown")]
-      )),
-      flows: Object.fromEntries(Object.entries(snapshot.flows).map(
-        ([name, entry]) => [name, assessTrust(entry, drift?.flowFreshness?.[name] ?? "unknown")]
-      ))
-    };
+    bundle.trust = await readSnapshotTrustIndex(readTrust, snapshot, drift);
     bundle.hint += " " + trustHint([
       ...Object.values(bundle.trust.features),
       ...Object.values(bundle.trust.flows),
@@ -6176,7 +6380,7 @@ async function assembleContext(rootDir, task, files) {
   const features = {};
   const staleMatches = [];
   for (const { name, feat, score } of featureScores) {
-    const trust = assessTrust(feat, drift?.featureFreshness?.[name] ?? "unknown");
+    const trust = await readTrust("feature", name, feat, drift?.featureFreshness?.[name] ?? "unknown");
     const stale2 = trust.freshness !== "current";
     if (stale2) staleMatches.push(name);
     features[name] = {
@@ -6191,7 +6395,7 @@ async function assembleContext(rootDir, task, files) {
   }
   const flows = {};
   for (const { name, flow, score } of flowScores) {
-    const trust = assessTrust(flow, drift?.flowFreshness?.[name] ?? "unknown");
+    const trust = await readTrust("flow", name, flow, drift?.flowFreshness?.[name] ?? "unknown");
     const stale2 = trust.freshness !== "current";
     if (stale2) staleMatches.push(name);
     flows[name] = {
@@ -6276,6 +6480,7 @@ var init_assemble = __esm({
     "use strict";
     init_snapshot();
     init_files();
+    init_trust2();
     init_drift();
     init_impact();
     init_lexical();
@@ -6641,8 +6846,8 @@ __export(client_exports, {
 function createConfluenceClient(config, fetchFn = fetch) {
   const baseUrl = config.baseUrl.replace(/\/+$/, "");
   const auth = "Basic " + Buffer.from(`${config.email}:${config.apiToken}`).toString("base64");
-  async function call(method, path34, body) {
-    const res = await fetchFn(`${baseUrl}${path34}`, {
+  async function call(method, path35, body) {
+    const res = await fetchFn(`${baseUrl}${path35}`, {
       method,
       headers: {
         Authorization: auth,
@@ -6654,7 +6859,7 @@ function createConfluenceClient(config, fetchFn = fetch) {
     if (!res.ok) {
       const text2 = await res.text();
       throw new Error(
-        `Confluence ${method} ${path34} failed: ${res.status} ${res.statusText} \u2014 ${text2}`
+        `Confluence ${method} ${path35} failed: ${res.status} ${res.statusText} \u2014 ${text2}`
       );
     }
     if (res.status === 204) return null;
@@ -6756,15 +6961,15 @@ __export(config_exports2, {
   validateProvider: () => validateProvider
 });
 import fs23 from "fs/promises";
-import path31 from "path";
+import path32 from "path";
 import os3 from "os";
-import { execFile as execFile18 } from "child_process";
-import { promisify as promisify18 } from "util";
+import { execFile as execFile9 } from "child_process";
+import { promisify as promisify9 } from "util";
 function configDir() {
-  return path31.join(os3.homedir(), ".mason");
+  return path32.join(os3.homedir(), ".mason");
 }
 function configFile() {
-  return path31.join(configDir(), "config.json");
+  return path32.join(configDir(), "config.json");
 }
 async function loadConfig() {
   try {
@@ -6794,7 +6999,7 @@ async function detectCLI(provider) {
   const cliName = provider === "claude" ? "claude" : provider === "gemini" ? "gemini" : provider === "ollama" ? "ollama" : null;
   if (!cliName) return { available: false };
   try {
-    const { stdout } = await exec15(cliName, ["--version"]);
+    const { stdout } = await exec7(cliName, ["--version"]);
     return { available: true, version: stdout.trim() };
   } catch {
     return { available: false };
@@ -6811,11 +7016,11 @@ async function loadConfluenceConfig() {
   const config = await loadConfig();
   return config?.confluence ?? null;
 }
-var exec15, DEFAULT_MODELS;
+var exec7, DEFAULT_MODELS;
 var init_config2 = __esm({
   "src/llm/config.ts"() {
     "use strict";
-    exec15 = promisify18(execFile18);
+    exec7 = promisify9(execFile9);
     DEFAULT_MODELS = {
       claude: "claude-sonnet-4-20250514",
       gemini: "gemini-2.5-flash",
@@ -6937,16 +7142,16 @@ var init_renderer = __esm({
 
 // src/confluence/diff.ts
 import fs24 from "fs/promises";
-import path32 from "path";
-import { createHash as createHash5 } from "crypto";
+import path33 from "path";
+import { createHash as createHash6 } from "crypto";
 function hashDescription(description) {
-  return createHash5("sha256").update(description, "utf8").digest("hex");
+  return createHash6("sha256").update(description, "utf8").digest("hex");
 }
 function syncStateDir(rootDir) {
-  return path32.join(rootDir, ".mason");
+  return path33.join(rootDir, ".mason");
 }
 function syncStatePath(rootDir) {
-  return path32.join(syncStateDir(rootDir), "confluence-sync.json");
+  return path33.join(syncStateDir(rootDir), "confluence-sync.json");
 }
 async function loadSyncState(rootDir) {
   try {
@@ -7014,8 +7219,8 @@ var init_diff = __esm({
 });
 
 // src/llm/providers.ts
-import { execFile as execFile19, spawn } from "child_process";
-import { promisify as promisify19 } from "util";
+import { execFile as execFile10, spawn } from "child_process";
+import { promisify as promisify10 } from "util";
 async function callLLM(config, userMessage, systemPrompt) {
   const model = config.model ?? getDefaultModel(config.provider);
   const system = systemPrompt ?? CLAUDE_MD_SYSTEM_PROMPT;
@@ -7172,12 +7377,12 @@ async function callOpenAIAPI(apiKey, model, system, userMessage) {
   });
   return response.choices[0]?.message?.content ?? "";
 }
-var exec16, CLAUDE_MD_SYSTEM_PROMPT;
+var exec8, CLAUDE_MD_SYSTEM_PROMPT;
 var init_providers = __esm({
   "src/llm/providers.ts"() {
     "use strict";
     init_config2();
-    exec16 = promisify19(execFile19);
+    exec8 = promisify10(execFile10);
     CLAUDE_MD_SYSTEM_PROMPT = `You are Mason, a context engineering tool. You've been given a comprehensive analysis of a codebase including:
 - Git history stats (commit patterns, frequently changed files, stale directories)
 - Project structure (directory layout, file counts by type)
@@ -7519,20 +7724,20 @@ import { z as z24 } from "zod";
 init_repair();
 init_advisory_review();
 import fs25 from "fs/promises";
-import path33 from "path";
-import { execFile as execFile20 } from "child_process";
-import { promisify as promisify20 } from "util";
+import path34 from "path";
+import { execFile as execFile11 } from "child_process";
+import { promisify as promisify11 } from "util";
 
 // src/audit/cli.ts
 init_audit();
 init_types();
 init_repair();
 init_findings();
-import path22 from "path";
+import path23 from "path";
 
 // src/audit/advisory-cli.ts
 init_advisory_review();
-import path21 from "path";
+import path22 from "path";
 import { stripVTControlCharacters } from "util";
 
 // src/audit/cli.ts
@@ -7625,8 +7830,8 @@ function formatFixPrompt(report, baselinePath) {
 }
 
 // src/analyzers/git-history.ts
-import { execFile as execFile11 } from "child_process";
-import { promisify as promisify11 } from "util";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
 
 // src/analyzers/base.ts
 import fs15 from "fs/promises";
@@ -7663,7 +7868,7 @@ var BaseAnalyzer = class {
 };
 
 // src/analyzers/git-history.ts
-var exec8 = promisify11(execFile11);
+var exec = promisify3(execFile3);
 var GitHistoryAnalyzer = class extends BaseAnalyzer {
   name = "git-history";
   async analyze(context) {
@@ -7684,7 +7889,7 @@ var GitHistoryAnalyzer = class extends BaseAnalyzer {
   }
   async git(args, cwd) {
     try {
-      const { stdout } = await exec8("git", args, { cwd, maxBuffer: 1e7 });
+      const { stdout } = await exec("git", args, { cwd, maxBuffer: 1e7 });
       return stdout.trim();
     } catch {
       return "";
@@ -7833,12 +8038,10 @@ async function runAll(context) {
 }
 
 // src/utils/git.ts
-import { execFile as execFile12 } from "child_process";
-import { promisify as promisify12 } from "util";
-var exec9 = promisify12(execFile12);
+init_git_read();
 async function isGitRepo(dir) {
   try {
-    await exec9("git", ["rev-parse", "--git-dir"], { cwd: dir });
+    await execGit(["rev-parse", "--git-dir"], { cwd: dir });
     return true;
   } catch {
     return false;
@@ -7847,10 +8050,10 @@ async function isGitRepo(dir) {
 
 // src/mcp/sampler.ts
 init_files();
-import path23 from "path";
-import { execFile as execFile13 } from "child_process";
-import { promisify as promisify13 } from "util";
-var exec10 = promisify13(execFile13);
+import path24 from "path";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var exec2 = promisify4(execFile4);
 var CONFIG_FILES = [
   // Build & project config
   "package.json",
@@ -7955,8 +8158,8 @@ async function sampleFiles(rootDir, maxFiles = 25) {
   const projectConfig = access.config;
   for (const filePath of projectConfig.alwaysInclude ?? []) {
     if (selected.size >= maxFiles) break;
-    const resolvedPath = path23.resolve(rootDir, filePath);
-    if (!resolvedPath.startsWith(path23.resolve(rootDir))) continue;
+    const resolvedPath = path24.resolve(rootDir, filePath);
+    if (!resolvedPath.startsWith(path24.resolve(rootDir))) continue;
     selected.set(filePath, "always-include (project config)");
   }
   let configCount = 0;
@@ -8012,7 +8215,7 @@ async function sampleFiles(rootDir, maxFiles = 25) {
     }
   }
   try {
-    const { stdout } = await exec10(
+    const { stdout } = await exec2(
       "git",
       ["log", "--since=3 months ago", "--format=", "--name-only"],
       { cwd: rootDir, maxBuffer: 5e6 }
@@ -8022,7 +8225,7 @@ async function sampleFiles(rootDir, maxFiles = 25) {
       if (!line) continue;
       if (line.includes("node_modules") || line.includes("/build/") || line.includes(".gradle") || line.includes("/generated/"))
         continue;
-      const ext = path23.extname(line).slice(1);
+      const ext = path24.extname(line).slice(1);
       if (!SOURCE_EXTENSIONS.includes(ext)) continue;
       fileCounts.set(line, (fileCounts.get(line) ?? 0) + 1);
     }
@@ -8142,10 +8345,10 @@ init_drift();
 init_paths();
 init_files();
 import { createHash as createHash4 } from "crypto";
-import { execFile as execFile14 } from "child_process";
-import { promisify as promisify14 } from "util";
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
 import { z as z10 } from "zod";
-var exec11 = promisify14(execFile14);
+var exec3 = promisify5(execFile5);
 var requestSchema = z10.object({
   id: z10.string().regex(/^[a-zA-Z0-9_-]+$/),
   action: z10.enum(["prepare", "accept", "reaffirm", "retire"]).default("prepare"),
@@ -8168,8 +8371,8 @@ async function reviewState(root, record) {
     changedFiles: touchedPaths(committed),
     localChanges: matchingPaths(anchors, workingTree.changedFiles)
   };
-  const reviewToken = createHash4("sha256").update(JSON.stringify({ record, evidence, workingTreeAvailable: workingTree.available })).digest("hex");
-  return { reviewToken, evidence, committed, workingTreeAvailable: workingTree.available };
+  const reviewToken2 = createHash4("sha256").update(JSON.stringify({ record, evidence, workingTreeAvailable: workingTree.available })).digest("hex");
+  return { reviewToken: reviewToken2, evidence, committed, workingTreeAvailable: workingTree.available };
 }
 async function previews(root, record, state) {
   const access = await createFileAccess(root);
@@ -8200,7 +8403,7 @@ async function previews(root, record, state) {
   let diffUnavailable;
   if (state.evidence.historyAvailable && diffPaths.length) {
     try {
-      const { stdout } = await exec11("git", ["--literal-pathspecs", "diff", "--no-ext-diff", "--no-textconv", "--no-color", "--no-renames", "-U3", record.refreshedHash, state.evidence.headHash, "--", ...diffPaths], { cwd: root, maxBuffer: 1024 * 1024 });
+      const { stdout } = await exec3("git", ["--literal-pathspecs", "diff", "--no-ext-diff", "--no-textconv", "--no-color", "--no-renames", "-U3", record.refreshedHash, state.evidence.headHash, "--", ...diffPaths], { cwd: root, maxBuffer: 1024 * 1024 });
       diff = stdout.slice(0, 16e3);
       if (stdout.length > diff.length) diffUnavailable = "Diff preview was truncated; inspect the full diff before reviewing.";
     } catch {
@@ -8275,7 +8478,9 @@ async function reviewDecision(root, input) {
 // src/mcp/tools.ts
 init_drift2();
 init_snapshot();
+init_trust2();
 init_drift();
+init_review();
 
 // src/snapshot/prompt.ts
 var BATCH_SYSTEM_PROMPT = `You are Mason, building one piece of a larger concept-to-files map via a Map-Reduce pattern.
@@ -8372,6 +8577,7 @@ ${JSON.stringify({ partials }, null, 2)}`;
 }
 
 // src/snapshot/partials.ts
+init_lock();
 init_storage();
 init_snapshot();
 import fs16 from "fs/promises";
@@ -8387,7 +8593,7 @@ var partialSchema = z11.object({
 var scopeSchema2 = z11.object({ files: z11.array(z11.string()), savedAt: z11.string() });
 async function savePartial(rootDir, partial) {
   if (!/^[a-zA-Z0-9_-]+$/.test(partial.batchId)) throw new Error(`Invalid batchId: ${partial.batchId}`);
-  await writeStoreJson(rootDir, `${DIRECTORY}/${partial.batchId}.json`, partialSchema.parse(partial));
+  await withSnapshotWrite(rootDir, () => writeStoreJson(rootDir, `${DIRECTORY}/${partial.batchId}.json`, partialSchema.parse(partial)));
 }
 async function loadAllPartials(rootDir) {
   let entries;
@@ -8407,14 +8613,16 @@ async function loadAllPartials(rootDir) {
   return partials.sort((a, b) => a.offset - b.offset);
 }
 async function saveScope(rootDir, files) {
-  await writeStoreJson(rootDir, `${DIRECTORY}/scope.json`, { files, savedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  await withSnapshotWrite(rootDir, () => writeStoreJson(rootDir, `${DIRECTORY}/scope.json`, { files, savedAt: (/* @__PURE__ */ new Date()).toISOString() }));
 }
 async function loadScope(rootDir) {
   const raw = await readStoreJson(rootDir, `${DIRECTORY}/scope.json`);
   return raw === null ? null : scopeSchema2.parse(raw).files;
 }
 async function clearScope(rootDir) {
-  await fs16.rm(await storePath(rootDir, `${DIRECTORY}/scope.json`), { force: true });
+  await withSnapshotWrite(rootDir, async () => {
+    await fs16.rm(await storePath(rootDir, `${DIRECTORY}/scope.json`), { force: true });
+  });
 }
 async function clearAllPartials(rootDir) {
   await fs16.rm(await storePath(rootDir, DIRECTORY), { recursive: true, force: true });
@@ -8426,7 +8634,7 @@ function batchIdFor(offset) {
 // src/mcp/tools.ts
 init_init();
 init_onboarding();
-var exec17 = promisify20(execFile20);
+var exec9 = promisify11(execFile11);
 async function buildContext(dir) {
   return {
     rootDir: dir,
@@ -8434,7 +8642,7 @@ async function buildContext(dir) {
   };
 }
 async function analyzeProject(dir) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const context = await buildContext(rootDir);
   const results = await runAll(context);
   const projectSnapshot = await detectProjectSnapshot(rootDir);
@@ -8489,7 +8697,7 @@ async function detectProjectSnapshot(rootDir) {
   const present = [];
   for (const file of buildFiles) {
     try {
-      await fs25.access(path33.join(rootDir, file));
+      await fs25.access(path34.join(rootDir, file));
       present.push(file);
     } catch {
     }
@@ -8531,7 +8739,7 @@ async function detectProjectSnapshot(rootDir) {
   const sourceFiles = await access.list();
   const fileCounts = {};
   for (const file of sourceFiles) {
-    const ext = path33.extname(file).slice(1);
+    const ext = path34.extname(file).slice(1);
     fileCounts[ext] = (fileCounts[ext] ?? 0) + 1;
   }
   return {
@@ -8542,7 +8750,7 @@ async function detectProjectSnapshot(rootDir) {
   };
 }
 async function getCodeSamples(dir, count4 = 15) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const samples = await sampleFiles(rootDir, count4);
   const output = {
     note: "These are previews (first ~60 lines). Read the file directly with your own tools to see it in full.",
@@ -8585,7 +8793,7 @@ async function unmappedContextResponse(rootDir) {
   });
 }
 async function getProjectStructure(dir) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const allFiles = await (await createFileAccess(rootDir)).list("**/*");
   const dirInfo = /* @__PURE__ */ new Map();
   for (const file of allFiles) {
@@ -8597,7 +8805,7 @@ async function getProjectStructure(dir) {
       }
       const info = dirInfo.get(dirPath);
       info.fileCount++;
-      const ext = path33.extname(file).slice(1);
+      const ext = path34.extname(file).slice(1);
       if (ext) {
         info.extensions.set(ext, (info.extensions.get(ext) ?? 0) + 1);
       }
@@ -8642,7 +8850,7 @@ async function buildChangedFilePreviews(rootDir, changedFiles) {
   return previews2;
 }
 async function getSnapshot(dir) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const snapshot = await loadSnapshot(rootDir);
   if (!snapshot) {
     return unmappedContextResponse(rootDir);
@@ -8680,9 +8888,9 @@ async function getSnapshot(dir) {
   const store = await loadDecisionStore2(rootDir);
   const decisionRecords = store.records;
   const decisionDrift = await computeDecisionDrift(rootDir, decisionRecords);
+  const readTrust = createSnapshotTrustReader(rootDir);
   const trust = {
-    features: Object.fromEntries(Object.entries(snapshot.features).map(([name, entry]) => [name, assessTrust(entry, drift?.featureFreshness?.[name] ?? "unknown")])),
-    flows: Object.fromEntries(Object.entries(snapshot.flows).map(([name, entry]) => [name, assessTrust(entry, drift?.flowFreshness?.[name] ?? "unknown")])),
+    ...await readSnapshotTrustIndex(readTrust, snapshot, drift),
     decisions: Object.fromEntries(decisionRecords.filter((d) => d.status === "active").map((d) => [d.id, decisionTrust(effectiveDecision(d), decisionDrift.freshness?.[d.id] ?? "unknown")]))
   };
   output.trust = trust;
@@ -8743,7 +8951,7 @@ function driftHint(report) {
   return "Read the changed files under staleFeatures/staleFlows, update those entries (fold unmappedFiles into the right features), and call save_snapshot with only the affected entries \u2014 unchanged entries are preserved. Drop ghostFiles from any entries that reference them, and delete features/flows that no longer exist via save_snapshot's removeFeatures/removeFlows.";
 }
 async function checkDrift(dir) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const report = await computeDrift(rootDir);
   if (!report) {
     return JSON.stringify({
@@ -8774,7 +8982,7 @@ async function checkDrift(dir) {
   return JSON.stringify({ exists: true, ...report, verification, hint });
 }
 async function generateSnapshotBatch(dir, offset = 0, batchSize = DEFAULT_BATCH_SIZE, files) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const scoped = files !== void 0 && files.length > 0;
   const scopeFiles = scoped ? sanitizePaths(rootDir, files) : void 0;
   const batch = await prepareSnapshotBatch(dir, offset, batchSize, scopeFiles);
@@ -8821,7 +9029,7 @@ async function generateSnapshotBatch(dir, offset = 0, batchSize = DEFAULT_BATCH_
   );
 }
 async function saveSnapshotPartial(dir, batchId, offset, features, flows) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   for (const feat of Object.values(features)) {
     feat.files = sanitizePaths(rootDir, feat.files);
     if (feat.tests) feat.tests = sanitizePaths(rootDir, feat.tests);
@@ -8850,7 +9058,7 @@ async function saveSnapshotPartial(dir, batchId, offset, features, flows) {
   );
 }
 async function reduceSnapshot(dir) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const partials = await loadAllPartials(rootDir);
   if (partials.length === 0) {
     return JSON.stringify(
@@ -8912,7 +9120,7 @@ async function reduceSnapshot(dir) {
   );
 }
 async function fullAnalysis(dir) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const [analysis, structure, samples, testMap, snapshot] = await Promise.all([
     analyzeProject(dir),
     getProjectStructure(dir),
@@ -8941,100 +9149,94 @@ function sanitizePaths(rootDir, files) {
   return sanitizeRepoPaths(files);
 }
 async function saveSnapshotData(dir, features, flows, removeFeatures = [], removeFlows = []) {
-  const rootDir = path33.resolve(dir);
-  const gitHash = await getCurrentGitHash(rootDir);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (const feat of Object.values(features)) {
-    feat.files = sanitizePaths(rootDir, feat.files);
-    if (feat.tests) feat.tests = sanitizePaths(rootDir, feat.tests);
-    feat.type = normalizeFeatureType(feat.type);
-  }
-  for (const flow of Object.values(flows)) {
-    flow.chain = sanitizePaths(rootDir, flow.chain);
-  }
-  const partials = await loadAllPartials(rootDir);
-  const replaceMode = partials.length > 0;
-  const previous = await loadSnapshot(rootDir);
-  const existing = replaceMode ? null : previous;
-  const preserveVerification = (next, old) => {
-    if (!old) return;
-    const semantic = (entry) => JSON.stringify({
-      description: entry.description,
-      files: "files" in entry ? entry.files : void 0,
-      chain: "chain" in entry ? entry.chain : void 0,
-      tests: "files" in entry ? entry.tests : void 0,
-      type: "files" in entry ? normalizeFeatureType(entry.type) : void 0
-    });
-    if (semantic(next) !== semantic(old)) return;
-    next.verifiedAt = old.verifiedAt;
-    next.verifiedHash = old.verifiedHash;
-    next.verificationFailed = old.verificationFailed;
-    next.verificationNote = old.verificationNote;
-  };
-  for (const [name, entry] of Object.entries(features)) preserveVerification(entry, previous?.features[name]);
-  for (const [name, entry] of Object.entries(flows)) preserveVerification(entry, previous?.flows[name]);
-  if (existing) {
-    if (existing.gitHash !== "unknown") {
-      for (const feat of Object.values(existing.features)) {
-        feat.refreshedHash ??= existing.gitHash;
+  const rootDir = path34.resolve(dir);
+  return updateSnapshot(rootDir, async (previous) => {
+    const gitHash = await getCurrentGitHash(rootDir);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const feat of Object.values(features)) {
+      feat.files = sanitizePaths(rootDir, feat.files);
+      if (feat.tests) feat.tests = sanitizePaths(rootDir, feat.tests);
+      feat.type = normalizeFeatureType(feat.type);
+    }
+    for (const flow of Object.values(flows)) {
+      flow.chain = sanitizePaths(rootDir, flow.chain);
+    }
+    const partials = await loadAllPartials(rootDir);
+    const replaceMode = partials.length > 0;
+    const existing = replaceMode ? null : previous;
+    const preserveVerification = (next, old) => {
+      delete next.verifiedAt;
+      delete next.verifiedHash;
+      delete next.verificationToken;
+      delete next.verificationFailed;
+      delete next.verificationNote;
+      if (!old) return;
+      if (JSON.stringify(snapshotEntryContent(next)) !== JSON.stringify(snapshotEntryContent(old))) return;
+      next.verificationToken = old.verificationToken;
+      next.verifiedAt = old.verifiedAt;
+      next.verifiedHash = old.verifiedHash;
+      next.verificationFailed = old.verificationFailed;
+      next.verificationNote = old.verificationNote;
+    };
+    for (const [name, entry] of Object.entries(features)) preserveVerification(entry, previous?.features[name]);
+    for (const [name, entry] of Object.entries(flows)) preserveVerification(entry, previous?.flows[name]);
+    if (existing) {
+      if (existing.gitHash !== "unknown") {
+        for (const feat of Object.values(existing.features)) {
+          feat.refreshedHash ??= existing.gitHash;
+        }
+        for (const flow of Object.values(existing.flows)) {
+          flow.refreshedHash ??= existing.gitHash;
+        }
       }
-      for (const flow of Object.values(existing.flows)) {
-        flow.refreshedHash ??= existing.gitHash;
+      const removedFeatures = removeFeatures.filter(
+        (name) => name in existing.features
+      );
+      const removedFlows = removeFlows.filter((name) => name in existing.flows);
+      for (const name of removedFeatures) delete existing.features[name];
+      for (const name of removedFlows) delete existing.flows[name];
+      if (gitHash !== "unknown") {
+        for (const feat of Object.values(features)) feat.refreshedHash = gitHash;
+        for (const flow of Object.values(flows)) flow.refreshedHash = gitHash;
       }
-    }
-    const removedFeatures = removeFeatures.filter(
-      (name) => name in existing.features
-    );
-    const removedFlows = removeFlows.filter((name) => name in existing.flows);
-    for (const name of removedFeatures) delete existing.features[name];
-    for (const name of removedFlows) delete existing.flows[name];
-    if (gitHash !== "unknown") {
-      for (const feat of Object.values(features)) feat.refreshedHash = gitHash;
-      for (const flow of Object.values(flows)) flow.refreshedHash = gitHash;
-    }
-    existing.features = { ...existing.features, ...features };
-    existing.flows = { ...existing.flows, ...flows };
-    existing.updatedAt = now;
-    existing.gitHash = gitHash;
-    await saveSnapshot(rootDir, existing);
-    await clearAllPartials(rootDir);
-    return JSON.stringify({
-      status: "updated",
-      mode: "merged",
-      features: Object.keys(existing.features).length,
-      flows: Object.keys(existing.flows).length,
-      removedFeatures: removedFeatures.length,
-      removedFlows: removedFlows.length
-    });
-  }
-  const snapshot = {
-    version: 2,
-    createdAt: now,
-    updatedAt: now,
-    gitHash,
-    features,
-    flows
-  };
-  await saveSnapshot(rootDir, snapshot);
-  await clearAllPartials(rootDir);
-  return JSON.stringify({
-    status: replaceMode ? "replaced" : "created",
-    mode: replaceMode ? "replaced-from-partials" : "fresh",
-    features: Object.keys(features).length,
-    flows: Object.keys(flows).length
+      existing.features = { ...existing.features, ...features };
+      existing.flows = { ...existing.flows, ...flows };
+      existing.updatedAt = now;
+      existing.gitHash = gitHash;
+      return { snapshot: existing, afterSave: () => clearAllPartials(rootDir), result: JSON.stringify({
+        status: "updated",
+        mode: "merged",
+        features: Object.keys(existing.features).length,
+        flows: Object.keys(existing.flows).length,
+        removedFeatures: removedFeatures.length,
+        removedFlows: removedFlows.length
+      }) };
+    }
+    const snapshot = {
+      version: 2,
+      createdAt: now,
+      updatedAt: now,
+      gitHash,
+      features,
+      flows
+    };
+    return { snapshot, afterSave: () => clearAllPartials(rootDir), result: JSON.stringify({
+      status: replaceMode ? "replaced" : "created",
+      mode: replaceMode ? "replaced-from-partials" : "fresh",
+      features: Object.keys(features).length,
+      flows: Object.keys(flows).length
+    }) };
   });
 }
 async function getImpact(dir, files) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const { analyzeImpact: analyzeImpact2 } = await Promise.resolve().then(() => (init_impact(), impact_exports));
   const result = await analyzeImpact2(rootDir, files);
   return JSON.stringify(result, null, 2);
 }
 var VERIFY_DEFAULT_SAMPLE = 5;
-var VERIFY_MAX_FILES_PER_ENTRY = 8;
-var VERIFY_SKELETON_CHARS = 500;
 async function verifySnapshot(dir, sample = VERIFY_DEFAULT_SAMPLE) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const snapshot = await loadSnapshot(rootDir);
   if (!snapshot) {
     return JSON.stringify({
@@ -9068,25 +9270,13 @@ async function verifySnapshot(dir, sample = VERIFY_DEFAULT_SAMPLE) {
   const picked = entries.slice(0, Math.max(1, sample));
   const toVerify = [];
   for (const entry of picked) {
-    const skeletons = [];
-    for (const filePath of entry.files.slice(0, VERIFY_MAX_FILES_PER_ENTRY)) {
-      const full = await access.read(filePath);
-      if (full) {
-        skeletons.push({
-          path: full.path,
-          content: full.content.slice(0, VERIFY_SKELETON_CHARS)
-        });
-      } else {
-        skeletons.push({ path: filePath, missing: true });
-      }
-    }
+    const stored = entry.kind === "feature" ? snapshot.features[entry.name] : snapshot.flows[entry.name];
     toVerify.push({
       name: entry.name,
       kind: entry.kind,
       description: entry.description,
       lastVerified: entry.verifiedAt ?? "never",
-      skeletons,
-      truncated: entry.files.length > VERIFY_MAX_FILES_PER_ENTRY
+      ...await prepareSnapshotReview(access, entry.kind, entry.name, stored)
     });
   }
   const neverVerified = entries.filter((e) => !e.verifiedAt).length;
@@ -9095,58 +9285,94 @@ async function verifySnapshot(dir, sample = VERIFY_DEFAULT_SAMPLE) {
     totalEntries: entries.length,
     neverVerified,
     entries: toVerify,
-    instructions: 'For each entry, judge from the skeletons whether the listed files actually implement the claimed feature/flow (missing files count against it). Then call save_verification with verdicts: {"<entry name>": {"ok": true|false, "note": "<one line, required when ok is false>"}}. Be skeptical \u2014 a plausible description is not evidence; the files must show it.'
+    instructions: 'Judge whether the files implement each claimed feature/flow, then call save_verification with verdicts: {"<entry name>": {"kind": "<feature|flow from the entry>", "reviewToken": "<token from the entry>", "ok": true|false, "note": "<required when ok is false>"}}. Tokens cover the entry and full contents of the previewed files (at most 8), including unavailable-file markers; previews themselves are truncated. This is a spot-check, not proof of unshown files. A conflict requires verify_snapshot and a fresh review; never reuse a verdict for changed content. If a feature and flow share a name, submit their verdicts in separate calls.'
   });
 }
 async function saveVerification(dir, verdicts) {
-  const rootDir = path33.resolve(dir);
-  const snapshot = await loadSnapshot(rootDir);
-  if (!snapshot) {
-    return JSON.stringify({ exists: false, hint: "No concept map exists." });
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const verifiedHash = await getCurrentGitHash(rootDir);
-  const stamped = [];
-  const unknown = [];
-  const failed = [];
-  for (const [name, verdict] of Object.entries(verdicts)) {
-    const entry = snapshot.features[name] ?? snapshot.flows[name];
-    if (!entry) {
-      unknown.push(name);
-      continue;
-    }
-    entry.verifiedAt = now;
-    entry.verifiedHash = verifiedHash;
-    if (verdict.ok) {
-      delete entry.verificationFailed;
-      delete entry.verificationNote;
-    } else {
-      entry.verificationFailed = true;
-      entry.verificationNote = verdict.note ?? "verification failed";
-      failed.push(name);
-    }
-    stamped.push(name);
-  }
-  snapshot.updatedAt = now;
-  await saveSnapshot(rootDir, snapshot);
-  return JSON.stringify({
-    stamped,
-    unknown,
-    failed,
-    hint: failed.length > 0 ? `Entries [${failed.join(", ")}] are mis-mapped. Re-map them: read their actual files, correct the entries, and call save_snapshot with only those entries (plus removeFeatures/removeFlows if a concept no longer exists).` : "All sampled entries verified. Re-run verify_snapshot periodically \u2014 it always picks the least-recently-verified entries next."
+  const rootDir = path34.resolve(dir);
+  return updateSnapshot(rootDir, async (snapshot) => {
+    if (!snapshot) {
+      return { snapshot: null, result: JSON.stringify({ exists: false, stamped: [], hint: "No concept map exists. Build it and run verify_snapshot before recording verdicts." }) };
+    }
+    const stamped = [], unknown = [], failed = [];
+    const conflicts = [], reviewRequired = [], invalid = [];
+    const candidates = [];
+    let access;
+    for (const [name, verdict] of Object.entries(verdicts)) {
+      if (!verdict.kind || !["feature", "flow"].includes(verdict.kind) || !/^[a-f0-9]{64}$/.test(verdict.reviewToken ?? "")) {
+        reviewRequired.push(name);
+        continue;
+      }
+      if (typeof verdict.ok !== "boolean" || !verdict.ok && !verdict.note?.trim()) {
+        invalid.push(name);
+        continue;
+      }
+      const collection = verdict.kind === "feature" ? snapshot.features : snapshot.flows;
+      if (!Object.hasOwn(collection, name)) {
+        unknown.push(name);
+        conflicts.push(name);
+        continue;
+      }
+      const entry = collection[name];
+      access ??= await createFileAccess(rootDir);
+      const current = await prepareSnapshotReview(access, verdict.kind, name, entry);
+      if (current.reviewToken !== verdict.reviewToken) conflicts.push(name);
+      else candidates.push({ name, verdict, entry });
+    }
+    const verifiedHash = candidates.length ? await getCurrentGitHash(rootDir) : "unknown";
+    const freshAccess = candidates.length ? await createFileAccess(rootDir) : null;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const { name, verdict, entry } of candidates) {
+      const current = await prepareSnapshotReview(freshAccess, verdict.kind, name, entry);
+      if (current.reviewToken !== verdict.reviewToken) {
+        conflicts.push(name);
+        continue;
+      }
+      entry.verifiedAt = now;
+      entry.verifiedHash = verifiedHash;
+      entry.verificationToken = verdict.reviewToken;
+      if (verdict.ok) {
+        delete entry.verificationFailed;
+        delete entry.verificationNote;
+      } else {
+        entry.verificationFailed = true;
+        entry.verificationNote = verdict.note.trim();
+        failed.push(name);
+      }
+      stamped.push(name);
+    }
+    const rejected = conflicts.length + reviewRequired.length + invalid.length;
+    const status = rejected ? stamped.length ? "partial" : conflicts.length ? "conflict" : reviewRequired.length ? "review_required" : "invalid" : stamped.length ? "saved" : "unchanged";
+    const hints = [];
+    if (conflicts.length) hints.push(`Entries [${conflicts.join(", ")}] changed or were deleted after review. Run verify_snapshot and review current evidence before retrying.`);
+    if (reviewRequired.length) hints.push(`Entries [${reviewRequired.join(", ")}] need kind and reviewToken from verify_snapshot. Inspect that evidence before submitting a verdict.`);
+    if (invalid.length) hints.push(`Entries [${invalid.join(", ")}] need a boolean ok and a non-empty note when ok is false.`);
+    if (failed.length) hints.push(`Entries [${failed.join(", ")}] are mis-mapped. Re-map them: read their actual files, correct the entries, and call save_snapshot with only those entries (plus removeFeatures/removeFlows if a concept no longer exists). Then run verify_snapshot for fresh review tokens.`);
+    if (!hints.length) hints.push(stamped.length ? "All submitted entries verified against the reviewed evidence. Re-run verify_snapshot periodically." : "No verdicts submitted; nothing changed.");
+    if (stamped.length) snapshot.updatedAt = now;
+    return { snapshot: stamped.length ? snapshot : null, result: JSON.stringify({
+      status,
+      stamped,
+      unknown,
+      failed,
+      conflicts,
+      reviewRequired,
+      invalid,
+      hint: hints.join(" ")
+    }) };
   });
 }
 async function saveDecision(dir, input) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const { upsertDecision: upsertDecision2 } = await Promise.resolve().then(() => (init_decisions(), decisions_exports));
   const result = await upsertDecision2(rootDir, input);
   return JSON.stringify(result);
 }
 async function reviewDecision2(dir, input) {
-  return JSON.stringify(await reviewDecision(path33.resolve(dir), input));
+  return JSON.stringify(await reviewDecision(path34.resolve(dir), input));
 }
 async function getContext(dir, task, files) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const { assembleContext: assembleContext2 } = await Promise.resolve().then(() => (init_assemble(), assemble_exports));
   const bundle = await assembleContext2(rootDir, task, files);
   return JSON.stringify(bundle);
@@ -9195,7 +9421,7 @@ async function masonInit(dir, options = {}) {
     return JSON.stringify(await setupProject2(dir, options), null, 2);
   }
   if (options.host) throw new Error("host applies only to mode: setup.");
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const marker = await loadProjectMarker(rootDir);
   const { loadSetup: loadSetup2 } = await Promise.resolve().then(() => (init_model(), model_exports));
   const setup = await loadSetup2(rootDir);
@@ -9215,7 +9441,7 @@ async function masonInit(dir, options = {}) {
   );
 }
 async function masonCompleteInit(dir, options = {}) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const existing = await loadProjectMarker(rootDir);
   const features = await loadProjectFeatures(rootDir);
   const marker = {
@@ -9324,7 +9550,7 @@ async function masonSetConfluence(input) {
   );
 }
 async function exportToConfluenceTool(dir, overrides) {
-  const rootDir = path33.resolve(dir);
+  const rootDir = path34.resolve(dir);
   const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports2));
   const { exportToConfluence: exportToConfluence2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
   const config = await loadConfig2();
@@ -9363,10 +9589,10 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.17.3"
+      version: "0.18.0"
     },
     {
-      instructions: (setupNotice ? setupNotice + "\n\n" : "") + 'Mason retrieves recorded decisions, file impact, and optional feature/flow maps. Use get_context with the task and known files, and get_impact before editing. Save learned rationale and constraints with save_decision; review and commit the local records through the project workflow. These tools work without initialization or a concept map. Consult trust and diagnostics: changed or unknown freshness needs source inspection, failed verification needs correction, and proposals are suggestions and legacy records are unreviewed. Accepted decisions are recorded team constraints, still subject to freshness checks. Use review_decision to prepare code evidence and record only authorized acceptance, reaffirmation, or retirement. Never invent a reviewer or treat these recorded identities as authenticated approval. mason_init returns documentation audit and committed-diff review findings with a quickstart guide. Use mode: "map" only when a full architecture map is requested. A missing map is not a setup failure; use decisions and source evidence. get_snapshot provides architecture navigation when a map is available. The mason-audit and mason-review CLIs also work without setup.'
+      instructions: (setupNotice ? setupNotice + "\n\n" : "") + 'Mason retrieves recorded decisions, file impact, and optional feature/flow maps. Use get_context with the task and known files, and get_impact before editing. Save learned rationale and constraints with save_decision; review and commit the local records through the project workflow. These tools work without initialization or a concept map. Consult trust and diagnostics: changed or unknown freshness needs source inspection, stale or unknown map verification needs a fresh review, recorded failed verdicts need correction, and proposals are suggestions and legacy records are unreviewed. Accepted decisions are recorded team constraints, still subject to freshness checks. Use review_decision to prepare code evidence and record only authorized acceptance, reaffirmation, or retirement. Never invent a reviewer or treat these recorded identities as authenticated approval. mason_init returns documentation audit and committed-diff review findings with a quickstart guide. Use mode: "map" only when a full architecture map is requested. A missing map is not a setup failure; use decisions and source evidence. get_snapshot provides architecture navigation when a map is available. The mason-audit and mason-review CLIs also work without setup.'
     }
   );
   server.tool(
@@ -9488,7 +9714,7 @@ function createMcpServer() {
   );
   server.tool(
     "get_snapshot",
-    "Return the optional feature-to-file architecture map with drift and trust evidence. If no map exists, returns exists:false plus project structure, Git signals, and test pairs. Decision capture, get_context, and get_impact still work. No initialization required.",
+    "Return the optional feature-to-file architecture map with drift and trust evidence. Map verification is rechecked against sampled source contents; stale or unknown verification requires a fresh review, and recordedVerdict preserves the historical verdict. If no map exists, returns exists:false plus project structure, Git signals, and test pairs. Decision capture, get_context, and get_impact still work. No initialization required.",
     {
       dir: z24.string().describe("Absolute path to the project root directory")
     },
@@ -9501,7 +9727,7 @@ function createMcpServer() {
   );
   server.tool(
     "get_context",
-    "Assemble task context: matching decisions with rationale, approval, owner, sources, last review, and freshness, plus related tests, file impact, and any available map entries. Proposals are suggestions; legacy records are unreviewed; accepted decisions are constraints subject to freshness. No initialization or map required. Pass task and optional files. map.status and diagnostics preserve missing or invalid knowledge. Impact covers up to three unique files, expanding directory anchors.",
+    "Assemble task context: matching decisions with rationale, approval, owner, sources, last review, and freshness, plus related tests, file impact, and any available map entries. Map verification is rechecked against sampled source contents; stale or unknown verification requires a fresh review, and recordedVerdict preserves the historical verdict. Proposals are suggestions; legacy records are unreviewed; accepted decisions are constraints subject to freshness. No initialization or map required. Pass task and optional files. map.status and diagnostics preserve missing or invalid knowledge. Impact covers up to three unique files, expanding directory anchors.",
     {
       dir: z24.string().describe("Absolute path to the project root directory"),
       task: z24.string().describe("The task, bug, or change request in natural language \u2014 e.g. 'add rate limiting to the API client' or a ticket description"),
@@ -9677,7 +9903,7 @@ function createMcpServer() {
   );
   server.tool(
     "verify_snapshot",
-    "Spot-check the concept map's CORRECTNESS (drift checks freshness; this checks entries were right to begin with). Returns a sample of entries \u2014 always the never-verified and least-recently-verified first \u2014 with skeletons of their claimed files, for you to judge whether the files actually implement what the entry claims. Report verdicts back via save_verification. Run periodically, or after an automated refresh wrote entries no human reviewed.",
+    "Spot-check the concept map's CORRECTNESS (drift checks freshness; this checks entries were right to begin with). Returns a sample of entries \u2014 always the never-verified and least-recently-verified first \u2014 with skeletons of their claimed files, for you to judge whether the files actually implement what the entry claims. Report verdicts back via save_verification with each entry\u2019s kind and reviewToken. Tokens bind the entry and bounded source evidence; changed evidence requires a fresh review. Run periodically, or after an automated refresh wrote entries no human reviewed.",
     {
       dir: z24.string().describe("Absolute path to the project root directory"),
       sample: z24.number().int().optional().describe("Entries to sample (default 5)")
@@ -9689,11 +9915,13 @@ function createMcpServer() {
   );
   server.tool(
     "save_verification",
-    "Record verify_snapshot verdicts. Entries judged ok are stamped verifiedAt; failures are flagged verificationFailed with your note and surface in get_context, get_snapshot, and mason_check_drift until corrected. Verdict notes are required for failures.",
+    "Record verify_snapshot verdicts using each entry\u2019s kind and reviewToken. Missing tokens request a fresh review; changed or deleted entries return conflicts without being stamped. Entries judged ok are stamped verifiedAt; failures are flagged verificationFailed with your note and surface in get_context, get_snapshot, and mason_check_drift until corrected. Verdict notes are required for failures.",
     {
       dir: z24.string().describe("Absolute path to the project root directory"),
       verdicts: z24.record(
         z24.object({
+          kind: z24.enum(["feature", "flow"]).optional().describe("Entry kind returned by verify_snapshot; required to record a verdict"),
+          reviewToken: z24.string().optional().describe("Copy the reviewToken from verify_snapshot after inspecting its evidence; required to record a verdict"),
           ok: z24.boolean(),
           note: z24.string().optional().describe("One line on what's wrong \u2014 required when ok is false")
         })