mason-context 0.17.4 → 0.19.0

package/dist/mason-mcp.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+if (!import.meta.url.endsWith("/mason-runtime.js")) await import("./mason-runtime.js").then(m => m.registerRuntime());
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -61,19 +62,19 @@ var init_git_read = __esm({
 import path from "path";
 function splitCommands(line) {
   const parts = [];
-  let quote = "", start = 0;
+  let quote2 = "", start = 0;
   for (let i = 0; i < line.length; i++) {
     const char = line[i];
     if (char === "\\") {
       i++;
       continue;
     }
-    if (quote) {
-      if (char === quote) quote = "";
+    if (quote2) {
+      if (char === quote2) quote2 = "";
       continue;
     }
     if (char === "'" || char === '"') {
-      quote = char;
+      quote2 = char;
       continue;
     }
     if (char === ";" || line.slice(i, i + 2) === "&&") {
@@ -1098,6 +1099,105 @@ 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, {
@@ -1203,8 +1303,15 @@ 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 {
@@ -1277,6 +1384,7 @@ var init_snapshot = __esm({
     init_files();
     init_files();
     init_storage();
+    init_lock();
     init_paths();
     init_test_map();
     repoPath = z.string().refine((value) => normalizeRepoPath(value) !== null, "Expected a relative repository path");
@@ -1284,6 +1392,7 @@ var init_snapshot = __esm({
       refreshedHash: z.string().optional(),
       verifiedAt: z.string().optional(),
       verifiedHash: z.string().optional(),
+      verificationToken: z.string().optional(),
       verificationFailed: z.boolean().optional(),
       verificationNote: z.string().optional()
     };
@@ -1311,7 +1420,7 @@ var init_snapshot = __esm({
 });
 
 // src/drift/drift.ts
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import path11 from "path";
 function parseChanges(output) {
   const fields = output.split("\0");
@@ -1379,7 +1488,7 @@ async function findGhostFiles(resolvedRoot, mappedFiles) {
   const ghosts = [];
   for (const file of mappedFiles) {
     try {
-      await fs6.access(path11.join(resolvedRoot, file));
+      await fs7.access(path11.join(resolvedRoot, file));
     } catch {
       ghosts.push(file);
     }
@@ -1561,7 +1670,7 @@ var init_deleted_reference = __esm({
 
 // src/audit/checks/new-module.ts
 import fg4 from "fast-glob";
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 import path13 from "path";
 function escapeRegExp(text2) {
   return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -1613,7 +1722,7 @@ async function collectModuleCandidates(root, combinedDocs) {
     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 fs7.readdir(await auditInputPath(root, dir), { withFileTypes: true });
+        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);
       }));
@@ -2026,6 +2135,10 @@ var init_release_metadata = __esm({
 });
 
 // src/audit/checks/deps-changed.ts
+function hasDependencyContent(content2) {
+  const text2 = content2.replace(/<!-- mason:start -->[\s\S]*?<!-- mason:end -->/g, "").replace(/<!--[\s\S]*?-->/g, "");
+  return /\b(?:dependenc(?:y|ies)|librar(?:y|ies)|frameworks?|tech(?:nology)? stack|prerequisites|requirements)\b/i.test(text2) || /\b(?:package\.json|build\.gradle(?:\.kts)?|settings\.gradle(?:\.kts)?|libs\.versions\.toml|Cargo\.toml|go\.mod|pyproject\.toml|requirements\.txt|Gemfile|composer\.json)\b/i.test(text2) || /\b(?:node(?:\.js)?|npm|pnpm|yarn|bun|deno|python|ruby|rust|go|java|jdk|kotlin|gradle|swift|php|react|vue|angular|compose|ktor|room)\s*(?:version\s*)?[`*:=>~^v\s-]*\d+(?:\.\d+)*\b/i.test(text2) || /\b(?:npm|pnpm|yarn|pip3?|cargo|gem|composer)\s+(?:install|add|require)\b/i.test(text2);
+}
 function manifestPathspecs(doc) {
   const scope = documentScope(doc);
   if (scope === ".") return MANIFEST_PATHSPECS;
@@ -2052,6 +2165,19 @@ async function checkDepsChanged(ctx) {
         reason: `${doc.path} has uncommitted edits \u2013 suppressed while in flight`
       });
     }
+    let content2 = doc.content;
+    if (doc.dirty) {
+      try {
+        content2 = (await inspectionGit(
+          ["show", `${doc.lastCommit.hash}:${doc.path}`],
+          { cwd: ctx.root, maxBuffer: 10 * 1024 * 1024, timeout: 1e4 }
+        )).stdout;
+      } catch {
+        result.skipped.push({ check: "deps-changed", doc: doc.path, reason: `${doc.path}: committed dependency content is unavailable` });
+        continue;
+      }
+    }
+    if (!hasDependencyContent(content2)) continue;
     const range = await commitsTouchingSince(
       ctx.root,
       doc.lastCommit.hash,
@@ -2097,6 +2223,7 @@ var init_deps_changed = __esm({
     init_docs();
     init_release_metadata();
     init_git();
+    init_inspection();
     init_checks();
     MANIFEST_COMMITS_CAP = 10;
     MANIFEST_PATHSPECS = [
@@ -2236,7 +2363,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.");
@@ -2461,7 +2590,7 @@ __export(decisions_exports, {
   upsertDecision: () => upsertDecision,
   withDecisionWrite: () => withDecisionWrite
 });
-import fs8 from "fs/promises";
+import fs9 from "fs/promises";
 import path17 from "path";
 import { createHash } from "crypto";
 import { z as z3 } from "zod";
@@ -2470,7 +2599,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 };
@@ -2529,7 +2658,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;
@@ -2538,7 +2667,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) {
@@ -2560,7 +2689,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(path17.join(rootDir, file));
+        await fs9.access(path17.join(rootDir, file));
       } catch {
         warnings.push(`anchor file does not exist on disk: ${file}`);
       }
@@ -2910,8 +3039,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 {
@@ -2920,65 +3047,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({
@@ -3510,7 +3586,7 @@ async function verifyOriginal(rootDir, baselinePath, options, session) {
       return {
         ...base,
         status: "review-required",
-        reason: "An audit cannot establish that this advisory was reviewed. Retain its original evidence and report a separate assessment; editing or committing the doc is not approval."
+        reason: (now ? "The current check still reports this advisory. " : finding.type === "deps-changed" ? "The current check no longer reports this condition; the historical advisory remains awaiting assessment. " : "The current check no longer reports the original finding; retained evidence still requires assessment. ") + "An audit cannot establish that this advisory was reviewed. Retain its original evidence and report a separate assessment; editing or committing the doc is not approval."
       };
     }
     return { ...base, status: "resolved", reason: "The original check ran and no longer reports this claim. Inspect the edit for semantic correctness." };
@@ -3701,7 +3777,7 @@ async function collectInputs(root) {
     git3(root, "status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ".", ":(exclude).mason/reports"),
     git3(root, "ls-files", "--stage", "-z", "--", ".", ":(exclude).mason/reports")
   ]) : ["", ""];
-  const common = [5, engineVersion, head, shallow, replacements, docContents];
+  const common = [6, engineVersion, head, shallow, replacements, docContents];
   const keys = {
     "deleted-reference": hash([common, claims, docStatus]),
     "new-module": hash([common, modules]),
@@ -3761,7 +3837,7 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     init_advisory_review();
-    engineVersion = true ? "0.17.4" : "development";
+    engineVersion = true ? "0.19.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() });
@@ -3771,18 +3847,49 @@ var init_evidence = __esm({
 // src/setup/model.ts
 var model_exports = {};
 __export(model_exports, {
+  INACTIVE_HOSTS_PATH: () => INACTIVE_HOSTS_PATH,
   SETUP_PATH: () => SETUP_PATH,
+  effectiveSetup: () => effectiveSetup,
+  inactiveHostsSchema: () => inactiveHostsSchema,
   loadSetup: () => loadSetup,
   loadSetupReceipt: () => loadSetupReceipt,
   setupHostSchema: () => setupHostSchema,
   setupSchema: () => setupSchema
 });
 import { z as z9 } from "zod";
+import fs14 from "fs/promises";
+import path22 from "path";
 async function loadSetup(root) {
   const raw = await readStoreJson(root, SETUP_PATH);
   if (raw === null) return null;
   return setupSchema.parse(raw);
 }
+async function effectiveSetup(root) {
+  const local = await loadSetup(root);
+  if (local) return { root, setup: local };
+  const common = await fs14.realpath(path22.resolve(root, (await git3(root, "rev-parse", "--git-common-dir")).trim()));
+  const own = await fs14.realpath((await git3(root, "rev-parse", "--absolute-git-dir")).trim());
+  if (common === own) return { root, setup: null };
+  const primary = (await git3(root, "worktree", "list", "--porcelain", "-z")).split("\0\0")[0].split("\0");
+  const candidate = primary.find((field) => field.startsWith("worktree "))?.slice(9);
+  if (!candidate || primary.includes("bare")) return { root, setup: null };
+  let inheritedRoot;
+  try {
+    inheritedRoot = await fs14.realpath((await git3(candidate, "rev-parse", "--show-toplevel")).trim());
+  } catch (error) {
+    if (/must be run in a work tree/.test(String(error.stderr))) return { root, setup: null };
+    throw error;
+  }
+  const inheritedCommon = await fs14.realpath(path22.resolve(
+    inheritedRoot,
+    (await git3(inheritedRoot, "rev-parse", "--git-common-dir")).trim()
+  ));
+  if (inheritedCommon !== common) throw new Error("Linked worktree setup does not belong to the same Git repository.");
+  const setup = await loadSetup(inheritedRoot);
+  const inactive = await readStoreJson(root, INACTIVE_HOSTS_PATH);
+  if (inactive && setup) for (const host of inactiveHostsSchema.parse(inactive).hosts) delete setup.hosts[host];
+  return { root: inheritedRoot, setup };
+}
 async function loadSetupReceipt(root, directory, host) {
   const raw = await readStoreJson(root, directory + "/setup-" + host + ".json");
   if (raw === null) return null;
@@ -3790,10 +3897,11 @@ async function loadSetupReceipt(root, directory, host) {
   if (receipt.root !== root || receipt.host !== host) throw new Error("Setup receipt belongs to another installation.");
   return receipt;
 }
-var setupHostSchema, setupSchema, SETUP_PATH, receiptSchema;
+var setupHostSchema, setupSchema, SETUP_PATH, INACTIVE_HOSTS_PATH, inactiveHostsSchema, receiptSchema;
 var init_model = __esm({
   "src/setup/model.ts"() {
     "use strict";
+    init_evidence();
     init_storage();
     setupHostSchema = z9.object({
       configuredVersion: z9.string(),
@@ -3807,6 +3915,8 @@ var init_model = __esm({
       claude: setupHostSchema.optional()
     }) });
     SETUP_PATH = ".mason/local/setup.json";
+    INACTIVE_HOSTS_PATH = ".mason/local/inactive-hosts.json";
+    inactiveHostsSchema = z9.object({ version: z9.literal(1), hosts: z9.array(z9.enum(["claude", "codex"])) });
     receiptSchema = z9.object({
       version: z9.literal(1),
       host: z9.enum(["codex", "claude"]),
@@ -3823,7 +3933,7 @@ var init_model = __esm({
 // src/setup/launcher.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 function globalCommand(args, platform = process.platform) {
   return platform === "win32" ? { command: "cmd.exe", args: ["/d", "/s", "/c", "mason", ...args] } : { command: "mason", args };
 }
@@ -3853,12 +3963,124 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.17.4" : "development";
+    executingVersion = () => true ? "0.19.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, {
@@ -3866,8 +4088,8 @@ __export(files_exports, {
   managedBlock: () => managedBlock,
   readText: () => readText
 });
-import fs17 from "fs/promises";
-import path25 from "path";
+import fs18 from "fs/promises";
+import path26 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function readText(root, file) {
   try {
@@ -3896,14 +4118,14 @@ async function applyEdit(root, edit) {
   if (edit.after === null) {
     const file2 = await storePath(root, edit.path);
     if (await readText(root, edit.path) !== edit.before) throw new Error("Input changed during removal: " + edit.path);
-    await fs17.unlink(file2);
+    await fs18.unlink(file2);
     return true;
   }
   const file = await storePath(root, edit.path, true);
-  const temporary = path25.join(path25.dirname(file), ".mason-setup-" + randomUUID3() + ".tmp");
+  const temporary = path26.join(path26.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);
+    const mode = await fs18.stat(file).then((s) => s.mode & 511, () => 384);
+    const handle = await fs18.open(temporary, "wx", mode);
     try {
       await handle.writeFile(edit.after, "utf8");
       await handle.sync();
@@ -3911,10 +4133,10 @@ async function applyEdit(root, edit) {
       await handle.close();
     }
     if (await readText(root, edit.path) !== edit.before) throw new Error("Integration input changed during update: " + edit.path);
-    await fs17.rename(temporary, file);
+    await fs18.rename(temporary, file);
     return true;
   } finally {
-    await fs17.rm(temporary, { force: true });
+    await fs18.rm(temporary, { force: true });
   }
 }
 var init_files2 = __esm({
@@ -3936,7 +4158,7 @@ __export(execution_exports, {
   recordExecution: () => recordExecution
 });
 import os2 from "os";
-import fs18 from "fs/promises";
+import fs19 from "fs/promises";
 import { randomUUID as randomUUID4 } from "crypto";
 import { z as z12 } from "zod";
 function parseExecution(raw) {
@@ -4064,7 +4286,7 @@ async function recordExecution(root, directory, event, run) {
       throw Object.assign(new Error(failure.message, { cause: error }), { failure });
     }
   } finally {
-    await fs18.rm(await storePath(root, owner), { force: true }).catch(() => {
+    await fs19.rm(await storePath(root, owner), { force: true }).catch(() => {
     });
   }
 }
@@ -4148,13 +4370,17 @@ async function observeReadOnlyTool(dir, event) {
 }
 function summarize(report) {
   const open = report.findings.filter((f) => f.status !== "resolved");
+  const onlyReview = report.status === "incomplete" && !report.diagnostics.length && !report.counts.unresolved && !report.counts.unverified && report.counts["review-required"] > 0;
   return [
-    `Mason: ${report.status}; ${report.counts.unresolved} unresolved, ${report.counts["review-required"]} need review, ${report.counts.unverified} unverified.`,
-    ...open.slice(0, 4).map((f) => `[${f.status}] ${cleanText(f.original.anchor.doc)}: ${cleanText(f.original.message)}`),
+    onlyReview ? `Mason: ${report.counts["review-required"]} advisor${report.counts["review-required"] === 1 ? "y" : "ies"} awaiting review; no unresolved issues.` : `Mason: ${report.status}; ${report.counts.unresolved} unresolved, ${report.counts["review-required"]} need review, ${report.counts.unverified} unverified.`,
+    ...open.slice(0, 4).map((f) => {
+      const detail = f.current ? f.current.message : f.status === "review-required" ? `${f.original.type}: current check no longer reports ${f.original.type === "deps-changed" ? "this condition" : "the original finding"}; historical evidence awaits assessment.` : `Original evidence: ${f.original.message}. ${f.reason}`;
+      return `[${f.status}] ${cleanText(f.original.anchor.doc)}: ${cleanText(detail)}`;
+    }),
     ...open.length > 4 ? [`${open.length - 4} more findings in the report.`] : [],
     ...report.diagnostics.slice(0, 2).map(cleanText),
     `Evidence: ${report.reportPath}. Resume/check with mason_automation(action: "check") or mason-auto check.`,
-    "Keep original evidence. Address findings relevant to the authorized task; report unrelated findings and unresolved advisories without approving them."
+    "Keep original evidence. Address findings relevant to the authorized task; report unrelated findings with a brief scope reason and suggested follow-up. Use review_advisory for authorized assessments; otherwise leave advisories open without approving them."
   ].join("\n");
 }
 async function loadState(ws) {
@@ -4378,7 +4604,7 @@ async function automate(dir, event) {
         if (event.event === "after_tool" && event.mutating) {
           session.mutationObserved = true;
           if (!event.toolId || !session.pending[event.toolId]) {
-            const gap = "A tool completed without an observed matching pre-tool capture; pre-edit coverage is unknown.";
+            const gap = "A tool completed without an observed matching pre-tool capture in this checkout; pre-edit coverage is unknown. The tool may have changed checkouts; captures are kept separately for each worktree.";
             if (!session.coverageGaps.includes(gap)) session.coverageGaps.push(gap);
           }
           if (event.toolId) delete session.pending[event.toolId];
@@ -4487,8 +4713,8 @@ var init_runtime = __esm({
 });
 
 // src/automation/hook-root.ts
-import fs19 from "fs/promises";
-import path26 from "path";
+import fs20 from "fs/promises";
+import path27 from "path";
 var init_hook_root = __esm({
   "src/automation/hook-root.ts"() {
     "use strict";
@@ -4893,7 +5119,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.
@@ -5331,10 +5557,10 @@ var init_check = __esm({
 });
 
 // src/review/evidence.ts
-import path27 from "path";
+import path28 from "path";
 import { z as z22 } from "zod";
 function relativeArtifact(root, file) {
-  const relative = path27.isAbsolute(file) ? path27.relative(root, file) : file;
+  const relative = path28.isAbsolute(file) ? path28.relative(root, file) : file;
   const normalized = normalizeRepoPath(relative);
   if (!normalized) throw new Error(`Evidence artifact must be inside the repository: ${file}`);
   return normalized;
@@ -5431,7 +5657,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 (!path27.posix.isAbsolute(sourceRoot) && !/^[A-Za-z]:[\\/]/.test(sourceRoot)) throw new Error("sourceRoot must identify the absolute checkout root on the check runner.");
+        if (!path28.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;
@@ -5552,8 +5778,8 @@ var init_evidence2 = __esm({
 });
 
 // src/review/review.ts
-import fs20 from "fs/promises";
-import path28 from "path";
+import fs21 from "fs/promises";
+import path29 from "path";
 import { execFile as execFile7 } from "child_process";
 import { promisify as promisify7 } from "util";
 async function resolveMergeBase(resolvedRoot, base, head) {
@@ -5582,7 +5808,7 @@ function anchorsTouched(record, changedFiles) {
   return matchingPaths(record.files, changedFiles);
 }
 async function computeReview(rootDir, base, options = {}) {
-  const resolvedRoot = path28.resolve(rootDir);
+  const resolvedRoot = path29.resolve(rootDir);
   const head = await getCurrentGitHash(resolvedRoot);
   if (head === "unknown") return null;
   const mergeBase = await resolveMergeBase(resolvedRoot, base, head);
@@ -5632,7 +5858,7 @@ async function computeReview(rootDir, base, options = {}) {
     analyzed,
     async (relPath) => {
       try {
-        await fs20.access(path28.join(resolvedRoot, relPath));
+        await fs21.access(path29.join(resolvedRoot, relPath));
         return true;
       } catch {
         return false;
@@ -5666,7 +5892,7 @@ async function computeReview(rootDir, base, options = {}) {
   return finalize();
 }
 var exec5, MAX_ANALYZED_FILES;
-var init_review = __esm({
+var init_review2 = __esm({
   "src/review/review.ts"() {
     "use strict";
     init_drift();
@@ -5755,7 +5981,7 @@ var init_onboarding = __esm({
   "src/mcp/onboarding.ts"() {
     "use strict";
     init_audit();
-    init_review();
+    init_review2();
     init_drift();
     init_snapshot();
     init_provenance();
@@ -5767,7 +5993,7 @@ var init_onboarding = __esm({
 });
 
 // src/impact/references.ts
-import path29 from "path";
+import path30 from "path";
 function templateEnd(content2, start) {
   let i = start + 1, interpolation = 0;
   while (i < content2.length) {
@@ -5789,10 +6015,10 @@ function templateEnd(content2, start) {
         continue;
       }
       if (c === '"' || c === "'") {
-        const quote = c;
+        const quote2 = c;
         for (i++; i < content2.length; i++) {
           if (content2[i] === "\\") i++;
-          else if (content2[i] === quote) {
+          else if (content2[i] === quote2) {
             i++;
             break;
           }
@@ -5893,10 +6119,10 @@ function jvmImports(content2) {
 }
 function resolveImport(file, specifier, available) {
   if (!specifier.startsWith("./") && !specifier.startsWith("../")) return null;
-  const relative = path29.posix.normalize(path29.posix.join(path29.posix.dirname(file), specifier));
+  const relative = path30.posix.normalize(path30.posix.join(path30.posix.dirname(file), specifier));
   if (relative.startsWith("../")) return null;
   if (available.has(relative)) return relative;
-  const ext = path29.posix.extname(relative);
+  const ext = path30.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));
@@ -5905,23 +6131,23 @@ function resolveImport(file, specifier, available) {
 function mentionsPath(content2, target) {
   return new RegExp(`(?<![\\w./\\\\-])(?:\\./)?${escape(target)}(?![\\w./\\\\-])`).test(content2);
 }
-function createReferenceMatcher(targets, available, targetContents = /* @__PURE__ */ new Map()) {
+function createReferenceMatcher(targets2, available, targetContents = /* @__PURE__ */ new Map()) {
   const counts = /* @__PURE__ */ new Map();
   for (const file of available) {
-    const name = path29.posix.basename(file, path29.posix.extname(file));
+    const name = path30.posix.basename(file, path30.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(path29.posix.extname(source.path)) ? imports(source.content).map((s) => resolveImport(source.path, s, available)).filter(Boolean) : []);
+    if (targets2.includes(source.path)) return [];
+    const resolved = new Set(jsExtensions.includes(path30.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);
     }
     const groups = /* @__PURE__ */ new Map();
     const add = (evidence, match) => groups.set(evidence, [...groups.get(evidence) ?? [], match]);
-    for (const target of targets) {
+    for (const target of targets2) {
       if (resolved.has(target)) {
         add("resolved-import", target);
         continue;
@@ -5930,7 +6156,7 @@ function createReferenceMatcher(targets, available, targetContents = /* @__PURE_
         add("explicit-path", target);
         continue;
       }
-      const ext = path29.posix.extname(target), name = path29.posix.basename(target, ext);
+      const ext = path30.posix.extname(target), name = path30.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);
@@ -5959,11 +6185,11 @@ var impact_exports = {};
 __export(impact_exports, {
   analyzeImpact: () => analyzeImpact
 });
-import path30 from "path";
+import path31 from "path";
 import { execFile as execFile8 } from "child_process";
 import { promisify as promisify8 } from "util";
 async function analyzeImpact(rootDir, targetFiles) {
-  const resolvedRoot = path30.resolve(rootDir);
+  const resolvedRoot = path31.resolve(rootDir);
   const resolvedTargets = await resolveTargetFiles(resolvedRoot, targetFiles);
   const [cochange, references, tests] = await Promise.all([
     getCochangeFiles(resolvedRoot, resolvedTargets),
@@ -5977,10 +6203,10 @@ async function analyzeImpact(rootDir, targetFiles) {
     tests
   };
 }
-async function resolveTargetFiles(rootDir, targets) {
+async function resolveTargetFiles(rootDir, targets2) {
   const resolved = [];
   const access = await createFileAccess(rootDir);
-  for (const target of targets) {
+  for (const target of targets2) {
     if (target.includes("/")) {
       const normalized = normalizeRepoPath(target);
       if (normalized) resolved.push(normalized);
@@ -6077,9 +6303,9 @@ async function getRelatedTests(rootDir, targetFiles) {
   const testFiles = await (await createFileAccess(rootDir)).list(testPatterns);
   const results = [];
   for (const target of targetFiles) {
-    const targetBaseName = path30.basename(target).replace(/\.[^.]+$/, "");
+    const targetBaseName = path31.basename(target).replace(/\.[^.]+$/, "");
     for (const testFile of testFiles) {
-      const testBaseName = path30.basename(testFile).replace(/\.[^.]+$/, "");
+      const testBaseName = path31.basename(testFile).replace(/\.[^.]+$/, "");
       const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
       if (sourceName === targetBaseName) {
         results.push({
@@ -6107,26 +6333,26 @@ var assemble_exports = {};
 __export(assemble_exports, {
   assembleContext: () => assembleContext
 });
-import path31 from "path";
-import fs21 from "fs/promises";
+import path32 from "path";
+import fs22 from "fs/promises";
 async function collectImpact(root, candidates) {
-  const targets = /* @__PURE__ */ new Set();
+  const targets2 = /* @__PURE__ */ new Set();
   let sourceFiles;
   for (const candidate of sanitizeRepoPaths(candidates)) {
-    const stat = await fs21.stat(path31.join(root, candidate)).catch(() => null);
+    const stat = await fs22.stat(path32.join(root, candidate)).catch(() => null);
     if (stat?.isDirectory()) {
       sourceFiles ??= await (await createFileAccess(root)).list();
       for (const file of sourceFiles) {
-        if (anchorMatches(candidate, file)) targets.add(file);
-        if (targets.size >= MAX_IMPACT_TARGETS) break;
+        if (anchorMatches(candidate, file)) targets2.add(file);
+        if (targets2.size >= MAX_IMPACT_TARGETS) break;
       }
     } else {
-      targets.add(candidate);
+      targets2.add(candidate);
     }
-    if (targets.size >= MAX_IMPACT_TARGETS) break;
+    if (targets2.size >= MAX_IMPACT_TARGETS) break;
   }
-  if (!targets.size) return { impact: null, relatedTests: [] };
-  const result = await analyzeImpact(root, [...targets]);
+  if (!targets2.size) return { impact: null, relatedTests: [] };
+  const result = await analyzeImpact(root, [...targets2]);
   const referenceCandidatesOmitted = result.references.filter((r) => r.evidence === "name-candidate").length;
   return {
     impact: {
@@ -6139,7 +6365,7 @@ async function collectImpact(root, candidates) {
   };
 }
 async function assembleContext(rootDir, task, files) {
-  const resolvedRoot = path31.resolve(rootDir);
+  const resolvedRoot = path32.resolve(rootDir);
   const mapState = await inspectSnapshot(resolvedRoot);
   const snapshot = mapState.snapshot;
   const store = await loadDecisionStore(resolvedRoot);
@@ -6171,6 +6397,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,
@@ -6197,14 +6424,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),
@@ -6217,7 +6437,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] = {
@@ -6232,7 +6452,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] = {
@@ -6317,6 +6537,7 @@ var init_assemble = __esm({
     "use strict";
     init_snapshot();
     init_files();
+    init_trust2();
     init_drift();
     init_impact();
     init_lexical();
@@ -6340,7 +6561,7 @@ __export(observations_exports, {
   observeActivation: () => observeActivation,
   readObservation: () => readObservation
 });
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import { z as z23 } from "zod";
 function observationPath(directory, host, revision, version = executingVersion()) {
   return `${directory}/activation/${host}-${revision}-${hash(version).slice(0, 12)}.json`;
@@ -6357,15 +6578,15 @@ async function observeActivation(dir, event, options = {}) {
   if (host !== "codex" && host !== "claude" || !process.env.MASON_SETUP_ROOT) return null;
   try {
     if (!revision) {
-      if ((await loadSetup(process.env.MASON_SETUP_ROOT))?.hosts[host]) {
+      if ((await effectiveSetup(process.env.MASON_SETUP_ROOT)).setup?.hosts[host]) {
         return "Mason setup is now present. Restart the assistant to connect this MCP session to the configured integration; activation has not been established by this session.";
       }
       return inactiveSetupMessage();
     }
     const capturedDirectory = options.directory?.match(/^\.mason\/reports\/automation\/[a-f0-9]{24}$/)?.[0] ?? options.reportPath?.match(/^(\.mason\/reports\/automation\/[a-f0-9]{24})\/checks\//)?.[1];
-    const ws = capturedDirectory ? { root: await fs22.realpath(dir), directory: capturedDirectory } : await workspace(dir);
-    if (ws.root !== await fs22.realpath(process.env.MASON_SETUP_ROOT)) return null;
-    const setup = await loadSetup(ws.root);
+    const ws = capturedDirectory ? { root: await fs23.realpath(dir), directory: capturedDirectory } : await workspace(dir);
+    if (ws.root !== await fs23.realpath(process.env.MASON_SETUP_ROOT)) return null;
+    const { setup } = await effectiveSetup(ws.root);
     if (setup?.hosts[host]?.revision !== revision) return "Mason setup changed; restart the assistant to observe the current integration.";
     const directory = ws.directory + "/activation";
     await withLock(ws.root, directory, async () => {
@@ -6439,8 +6660,9 @@ __export(status_exports, {
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 async function setupStatus(dir) {
   const ws = await workspace(dir);
-  const setup = await loadSetup(ws.root);
-  if (!setup) {
+  const activation = await effectiveSetup(ws.root);
+  const setup = activation.setup;
+  if (!setup || !Object.keys(setup.hosts).length) {
     const partial = await Promise.all(["codex", "claude"].map(async (host) => ({
       host,
       receipt: await loadSetupReceipt(ws.root, ws.directory, host)
@@ -6474,7 +6696,7 @@ async function setupStatus(dir) {
     ]));
     const hooks = isDeepStrictEqual2(compatibleHooks, expectedHooks) && !config.disabled;
     const local = await loadSetupReceipt(ws.root, ws.directory, host);
-    const configured = local?.status === "configured" && local.root === ws.root && local.revision === entry.revision;
+    const configured = activation.root !== ws.root || local?.status === "configured" && local.root === ws.root && local.revision === entry.revision;
     const observation = await readObservation(ws.root, ws.directory, host, entry.revision, installed.version ?? "unavailable");
     const sessions = Object.values(observation?.sessions ?? {}).sort((a, b) => b.at.localeCompare(a.at));
     const complete = sessions.find((session) => events.every((event) => session.events.includes(event)));
@@ -6506,6 +6728,7 @@ async function setupStatus(dir) {
     status: statuses.length && statuses.every((status) => status === "active") ? "active" : statuses.includes("attention") ? "attention" : "pending",
     root: ws.root,
     hosts,
+    activationRoot: activation.root,
     decisionRecords: decisions.records.length,
     diagnostics: decisions.diagnostics,
     scope: "Activation receipts record observed use after setup, not complete interception, correct repairs, or measured usefulness. Host trust and higher-priority settings may prevent execution. Receipts are local to this worktree and branch."
@@ -6513,6 +6736,9 @@ async function setupStatus(dir) {
 }
 function summarizeActivation(status) {
   const lines = ["Mason setup: " + status.status + "."];
+  if (status.activationRoot && status.activationRoot !== status.root) {
+    lines.push("Activation inherited from " + status.activationRoot + "; evidence belongs to this worktree.");
+  }
   for (const [host, state] of Object.entries(status.hosts)) {
     lines.push(
       `${host}: ${state.status}`,
@@ -6682,8 +6908,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, path35, body) {
-    const res = await fetchFn(`${baseUrl}${path35}`, {
+  async function call(method, path42, body) {
+    const res = await fetchFn(`${baseUrl}${path42}`, {
       method,
       headers: {
         Authorization: auth,
@@ -6695,7 +6921,7 @@ function createConfluenceClient(config, fetchFn = fetch) {
     if (!res.ok) {
       const text2 = await res.text();
       throw new Error(
-        `Confluence ${method} ${path35} failed: ${res.status} ${res.statusText} \u2014 ${text2}`
+        `Confluence ${method} ${path42} failed: ${res.status} ${res.statusText} \u2014 ${text2}`
       );
     }
     if (res.status === 204) return null;
@@ -6796,28 +7022,28 @@ __export(config_exports2, {
   saveConfluenceConfig: () => saveConfluenceConfig,
   validateProvider: () => validateProvider
 });
-import fs23 from "fs/promises";
-import path32 from "path";
+import fs24 from "fs/promises";
+import path33 from "path";
 import os3 from "os";
 import { execFile as execFile9 } from "child_process";
 import { promisify as promisify9 } from "util";
 function configDir() {
-  return path32.join(os3.homedir(), ".mason");
+  return path33.join(os3.homedir(), ".mason");
 }
 function configFile() {
-  return path32.join(configDir(), "config.json");
+  return path33.join(configDir(), "config.json");
 }
 async function loadConfig() {
   try {
-    const raw = await fs23.readFile(configFile(), "utf-8");
+    const raw = await fs24.readFile(configFile(), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function saveConfig(config) {
-  await fs23.mkdir(configDir(), { recursive: true });
-  await fs23.writeFile(configFile(), JSON.stringify(config, null, 2), "utf-8");
+  await fs24.mkdir(configDir(), { recursive: true });
+  await fs24.writeFile(configFile(), JSON.stringify(config, null, 2), "utf-8");
 }
 function getDefaultModel(provider) {
   return DEFAULT_MODELS[provider];
@@ -6977,21 +7203,21 @@ var init_renderer = __esm({
 });
 
 // src/confluence/diff.ts
-import fs24 from "fs/promises";
-import path33 from "path";
-import { createHash as createHash5 } from "crypto";
+import fs25 from "fs/promises";
+import path34 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 path33.join(rootDir, ".mason");
+  return path34.join(rootDir, ".mason");
 }
 function syncStatePath(rootDir) {
-  return path33.join(syncStateDir(rootDir), "confluence-sync.json");
+  return path34.join(syncStateDir(rootDir), "confluence-sync.json");
 }
 async function loadSyncState(rootDir) {
   try {
-    const raw = await fs24.readFile(syncStatePath(rootDir), "utf-8");
+    const raw = await fs25.readFile(syncStatePath(rootDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 2) return null;
     return parsed;
@@ -7000,8 +7226,8 @@ async function loadSyncState(rootDir) {
   }
 }
 async function saveSyncState(rootDir, state) {
-  await fs24.mkdir(syncStateDir(rootDir), { recursive: true });
-  await fs24.writeFile(
+  await fs25.mkdir(syncStateDir(rootDir), { recursive: true });
+  await fs25.writeFile(
     syncStatePath(rootDir),
     JSON.stringify(state, null, 2),
     "utf-8"
@@ -7559,8 +7785,8 @@ import { z as z24 } from "zod";
 // src/mcp/tools.ts
 init_repair();
 init_advisory_review();
-import fs25 from "fs/promises";
-import path34 from "path";
+import fs26 from "fs/promises";
+import path35 from "path";
 import { execFile as execFile11 } from "child_process";
 import { promisify as promisify11 } from "util";
 
@@ -7569,11 +7795,11 @@ init_audit();
 init_types();
 init_repair();
 init_findings();
-import path23 from "path";
+import path24 from "path";
 
 // src/audit/advisory-cli.ts
 init_advisory_review();
-import path22 from "path";
+import path23 from "path";
 import { stripVTControlCharacters } from "util";
 
 // src/audit/cli.ts
@@ -7670,7 +7896,7 @@ import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
 
 // src/analyzers/base.ts
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 import fg6 from "fast-glob";
 var BaseAnalyzer = class {
   async findFiles(patterns, root) {
@@ -7681,7 +7907,7 @@ var BaseAnalyzer = class {
     });
   }
   async readFile(filePath) {
-    return fs15.readFile(filePath, "utf-8");
+    return fs16.readFile(filePath, "utf-8");
   }
   createFinding(partial) {
     return {
@@ -7886,7 +8112,7 @@ async function isGitRepo(dir) {
 
 // src/mcp/sampler.ts
 init_files();
-import path24 from "path";
+import path25 from "path";
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
 var exec2 = promisify4(execFile4);
@@ -7994,8 +8220,8 @@ async function sampleFiles(rootDir, maxFiles = 25) {
   const projectConfig = access.config;
   for (const filePath of projectConfig.alwaysInclude ?? []) {
     if (selected.size >= maxFiles) break;
-    const resolvedPath = path24.resolve(rootDir, filePath);
-    if (!resolvedPath.startsWith(path24.resolve(rootDir))) continue;
+    const resolvedPath = path25.resolve(rootDir, filePath);
+    if (!resolvedPath.startsWith(path25.resolve(rootDir))) continue;
     selected.set(filePath, "always-include (project config)");
   }
   let configCount = 0;
@@ -8061,7 +8287,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 = path24.extname(line).slice(1);
+      const ext = path25.extname(line).slice(1);
       if (!SOURCE_EXTENSIONS.includes(ext)) continue;
       fileCounts.set(line, (fileCounts.get(line) ?? 0) + 1);
     }
@@ -8207,8 +8433,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);
@@ -8314,7 +8540,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.
@@ -8411,9 +8639,10 @@ ${JSON.stringify({ partials }, null, 2)}`;
 }
 
 // src/snapshot/partials.ts
+init_lock();
 init_storage();
 init_snapshot();
-import fs16 from "fs/promises";
+import fs17 from "fs/promises";
 import { z as z11 } from "zod";
 var DIRECTORY = ".mason/partial-snapshots";
 var partialSchema = z11.object({
@@ -8426,12 +8655,12 @@ 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;
   try {
-    entries = await fs16.readdir(await storePath(rootDir, DIRECTORY));
+    entries = await fs17.readdir(await storePath(rootDir, DIRECTORY));
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -8446,17 +8675,19 @@ 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 fs17.rm(await storePath(rootDir, `${DIRECTORY}/scope.json`), { force: true });
+  });
 }
 async function clearAllPartials(rootDir) {
-  await fs16.rm(await storePath(rootDir, DIRECTORY), { recursive: true, force: true });
+  await fs17.rm(await storePath(rootDir, DIRECTORY), { recursive: true, force: true });
 }
 function batchIdFor(offset) {
   return `batch-${String(offset).padStart(6, "0")}`;
@@ -8473,7 +8704,7 @@ async function buildContext(dir) {
   };
 }
 async function analyzeProject(dir) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const context = await buildContext(rootDir);
   const results = await runAll(context);
   const projectSnapshot = await detectProjectSnapshot(rootDir);
@@ -8528,7 +8759,7 @@ async function detectProjectSnapshot(rootDir) {
   const present = [];
   for (const file of buildFiles) {
     try {
-      await fs25.access(path34.join(rootDir, file));
+      await fs26.access(path35.join(rootDir, file));
       present.push(file);
     } catch {
     }
@@ -8570,7 +8801,7 @@ async function detectProjectSnapshot(rootDir) {
   const sourceFiles = await access.list();
   const fileCounts = {};
   for (const file of sourceFiles) {
-    const ext = path34.extname(file).slice(1);
+    const ext = path35.extname(file).slice(1);
     fileCounts[ext] = (fileCounts[ext] ?? 0) + 1;
   }
   return {
@@ -8581,7 +8812,7 @@ async function detectProjectSnapshot(rootDir) {
   };
 }
 async function getCodeSamples(dir, count4 = 15) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.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.",
@@ -8624,7 +8855,7 @@ async function unmappedContextResponse(rootDir) {
   });
 }
 async function getProjectStructure(dir) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const allFiles = await (await createFileAccess(rootDir)).list("**/*");
   const dirInfo = /* @__PURE__ */ new Map();
   for (const file of allFiles) {
@@ -8636,7 +8867,7 @@ async function getProjectStructure(dir) {
       }
       const info = dirInfo.get(dirPath);
       info.fileCount++;
-      const ext = path34.extname(file).slice(1);
+      const ext = path35.extname(file).slice(1);
       if (ext) {
         info.extensions.set(ext, (info.extensions.get(ext) ?? 0) + 1);
       }
@@ -8681,7 +8912,7 @@ async function buildChangedFilePreviews(rootDir, changedFiles) {
   return previews2;
 }
 async function getSnapshot(dir) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const snapshot = await loadSnapshot(rootDir);
   if (!snapshot) {
     return unmappedContextResponse(rootDir);
@@ -8719,9 +8950,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;
@@ -8782,7 +9013,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 = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const report = await computeDrift(rootDir);
   if (!report) {
     return JSON.stringify({
@@ -8813,7 +9044,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 = path34.resolve(dir);
+  const rootDir = path35.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);
@@ -8860,7 +9091,7 @@ async function generateSnapshotBatch(dir, offset = 0, batchSize = DEFAULT_BATCH_
   );
 }
 async function saveSnapshotPartial(dir, batchId, offset, features, flows) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   for (const feat of Object.values(features)) {
     feat.files = sanitizePaths(rootDir, feat.files);
     if (feat.tests) feat.tests = sanitizePaths(rootDir, feat.tests);
@@ -8889,7 +9120,7 @@ async function saveSnapshotPartial(dir, batchId, offset, features, flows) {
   );
 }
 async function reduceSnapshot(dir) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const partials = await loadAllPartials(rootDir);
   if (partials.length === 0) {
     return JSON.stringify(
@@ -8951,7 +9182,7 @@ async function reduceSnapshot(dir) {
   );
 }
 async function fullAnalysis(dir) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const [analysis, structure, samples, testMap, snapshot] = await Promise.all([
     analyzeProject(dir),
     getProjectStructure(dir),
@@ -8980,100 +9211,94 @@ function sanitizePaths(rootDir, files) {
   return sanitizeRepoPaths(files);
 }
 async function saveSnapshotData(dir, features, flows, removeFeatures = [], removeFlows = []) {
-  const rootDir = path34.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 = path35.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 = path34.resolve(dir);
+  const rootDir = path35.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 = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const snapshot = await loadSnapshot(rootDir);
   if (!snapshot) {
     return JSON.stringify({
@@ -9107,25 +9332,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;
@@ -9134,58 +9347,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 = path34.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 = path35.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 = path34.resolve(dir);
+  const rootDir = path35.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(path34.resolve(dir), input));
+  return JSON.stringify(await reviewDecision(path35.resolve(dir), input));
 }
 async function getContext(dir, task, files) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const { assembleContext: assembleContext2 } = await Promise.resolve().then(() => (init_assemble(), assemble_exports));
   const bundle = await assembleContext2(rootDir, task, files);
   return JSON.stringify(bundle);
@@ -9234,7 +9483,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 = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const marker = await loadProjectMarker(rootDir);
   const { loadSetup: loadSetup2 } = await Promise.resolve().then(() => (init_model(), model_exports));
   const setup = await loadSetup2(rootDir);
@@ -9254,7 +9503,7 @@ async function masonInit(dir, options = {}) {
   );
 }
 async function masonCompleteInit(dir, options = {}) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.resolve(dir);
   const existing = await loadProjectMarker(rootDir);
   const features = await loadProjectFeatures(rootDir);
   const marker = {
@@ -9363,7 +9612,7 @@ async function masonSetConfluence(input) {
   );
 }
 async function exportToConfluenceTool(dir, overrides) {
-  const rootDir = path34.resolve(dir);
+  const rootDir = path35.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();
@@ -9402,10 +9651,10 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.17.4"
+      version: "0.19.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(
@@ -9527,7 +9776,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")
     },
@@ -9540,7 +9789,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"),
@@ -9716,7 +9965,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)")
@@ -9728,11 +9977,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")
         })
@@ -9781,14 +10032,592 @@ function createMcpServer() {
   );
   return server;
 }
-async function startMcpServer() {
+async function startMcpServer(onClose) {
   const server = createMcpServer();
+  if (onClose) server.server.onclose = onClose;
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
 
+// src/distribution/updates.ts
+init_store();
+init_storage();
+import fs33 from "fs/promises";
+import path41 from "path";
+import { spawn as spawn3 } from "child_process";
+import { randomUUID as randomUUID11 } from "crypto";
+import { z as z30 } from "zod";
+
+// src/distribution/state.ts
+init_storage();
+import os5 from "os";
+import path37 from "path";
+import { fileURLToPath } from "url";
+import fs28 from "fs/promises";
+import { z as z26 } from "zod";
+
+// src/distribution/path.ts
+import fs27 from "fs/promises";
+import os4 from "os";
+import path36 from "path";
+import { execFile as execFile12 } from "child_process";
+import { promisify as promisify12 } from "util";
+import { createHash as createHash7, randomUUID as randomUUID7 } from "crypto";
+import { z as z25 } from "zod";
+var execute2 = promisify12(execFile12);
+var pathChangeSchema = z25.discriminatedUnion("kind", [
+  z25.object({ kind: z25.literal("profile"), file: z25.string(), block: z25.string(), created: z25.boolean() }),
+  z25.object({ kind: z25.literal("windows"), entry: z25.string(), created: z25.boolean() })
+]);
+var quote = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
+async function configurePath(bin, previous, save, options = {}) {
+  const env = options.env ?? process.env, platform = options.platform ?? process.platform;
+  const changes = [...previous];
+  const currentPath = platform === "win32" ? Object.entries(env).find(([key]) => key.toLowerCase() === "path")?.[1] : env.PATH;
+  const alreadyOnPath = platform === "win32" ? hasWindowsEntry(currentPath ?? null, bin, env) : (currentPath ?? "").split(":").some((entry) => path36.posix.isAbsolute(entry) && path36.posix.resolve(entry) === path36.posix.resolve(bin));
+  const setupHint = "To connect a project, run one of these inside its directory:\n  Codex:       mason setup --host codex\n  Claude Code: mason setup --host claude";
+  const message2 = (alreadyOnPath ? "" : "Open a new terminal to use mason.\n") + setupHint;
+  const manual = (reason2) => ({ status: "manual", changes, message: `${reason2}
+${alreadyOnPath ? "" : `Add ${bin} to your PATH.
+`}${setupHint}` });
+  if (env.MASON_NO_MODIFY_PATH === "1") return manual("Automatic PATH setup is disabled (MASON_NO_MODIFY_PATH=1).");
+  if (/[\r\n\0]/.test(bin) || bin.includes(platform === "win32" ? ";" : ":")) return manual("This installation path cannot be represented safely in PATH.");
+  try {
+    if (platform === "win32") {
+      const current = await windowsPath("read");
+      if (!hasWindowsEntry(current.value, bin)) {
+        if (!changes.some((c) => c.kind === "windows" && c.entry === bin)) {
+          changes.push({ kind: "windows", entry: bin, created: current.value === null });
+          await save(changes);
+        }
+        await windowsPath("add", bin, current);
+      }
+      return { status: "configured", changes, message: message2 };
+    }
+    const shell = path36.basename(env.SHELL ?? os4.userInfo().shell ?? "");
+    const userHome = options.userHome ?? os4.homedir();
+    let profiles2;
+    if (!["bash", "zsh", "sh"].includes(shell)) return manual(`Automatic PATH setup is unavailable for ${shell || "an unknown shell"}.`);
+    if (env.MASON_PROFILE) profiles2 = [path36.resolve(env.MASON_PROFILE)];
+    else if (shell === "zsh") profiles2 = [path36.join(env.ZDOTDIR || userHome, ".zshrc")];
+    else if (shell === "sh") profiles2 = [path36.join(userHome, ".profile")];
+    else {
+      const candidates = [".bash_profile", ".bash_login", ".profile"].map((name) => path36.join(userHome, name));
+      let login = candidates[2];
+      for (const file of candidates) if (await fs27.lstat(file).then(() => true, (error) => {
+        if (error.code === "ENOENT") return false;
+        throw error;
+      })) {
+        login = file;
+        break;
+      }
+      profiles2 = [path36.join(userHome, ".bashrc"), login];
+    }
+    const marker = `# >>> mason PATH ${createHash7("sha256").update(bin).digest("hex").slice(0, 12)} >>>`;
+    for (const profile of profiles2) {
+      const stat = await fs27.lstat(profile).catch((error) => {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      });
+      const file = stat?.isSymbolicLink() ? await fs27.realpath(profile) : path36.resolve(profile);
+      const original = await fs27.readFile(file).catch((error) => {
+        if (error.code === "ENOENT" && !stat) return null;
+        throw error;
+      });
+      if (original && !Buffer.from(original.toString("utf8")).equals(original)) return manual(`Shell profile is not UTF-8: ${profile}.`);
+      const text2 = original?.toString("utf8") ?? "";
+      const owned = changes.find((c) => c.kind === "profile" && c.file === file);
+      if (owned && text2.includes(owned.block)) continue;
+      if (text2.includes(marker) || owned && text2.includes("# <<< mason PATH")) return manual(`Mason's PATH block was edited; retained ${profile}.`);
+      const newline = text2.includes("\r\n") ? "\r\n" : "\n";
+      const block = owned?.block ?? ("\n" + marker + '\ncase ":${PATH-}:" in\n  *:' + quote(bin) + ":*) ;;\n  *) export PATH=" + quote(bin) + ':"${PATH-}" ;;\nesac\n# <<< mason PATH <<<\n').replaceAll("\n", newline);
+      if (!owned) {
+        changes.push({ kind: "profile", file, block, created: original === null });
+        await save(changes);
+      }
+      await fs27.mkdir(path36.dirname(file), { recursive: true });
+      const handle = await fs27.open(file, original === null ? "ax+" : "a+", 384);
+      try {
+        if (!(await handle.readFile()).equals(original ?? Buffer.alloc(0))) throw new Error(`Shell profile changed during installation: ${profile}`);
+        await handle.writeFile(block);
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+    }
+    return { status: "configured", changes, message: message2 };
+  } catch (error) {
+    return manual(`Could not configure PATH: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+var normalizeWindowsEntry = (value) => path36.win32.normalize(value.trim().replace(/^"(.*)"$/, "$1")).replace(/[\\/]+$/, "").toLowerCase();
+var hasWindowsEntry = (value, entry, env = process.env) => {
+  const variables = new Map(Object.entries(env).map(([key, value2]) => [key.toLowerCase(), value2]));
+  const expand = (part) => part.replace(/%([^%]+)%/g, (match, key) => variables.get(key.toLowerCase()) ?? match);
+  return (value ?? "").split(";").some((part) => normalizeWindowsEntry(expand(part)) === normalizeWindowsEntry(entry));
+};
+async function windowsPath(action, entry = "", expected, removeEmpty = false) {
+  const payload = Buffer.from(JSON.stringify({ action, entry, expected, removeEmpty })).toString("base64");
+  const script = `$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = New-Object Text.UTF8Encoding($false)
+$p = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${payload}')) | ConvertFrom-Json
+$key = [Microsoft.Win32.Registry]::CurrentUser.CreateSubKey('Environment')
+try {
+  $value = $key.GetValue('Path', $null, [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)
+  $kind = if ($null -eq $value) { $null } else { $key.GetValueKind('Path').ToString() }
+  if ($null -ne $kind -and $kind -notin @('String','ExpandString')) { throw 'User PATH is not a string.' }
+  if ($p.action -eq 'read') { @{ value = $value; kind = $kind } | ConvertTo-Json -Compress; exit 0 }
+  if ($p.expected -and ($value -cne $p.expected.value -or $kind -cne $p.expected.kind)) { throw 'User PATH changed concurrently; retry the operation.' }
+  $parts = if ($null -eq $value -or $value -eq '') { @() } else { @($value.Split(';')) }
+  if ($p.action -eq 'add') { $next = (@($p.entry) + $parts) -join ';' }
+  else { $next = (@($parts | Where-Object { $_ -cne $p.entry })) -join ';' }
+  if ($next -cne $value) {
+    $writeKind = if ($kind) { [Microsoft.Win32.RegistryValueKind]$kind } else { [Microsoft.Win32.RegistryValueKind]::ExpandString }
+    if ($p.action -eq 'remove' -and $p.removeEmpty -and $next -eq '') { $key.DeleteValue('Path', $false) }
+    else { $key.SetValue('Path', $next, $writeKind) }
+    Add-Type -TypeDefinition 'using System; using System.Runtime.InteropServices; public class MasonEnvironment { [DllImport("user32.dll", CharSet=CharSet.Unicode, SetLastError=true)] public static extern IntPtr SendMessageTimeout(IntPtr h, uint m, UIntPtr w, string l, uint f, uint t, out UIntPtr r); }'
+    $result = [UIntPtr]::Zero
+    [void][MasonEnvironment]::SendMessageTimeout([IntPtr]0xffff, 0x1a, [UIntPtr]::Zero, 'Environment', 2, 1000, [ref]$result)
+  }
+  @{ value = $next; kind = $kind } | ConvertTo-Json -Compress
+} finally { $key.Dispose() }
+`;
+  const { stdout } = await execute2("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64")], { windowsHide: true, timeout: 15e3, maxBuffer: 1024 * 1024 });
+  return JSON.parse(stdout.replace(/^\uFEFF/, "").trim());
+}
+
+// src/distribution/state.ts
+var releaseVersion = z26.string().regex(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/);
+var bundleId = z26.string().regex(/^[a-f0-9]{24}$/);
+var updatePolicySchema = z26.object({
+  enabled: z26.boolean(),
+  revision: z26.string(),
+  pinnedVersion: releaseVersion.optional(),
+  mirror: z26.string().optional()
+});
+var recordSchema3 = z26.object({
+  format: z26.literal(1),
+  home: z26.string(),
+  bin: z26.string(),
+  current: bundleId,
+  version: releaseVersion,
+  launchers: z26.record(z26.string()),
+  previousLaunchers: z26.record(z26.string()).optional(),
+  pathChanges: z26.array(pathChangeSchema).optional(),
+  updates: updatePolicySchema.optional(),
+  previous: z26.object({ id: bundleId, version: releaseVersion }).optional(),
+  pending: z26.object({ id: bundleId, version: releaseVersion, policyRevision: z26.string() }).optional()
+});
+async function readInstallation(home) {
+  const raw = await readStoreJson(home, "install.json");
+  if (!raw) throw new Error("Run this command from a standalone installation. npm users can upgrade with npm.");
+  const record = recordSchema3.parse(raw);
+  if (record.home !== await fs28.realpath(home)) throw new Error("Invalid standalone installation receipt.");
+  return record;
+}
+function standaloneLocation() {
+  const bundle = path37.resolve(path37.dirname(fileURLToPath(import.meta.url)), "../..");
+  const home = path37.dirname(path37.dirname(bundle));
+  if (path37.dirname(bundle) !== path37.join(home, "versions") || !/^[a-f0-9]{24}$/.test(path37.basename(bundle))) {
+    return null;
+  }
+  return { home, bundle };
+}
+async function currentInstallation() {
+  const location2 = standaloneLocation();
+  if (!location2) throw new Error("Run this command from a standalone installation. npm users can upgrade with npm.");
+  const { home, bundle } = location2;
+  const record = await readInstallation(home);
+  return { home, bundle, record };
+}
+function automaticUpdatesAllowed(record, env = process.env) {
+  return record.updates?.enabled === true && !record.updates.pinnedVersion && !record.updates.mirror && !env.CI && env.MASON_NO_AUTO_UPDATE !== "1" && !env.MASON_RELEASE_BASE && !env.MASON_VERSION;
+}
+function newerStableVersion(candidate, installed) {
+  if (!/^\d+\.\d+\.\d+$/.test(candidate)) return false;
+  const a = candidate.split(".").map(BigInt), b = installed.split("-")[0].split(".").map(BigInt);
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] > b[i];
+  }
+  return installed.includes("-");
+}
+
+// src/distribution/bundle.ts
+init_storage();
+import fs29 from "fs/promises";
+import path38 from "path";
+import { createHash as createHash8 } from "crypto";
+import { z as z27 } from "zod";
+var targets = ["darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "win32-arm64", "win32-x64"];
+var digest2 = z27.string().regex(/^[a-f0-9]{64}$/);
+var bundleSchema = z27.object({
+  format: z27.literal(1),
+  version: z27.string().regex(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/),
+  target: z27.enum(targets),
+  nodeVersion: z27.string(),
+  files: z27.record(digest2)
+}).strict();
+var sha256 = (bytes) => createHash8("sha256").update(bytes).digest("hex");
+async function readBundle(root) {
+  const bytes = await fs29.readFile(await storePath(root, "bundle.json"));
+  const manifest = bundleSchema.parse(JSON.parse(bytes.toString("utf8")));
+  const windows = manifest.target.startsWith("win32-");
+  for (const file of Object.keys(manifest.files)) {
+    if (file.includes("\\") || file.split("/").some((p) => !p || p === "." || p === "..") || path38.isAbsolute(file)) {
+      throw new Error("Unsafe path in Mason bundle: " + file);
+    }
+  }
+  for (const required of [windows ? "node.exe" : "node", "app/package.json", "app/dist/mason.js", "app/dist/mason-auto.js", "app/dist/mason-mcp.js"]) {
+    if (!manifest.files[required]) throw new Error("Incomplete Mason bundle: " + required);
+  }
+  return { manifest, manifestHash: sha256(bytes) };
+}
+async function verifyBundle(root, expectedHash) {
+  const bundle = await readBundle(root);
+  if (expectedHash && bundle.manifestHash !== expectedHash) throw new Error("Mason bundle manifest changed.");
+  if (bundle.manifest.target !== `${process.platform}-${process.arch}`) throw new Error("Mason bundle is for another platform. Install this platform's bundle and rerun setup.");
+  const files = Object.keys(bundle.manifest.files);
+  for (let i = 0; i < files.length; i += 8) await Promise.all(files.slice(i, i + 8).map(async (file) => {
+    if (sha256(await fs29.readFile(await storePath(root, file))) !== bundle.manifest.files[file]) throw new Error("Mason bundle checksum mismatch: " + file);
+  }));
+  return bundle;
+}
+
+// src/distribution/runtime.ts
+init_store();
+init_storage();
+import fs30 from "fs/promises";
+import { unlinkSync } from "fs";
+import os6 from "os";
+import path39 from "path";
+import { randomUUID as randomUUID8 } from "crypto";
+import { z as z28 } from "zod";
+var leaseSchema = z28.object({ pid: z28.number().int().positive(), host: z28.string(), bundle: z28.string().regex(/^[a-f0-9]{24}$/) });
+
+// src/distribution/install.ts
+import fs32 from "fs/promises";
+import os8 from "os";
+import path40 from "path";
+import { execFile as execFile13, spawn as spawn2 } from "child_process";
+import { promisify as promisify13 } from "util";
+import { randomUUID as randomUUID10 } from "crypto";
+init_storage();
+init_store();
+
+// src/distribution/sessions.ts
+init_storage();
+import fs31 from "fs/promises";
+import os7 from "os";
+import { randomUUID as randomUUID9 } from "crypto";
+import { z as z29 } from "zod";
+var leaseSchema2 = z29.object({ pid: z29.number().int().positive(), host: z29.string() });
+async function hasRunningMcp(home) {
+  const directory = await storePath(home, "sessions");
+  const files = await fs31.readdir(directory).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  });
+  for (const name of files) {
+    if (!/^[a-f0-9-]+\.json$/.test(name)) return true;
+    const relative = "sessions/" + name;
+    try {
+      const raw = await readStoreJson(home, relative);
+      if (raw === null) continue;
+      const lease = leaseSchema2.parse(raw);
+      if (lease.host !== os7.hostname()) return true;
+      try {
+        process.kill(lease.pid, 0);
+        return true;
+      } catch (error) {
+        if (error.code !== "ESRCH") return true;
+      }
+      await fs31.rm(await storePath(home, relative), { force: true });
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+async function registerMcp(home) {
+  const name = `sessions/${randomUUID9()}.json`;
+  await writeStoreJson(home, name, { pid: process.pid, host: os7.hostname() });
+  return async () => {
+    await fs31.rm(await storePath(home, name), { force: true }).catch(() => {
+    });
+  };
+}
+
+// src/distribution/install.ts
+var shQuote = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
+var psQuote = (s) => "'" + s.replace(/'/g, "''") + "'";
+var WINDOWS_BATCH_LAUNCHER = '@echo off\r\ngoto #_mason_handoff_# 2>NUL || title %COMSPEC% & powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "%~dp0mason-launcher.ps1" %*\r\n';
+var launcherNames = ["mason", "mason.cmd", "mason.ps1", "mason-launcher.ps1"];
+async function replace(file, content2, mode = 384) {
+  const temp = file + ".tmp-" + randomUUID10();
+  try {
+    await fs32.writeFile(temp, content2, { mode, flag: "wx" });
+    await fs32.rename(temp, file);
+  } finally {
+    await fs32.rm(temp, { force: true });
+  }
+}
+function assertUpdatePolicy(record, version, revision) {
+  if (!record || !automaticUpdatesAllowed(record, { ...process.env, MASON_VERSION: "" }) || record.updates?.revision !== revision || !newerStableVersion(version, record.version)) {
+    throw new Error("Update policy or installed version changed; download was not activated.");
+  }
+}
+async function installLocked2(home, source, bundle, progress, options, alreadyStaged = false) {
+  const raw = await readStoreJson(home, "install.json");
+  const previous = raw === null ? null : recordSchema3.parse(raw);
+  if (options.stageOnly) assertUpdatePolicy(previous, bundle.manifest.version, options.policyRevision);
+  if (!previous) for (const file of await fs32.readdir(home)) {
+    if (file === ".install-lock") continue;
+    const directory = path40.join(home, file);
+    const stat = await fs32.lstat(directory);
+    if (!["versions", "bin"].includes(file) || !stat.isDirectory() || (await fs32.readdir(directory)).length) {
+      throw new Error("Mason installation directory is not empty and has no ownership receipt.");
+    }
+  }
+  const selectedBin = path40.resolve(process.env.MASON_BIN_DIR ?? previous?.bin ?? (process.platform === "win32" ? path40.join(home, "bin") : path40.join(os8.homedir(), ".local/bin")));
+  await fs32.mkdir(selectedBin, { recursive: true });
+  const bin = await fs32.realpath(selectedBin);
+  if (previous && (previous.home !== home || previous.bin !== bin)) throw new Error("Installation paths differ from the existing Mason receipt.");
+  const id = bundle.manifestHash.slice(0, 24);
+  const destination = await storePath(home, "versions/" + id);
+  if (options.stageOnly) {
+    const receipt2 = { ...previous, pending: { id, version: bundle.manifest.version, policyRevision: options.policyRevision } };
+    await writeStoreJson(home, "install.json", receipt2);
+    return { home, bin, version: bundle.manifest.version, previousVersion: previous.version, path: { message: "Update staged for a future MCP launch." } };
+  }
+  const launchers = process.platform === "win32" ? {
+    "mason.cmd": WINDOWS_BATCH_LAUNCHER,
+    "mason-launcher.ps1": `$ErrorActionPreference = 'Stop'
+$previousToken = $env:MASON_UNINSTALL_TOKEN
+$token = [Guid]::NewGuid().ToString()
+$env:MASON_UNINSTALL_TOKEN = $token
+try {
+  & ${psQuote(path40.join(destination, "node.exe"))} ${psQuote(path40.join(destination, "app/dist/mason.js"))} @args
+  $code = $LASTEXITCODE
+  if ($code -eq 0 -and $args.Count -eq 1 -and $args[0] -eq 'uninstall') {
+    if ([IO.File]::ReadAllText(${psQuote(path40.join(home, ".uninstall-request.txt"))}) -cne $token) { throw 'Mason did not authorize installation cleanup.' }
+    Remove-Item -LiteralPath ${psQuote(home)} -Recurse -Force
+    Write-Output ${psQuote("Removed standalone installation: " + home)}
+  }
+  exit $code
+} catch { [Console]::Error.WriteLine($_.Exception.Message); exit 2 }
+finally { $env:MASON_UNINSTALL_TOKEN = $previousToken }
+`
+  } : { mason: `#!/bin/sh
+exec ${shQuote(path40.join(destination, "node"))} ${shQuote(path40.join(destination, "app/dist/mason.js"))} "$@"
+` };
+  for (const [name, content2] of Object.entries(launchers)) {
+    const file = await storePath(bin, name);
+    const old = await fs32.readFile(file, "utf8").catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (old !== null && old !== previous?.launchers[name] && old !== previous?.previousLaunchers?.[name] && old !== content2) throw new Error("Refusing to replace an unrelated or edited launcher: " + file);
+  }
+  const retired = Object.entries({ ...previous?.previousLaunchers, ...previous?.launchers }).filter(([name]) => !(name in launchers));
+  const checkRetired = async (name, expected) => {
+    if (!launcherNames.includes(name)) throw new Error("Invalid owned launcher name.");
+    const actual = await fs32.readFile(await storePath(bin, name), "utf8").catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (actual !== null && actual !== expected) throw new Error("Retired launcher was edited; retained: " + name);
+  };
+  for (const [name, expected] of retired) await checkRetired(name, expected);
+  progress?.step(`Installing Mason ${bundle.manifest.version}`);
+  const updates = options.preservePolicy && previous?.updates ? { ...previous.updates } : {
+    ...previous?.updates ?? { enabled: !previous && !process.env.CI && process.env.MASON_NO_AUTO_UPDATE !== "1" },
+    revision: randomUUID10(),
+    pinnedVersion: process.env.MASON_VERSION?.replace(/^v/, "") || void 0,
+    mirror: process.env.MASON_RELEASE_BASE || previous?.updates?.mirror
+  };
+  if (options.rollback) {
+    updates.pinnedVersion = bundle.manifest.version;
+    updates.revision = randomUUID10();
+  }
+  const receipt = {
+    format: 1,
+    home,
+    bin,
+    current: id,
+    version: bundle.manifest.version,
+    launchers,
+    pathChanges: previous?.pathChanges ?? [],
+    updates,
+    previous: previous && previous.current !== id ? { id: previous.current, version: previous.version } : previous?.previous
+  };
+  await writeStoreJson(home, "install.json", previous ? { ...previous, previousLaunchers: launchers } : receipt);
+  try {
+    if (!alreadyStaged) await copyBundle(home, source, destination, bundle);
+    for (const [name, content2] of Object.entries(launchers)) await replace(await storePath(bin, name, true), content2, 493);
+    for (const [name, expected] of retired) {
+      await checkRetired(name, expected);
+      await fs32.rm(await storePath(bin, name), { force: true });
+    }
+    await writeStoreJson(home, "install.json", receipt);
+  } catch (error) {
+    if (previous) {
+      for (const [name, content2] of Object.entries(previous.launchers)) await replace(await storePath(bin, name, true), content2, 493);
+      await writeStoreJson(home, "install.json", previous);
+    }
+    throw error;
+  }
+  if (options.preservePolicy) return { home, bin, version: receipt.version, previousVersion: previous?.version, path: { message: "Installation selected." } };
+  progress?.step("Checking terminal command availability");
+  const pathResult = await configurePath(bin, receipt.pathChanges ?? [], async (changes) => {
+    receipt.pathChanges = changes;
+    await writeStoreJson(home, "install.json", receipt);
+  });
+  return { home, bin, version: bundle.manifest.version, previousVersion: previous?.version, path: pathResult };
+}
+async function copyBundle(home, source, destination, bundle) {
+  const exists = await fs32.lstat(destination).then(() => true, (error) => {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  });
+  if (exists) {
+    await verifyBundle(destination, bundle.manifestHash);
+    return;
+  }
+  const stage = await storePath(home, "versions/.install-" + randomUUID10(), true);
+  await fs32.mkdir(stage);
+  try {
+    for (const file of ["bundle.json", ...Object.keys(bundle.manifest.files)]) {
+      const from = await storePath(source, file), to = await storePath(stage, file, true);
+      await fs32.copyFile(from, to);
+      await fs32.chmod(to, (await fs32.stat(from)).mode & 511);
+    }
+    await verifyBundle(stage, bundle.manifestHash);
+    try {
+      await fs32.rename(stage, destination);
+    } catch (error) {
+      try {
+        await verifyBundle(destination, bundle.manifestHash);
+      } catch {
+        throw error;
+      }
+    }
+  } finally {
+    await fs32.rm(stage, { recursive: true, force: true });
+  }
+}
+async function prepareStandaloneMcp(home) {
+  const before = await readInstallation(home), candidate = before.pending;
+  let verified, verificationError;
+  if (candidate && automaticUpdatesAllowed(before) && !await hasRunningMcp(home)) {
+    try {
+      verified = await verifyBundle(await storePath(home, "versions/" + candidate.id));
+      if (verified.manifestHash.slice(0, 24) !== candidate.id || verified.manifest.version !== candidate.version) throw new Error("Staged update changed.");
+    } catch (error) {
+      verificationError = error;
+    }
+  }
+  return withLock(home, ".install-lock", async () => {
+    let record = await readInstallation(home);
+    const pending = record.pending;
+    if (pending && candidate?.id === pending.id && (verified || verificationError) && automaticUpdatesAllowed(record) && pending.policyRevision === record.updates?.revision && newerStableVersion(pending.version, record.version) && !await hasRunningMcp(home)) {
+      try {
+        if (verificationError) throw verificationError;
+        const source = await storePath(home, "versions/" + pending.id);
+        await installLocked2(home, source, verified, void 0, { preservePolicy: true }, true);
+        record = await readInstallation(home);
+      } catch (error) {
+        record = await readInstallation(home);
+        delete record.pending;
+        await writeStoreJson(home, "install.json", record);
+        await writeStoreJson(home, "update-status.json", { lastAttempt: Date.now(), error: String(error) });
+      }
+    }
+    const release = await registerMcp(home);
+    return { bundle: await storePath(home, "versions/" + record.current), release };
+  });
+}
+
+// src/distribution/updates.ts
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var RELEASE_AGE_MS = 24 * 60 * 60 * 1e3;
+var releaseListSchema = z30.array(z30.object({ tag_name: z30.string(), draft: z30.boolean(), prerelease: z30.boolean(), published_at: z30.string().nullable() }));
+var updateManifestSchema = z30.object({
+  format: z30.literal(1),
+  version: z30.string().regex(/^\d+\.\d+\.\d+$/),
+  publishedAt: z30.string().datetime(),
+  assets: z30.record(z30.string().regex(/^[a-f0-9]{64}$/))
+}).strict();
+var statusSchema2 = z30.object({ lastAttempt: z30.number(), availableVersion: z30.string().optional(), error: z30.string().optional() });
+async function scheduleAutomaticUpdate() {
+  try {
+    const { home, record } = await currentInstallation();
+    if (!automaticUpdatesAllowed(record)) return;
+    const status = statusSchema2.safeParse(await readStoreJson(home, "update-status.json"));
+    const now = Date.now();
+    if (status.success && status.data.lastAttempt <= now && now - status.data.lastAttempt < CHECK_INTERVAL_MS) return;
+    const bundle = await storePath(home, "versions/" + record.current);
+    const child = spawn3(
+      path41.join(bundle, process.platform === "win32" ? "node.exe" : "node"),
+      [path41.join(bundle, "app/dist/mason.js"), "internal-update"],
+      { cwd: home, env: process.env, stdio: "ignore", detached: true, windowsHide: true }
+    );
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function startMcpWithUpdates(start) {
+  const current = standaloneLocation();
+  if (!current) {
+    await start();
+    return;
+  }
+  const session = await prepareStandaloneMcp(current.home);
+  if (session.bundle !== current.bundle) {
+    const child = spawn3(
+      path41.join(session.bundle, process.platform === "win32" ? "node.exe" : "node"),
+      [path41.join(session.bundle, "app/dist/mason-mcp.js"), ...process.argv.slice(2)],
+      { stdio: "inherit", windowsHide: true }
+    );
+    const interrupt = () => {
+      child.kill("SIGINT");
+    }, terminate = () => {
+      child.kill("SIGTERM");
+    };
+    process.on("SIGINT", interrupt);
+    process.on("SIGTERM", terminate);
+    try {
+      process.exitCode = await new Promise((resolve2, reject) => {
+        child.on("error", reject);
+        child.on("exit", (code) => resolve2(code ?? 1));
+      });
+    } finally {
+      process.off("SIGINT", interrupt);
+      process.off("SIGTERM", terminate);
+      await session.release();
+    }
+    return;
+  }
+  const timer = setInterval(() => {
+    void scheduleAutomaticUpdate();
+  }, 60 * 60 * 1e3);
+  timer.unref();
+  const stop = () => {
+    clearInterval(timer);
+    void session?.release();
+  };
+  try {
+    await start(stop);
+    void scheduleAutomaticUpdate();
+  } catch (error) {
+    stop();
+    throw error;
+  }
+}
+
 // bin/mason-mcp.ts
-startMcpServer().catch((err) => {
+startMcpWithUpdates(startMcpServer).catch((err) => {
   process.stderr.write(`Mason MCP server error: ${err}
 `);
   process.exit(1);