mason-context 0.22.0 → 0.23.1

package/dist/mason-mcp.js

@@ -483,11 +483,12 @@ async function storePath(root, relative, createParents = false) {
   }
   return current;
 }
-async function readStoreJson(root, relative) {
+async function readStoreJson(root, relative, maxBytes = STORE_MAX_BYTES) {
   try {
     const file = await storePath(root, relative);
-    const raw = await readBoundedFile(file, 10 * 1024 * 1024);
-    if (raw === null) throw new Error("file is not regular or exceeds 10 MiB");
+    const raw = await readBoundedFile(file, maxBytes);
+    if (raw === null)
+      throw new Error(`file is not regular or exceeds ${maxBytes / 1024 / 1024} MiB`);
     const parsed = JSON.parse(raw);
     if (parsed === null) throw new Error("expected a JSON object, received null");
     return parsed;
@@ -499,9 +500,9 @@ async function readStoreJson(root, relative) {
     );
   }
 }
-async function writeStoreJson(root, relative, value) {
-  const payload = JSON.stringify(value, null, 2) + "\n";
-  if (Buffer.byteLength(payload) > 10 * 1024 * 1024) {
+async function writeStoreJson(root, relative, value, options = {}) {
+  const payload = JSON.stringify(value, null, options.compact ? void 0 : 2) + "\n";
+  if (Buffer.byteLength(payload) > STORE_MAX_BYTES) {
     throw new Error(`Mason store ${relative} exceeds 10 MiB`);
   }
   const file = await storePath(root, relative, true);
@@ -519,11 +520,13 @@ async function writeStoreJson(root, relative, value) {
     await fs2.rm(temporary, { force: true });
   }
 }
+var STORE_MAX_BYTES;
 var init_storage = __esm({
   "src/utils/storage.ts"() {
     "use strict";
     init_paths();
     init_files();
+    STORE_MAX_BYTES = 10 * 1024 * 1024;
   }
 });
 
@@ -544,7 +547,12 @@ async function captureAnchorScopes(root, scopes2) {
     );
     const inventory = access.inventory();
     if (!inventory) throw new Error("Git anchor inventory unavailable");
-    const ignored = await inspectionGit(
+    const visible = indexMatchingPaths(
+      union.map((anchor) => [anchor]),
+      inventory
+    );
+    const hidden = new Set(union.filter((_, index2) => !visible[index2].length));
+    const ignored = hidden.size ? (await inspectionGit(
       [
         "ls-files",
         "-z",
@@ -552,13 +560,11 @@ async function captureAnchorScopes(root, scopes2) {
         "--ignored",
         "--exclude-standard",
         "--",
-        ...union.map((anchor) => `:(literal)${anchor}`)
+        ...[...hidden].map((anchor) => `:(literal)${anchor}`)
       ],
       { cwd: root, maxBuffer: 8 * 1024 * 1024 }
-    );
-    const files = [
-      .../* @__PURE__ */ new Set([...inventory, ...ignored.stdout.split("\0").filter(Boolean)])
-    ].sort();
+    )).stdout.split("\0").filter(Boolean) : [];
+    const files = [.../* @__PURE__ */ new Set([...inventory, ...ignored])].sort();
     const patterns = await Promise.all(
       union.map(async (anchor) => {
         const literal2 = fg3.escapePath(anchor);
@@ -574,7 +580,7 @@ async function captureAnchorScopes(root, scopes2) {
     const filesByScope = new Map(
       scopes2.map((scope, index2) => [JSON.stringify([...new Set(scope)].sort()), indexed[index2]])
     );
-    return { filesByScope, eligible };
+    return { filesByScope, eligible, hidden, ignored: new Set(ignored) };
   };
   return Promise.all(
     scopes2.map((scope) => {
@@ -586,8 +592,10 @@ async function captureAnchorScopes(root, scopes2) {
           const capture = { anchors, files: {}, complete: true };
           if (!anchors.length) return capture;
           try {
-            const { eligible, filesByScope } = await (context ??= prepareContext());
-            const files = filesByScope.get(JSON.stringify(anchors));
+            const { eligible, filesByScope, hidden, ignored } = await (context ??= prepareContext());
+            const files = filesByScope.get(JSON.stringify(anchors)).filter(
+              (file) => !ignored.has(file) || anchors.some((anchor) => hidden.has(anchor) && anchorMatches(anchor, file))
+            );
             if (files.length > 2e3) return { ...capture, complete: false };
             for (const file of files) {
               const evidence = await inspectionRead(
@@ -3626,6 +3634,195 @@ var init_deps_changed = __esm({
   }
 });
 
+// src/decisions/excerpts.ts
+import { createHash as createHash4 } from "crypto";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+function driftBaseline(record) {
+  const effective = effectiveDecision(record);
+  const inspection = latestDecisionInspection(
+    record,
+    decisionApproval(effective) === "accepted" ? "operative" : "all"
+  );
+  return {
+    record: effective,
+    capture: inspection?.capture ?? (effective.version === 2 ? effective.capture : void 0),
+    commits: [inspection?.headHash, effective.refreshedHash].filter(
+      (hash2) => !!hash2 && /^[a-f0-9]{40,64}$/.test(hash2)
+    )
+  };
+}
+async function capturedCommit(root, file, hash2, preferred) {
+  if (/[\n\r]/.test(file)) return null;
+  const { stdout } = await exec(
+    "git",
+    ["--literal-pathspecs", "log", "-n", String(HISTORY_DEPTH), "--format=%H", "--", file],
+    { cwd: root, maxBuffer: 1024 * 1024 }
+  );
+  const commits = [.../* @__PURE__ */ new Set([...preferred, ...stdout.split("\n").filter(Boolean)])];
+  const batch = exec("git", ["cat-file", "--batch"], {
+    cwd: root,
+    encoding: "buffer",
+    maxBuffer: 64 * 1024 * 1024
+  });
+  batch.child.stdin.end(commits.map((commit) => `${commit}:${file}
+`).join(""));
+  const output = (await batch).stdout;
+  let position = 0;
+  for (const commit of commits) {
+    const end = output.indexOf(10, position);
+    if (end < 0) break;
+    const header = output.subarray(position, end).toString("utf8").split(" ");
+    position = end + 1;
+    if (header[1] !== "blob") continue;
+    const size = Number(header[2]);
+    const bytes = output.subarray(position, position + size);
+    position += size + 1;
+    if (createHash4("sha256").update(bytes).digest("hex") === hash2) return commit;
+  }
+  return null;
+}
+function namedIdentifiers(text2) {
+  const names = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    if (name.length >= 3) names.add(name);
+  };
+  for (const [, span] of text2.matchAll(/`([^`]+)`/g))
+    for (const [name] of span.matchAll(/[A-Za-z_$][\w$]*(?:-[A-Za-z0-9_$]+)*/g)) add(name);
+  for (const [, name] of text2.matchAll(/([A-Za-z_$][\w$]*)\(/g)) add(name);
+  for (const [name] of text2.matchAll(/[A-Za-z_$][\w$]*/g))
+    if (/[a-z][A-Z]|[_$]/.test(name)) add(name);
+  return [...names];
+}
+function codeTokens(code) {
+  const tokens2 = /* @__PURE__ */ new Set();
+  for (const [name] of code.matchAll(/[A-Za-z_$][\w$]*/g)) {
+    tokens2.add(name.toLowerCase());
+    for (const part of name.split(/_+|(?<=[a-z0-9])(?=[A-Z])/))
+      if (part.length >= 3) tokens2.add(part.toLowerCase());
+  }
+  return tokens2;
+}
+function parseHunks(diff) {
+  const hunks = [];
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("@@")) hunks.push({ header: line, lines: [] });
+    else if (hunks.length && /^[+-]/.test(line)) hunks.at(-1).lines.push(line);
+  }
+  return hunks;
+}
+async function driftExcerpt(root, record, changedFiles) {
+  const baseline = driftBaseline(record);
+  const excerpt = { mentions: [], relevance: "unknown", files: [], omittedFiles: [] };
+  const named = namedIdentifiers(`${baseline.record.title}
+${baseline.record.body}`);
+  const found = /* @__PURE__ */ new Set();
+  let complete = !!baseline.capture && changedFiles.length <= MAX_DIFFED_FILES;
+  const access = await createFileAccess(root);
+  for (const [index2, file] of changedFiles.slice(0, MAX_DIFFED_FILES).entries()) {
+    let hunks = null;
+    let unavailable;
+    const captured = baseline.capture?.files[file];
+    try {
+      if (!baseline.capture?.anchors.some((anchor) => anchorMatches(anchor, file))) {
+        unavailable = "not in the captured anchor scope";
+      } else if (captured === void 0) {
+        const source = await access.read(file);
+        if (source)
+          hunks = [
+            {
+              header: "(added since capture)",
+              lines: source.content.replace(/\r?\n$/, "").split("\n").map((line) => "+" + line)
+            }
+          ];
+        else unavailable = "added since capture but unreadable";
+      } else {
+        const commit = await capturedCommit(root, file, captured, baseline.commits);
+        if (!commit) unavailable = "captured content is not in recent Git history";
+        else {
+          const { stdout } = await exec(
+            "git",
+            [
+              "--literal-pathspecs",
+              "diff",
+              "--no-ext-diff",
+              "--no-textconv",
+              "--no-color",
+              "--no-renames",
+              "-U0",
+              commit,
+              "--",
+              file
+            ],
+            { cwd: root, maxBuffer: 1024 * 1024 }
+          );
+          hunks = parseHunks(stdout);
+        }
+      }
+    } catch {
+      unavailable = "diff could not be read within its bounds";
+    }
+    if (!hunks?.length) complete = false;
+    const code = (hunks ?? []).map((hunk) => [hunk.header, ...hunk.lines.map((line) => line.slice(1))].join("\n")).join("\n");
+    const tokens2 = codeTokens(code);
+    for (const name of named)
+      if (name.includes("-") ? code.toLowerCase().includes(name.toLowerCase()) : tokens2.has(name.toLowerCase()))
+        found.add(name);
+    if (index2 >= MAX_SHOWN_FILES) excerpt.omittedFiles.push(file);
+    else
+      excerpt.files.push({
+        path: file,
+        hunks: (hunks ?? []).slice(0, MAX_SHOWN_HUNKS).map((hunk) => ({ ...hunk, lines: hunk.lines.slice(0, MAX_HUNK_LINES) })),
+        omittedHunks: Math.max(0, (hunks?.length ?? 0) - MAX_SHOWN_HUNKS),
+        ...unavailable ? { unavailable } : {}
+      });
+  }
+  excerpt.omittedFiles.push(...changedFiles.slice(MAX_DIFFED_FILES));
+  excerpt.mentions = [...found].sort();
+  excerpt.relevance = found.size ? "mentioned" : complete && named.length ? "low" : "unknown";
+  if (excerpt.relevance === "unknown")
+    excerpt.unknownReason = named.length ? "incomplete" : "no-identifiers";
+  return excerpt;
+}
+function formatDriftExcerpt(title, id, excerpt) {
+  const safe = (value, max = 160) => value.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, max);
+  const lines = [`Changed lines for decision ${JSON.stringify(safe(title, 250))} (${safe(id)}):`];
+  lines.push(
+    excerpt.relevance === "mentioned" ? `  Changed lines mention identifiers named by the decision: ${excerpt.mentions.map((name) => safe(name, 60)).join(", ")}.` : excerpt.relevance === "low" ? "  Low relevance: no changed line or enclosing declaration mentions an identifier named by the decision. This is a name match, not evidence of consistency; inspect before recording." : excerpt.unknownReason === "no-identifiers" ? "  Relevance not assessed: the decision names no code identifiers (such as `refresh()` or onRefresh) to match against the changes." : "  Relevance unknown: some changed content could not be compared with its captured version."
+  );
+  for (const file of excerpt.files) {
+    if (file.unavailable) {
+      lines.push(`  ${safe(file.path)}: ${file.unavailable}.`);
+      continue;
+    }
+    for (const hunk of file.hunks)
+      lines.push(
+        `  ${safe(file.path)} ${safe(hunk.header, 120)}`,
+        ...hunk.lines.map((line) => "    " + safe(line))
+      );
+    if (!file.hunks.length) lines.push(`  ${safe(file.path)}: changed without text hunks.`);
+    if (file.omittedHunks) lines.push(`  ${safe(file.path)}: ${file.omittedHunks} more hunk(s).`);
+  }
+  if (excerpt.omittedFiles.length)
+    lines.push(`  ${excerpt.omittedFiles.length} more changed file(s) not shown.`);
+  return lines.join("\n");
+}
+var exec, MAX_DIFFED_FILES, MAX_SHOWN_FILES, MAX_SHOWN_HUNKS, MAX_HUNK_LINES, HISTORY_DEPTH;
+var init_excerpts = __esm({
+  "src/decisions/excerpts.ts"() {
+    "use strict";
+    init_files();
+    init_paths();
+    init_provenance();
+    exec = promisify2(execFile2);
+    MAX_DIFFED_FILES = 8;
+    MAX_SHOWN_FILES = 3;
+    MAX_SHOWN_HUNKS = 2;
+    MAX_HUNK_LINES = 8;
+    HISTORY_DEPTH = 20;
+  }
+});
+
 // src/decisions/drift.ts
 import path17 from "path";
 async function computeDecisionDrift(rootDir, decisions) {
@@ -3690,15 +3887,11 @@ async function computeDecisionDrift(rootDir, decisions) {
   };
   for (const record of store.records) {
     if (record.status !== "active") continue;
-    const effective = effectiveDecision(record);
-    const inspection = latestDecisionInspection(
-      record,
-      decisionApproval(effective) === "accepted" ? "operative" : "all"
-    );
-    const state = await inspect(effective, inspection?.capture);
+    const baseline = driftBaseline(record);
+    const state = await inspect(baseline.record, baseline.capture);
     report.freshness[record.id] = state.freshness;
     if (state.changedFiles.length) report.staleDecisions[record.id] = state.changedFiles;
-    if (effective !== record)
+    if (baseline.record !== record)
       (report.pendingProposals ??= {})[record.id] = await inspect(
         record,
         latestDecisionInspection(record)?.capture
@@ -3714,13 +3907,14 @@ var init_drift2 = __esm({
     init_paths();
     init_snapshot();
     init_decisions();
+    init_excerpts();
     init_provenance();
   }
 });
 
 // src/audit/checks/decision-anchor.ts
 async function checkDecisionAnchors(ctx) {
-  const result = emptyResult();
+  const result = { ...emptyResult(), incompleteDecisions: [] };
   if (!ctx.decisionsPresent) return result;
   const store = await loadDecisionStore(ctx.root);
   const records = store.records;
@@ -3752,6 +3946,7 @@ async function checkDecisionAnchors(ctx) {
         check: "decision-anchor-drift",
         reason: `Anchor evidence for decision ${record.id} is incomplete or unreadable`
       });
+      result.incompleteDecisions.push(record.id);
       continue;
     }
     if (!changedFiles.length) continue;
@@ -3813,7 +4008,7 @@ var init_checks = __esm({
 });
 
 // src/audit/findings.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { z as z6 } from "zod";
 function findingId(finding) {
   const e = finding.evidence;
@@ -3844,7 +4039,7 @@ var digest, checkSchema, commitSchema, anchorSchema, count, scopeSchema, evidenc
 var init_findings = __esm({
   "src/audit/findings.ts"() {
     "use strict";
-    digest = (value) => createHash4("sha256").update(JSON.stringify(value)).digest("hex");
+    digest = (value) => createHash5("sha256").update(JSON.stringify(value)).digest("hex");
     checkSchema = z6.enum([
       "deleted-reference",
       "new-module",
@@ -3951,12 +4146,25 @@ var init_findings = __esm({
   }
 });
 
+// src/automation/pending-tools.ts
+function boundPending(pending) {
+  for (const key of Object.keys(pending).slice(0, -PENDING_LIMIT + 1)) delete pending[key];
+}
+var PENDING_LIMIT;
+var init_pending_tools = __esm({
+  "src/automation/pending-tools.ts"() {
+    "use strict";
+    PENDING_LIMIT = 32;
+  }
+});
+
 // src/automation/stop-review.ts
 import { z as z7 } from "zod";
 function observeDecisionEdits(session, inputs, event) {
   if (event.host !== "claude" || !event.mutating || !event.toolId) return;
   const state = session.stopReview ??= empty();
   if (event.event === "before_tool") {
+    boundPending(state.pending);
     state.pending[event.toolId] = { head: inputs.head, evidence: inputs.decisionEvidence };
   } else if (event.event === "after_tool") {
     const before = state.pending[event.toolId];
@@ -4013,7 +4221,7 @@ function decisionStopReview(session, inputs, report, reentry) {
     }
     decisions.set(evidence.decisionId, value);
   }
-  if (!decisions.size) return { reason: null, block: false };
+  if (!decisions.size) return { reason: null, block: false, decisions: [] };
   let fresh = false;
   for (const [id, value] of decisions) {
     const previous = state.delivered[id];
@@ -4036,7 +4244,7 @@ function decisionStopReview(session, inputs, report, reentry) {
     "If contradicted or uncertain, explain the mismatch to the user and request direction. Do not accept, reaffirm, or retire a decision without authorized human review. A revised proposal leaves the accepted revision operative until reviewed.",
     `Evidence: ${report.reportPath}. Concurrent changes can contribute; captures do not prove authorship. This reminder does not resolve the finding.`
   ].join("\n");
-  return { reason: reason2, block: !reentry && fresh };
+  return { reason: reason2, block: !reentry && fresh, decisions: [...decisions.keys()] };
 }
 var evidenceSchema2, stopReviewSchema, empty;
 var init_stop_review = __esm({
@@ -4044,6 +4252,7 @@ var init_stop_review = __esm({
     "use strict";
     init_anchors();
     init_findings();
+    init_pending_tools();
     evidenceSchema2 = z7.record(z7.object({ digest: z7.string(), capture: anchorCaptureSchema }));
     stopReviewSchema = z7.object({
       pending: z7.record(z7.object({ head: z7.string(), evidence: evidenceSchema2 })),
@@ -4200,16 +4409,41 @@ function parseState(raw) {
     throw new Error("Invalid automation state; original evidence was retained.", { cause: error });
   }
 }
+function clearPendingTools(session) {
+  session.pending = {};
+  if (session.stopReview) session.stopReview.pending = {};
+}
+function pruneSessions(state, now, active, limit = SESSION_LIMIT) {
+  for (const session of Object.values(state.sessions))
+    if (now.getTime() - Date.parse(session.lastUsed) > IDLE_PENDING_MS) clearPendingTools(session);
+  const evictable = Object.keys(state.sessions).filter((key) => key !== active).sort((a, b) => state.sessions[a].lastUsed.localeCompare(state.sessions[b].lastUsed));
+  const excess = Object.keys(state.sessions).length - limit;
+  for (const key of evictable.slice(0, Math.max(0, excess))) delete state.sessions[key];
+}
+function serializeState(state, active) {
+  let payload = JSON.stringify(state) + "\n";
+  while (Buffer.byteLength(payload) > STORE_MAX_BYTES) {
+    const before = Object.keys(state.sessions).length;
+    pruneSessions(state, /* @__PURE__ */ new Date(), active, before - 1);
+    if (Object.keys(state.sessions).length === before)
+      throw new Error(
+        "Mason automation state exceeds 10 MiB after evicting every other session; inspect the active session in .mason/reports/automation/<id>/state.json. Original evidence was retained."
+      );
+    payload = JSON.stringify(state) + "\n";
+  }
+  return state;
+}
 function withLock(root, directory3, run, waitMs = 5e3) {
   return withStoreLock(root, directory3, run, waitMs, "Automation");
 }
-var hostSchema, events, stateSchema;
+var hostSchema, events, stateSchema, SESSION_LIMIT, IDLE_PENDING_MS, STATE_READ_MAX_BYTES;
 var init_store = __esm({
   "src/automation/store.ts"() {
     "use strict";
     init_store_lock();
     init_stop_review();
     init_notifications();
+    init_storage();
     hostSchema = z9.enum(["claude", "codex"]);
     events = [
       "session_start",
@@ -4231,6 +4465,8 @@ var init_store = __esm({
           host: hostSchema,
           lastUsed: z9.string(),
           notifiedDiagnostics: z9.array(z9.string()).default([]),
+          /** Digest of the upstream drift notice already shown to this session. */
+          upstreamNotice: z9.string().optional(),
           pending: z9.record(z9.string()),
           stopReview: stopReviewSchema.optional(),
           coverageGaps: z9.array(z9.string()),
@@ -4245,6 +4481,9 @@ var init_store = __esm({
       agentNotifications: notificationStateSchema.optional(),
       analysis: z9.object({ id: z9.string(), fingerprint: z9.string(), completedAt: z9.number(), path: z9.string() }).optional()
     });
+    SESSION_LIMIT = 32;
+    IDLE_PENDING_MS = 24 * 60 * 60 * 1e3;
+    STATE_READ_MAX_BYTES = 64 * 1024 * 1024;
   }
 });
 
@@ -4977,9 +5216,18 @@ var init_repair = __esm({
 });
 
 // src/automation/evidence.ts
+var evidence_exports = {};
+__export(evidence_exports, {
+  checkCache: () => checkCache,
+  git: () => git3,
+  hash: () => hash,
+  readGuidanceInputs: () => readGuidanceInputs,
+  readInputs: () => readInputs,
+  workspace: () => workspace
+});
 import fs14 from "fs/promises";
 import path20 from "path";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { z as z12 } from "zod";
 async function git3(root, ...args) {
   return profilePhase(
@@ -5246,8 +5494,8 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     init_advisory_review();
-    engineVersion = true ? "0.22.0" : "development";
-    hash = (value) => createHash5("sha256").update(JSON.stringify(value)).digest("hex");
+    engineVersion = true ? "0.23.1" : "development";
+    hash = (value) => createHash6("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
     cacheSchema = z12.object({
       version: z12.literal(1),
@@ -5358,8 +5606,8 @@ var init_model = __esm({
 
 // src/setup/launcher.ts
 import { z as z14 } from "zod";
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
 import fs16 from "fs/promises";
 function globalCommand(args, platform = process.platform) {
   return platform === "win32" ? { command: "cmd.exe", args: ["/d", "/s", "/c", "mason", ...args] } : { command: "mason", args };
@@ -5367,7 +5615,7 @@ function globalCommand(args, platform = process.platform) {
 async function installedCommand() {
   const invocation = globalCommand(["internal-integration-version"]);
   try {
-    const { stdout } = await promisify2(execFile2)(invocation.command, invocation.args, {
+    const { stdout } = await promisify3(execFile3)(invocation.command, invocation.args, {
       timeout: 5e3,
       maxBuffer: 8192,
       windowsHide: true
@@ -5396,14 +5644,66 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.22.0" : "development";
+    executingVersion = () => true ? "0.23.1" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host}`;
   }
 });
 
+// src/decisions/attribution.ts
+async function branchAttribution(root) {
+  const git4 = async (...args) => (await execGit(args, { cwd: root, maxBuffer: 16 * 1024 * 1024 })).stdout.trim();
+  let target = null;
+  for (const ref of TARGETS) {
+    try {
+      await git4("rev-parse", "--verify", "--quiet", `${ref}^{commit}`);
+      target = ref === "refs/remotes/origin/HEAD" ? await git4("symbolic-ref", "--short", ref) : ref.replace(/^refs\/(remotes|heads)\//, "");
+      break;
+    } catch {
+    }
+  }
+  if (!target) return null;
+  const current = await git4("symbolic-ref", "--quiet", "--short", "HEAD").catch(() => "");
+  if (current && (target === current || target.endsWith("/" + current))) return null;
+  let mergeBase, head;
+  try {
+    [mergeBase, head] = await Promise.all([
+      git4("merge-base", "HEAD", target),
+      git4("rev-parse", "HEAD")
+    ]);
+  } catch {
+    return null;
+  }
+  if (!mergeBase || mergeBase === head) return null;
+  const [committed, workingTree] = await Promise.all([
+    git4("diff", "--name-only", "--no-renames", "-z", mergeBase, "HEAD"),
+    getWorkingTree(root)
+  ]);
+  if (!workingTree.available) return null;
+  return {
+    target,
+    mergeBase,
+    branchFiles: /* @__PURE__ */ new Set([...committed.split("\0").filter(Boolean), ...workingTree.changedFiles])
+  };
+}
+var TARGETS;
+var init_attribution = __esm({
+  "src/decisions/attribution.ts"() {
+    "use strict";
+    init_drift();
+    init_git_read();
+    TARGETS = [
+      "refs/remotes/origin/HEAD",
+      "refs/remotes/origin/main",
+      "refs/remotes/origin/master",
+      "refs/heads/main",
+      "refs/heads/master"
+    ];
+  }
+});
+
 // src/snapshot/review.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 function snapshotEntryContent(entry) {
   return {
     description: entry.description,
@@ -5414,7 +5714,7 @@ function snapshotEntryContent(entry) {
   };
 }
 function reviewToken(kind, name, entry, evidence) {
-  return createHash7("sha256").update(
+  return createHash8("sha256").update(
     JSON.stringify({
       version: 1,
       kind,
@@ -5467,7 +5767,7 @@ var init_review = __esm({
     init_snapshot();
     VERIFY_MAX_FILES_PER_ENTRY = 8;
     VERIFY_SKELETON_CHARS = 500;
-    sourceHash = (content2) => createHash7("sha256").update(content2).digest("hex");
+    sourceHash = (content2) => createHash8("sha256").update(content2).digest("hex");
   }
 });
 
@@ -5929,8 +6229,9 @@ async function executionStatus(root, directory3) {
   const outstanding = [...log.attempts].reverse().find(
     (a) => ["failed", "unknown"].includes(a.status) && (!completed || (a.finishedAt ?? a.startedAt) >= completed.startedAt)
   );
-  const status = log.attempts.some((a) => a.status === "running") ? "running" : outstanding?.status ?? log.attempts.at(-1)?.status ?? "not-observed";
-  return { status, attempts: log.attempts, discardedAttempts: log.discardedAttempts };
+  const inFlight = log.attempts.some((a) => a.status === "running");
+  const status = outstanding?.status ?? (completed ? "completed" : inFlight ? "running" : log.attempts.at(-1)?.status ?? "not-observed");
+  return { status, inFlight, attempts: log.attempts, discardedAttempts: log.discardedAttempts };
 }
 var failureSchema, attemptSchema, executionSchema, notificationsSchema, leasePath;
 var init_execution = __esm({
@@ -6103,7 +6404,7 @@ async function observeReadOnlyTool(dir, event) {
   const ws = await profilePhase("automation.workspace", () => workspace(dir));
   await withLock(ws.root, ws.directory, async () => {
     const statePath2 = ws.directory + "/state.json";
-    const raw = await readStoreJson(ws.root, statePath2);
+    const raw = await readStoreJson(ws.root, statePath2, STATE_READ_MAX_BYTES);
     if (raw === null) return;
     const state = parseState(raw);
     if (state.root !== ws.root || state.gitDir !== ws.gitDir || state.branch !== ws.branch) {
@@ -6116,7 +6417,14 @@ async function observeReadOnlyTool(dir, event) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     session.lastUsed = now;
     session.events[event.event] = { at: now, count: (session.events[event.event]?.count ?? 0) + 1 };
-    await writeStoreJson(ws.root, statePath2, state);
+    await writeStoreJson(
+      ws.root,
+      statePath2,
+      serializeState(state, hash([event.host, event.sessionId])),
+      {
+        compact: true
+      }
+    );
   });
   return { root: ws.root, directory: ws.directory };
 }
@@ -6136,7 +6444,7 @@ function summarize(report) {
   ].join("\n");
 }
 async function loadState(ws) {
-  const raw = await readStoreJson(ws.root, ws.directory + "/state.json");
+  const raw = await readStoreJson(ws.root, ws.directory + "/state.json", STATE_READ_MAX_BYTES);
   const state = raw === null ? {
     version: 1,
     root: ws.root,
@@ -6368,13 +6676,47 @@ async function analyze(ws, inputs, event, startedAt) {
           completedAt: analysis.completedAt,
           path: analysisPath
         };
-        await writeStoreJson(ws.root, ws.directory + "/state.json", state);
+        await writeStoreJson(ws.root, ws.directory + "/state.json", serializeState(state, null), {
+          compact: true
+        });
       });
       return { analysis, shared: false };
     },
     Math.max(0, 25e3 - (Date.now() - startedAt))
   );
 }
+function upstreamDriftNotice(drift) {
+  const listed = drift.decisions.slice(0, 5).map((decision) => `${JSON.stringify(cleanText(decision.title))} (${cleanText(decision.id)})`);
+  const more = drift.decisions.length - listed.length;
+  return [
+    `Mason: ${drift.decisions.length} decision(s) have anchors changed only by ${cleanText(drift.target)} since this branch's merge-base, not by this branch: ${listed.join(", ")}${more ? ` and ${more} more` : ""}.`,
+    `They are not this checkout's work and do not block. Inspect them on ${cleanText(drift.target)}, where they are reported as usual; inspections recorded here would ride along with this branch.`
+  ].join("\n");
+}
+async function driftExcerpts(root, report, ids) {
+  const unique = [...new Set(ids)].slice(0, 4);
+  if (!unique.length) return null;
+  const records = (await loadDecisionStore(root)).records;
+  const sections = [];
+  for (const id of unique) {
+    const record = records.find((candidate) => candidate.id === id);
+    const changed = /* @__PURE__ */ new Set();
+    let title = record?.title ?? id;
+    for (const finding of report.findings) {
+      const evidence = finding.current?.evidence;
+      if (finding.status === "resolved" || evidence?.kind !== "decision-anchor") continue;
+      if (evidence.decisionId !== id) continue;
+      title = evidence.title;
+      for (const file of evidence.changedFiles) changed.add(file);
+    }
+    if (!record || !changed.size) continue;
+    try {
+      sections.push(formatDriftExcerpt(title, id, await driftExcerpt(root, record, [...changed])));
+    } catch {
+    }
+  }
+  return sections.join("\n") || null;
+}
 async function guidanceAnalysis(ws, inputs) {
   const checked = await checkDecisionAnchors({
     root: ws.root,
@@ -6383,7 +6725,27 @@ async function guidanceAnalysis(ws, inputs) {
     changesSinceDoc: /* @__PURE__ */ new Map(),
     decisionsPresent: true
   });
-  const findings = checked.advisories.map((current) => ({
+  const attribution = checked.advisories.length ? await branchAttribution(ws.root).catch(() => null) : null;
+  const own = new Set(
+    checked.advisories.flatMap(
+      (advisory) => advisory.evidence.kind === "decision-anchor" && advisory.evidence.changedFiles.some((file) => attribution?.branchFiles.has(file)) ? [advisory.evidence.decisionId] : []
+    )
+  );
+  const upstream = /* @__PURE__ */ new Map();
+  const advisories = checked.advisories.filter((advisory) => {
+    const evidence = advisory.evidence;
+    if (!attribution || evidence.kind !== "decision-anchor" || own.has(evidence.decisionId))
+      return true;
+    const entry = upstream.get(evidence.decisionId) ?? {
+      id: evidence.decisionId,
+      title: evidence.title,
+      changedFiles: []
+    };
+    entry.changedFiles = [.../* @__PURE__ */ new Set([...entry.changedFiles, ...evidence.changedFiles])].sort();
+    upstream.set(evidence.decisionId, entry);
+    return false;
+  });
+  const findings = advisories.map((current) => ({
     id: findingId(current),
     original: current,
     current,
@@ -6395,13 +6757,16 @@ async function guidanceAnalysis(ws, inputs) {
     const prior = z19.object({ findings: z19.array(repairFindingSchema) }).parse(await readStoreJson(ws.root, before.guidance.path));
     const currentIds = new Set(findings.map((finding) => finding.id));
     const records = (await loadDecisionStore(ws.root)).records;
+    const incomplete = new Set(checked.incompleteDecisions);
+    const sharedSkip = checked.skipped.length > checked.incompleteDecisions.length;
     for (const previous of prior.findings) {
       if (currentIds.has(previous.id) || previous.original.evidence.kind !== "decision-anchor")
         continue;
       const evidence = previous.original.evidence;
+      if (upstream.has(evidence.decisionId)) continue;
       const record = records.find((record2) => record2.id === evidence.decisionId);
       const capture = record && inputs.decisionEvidence[record.id]?.capture;
-      const resolved = record?.status === "retired" || !!record && !!capture?.complete && capture.anchors.length > 0 && !checked.skipped.length;
+      const resolved = record?.status === "retired" || !!record && !!capture?.complete && capture.anchors.length > 0 && !sharedSkip && !incomplete.has(record.id);
       findings.push({
         id: previous.id,
         original: previous.original,
@@ -6426,6 +6791,13 @@ async function guidanceAnalysis(ws, inputs) {
     baselinePaths: [],
     reportPath: "",
     findings,
+    ...attribution && upstream.size ? {
+      upstreamDrift: {
+        target: attribution.target,
+        mergeBase: attribution.mergeBase,
+        decisions: [...upstream.values()]
+      }
+    } : {},
     diagnostics: [
       ...checked.skipped.map((item) => item.reason),
       ...findings.filter((finding) => finding.status === "unverified").map((finding) => `Decision ${finding.id}: ${finding.reason}`)
@@ -6503,17 +6875,13 @@ async function runAutomation(dir, event, guidance) {
           const now = (/* @__PURE__ */ new Date()).toISOString();
           const key = event.host && event.sessionId ? hash([event.host, event.sessionId]) : null;
           const newSession = key !== null && !state.sessions[key];
+          pruneSessions(
+            state,
+            new Date(now),
+            newSession ? null : key,
+            newSession ? SESSION_LIMIT - 1 : SESSION_LIMIT
+          );
           if (key && !state.sessions[key]) {
-            const keys = Object.keys(state.sessions).sort(
-              (a, b) => state.sessions[a].lastUsed.localeCompare(state.sessions[b].lastUsed)
-            );
-            const removable = keys.filter((k) => !Object.keys(state.sessions[k].pending).length);
-            for (const expired of removable.slice(0, Math.max(0, keys.length - 31)))
-              delete state.sessions[expired];
-            if (Object.keys(state.sessions).length >= 128)
-              throw new Error(
-                "Too many sessions with unfinished tool calls; original evidence was retained."
-              );
             state.sessions[key] = {
               host: event.host,
               notifiedDiagnostics: [],
@@ -6533,8 +6901,7 @@ async function runAutomation(dir, event, guidance) {
               count: (session.events[event.event]?.count ?? 0) + 1
             };
             if (event.event === "before_tool" && event.mutating && event.toolId) {
-              if (Object.keys(session.pending).length >= 128)
-                throw new Error("Too many unfinished tool calls to track pre-edit evidence.");
+              boundPending(session.pending);
               session.pending[event.toolId] = inputs.fingerprint;
             }
             if (event.event === "after_tool" && event.mutating) {
@@ -6560,11 +6927,23 @@ async function runAutomation(dir, event, guidance) {
                 ...diagnostics
               ])
             ];
-          const stopReview = session && event.host === "claude" && event.event === "task_end" && config.stopBlock === "drift" ? decisionStopReview(session, inputs, report, !!event.stopHookActive) : { reason: null, block: false };
+          const stopReview = session && event.host === "claude" && event.event === "task_end" && config.stopBlock === "drift" ? decisionStopReview(session, inputs, report, !!event.stopHookActive) : { reason: null, block: false, decisions: [] };
+          const excerpts = session ? await driftExcerpts(ws.root, report, [
+            ...stopReview.decisions,
+            ...[...selected, ...feedback].flatMap((finding) => {
+              const evidence = (finding.current ?? finding.original).evidence;
+              return evidence.kind === "decision-anchor" ? [evidence.decisionId] : [];
+            })
+          ]) : null;
+          const upstream = report.upstreamDrift ? upstreamDriftNotice(report.upstreamDrift) : null;
+          const upstreamNotice = session && upstream && session.upstreamNotice !== hash(upstream) ? upstream : null;
+          if (session) session.upstreamNotice = upstream ? hash(upstream) : void 0;
           const message2 = !session ? summarize(report) : [
             stopReview.reason,
             completionSummary(selected, report.reportPath),
             completionSummary(feedback, report.reportPath),
+            excerpts,
+            upstreamNotice,
             ...diagnostics.length ? [
               `Mason: verification limited. ${diagnostics.slice(0, 2).map(cleanText).join(" ")} Evidence: ${report.reportPath}.`
             ] : []
@@ -6582,7 +6961,10 @@ async function runAutomation(dir, event, guidance) {
             state.latest = report.reportPath;
           }
           if (persistReport) await writeStoreJson(ws.root, report.reportPath, report);
-          await writeStoreJson(ws.root, ws.directory + "/state.json", state);
+          if (session && event.event === "task_end") clearPendingTools(session);
+          await writeStoreJson(ws.root, ws.directory + "/state.json", serializeState(state, key), {
+            compact: true
+          });
           return {
             report,
             message: message2,
@@ -6620,7 +7002,7 @@ async function automationStatus(dir) {
   const knowledge = await pendingKnowledge2(ws.root);
   const execution = await executionStatus(ws.root, ws.directory);
   const notifications = await failureNotifications(ws.root, ws.directory);
-  const raw = await readStoreJson(ws.root, ws.directory + "/state.json");
+  const raw = await readStoreJson(ws.root, ws.directory + "/state.json", STATE_READ_MAX_BYTES);
   if (raw === null)
     return {
       version: 1,
@@ -6648,7 +7030,10 @@ async function automationStatus(dir) {
     host.sessions++;
     host.observedEvents = [.../* @__PURE__ */ new Set([...host.observedEvents, ...Object.keys(session.events)])];
   }
-  const unfinished = ["failed", "unknown", "running"].includes(execution.status);
+  const unfinished = ["failed", "unknown"].includes(execution.status);
+  const pendingSessions = Object.values(state.sessions).filter(
+    (session) => Object.keys(session.pending).length
+  );
   return {
     version: 1,
     stopBlock: config.stopBlock,
@@ -6661,6 +7046,12 @@ async function automationStatus(dir) {
     auditReportPath: state.latest,
     verificationStatus: unfinished ? "unavailable" : latest?.status ?? "unavailable",
     hosts,
+    sessions: Object.keys(state.sessions).length,
+    unfinishedToolCalls: pendingSessions.reduce(
+      (total, session) => total + Object.keys(session.pending).length,
+      0
+    ),
+    oldestUnfinishedSessionUsedAt: pendingSessions.map((session) => session.lastUsed).sort()[0] ?? null,
     execution,
     notifications,
     knowledge,
@@ -6673,6 +7064,8 @@ var init_runtime = __esm({
   "src/automation/runtime.ts"() {
     "use strict";
     init_decisions();
+    init_excerpts();
+    init_attribution();
     init_decision_anchor();
     init_config();
     init_stop_review();
@@ -6685,6 +7078,7 @@ var init_runtime = __esm({
     init_types();
     init_storage();
     init_evidence();
+    init_pending_tools();
     init_store();
     SCOPE = "Documentation audit evidence only. Hook receipts show observed events, not complete interception. Resolved findings no longer fail their checks or have a recorded assessment covering current evidence. Repair and review only within the user's task authorization.";
     priority = { resolved: 0, "review-required": 1, unresolved: 2, unverified: 3 };
@@ -6750,7 +7144,7 @@ import { z as z20 } from "zod";
 import fs21 from "fs/promises";
 import path24 from "path";
 import os3 from "os";
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 var hookStdinSchema;
 var init_hook = __esm({
   "src/hook/hook.ts"() {
@@ -6773,6 +7167,9 @@ var init_hook = __esm({
 
 // src/automation/adapters.ts
 import { z as z21 } from "zod";
+function hookEvents(host) {
+  return [...HOOK_EVENTS, ...OPTIONAL_HOOK_EVENTS[host]];
+}
 function managedHookCommand(host, platform = process.platform, legacy = false) {
   const command = `mason --setup-host ${host}${legacy ? " auto" : ""} hook --host ${host}`;
   return platform === "win32" ? `cmd.exe /d /s /c "where mason >nul 2>nul & if errorlevel 1 (exit /b 0) else (${command})"` : `if command -v mason >/dev/null 2>&1; then ${command}; fi`;
@@ -6805,11 +7202,11 @@ function hookConfig(host, command = "npx --no-install --package mason-context ma
   };
   return {
     hooks: Object.fromEntries(
-      HOOK_EVENTS.map((name) => [
+      hookEvents(host).map((name) => [
         name,
         [
           {
-            ...["PreToolUse", "PostToolUse"].includes(name) ? { matcher: ".*" } : {},
+            ...["PreToolUse", "PostToolUse", "PostToolUseFailure"].includes(name) ? { matcher: ".*" } : {},
             hooks: [{ ...handler }]
           }
         ]
@@ -6817,7 +7214,7 @@ function hookConfig(host, command = "npx --no-install --package mason-context ma
     )
   };
 }
-var inputSchema, HOOK_EVENTS;
+var inputSchema, HOOK_EVENTS, OPTIONAL_HOOK_EVENTS;
 var init_adapters = __esm({
   "src/automation/adapters.ts"() {
     "use strict";
@@ -6835,6 +7232,7 @@ var init_adapters = __esm({
         "UserPromptSubmit",
         "PreToolUse",
         "PostToolUse",
+        "PostToolUseFailure",
         "Stop"
       ]),
       tool_name: z21.string().optional(),
@@ -6851,6 +7249,10 @@ var init_adapters = __esm({
       "PostToolUse",
       "Stop"
     ];
+    OPTIONAL_HOOK_EVENTS = {
+      claude: ["PostToolUseFailure"],
+      codex: []
+    };
   }
 });
 
@@ -6983,7 +7385,7 @@ async function planAutomationInstall(root, host, command) {
   const pending = ownershipText === null ? [] : ownershipSchema.parse(JSON.parse(ownershipText)).files[file]?.hookCommands ?? [];
   const owned = /* @__PURE__ */ new Set([previous, ...pending, newCommand, ...knownManagedHookCommands(host)]);
   const hooks = existing.hooks ?? {};
-  for (const event of HOOK_EVENTS) {
+  for (const event of hookEvents(host)) {
     hooks[event] = (hooks[event] ?? []).map((group) => ({
       ...group,
       hooks: group.hooks.filter(
@@ -7017,7 +7419,7 @@ async function installLocked(root, host, command) {
     configPath: file,
     status: "configured",
     command: newCommand,
-    events: HOOK_EVENTS,
+    events: hookEvents(host),
     next: host === "codex" ? "Review/trust these hooks using Codex /hooks and start a new session. mason status reports observed events separately from configuration." : "Start a new Claude Code session. mason status reports observed events separately from configuration.",
     note: "Install mason-context in the project before using the default command. Ignore .mason/reports/ to keep local evidence out of commits. Hooks preserve evidence and suggest scoped repairs; they do not approve edits or decisions."
   };
@@ -7032,7 +7434,7 @@ async function installedAutomation(dir) {
     const current = automationConfigSchema.parse(
       await readStoreJson(ws.root, configPath3(host)) ?? {}
     );
-    const configuredEvents = HOOK_EVENTS.filter(
+    const configuredEvents = hookEvents(host).filter(
       (event) => current.hooks?.[event]?.some(
         (group) => group.hooks.some(
           (handler) => handler.type === "command" && handler.command === expected.command
@@ -7042,7 +7444,7 @@ async function installedAutomation(dir) {
     result[host] = {
       configPath: configPath3(host),
       configuredEvents,
-      status: current.disableAllHooks === true ? "disabled" : configuredEvents.length === HOOK_EVENTS.length ? "configured" : "incomplete",
+      status: current.disableAllHooks === true ? "disabled" : HOOK_EVENTS.every((event) => configuredEvents.includes(event)) ? "configured" : "incomplete",
       runtime: "Host version, trust, policy, and tool coverage still determine execution; inspect observed events."
     };
   }
@@ -7071,16 +7473,33 @@ var init_install = __esm({
   }
 });
 
+// src/decisions/merge.ts
+import fs22 from "fs/promises";
+var MERGE_DRIVER_NAME, MERGE_ATTRIBUTE, MERGE_DRIVER_COMMAND;
+var init_merge = __esm({
+  "src/decisions/merge.ts"() {
+    "use strict";
+    init_files();
+    init_provenance();
+    MERGE_DRIVER_NAME = "mason-decision";
+    MERGE_ATTRIBUTE = `.mason/decisions/*.json merge=${MERGE_DRIVER_NAME}`;
+    MERGE_DRIVER_COMMAND = "mason merge-decision %O %A %B %L %P || git merge-file --marker-size=%L -L ours -L base -L theirs %A %O %B";
+  }
+});
+
 // src/setup/config.ts
 var config_exports = {};
 __export(config_exports, {
   ancillaryEdits: () => ancillaryEdits,
+  configureDecisionMerge: () => configureDecisionMerge,
+  decisionMergeStatus: () => decisionMergeStatus,
   hookEdits: () => hookEdits,
   inspectHostConfig: () => inspectHostConfig,
   inspectIntegration: () => inspectIntegration,
   instructionEdits: () => instructionEdits,
   mcpEdit: () => mcpEdit,
-  mcpPath: () => mcpPath
+  mcpPath: () => mcpPath,
+  mergeDriverSummary: () => mergeDriverSummary
 });
 import { isDeepStrictEqual } from "util";
 import { parse as parse2, stringify } from "smol-toml";
@@ -7202,6 +7621,7 @@ async function hookEdits(root, host) {
 }
 async function ancillaryEdits(root) {
   const ignore = await readText(root, ".gitignore");
+  const attributes = await readText(root, ".gitattributes");
   const rules = [
     "!/.mason/",
     "/.mason/*",
@@ -7219,9 +7639,45 @@ async function ancillaryEdits(root) {
       path: ".gitignore",
       before: ignore,
       after: managedBlock(ignore ?? "", "# mason:ignore:start", "# mason:ignore:end", rules)
+    },
+    // Unconfigured checkouts keep Git's text merge; mason setup enables the driver locally.
+    {
+      path: ".gitattributes",
+      before: attributes,
+      after: managedBlock(
+        attributes ?? "",
+        "# mason:merge:start",
+        "# mason:merge:end",
+        MERGE_ATTRIBUTE
+      )
     }
   ];
 }
+async function decisionMergeStatus(root) {
+  const { git: git4 } = await Promise.resolve().then(() => (init_evidence(), evidence_exports));
+  const attribute = (await git4(root, "check-attr", "merge", "--", ".mason/decisions/record.json")).trim();
+  const driver = await git4(root, "config", "--get", `merge.${MERGE_DRIVER_NAME}.driver`).then(
+    (value) => value.trim(),
+    () => null
+  );
+  return {
+    attribute: attribute.endsWith(`: merge: ${MERGE_DRIVER_NAME}`),
+    driver: driver === null ? "missing" : driver === MERGE_DRIVER_COMMAND ? "configured" : "custom"
+  };
+}
+function mergeDriverSummary(state) {
+  const driver = state.driver === "configured" ? "Decision record merge driver: configured." : state.driver === "custom" ? "Decision record merge driver: customized in Git config; Mason left it unchanged." : "Decision record merge driver: not configured; Git text-merges decision records. Run mason setup to enable it.";
+  return state.attribute ? driver : driver + " The .gitattributes entry is missing; a maintainer can add it with mason init.";
+}
+async function configureDecisionMerge(root) {
+  const status = await decisionMergeStatus(root);
+  if (status.driver !== "missing") return status;
+  const { git: git4 } = await Promise.resolve().then(() => (init_evidence(), evidence_exports));
+  const section = `merge.${MERGE_DRIVER_NAME}`;
+  await git4(root, "config", "--local", `${section}.name`, "Mason decision record merge");
+  await git4(root, "config", "--local", `${section}.driver`, MERGE_DRIVER_COMMAND);
+  return { ...status, driver: "configured" };
+}
 async function inspectHostConfig(root, host, plannedMcp) {
   const text2 = plannedMcp ?? await readText(root, mcpPath(host));
   const config = host === "codex" ? parse2(text2 ?? "") : object.parse(JSON.parse(text2 ?? "{}"));
@@ -7272,7 +7728,10 @@ async function inspectIntegration(root, host) {
     ])
   );
   const mcpCompatible = isDeepStrictEqual({ command: config.mcp?.command, args: config.mcp?.args }, mcpCommand(host)) && (config.mcp?.type === void 0 || config.mcp.type === "stdio");
-  const hooksCompatible = isDeepStrictEqual(normalizedHooks, expectedHooks);
+  const required = new Set(HOOK_EVENTS);
+  const hooksCompatible = Object.entries(expectedHooks).every(
+    ([event, groups]) => isDeepStrictEqual(normalizedHooks[event], groups) || !required.has(event) && !normalizedHooks[event]?.length
+  );
   return {
     ...config,
     instructions,
@@ -7294,6 +7753,7 @@ var init_config2 = __esm({
     init_install();
     init_files2();
     init_launcher();
+    init_merge();
     object = z24.record(z24.unknown());
     mcpPath = (host) => host === "codex" ? ".codex/config.toml" : ".mcp.json";
     TOML_START = "# mason:mcp:start";
@@ -7618,8 +8078,8 @@ __export(impact_exports, {
   analyzeImpact: () => analyzeImpact
 });
 import path29 from "path";
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify6 } from "util";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
 async function analyzeImpact(rootDir, targetFiles) {
   const resolvedRoot = path29.resolve(rootDir);
   const resolvedTargets = await resolveTargetFiles(resolvedRoot, targetFiles);
@@ -7664,7 +8124,7 @@ async function getCochangeFiles(rootDir, targetFiles) {
   let totalTargetCommits = 0;
   for (const targetFile of targetFiles) {
     try {
-      const { stdout: commitLog } = await exec4(
+      const { stdout: commitLog } = await exec5(
         "git",
         ["log", "--format=%H", "-n", "500", "--", targetFile],
         { cwd: rootDir, maxBuffer: 5e6 }
@@ -7674,7 +8134,7 @@ async function getCochangeFiles(rootDir, targetFiles) {
       if (commits.length === 0) continue;
       for (const commit of commits) {
         try {
-          const { stdout: filesInCommit } = await exec4(
+          const { stdout: filesInCommit } = await exec5(
             "git",
             ["diff-tree", "--no-commit-id", "--name-only", "-r", commit],
             { cwd: rootDir }
@@ -7751,14 +8211,14 @@ async function getRelatedTests(rootDir, targetFiles) {
   }
   return results;
 }
-var exec4;
+var exec5;
 var init_impact = __esm({
   "src/impact/impact.ts"() {
     "use strict";
     init_files();
     init_paths();
     init_references();
-    exec4 = promisify6(execFile6);
+    exec5 = promisify7(execFile7);
   }
 });
 
@@ -7768,12 +8228,12 @@ __export(assemble_exports, {
   assembleContext: () => assembleContext
 });
 import path30 from "path";
-import fs23 from "fs/promises";
+import fs24 from "fs/promises";
 async function collectImpact(root, candidates) {
   const targets2 = /* @__PURE__ */ new Set();
   let sourceFiles;
   for (const candidate of sanitizeRepoPaths(candidates)) {
-    const stat = await fs23.stat(path30.join(root, candidate)).catch(() => null);
+    const stat = await fs24.stat(path30.join(root, candidate)).catch(() => null);
     if (stat?.isDirectory()) {
       sourceFiles ??= await (await createFileAccess(root)).list();
       for (const file of sourceFiles) {
@@ -8046,7 +8506,7 @@ __export(observations_exports, {
   observeActivation: () => observeActivation,
   readObservation: () => readObservation
 });
-import fs24 from "fs/promises";
+import fs25 from "fs/promises";
 import { z as z30 } from "zod";
 function observationPath(directory3, host, revision, version = executingVersion()) {
   return `${directory3}/activation/${host}-${revision}-${hash(version).slice(0, 12)}.json`;
@@ -8070,8 +8530,8 @@ async function observeActivation(dir, event, options = {}) {
       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 fs24.realpath(dir), directory: capturedDirectory } : await workspace(dir);
-    if (ws.root !== await fs24.realpath(process.env.MASON_SETUP_ROOT)) return null;
+    const ws = capturedDirectory ? { root: await fs25.realpath(dir), directory: capturedDirectory } : await workspace(dir);
+    if (ws.root !== await fs25.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.";
@@ -8152,6 +8612,7 @@ async function setupStatus(dir) {
   const ws = await workspace(dir);
   const activation = await effectiveSetup(ws.root);
   const setup = activation.setup;
+  const mergeDriver = await decisionMergeStatus(ws.root);
   if (!setup || !Object.keys(setup.hosts).length) {
     const partial = await Promise.all(
       ["codex", "claude"].map(async (host) => ({
@@ -8182,6 +8643,7 @@ async function setupStatus(dir) {
       status: pending.length ? "incomplete" : "not-configured",
       hosts: {},
       configuration,
+      mergeDriver,
       next: pending.length ? "Setup did not finish. Rerun mason setup --host " + pending[0] + " to resume local activation; use mason init if shared configuration needs updating." : "Project hooks are inactive. Run mason setup --host codex or --host claude for compatible shared configuration; a maintainer uses mason init to prepare missing or incompatible configuration."
     };
   }
@@ -8256,6 +8718,7 @@ async function setupStatus(dir) {
     hosts,
     activationRoot: activation.root,
     decisionRecords: decisions.records.length,
+    mergeDriver,
     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."
   };
@@ -8278,6 +8741,8 @@ function summarizeActivation(status) {
     lines.push(...state.updates.map((message2) => "  Optional: " + message2));
   }
   if ("decisionRecords" in status) lines.push(`Decision records: ${status.decisionRecords}.`);
+  if (status.mergeDriver.attribute || status.mergeDriver.driver !== "missing")
+    lines.push(mergeDriverSummary(status.mergeDriver));
   if (status.next) lines.push(status.next);
   return lines.join("\n");
 }
@@ -8395,6 +8860,7 @@ async function setupProject(dir, options = {}) {
       after: JSON.stringify(setup, null, 2) + "\n"
     }))
       changedFiles.push(SETUP_PATH);
+    const mergeDriver = await configureDecisionMerge(ws.root);
     options.progress?.step("Checking agent configuration");
     for (const input of sharedInputs)
       if (await readText(ws.root, input.path) !== input.before)
@@ -8418,6 +8884,7 @@ async function setupProject(dir, options = {}) {
       runtime: { kind: "global", command: "mason", version: installed.version },
       changedFiles,
       receiptPath,
+      mergeDriver,
       activation: await setupStatus(ws.root),
       next: configured.disabled || configured.mcpDisabled ? "Mason hooks or MCP are disabled in project configuration. Review that setting before activation." : host === "codex" ? "Review/trust this project's MCP configuration and hooks in Codex (/hooks in the CLI), then start a new session and give it a normal task." : "Approve the project MCP server in Claude Code, then start a new session and give it a normal task."
     };
@@ -8429,6 +8896,7 @@ function summarizeSetup(result) {
     "  MCP server and lifecycle hooks use mason from PATH.",
     "  Existing shared configuration validated; only local activation state was written.",
     `  ${result.changedFiles.length} files changed.`,
+    "  " + mergeDriverSummary(result.mergeDriver),
     "Activation: " + result.activation.status + ".",
     result.next,
     "If the assistant cannot find mason, restart the desktop app so it picks up PATH.",
@@ -8526,15 +8994,17 @@ init_snapshot();
 init_drift();
 init_paths();
 init_files();
-import { createHash as createHash6 } from "crypto";
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
+init_attribution();
+import { createHash as createHash7 } from "crypto";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
 import { z as z15 } from "zod";
-var exec = promisify3(execFile3);
+var exec2 = promisify4(execFile4);
 var requestSchema = z15.object({
   id: z15.string().regex(/^[a-zA-Z0-9_-]+$/),
   action: z15.enum(["prepare", "inspect", "accept", "reaffirm", "retire"]).default("prepare"),
   inspectionScope: z15.enum(["all", "operative"]).default("all"),
+  diffFrom: z15.enum(["lastReview", "capture"]).default("lastReview"),
   inspector: z15.string().trim().min(1).max(200).optional(),
   reviewer: z15.string().trim().min(1).max(200).optional(),
   note: z15.string().trim().min(1).max(1500).optional(),
@@ -8561,7 +9031,7 @@ async function reviewState(root, record, scope = "all") {
     localChanges: matchingPaths(anchors, workingTree.changedFiles)
   };
   const capture = await captureAnchors(root, anchors);
-  const reviewToken2 = createHash6("sha256").update(
+  const reviewToken2 = createHash7("sha256").update(
     JSON.stringify({
       record,
       evidence,
@@ -8572,11 +9042,54 @@ async function reviewState(root, record, scope = "all") {
   ).digest("hex");
   return { reviewToken: reviewToken2, evidence, capture, committed, workingTreeAvailable: workingTree.available };
 }
-async function previews(root, record, state) {
+var RETURNED_INSPECTIONS = 2;
+var MAX_PREVIEW_COMMITS = 20;
+async function diffSince(root, record, scope, diffFrom) {
+  const baseline = (scope === "operative" ? effectiveDecision(record) : record).refreshedHash;
+  const inspection = diffFrom === "lastReview" ? latestDecisionInspection(record, scope) : void 0;
+  if (inspection && /^[a-f0-9]{40,64}$/.test(inspection.headHash)) {
+    try {
+      await exec2("git", ["cat-file", "-e", `${inspection.headHash}^{commit}`], { cwd: root });
+      return { from: "inspection", commit: inspection.headHash, at: inspection.at };
+    } catch {
+      return {
+        from: "baseline",
+        commit: baseline,
+        note: "The latest inspection's commit is not available locally; the diff starts at the evidence baseline."
+      };
+    }
+  }
+  return { from: "baseline", commit: baseline };
+}
+function trimInspections(record) {
+  return record.version === 2 && (record.inspections?.length ?? 0) > RETURNED_INSPECTIONS ? { ...record, inspections: record.inspections.slice(-RETURNED_INSPECTIONS) } : record;
+}
+async function previews(root, state, since) {
   const access = await createFileAccess(root);
   const anchors = state.capture.anchors;
+  const git4 = (args) => exec2("git", ["--literal-pathspecs", ...args, "--", ...anchors], {
+    cwd: root,
+    maxBuffer: 1024 * 1024
+  }).then(({ stdout }) => stdout);
+  const range = state.evidence.headHash === "unknown" ? null : [since.commit, state.evidence.headHash];
+  let changedSince = [];
+  let commits = [];
+  if (range && anchors.length)
+    try {
+      changedSince = (await git4(["diff", "--name-only", "--no-renames", ...range])).split("\n").filter(Boolean);
+      commits = (await git4([
+        "log",
+        "--oneline",
+        "--no-decorate",
+        "-n",
+        String(MAX_PREVIEW_COMMITS + 1),
+        `${range[0]}..${range[1]}`
+      ])).split("\n").filter(Boolean);
+    } catch {
+    }
   const candidates = [
     .../* @__PURE__ */ new Set([
+      ...changedSince,
       ...state.evidence.changedFiles,
       ...state.evidence.localChanges,
       ...anchors,
@@ -8587,7 +9100,6 @@ async function previews(root, record, state) {
   ];
   const files = [];
   const omittedFiles = [];
-  const diffPaths = [];
   for (const file of candidates) {
     if (files.length >= 6) {
       omittedFiles.push(file);
@@ -8603,37 +9115,46 @@ async function previews(root, record, state) {
       preview: source.content.slice(0, 2e3),
       totalLines: source.totalLines
     });
-    if (state.evidence.changedFiles.includes(file)) diffPaths.push(file);
   }
   let diff = null;
   let diffUnavailable;
-  if (state.evidence.historyAvailable && diffPaths.length) {
+  if (range && changedSince.length) {
     try {
-      const { stdout } = await exec(
-        "git",
-        [
-          "--literal-pathspecs",
-          "diff",
-          "--no-ext-diff",
-          "--no-textconv",
-          "--no-color",
-          "--no-renames",
-          "-U3",
-          record.refreshedHash,
-          state.evidence.headHash,
-          "--",
-          ...diffPaths
-        ],
-        { cwd: root, maxBuffer: 1024 * 1024 }
-      );
+      const stdout = await git4([
+        "diff",
+        "--no-ext-diff",
+        "--no-textconv",
+        "--no-color",
+        "--no-renames",
+        "-U3",
+        ...range
+      ]);
       diff = stdout.slice(0, 16e3);
       if (stdout.length > diff.length)
         diffUnavailable = "Diff preview was truncated; inspect the full diff before reviewing.";
     } catch {
       diffUnavailable = "Diff preview could not be read within its size bound; inspect the diff separately.";
     }
+  } else if (range && !changedSince.length && since.commit !== state.evidence.headHash) {
+    try {
+      await exec2("git", ["cat-file", "-e", `${since.commit}^{commit}`], { cwd: root });
+    } catch {
+      diffUnavailable = "The diff base is not available locally; inspect the history separately.";
+    }
   }
+  const branch = changedSince.length ? await branchAttribution(root).catch(() => null) : null;
   return {
+    diffSince: since,
+    ...branch ? {
+      attribution: {
+        target: branch.target,
+        mergeBase: branch.mergeBase,
+        branchFiles: changedSince.filter((file) => branch.branchFiles.has(file)),
+        targetFiles: changedSince.filter((file) => !branch.branchFiles.has(file))
+      }
+    } : {},
+    commits: commits.slice(0, MAX_PREVIEW_COMMITS),
+    ...commits.length > MAX_PREVIEW_COMMITS ? { commitsTruncated: true } : {},
     files,
     diff,
     diffUnavailable,
@@ -8669,10 +9190,12 @@ async function reviewDecision(root, input) {
       };
     const state = await reviewState(root, record, request.inspectionScope);
     const operativeDecision = effectiveDecision(record);
+    const inspections2 = record.version === 2 ? record.inspections?.length ?? 0 : 0;
     return {
       status: "prepared",
-      record,
-      ...operativeDecision !== record && request.inspectionScope === "all" ? { operativeDecision } : {},
+      record: trimInspections(record),
+      ...inspections2 > RETURNED_INSPECTIONS ? { omittedInspections: inspections2 - RETURNED_INSPECTIONS } : {},
+      ...operativeDecision !== record && request.inspectionScope === "all" ? { operativeDecision: trimInspections(operativeDecision) } : {},
       inspectionScope: request.inspectionScope,
       ...request.inspectionScope === "operative" ? {
         inspectionTarget: {
@@ -8693,8 +9216,8 @@ async function reviewDecision(root, input) {
       diagnostics,
       previews: await previews(
         root,
-        request.inspectionScope === "operative" ? operativeDecision : record,
-        state
+        state,
+        await diffSince(root, record, request.inspectionScope, request.diffFrom)
       ),
       hint: request.inspectionScope === "operative" ? "Inspect only the accepted inspectionTarget against its source and diff. Use the same inspectionScope: operative and token with action inspect. This reports no contradiction for that revision only; pending content remains unassessed and visible. Do not attest to the draft or infer human approval. If the accepted guidance is contradicted or uncertain, explain that instead of recording no contradiction." : "Inspect the proposed content, operativeDecision, sources, history, and code changes. A pending proposal leaves the prior accepted revision operative; accepting it replaces that revision, and retirement withdraws the entire decision including its proposal. Evidence covers both revisions' anchors. After inspecting the relevant code, action inspect with inspector, note and reviewToken records no_contradiction_found without human approval; it does not accept or reaffirm the decision. Only record acceptance or reaffirmation when the user or cited team review has authorized it. Supply that reviewer's identity, a reason, and this reviewToken. Do not invent identities or infer agreement from unchanged code. Acceptance and reaffirmation require committed anchor changes; retirement is available independently. Missing old history remains visible in the event even if a reviewer establishes a new baseline at HEAD. Saved reviews are local assertions for normal PR review, not authenticated approvals."
     };
@@ -8850,15 +9373,15 @@ init_provenance();
 init_decisions();
 init_paths();
 init_drift2();
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import path27 from "path";
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify5 } from "util";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
 
 // src/review/cochange.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
-var exec2 = promisify4(execFile4);
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+var exec3 = promisify5(execFile5);
 var HISTORY_COMMITS = 1500;
 var MIN_FILE_COMMITS = 5;
 var MIN_SHARED_COMMITS = 4;
@@ -8866,11 +9389,11 @@ var MIN_COCHANGE_RATE = 0.6;
 var MAX_COMMIT_FILES = 30;
 async function buildMatrix(resolvedRoot) {
   try {
-    const { stdout: shallow } = await exec2("git", ["rev-parse", "--is-shallow-repository"], {
+    const { stdout: shallow } = await exec3("git", ["rev-parse", "--is-shallow-repository"], {
       cwd: resolvedRoot
     });
     if (shallow.trim() === "true") return null;
-    const { stdout } = await exec2(
+    const { stdout } = await exec3(
       "git",
       ["log", `-n${HISTORY_COMMITS}`, "--format=%x01", "--name-only", "-M"],
       { cwd: resolvedRoot, maxBuffer: 100 * 1024 * 1024 }
@@ -9642,11 +10165,11 @@ function summarizeEvidence(evidence) {
 
 // src/review/review.ts
 init_snapshot();
-var exec3 = promisify5(execFile5);
+var exec4 = promisify6(execFile6);
 var MAX_ANALYZED_FILES = 50;
 async function resolveMergeBase(resolvedRoot, base, head) {
   try {
-    const { stdout } = await exec3("git", ["merge-base", base, head], {
+    const { stdout } = await exec4("git", ["merge-base", base, head], {
       cwd: resolvedRoot
     });
     return stdout.trim() || null;
@@ -9657,7 +10180,7 @@ async function resolveMergeBase(resolvedRoot, base, head) {
 async function defaultBase(resolvedRoot) {
   for (const ref of ["origin/HEAD", "origin/main", "origin/master", "main"]) {
     try {
-      await exec3("git", ["rev-parse", "--verify", "--quiet", ref], {
+      await exec4("git", ["rev-parse", "--verify", "--quiet", ref], {
         cwd: resolvedRoot
       });
       return ref;
@@ -9731,7 +10254,7 @@ async function computeReview(rootDir, base, options = {}) {
     analyzed,
     async (relPath) => {
       try {
-        await fs22.access(path27.join(resolvedRoot, relPath));
+        await fs23.access(path27.join(resolvedRoot, relPath));
         return true;
       } catch {
         return false;
@@ -10398,7 +10921,7 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.22.0"
+      version: "0.23.1"
     },
     {
       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 as soon as evidence supports them, without waiting for implementation or merge; 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 and inspect code evidence without claiming human approval; acceptance, reaffirmation, or retirement require an authorized review. 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. 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."
@@ -10541,7 +11064,7 @@ function createMcpServer() {
         `Short, specific headline (max ${TITLE_MAX_CHARS} characters). Generates a stable id on creation; revising the title keeps the existing id.`
       ),
       body: decisionBodySchema.describe(
-        `The knowledge itself: what was tried/decided, why, and what to avoid. Must contain information NOT derivable by reading the code. Aim for ${BODY_RECOMMENDED_CHARS} characters or fewer; up to ${BODY_MAX_CHARS} is accepted with a warning above the target. Matching context and hooks include the full body. Preserve exceptions; use sources for supporting references.`
+        `The knowledge itself: what was tried/decided, why, and what to avoid. Must contain information NOT derivable by reading the code. Aim for ${BODY_RECOMMENDED_CHARS} characters or fewer; up to ${BODY_MAX_CHARS} is accepted with a warning above the target. Matching context and hooks include the full body. Preserve exceptions; use sources for supporting references. Name the functions, types, or settings the decision constrains in backticks, such as \`refresh()\`; drift notices use those names to judge whether a change is relevant.`
       ),
       category: z31.enum(["decision", "gotcha", "deprecation", "convention"]),
       files: z31.array(z31.string()).optional().describe(
@@ -10582,7 +11105,7 @@ function createMcpServer() {
   );
   server.tool(
     "review_decision",
-    "Prepare a decision review: returns the full record and history, any operative accepted revision, provenance, changes and previews for both sets of anchors, and a reviewToken. For accepted-guidance inspection use inspectionScope operative on both prepare and inspect; pending proposals remain unassessed. Default all scope covers both revisions. After source inspection, record inspect with inspector, note and token to report no contradiction found without human acceptance. For human review, prepare with all scope, then record accept, reaffirm, or retire with its token, the authorized reviewer, and a reason. Acceptance replaces the operative revision; retirement withdraws the entire record including its proposal. Acceptance requires owner, source, readable Git HEAD, and committed anchor changes. Changed records or code invalidate the token. Identities and approvals are recorded assertions for normal PR review, not authenticated proof.",
+    "Prepare a decision review: returns the record and history with its latest two inspections (older ones are counted), any operative accepted revision, provenance, changes, and source, diff and commit previews since the latest valid inspection for both sets of anchors, and a reviewToken. For accepted-guidance inspection use inspectionScope operative on both prepare and inspect; pending proposals remain unassessed. Default all scope covers both revisions. After source inspection, record inspect with inspector, note and token to report no contradiction found without human acceptance. For human review, prepare with all scope, then record accept, reaffirm, or retire with its token, the authorized reviewer, and a reason. Acceptance replaces the operative revision; retirement withdraws the entire record including its proposal. Acceptance requires owner, source, readable Git HEAD, and committed anchor changes. Changed records or code invalidate the token. Identities and approvals are recorded assertions for normal PR review, not authenticated proof.",
     {
       dir: z31.string().describe("Absolute path to the project root directory"),
       id: z31.string().regex(/^[a-zA-Z0-9_-]+$/).describe("Decision id from get_context or save_decision"),
@@ -10592,6 +11115,9 @@ function createMcpServer() {
       inspectionScope: z31.enum(["all", "operative"]).optional().default("all").describe(
         "For prepare/inspect only: all covers the full record and both anchor sets (default); operative covers only an active accepted revision, leaving a pending draft unassessed. Use the same scope when submitting its token."
       ),
+      diffFrom: z31.enum(["lastReview", "capture"]).optional().default("lastReview").describe(
+        "For prepare only: lastReview previews changes since the latest inspection still valid for this record and scope (default); capture previews the full history since the evidence baseline."
+      ),
       inspector: z31.string().trim().min(1).max(200).optional().describe(
         "Actual agent or person performing inspection; required for inspect. Does not claim human approval."
       ),
@@ -10679,7 +11205,7 @@ async function startMcpServer(onClose) {
 init_validation();
 init_store();
 init_storage();
-import fs31 from "fs/promises";
+import fs32 from "fs/promises";
 import path37 from "path";
 import { spawn as spawn2 } from "child_process";
 import { randomUUID as randomUUID11 } from "crypto";
@@ -10690,19 +11216,19 @@ init_storage();
 import os5 from "os";
 import path33 from "path";
 import { fileURLToPath } from "url";
-import fs26 from "fs/promises";
+import fs27 from "fs/promises";
 import { z as z33 } from "zod";
 
 // src/distribution/path.ts
 init_validation();
-import fs25 from "fs/promises";
+import fs26 from "fs/promises";
 import os4 from "os";
 import path32 from "path";
-import { execFile as execFile7 } from "child_process";
-import { promisify as promisify7 } from "util";
-import { createHash as createHash9, randomUUID as randomUUID7 } from "crypto";
+import { execFile as execFile8 } from "child_process";
+import { promisify as promisify8 } from "util";
+import { createHash as createHash10, randomUUID as randomUUID7 } from "crypto";
 import { z as z32 } from "zod";
-var execute2 = promisify7(execFile7);
+var execute2 = promisify8(execFile8);
 var pathChangeSchema = z32.discriminatedUnion("kind", [
   z32.object({
     kind: z32.literal("profile"),
@@ -10759,7 +11285,7 @@ ${alreadyOnPath ? "" : `Add ${bin} to your PATH.
       );
       let login = candidates[2];
       for (const file of candidates)
-        if (await fs25.lstat(file).then(
+        if (await fs26.lstat(file).then(
           () => true,
           (error) => {
             if (hasErrorCode(error, "ENOENT")) return false;
@@ -10771,14 +11297,14 @@ ${alreadyOnPath ? "" : `Add ${bin} to your PATH.
         }
       profiles2 = [path32.join(userHome, ".bashrc"), login];
     }
-    const marker = `# >>> mason PATH ${createHash9("sha256").update(bin).digest("hex").slice(0, 12)} >>>`;
+    const marker = `# >>> mason PATH ${createHash10("sha256").update(bin).digest("hex").slice(0, 12)} >>>`;
     for (const profile of profiles2) {
-      const stat = await fs25.lstat(profile).catch((error) => {
+      const stat = await fs26.lstat(profile).catch((error) => {
         if (hasErrorCode(error, "ENOENT")) return null;
         throw error;
       });
-      const file = stat?.isSymbolicLink() ? await fs25.realpath(profile) : path32.resolve(profile);
-      const original = await fs25.readFile(file).catch((error) => {
+      const file = stat?.isSymbolicLink() ? await fs26.realpath(profile) : path32.resolve(profile);
+      const original = await fs26.readFile(file).catch((error) => {
         if (hasErrorCode(error, "ENOENT") && !stat) return null;
         throw error;
       });
@@ -10797,8 +11323,8 @@ ${alreadyOnPath ? "" : `Add ${bin} to your PATH.
         changes.push({ kind: "profile", file, block, created: original === null });
         await save(changes);
       }
-      await fs25.mkdir(path32.dirname(file), { recursive: true });
-      const handle = await fs25.open(file, original === null ? "ax+" : "a+", 384);
+      await fs26.mkdir(path32.dirname(file), { recursive: true });
+      const handle = await fs26.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}`);
@@ -10893,7 +11419,7 @@ async function readInstallation(home) {
       "Run this command from a standalone installation. npm users can upgrade with npm."
     );
   const record = recordSchema3.parse(raw);
-  if (record.home !== await fs26.realpath(home))
+  if (record.home !== await fs27.realpath(home))
     throw new Error("Invalid standalone installation receipt.");
   return record;
 }
@@ -10929,9 +11455,9 @@ function newerStableVersion(candidate, installed) {
 
 // src/distribution/bundle.ts
 init_storage();
-import fs27 from "fs/promises";
+import fs28 from "fs/promises";
 import path34 from "path";
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { z as z34 } from "zod";
 var targets = [
   "darwin-arm64",
@@ -10949,9 +11475,9 @@ var bundleSchema = z34.object({
   nodeVersion: z34.string(),
   files: z34.record(digest2)
 }).strict();
-var sha256 = (bytes) => createHash10("sha256").update(bytes).digest("hex");
+var sha256 = (bytes) => createHash11("sha256").update(bytes).digest("hex");
 async function readBundle(root) {
-  const bytes = await fs27.readFile(await storePath(root, "bundle.json"));
+  const bytes = await fs28.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)) {
@@ -10981,7 +11507,7 @@ async function verifyBundle(root, expectedHash) {
   for (let i = 0; i < files.length; i += 8)
     await Promise.all(
       files.slice(i, i + 8).map(async (file) => {
-        if (sha256(await fs27.readFile(await storePath(root, file))) !== bundle.manifest.files[file])
+        if (sha256(await fs28.readFile(await storePath(root, file))) !== bundle.manifest.files[file])
           throw new Error("Mason bundle checksum mismatch: " + file);
       })
     );
@@ -10992,7 +11518,7 @@ async function verifyBundle(root, expectedHash) {
 init_validation();
 init_store();
 init_storage();
-import fs28 from "fs/promises";
+import fs29 from "fs/promises";
 import { unlinkSync } from "fs";
 import os6 from "os";
 import path35 from "path";
@@ -11011,11 +11537,11 @@ var leaseSchema = z35.object({
 
 // src/distribution/install.ts
 init_validation();
-import fs30 from "fs/promises";
+import fs31 from "fs/promises";
 import os8 from "os";
 import path36 from "path";
-import { execFile as execFile8, spawn } from "child_process";
-import { promisify as promisify8 } from "util";
+import { execFile as execFile9, spawn } from "child_process";
+import { promisify as promisify9 } from "util";
 import { randomUUID as randomUUID10 } from "crypto";
 init_storage();
 init_store();
@@ -11023,14 +11549,14 @@ init_store();
 // src/distribution/sessions.ts
 init_validation();
 init_storage();
-import fs29 from "fs/promises";
+import fs30 from "fs/promises";
 import os7 from "os";
 import { randomUUID as randomUUID9 } from "crypto";
 import { z as z36 } from "zod";
 var leaseSchema2 = z36.object({ pid: z36.number().int().positive(), host: z36.string() });
 async function hasRunningMcp(home) {
   const directory3 = await storePath(home, "sessions");
-  const files = await fs29.readdir(directory3).catch((error) => {
+  const files = await fs30.readdir(directory3).catch((error) => {
     if (hasErrorCode(error, "ENOENT")) return [];
     throw error;
   });
@@ -11048,7 +11574,7 @@ async function hasRunningMcp(home) {
       } catch (error) {
         if (error.code !== "ESRCH") return true;
       }
-      await fs29.rm(await storePath(home, relative), { force: true });
+      await fs30.rm(await storePath(home, relative), { force: true });
     } catch {
       return true;
     }
@@ -11059,7 +11585,7 @@ async function registerMcp(home) {
   const name = `sessions/${randomUUID9()}.json`;
   await writeStoreJson(home, name, { pid: process.pid, host: os7.hostname() });
   return async () => {
-    await fs29.rm(await storePath(home, name), { force: true }).catch(() => {
+    await fs30.rm(await storePath(home, name), { force: true }).catch(() => {
     });
   };
 }
@@ -11072,10 +11598,10 @@ var launcherNames = ["mason", "mason.cmd", "mason.ps1", "mason-launcher.ps1"];
 async function replace(file, content2, mode = 384) {
   const temp = file + ".tmp-" + randomUUID10();
   try {
-    await fs30.writeFile(temp, content2, { mode, flag: "wx" });
-    await fs30.rename(temp, file);
+    await fs31.writeFile(temp, content2, { mode, flag: "wx" });
+    await fs31.rename(temp, file);
   } finally {
-    await fs30.rm(temp, { force: true });
+    await fs31.rm(temp, { force: true });
   }
 }
 function assertUpdatePolicy(record, version, revision) {
@@ -11089,19 +11615,19 @@ async function installLocked2(home, source, bundle, progress, options, alreadySt
   if (options.stageOnly)
     assertUpdatePolicy(previous, bundle.manifest.version, options.policyRevision);
   if (!previous)
-    for (const file of await fs30.readdir(home)) {
+    for (const file of await fs31.readdir(home)) {
       if (file === ".install-lock") continue;
       const directory3 = path36.join(home, file);
-      const stat = await fs30.lstat(directory3);
-      if (!["versions", "bin"].includes(file) || !stat.isDirectory() || (await fs30.readdir(directory3)).length) {
+      const stat = await fs31.lstat(directory3);
+      if (!["versions", "bin"].includes(file) || !stat.isDirectory() || (await fs31.readdir(directory3)).length) {
         throw new Error("Mason installation directory is not empty and has no ownership receipt.");
       }
     }
   const selectedBin = path36.resolve(
     process.env.MASON_BIN_DIR ?? previous?.bin ?? (process.platform === "win32" ? path36.join(home, "bin") : path36.join(os8.homedir(), ".local/bin"))
   );
-  await fs30.mkdir(selectedBin, { recursive: true });
-  const bin = await fs30.realpath(selectedBin);
+  await fs31.mkdir(selectedBin, { recursive: true });
+  const bin = await fs31.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);
@@ -11145,7 +11671,7 @@ exec ${shQuote(path36.join(destination, "node"))} ${shQuote(path36.join(destinat
   };
   for (const [name, content2] of Object.entries(launchers)) {
     const file = await storePath(bin, name);
-    const old = await fs30.readFile(file, "utf8").catch((error) => {
+    const old = await fs31.readFile(file, "utf8").catch((error) => {
       if (hasErrorCode(error, "ENOENT")) return null;
       throw error;
     });
@@ -11157,7 +11683,7 @@ exec ${shQuote(path36.join(destination, "node"))} ${shQuote(path36.join(destinat
   );
   const checkRetired = async (name, expected) => {
     if (!launcherNames.includes(name)) throw new Error("Invalid owned launcher name.");
-    const actual = await fs30.readFile(await storePath(bin, name), "utf8").catch((error) => {
+    const actual = await fs31.readFile(await storePath(bin, name), "utf8").catch((error) => {
       if (hasErrorCode(error, "ENOENT")) return null;
       throw error;
     });
@@ -11200,7 +11726,7 @@ exec ${shQuote(path36.join(destination, "node"))} ${shQuote(path36.join(destinat
       await replace(await storePath(bin, name, true), content2, 493);
     for (const [name, expected] of retired) {
       await checkRetired(name, expected);
-      await fs30.rm(await storePath(bin, name), { force: true });
+      await fs31.rm(await storePath(bin, name), { force: true });
     }
     await writeStoreJson(home, "install.json", receipt);
   } catch (error) {
@@ -11233,7 +11759,7 @@ exec ${shQuote(path36.join(destination, "node"))} ${shQuote(path36.join(destinat
   };
 }
 async function copyBundle(home, source, destination, bundle) {
-  const exists = await fs30.lstat(destination).then(
+  const exists = await fs31.lstat(destination).then(
     () => true,
     (error) => {
       if (hasErrorCode(error, "ENOENT")) return false;
@@ -11245,16 +11771,16 @@ async function copyBundle(home, source, destination, bundle) {
     return;
   }
   const stage = await storePath(home, "versions/.install-" + randomUUID10(), true);
-  await fs30.mkdir(stage);
+  await fs31.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 fs30.copyFile(from, to);
-      await fs30.chmod(to, (await fs30.stat(from)).mode & 511);
+      await fs31.copyFile(from, to);
+      await fs31.chmod(to, (await fs31.stat(from)).mode & 511);
     }
     await verifyBundle(stage, bundle.manifestHash);
     try {
-      await fs30.rename(stage, destination);
+      await fs31.rename(stage, destination);
     } catch (error) {
       try {
         await verifyBundle(destination, bundle.manifestHash);
@@ -11263,7 +11789,7 @@ async function copyBundle(home, source, destination, bundle) {
       }
     }
   } finally {
-    await fs30.rm(stage, { recursive: true, force: true });
+    await fs31.rm(stage, { recursive: true, force: true });
   }
 }
 async function prepareStandaloneMcp(home) {