mason-context 0.22.0 → 0.23.1

package/dist/mason.js

@@ -426,11 +426,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;
@@ -442,9 +443,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);
@@ -462,11 +463,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;
   }
 });
 
@@ -553,7 +556,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((_, index) => !visible[index].length));
+    const ignored = hidden.size ? (await inspectionGit(
       [
         "ls-files",
         "-z",
@@ -561,13 +569,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);
@@ -583,7 +589,7 @@ async function captureAnchorScopes(root, scopes2) {
     const filesByScope = new Map(
       scopes2.map((scope, index) => [JSON.stringify([...new Set(scope)].sort()), indexed[index]])
     );
-    return { filesByScope, eligible };
+    return { filesByScope, eligible, hidden, ignored: new Set(ignored) };
   };
   return Promise.all(
     scopes2.map((scope) => {
@@ -595,8 +601,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(
@@ -3003,6 +3011,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 tokens = /* @__PURE__ */ new Set();
+  for (const [name] of code.matchAll(/[A-Za-z_$][\w$]*/g)) {
+    tokens.add(name.toLowerCase());
+    for (const part of name.split(/_+|(?<=[a-z0-9])(?=[A-Z])/))
+      if (part.length >= 3) tokens.add(part.toLowerCase());
+  }
+  return tokens;
+}
+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 [index, 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 tokens = codeTokens(code);
+    for (const name of named)
+      if (name.includes("-") ? code.toLowerCase().includes(name.toLowerCase()) : tokens.has(name.toLowerCase()))
+        found.add(name);
+    if (index >= 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) {
@@ -3067,15 +3264,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
@@ -3091,13 +3284,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;
@@ -3129,6 +3323,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;
@@ -3190,7 +3385,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;
@@ -3221,7 +3416,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",
@@ -3328,12 +3523,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];
@@ -3390,7 +3598,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];
@@ -3413,7 +3621,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, block: !reentry && fresh };
+  return { reason, block: !reentry && fresh, decisions: [...decisions.keys()] };
 }
 var evidenceSchema2, stopReviewSchema, empty;
 var init_stop_review = __esm({
@@ -3421,6 +3629,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 })),
@@ -3577,16 +3786,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",
@@ -3608,6 +3842,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()),
@@ -3622,6 +3858,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;
   }
 });
 
@@ -4354,9 +4593,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, ...args2) {
   return profilePhase(
@@ -4595,8 +4843,8 @@ function checkCache(raw, inputs) {
     diagnostic,
     has: (name) => entries[name]?.key === inputs.keys[name] && !entries[name].result.skipped.length,
     serialize: () => {
-      const canonical = cacheSchema.shape.entries.parse(entries);
-      return { version: 1, entries: canonical, digest: hash(canonical) };
+      const canonical2 = cacheSchema.shape.entries.parse(entries);
+      return { version: 1, entries: canonical2, digest: hash(canonical2) };
     }
   };
 }
@@ -4623,8 +4871,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),
@@ -5099,8 +5347,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({
@@ -5159,6 +5408,58 @@ var init_execution = __esm({
   }
 });
 
+// src/decisions/attribution.ts
+async function branchAttribution(root) {
+  const git4 = async (...args2) => (await execGit(args2, { 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/decisions/pending.ts
 var pending_exports = {};
 __export(pending_exports, {
@@ -5245,7 +5546,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) {
@@ -5258,7 +5559,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 };
 }
@@ -5278,7 +5586,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,
@@ -5510,13 +5818,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,
@@ -5525,7 +5867,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,
@@ -5537,13 +5899,16 @@ async function guidanceAnalysis(ws, inputs) {
     const prior = z16.object({ findings: z16.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,
@@ -5568,6 +5933,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}`)
@@ -5645,17 +6017,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: [],
@@ -5675,8 +6043,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) {
@@ -5702,11 +6069,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 message = !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}.`
             ] : []
@@ -5724,7 +6103,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,
@@ -5762,7 +6144,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,
@@ -5790,7 +6172,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,
@@ -5803,6 +6188,12 @@ async function automationStatus(dir) {
     auditReportPath: state.latest,
     verificationStatus: unfinished ? "unavailable" : latest?.status ?? "unavailable",
     hosts: hosts2,
+    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,
@@ -5815,6 +6206,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();
@@ -5827,6 +6220,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 };
@@ -5930,7 +6324,7 @@ import { z as z17 } from "zod";
 import fs18 from "fs/promises";
 import path22 from "path";
 import os3 from "os";
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 async function exists(p) {
   try {
     await fs18.access(p);
@@ -6022,10 +6416,10 @@ async function runHook(stdinText, env = {}) {
   const stateDir = env.stateDir ?? os3.tmpdir();
   const stateFile = path22.join(
     stateDir,
-    `mason-hook-${createHash6("sha256").update(root).digest("hex").slice(0, 12)}-${stateKey(input)}.json`
+    `mason-hook-${createHash7("sha256").update(root).digest("hex").slice(0, 12)}-${stateKey(input)}.json`
   );
   const injected = await loadInjected(stateFile);
-  const recordKey = (record) => `${record.id}:${createHash6("sha256").update(JSON.stringify(record)).digest("hex")}`;
+  const recordKey = (record) => `${record.id}:${createHash7("sha256").update(JSON.stringify(record)).digest("hex")}`;
   const previouslyInjected = (record) => [...injected].some((key) => key === record.id || key.startsWith(`${record.id}:`));
   const fresh = records.filter(
     (r) => !injected.has(recordKey(r)) && (previouslyInjected(r) || r.status === "active" && anchorsCover(r, relPath))
@@ -6175,8 +6569,8 @@ __export(launcher_exports, {
   prepareLaunch: () => prepareLaunch
 });
 import { z as z19 } 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 fs20 from "fs/promises";
 function globalCommand(args2, platform = process.platform) {
   return platform === "win32" ? { command: "cmd.exe", args: ["/d", "/s", "/c", "mason", ...args2] } : { command: "mason", args: args2 };
@@ -6184,7 +6578,7 @@ function globalCommand(args2, 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
@@ -6230,7 +6624,7 @@ 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}`;
   }
@@ -6431,10 +6825,19 @@ async function runAutomationHook(host, stdin, options = {}) {
     if (!message) return null;
     return {
       systemMessage: message,
-      ...["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse"].includes(name) ? { hookSpecificOutput: { hookEventName: name, additionalContext: message } } : {}
+      ...[
+        "SessionStart",
+        "UserPromptSubmit",
+        "PreToolUse",
+        "PostToolUse",
+        "PostToolUseFailure"
+      ].includes(name) ? { hookSpecificOutput: { hookEventName: name, additionalContext: message } } : {}
     };
   }
 }
+function hookEvents(host) {
+  return [...HOOK_EVENTS, ...OPTIONAL_HOOK_EVENTS[host]];
+}
 function managedHookCommand(host, platform = process.platform, legacy = false) {
   const command2 = `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 (${command2})"` : `if command -v mason >/dev/null 2>&1; then ${command2}; fi`;
@@ -6467,11 +6870,11 @@ function hookConfig(host, command2 = "npx --no-install --package mason-context m
   };
   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 }]
           }
         ]
@@ -6479,7 +6882,7 @@ function hookConfig(host, command2 = "npx --no-install --package mason-context m
     )
   };
 }
-var inputSchema, lifecycle, HOOK_EVENTS;
+var inputSchema, lifecycle, HOOK_EVENTS, OPTIONAL_HOOK_EVENTS;
 var init_adapters = __esm({
   "src/automation/adapters.ts"() {
     "use strict";
@@ -6497,6 +6900,7 @@ var init_adapters = __esm({
         "UserPromptSubmit",
         "PreToolUse",
         "PostToolUse",
+        "PostToolUseFailure",
         "Stop"
       ]),
       tool_name: z21.string().optional(),
@@ -6511,6 +6915,8 @@ var init_adapters = __esm({
       UserPromptSubmit: "turn_start",
       PreToolUse: "before_tool",
       PostToolUse: "after_tool",
+      // Claude reports failed calls separately; they still end the paired tool capture.
+      PostToolUseFailure: "after_tool",
       Stop: "task_end"
     };
     HOOK_EVENTS = [
@@ -6520,6 +6926,10 @@ var init_adapters = __esm({
       "PostToolUse",
       "Stop"
     ];
+    OPTIONAL_HOOK_EVENTS = {
+      claude: ["PostToolUseFailure"],
+      codex: []
+    };
   }
 });
 
@@ -6742,16 +7152,126 @@ Existing maps remain readable for legacy projects. Managed map creation has been
   }
 });
 
+// src/decisions/merge.ts
+var merge_exports = {};
+__export(merge_exports, {
+  MERGE_ATTRIBUTE: () => MERGE_ATTRIBUTE,
+  MERGE_DRIVER_COMMAND: () => MERGE_DRIVER_COMMAND,
+  MERGE_DRIVER_NAME: () => MERGE_DRIVER_NAME,
+  mergeDecisionRecords: () => mergeDecisionRecords,
+  runDecisionMerge: () => runDecisionMerge
+});
+import fs23 from "fs/promises";
+function appendOnly(base, ours, theirs) {
+  if (base === void 0 && ours === void 0 && theirs === void 0) return void 0;
+  const lists = [base ?? [], ours ?? [], theirs ?? []];
+  if (!lists.every(Array.isArray)) return null;
+  const [common, current, incoming] = lists;
+  const extendsCommon = (list) => list.length >= common.length && common.every((entry, i) => canonical(entry) === canonical(list[i]));
+  if (!extendsCommon(current) || !extendsCommon(incoming)) return null;
+  const added = /* @__PURE__ */ new Map();
+  for (const entry of [...current.slice(common.length), ...incoming.slice(common.length)])
+    added.set(canonical(entry), entry);
+  const at = (entry) => String(entry.at ?? "");
+  const appended = [...added].sort(
+    ([a, x], [b, y]) => at(x) < at(y) ? -1 : at(x) > at(y) ? 1 : a < b ? -1 : a > b ? 1 : 0
+  );
+  return [...common, ...appended.map(([, entry]) => entry)];
+}
+function mergeDecisionRecords(baseText, oursText, theirsText, expectedId) {
+  const conflict = (reason) => ({ status: "conflict", reason });
+  let parsed;
+  try {
+    parsed = [baseText, oursText, theirsText].map((text2) => JSON.parse(text2));
+  } catch {
+    return conflict("a version is not valid JSON");
+  }
+  if (!parsed.every((value) => value && typeof value === "object" && !Array.isArray(value)))
+    return conflict("a version is not a JSON object");
+  const [base, ours, theirs] = parsed;
+  for (const [label, side] of [
+    ["current", ours],
+    ["incoming", theirs]
+  ])
+    if (!decisionSchema.safeParse(side).success)
+      return conflict(`the ${label} version is not a valid decision record`);
+  const merged = {};
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(ours), ...Object.keys(theirs), ...Object.keys(base)])) {
+    if (APPEND_ONLY.has(key)) {
+      const list = appendOnly(base[key], ours[key], theirs[key]);
+      if (list === null) return conflict(`${key} on one side does not extend the common version`);
+      if (list !== void 0) merged[key] = list;
+      continue;
+    }
+    const [b, o, t] = [base[key], ours[key], theirs[key]].map(canonical);
+    if (o !== t && o !== b && t !== b) return conflict(`both sides changed ${key}`);
+    const value = o === b ? theirs[key] : ours[key];
+    if (value !== void 0) merged[key] = value;
+  }
+  const result = decisionSchema.safeParse(merged);
+  if (!result.success)
+    return conflict(`the combined record is invalid: ${result.error.issues[0].message}`);
+  if (expectedId !== void 0 && result.data.id !== expectedId)
+    return conflict("the record id does not match its file name");
+  return { status: "merged", text: JSON.stringify(result.data, null, 2) + "\n" };
+}
+async function runDecisionMerge(args2) {
+  const [basePath, oursPath, theirsPath, , pathname] = args2;
+  if (!basePath || !oursPath || !theirsPath || args2.length > 5)
+    throw new Error(
+      "Usage: mason merge-decision <base> <current> <incoming> [marker-size] [path]. Git runs this through the merge driver that mason setup configures."
+    );
+  const read = async (file) => {
+    const text2 = await readBoundedFile(file, 10 * 1024 * 1024);
+    if (text2 === null) throw new Error(`${file} is not a regular file or exceeds 10 MiB`);
+    return text2;
+  };
+  const id = pathname && /(?:^|\/)\.mason\/decisions\/([^/]+)\.json$/.exec(pathname)?.[1];
+  const result = mergeDecisionRecords(
+    await read(basePath),
+    await read(oursPath),
+    await read(theirsPath),
+    id || void 0
+  );
+  if (result.status === "conflict") {
+    console.error(
+      `Mason: ${pathname || "decision record"}: ${result.reason}; leaving it to Git's text merge.`
+    );
+    return 1;
+  }
+  await fs23.writeFile(oursPath, result.text, "utf8");
+  return 0;
+}
+var MERGE_DRIVER_NAME, MERGE_ATTRIBUTE, MERGE_DRIVER_COMMAND, APPEND_ONLY, canonical;
+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";
+    APPEND_ONLY = /* @__PURE__ */ new Set(["history", "inspections"]);
+    canonical = (value) => JSON.stringify(
+      value,
+      (_, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : item
+    );
+  }
+});
+
 // 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";
@@ -6873,6 +7393,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/*",
@@ -6890,9 +7411,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 ?? "{}"));
@@ -6943,7 +7500,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,
@@ -6965,6 +7525,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";
@@ -7011,7 +7572,7 @@ async function planAutomationInstall(root, host, command2) {
   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(
@@ -7045,7 +7606,7 @@ async function installLocked(root, host, command2) {
     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."
   };
@@ -7060,7 +7621,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
@@ -7070,7 +7631,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."
     };
   }
@@ -7106,7 +7667,7 @@ __export(teardown_exports, {
   teardownProject: () => teardownProject
 });
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
-import fs23 from "fs/promises";
+import fs24 from "fs/promises";
 import path25 from "path";
 import { parse as parse3, stringify as stringify2 } from "smol-toml";
 import fg8 from "fast-glob";
@@ -7132,7 +7693,7 @@ async function planProjectTeardown(root, selected) {
   const ownership = ownershipBefore === null ? { version: 1, files: {} } : ownershipSchema.parse(JSON.parse(ownershipBefore));
   const setupBefore = await read(SETUP_PATH);
   const setup = setupBefore === null ? null : setupSchema.parse(JSON.parse(setupBefore));
-  const linked = (await workspace(root)).gitDir !== await fs23.realpath(
+  const linked = (await workspace(root)).gitDir !== await fs24.realpath(
     path25.resolve(root, (await git3(root, "rev-parse", "--git-common-dir")).trim())
   );
   const inactiveBefore = linked && !setup ? await read(INACTIVE_HOSTS_PATH) : null;
@@ -7282,9 +7843,9 @@ async function planProjectTeardown(root, selected) {
           const block = blockSpan(after, start, end);
           if (!block) continue;
           const pointer = "Mason project knowledge and shared project instructions:\n@" + (file.startsWith(".claude/") ? "../AGENTS.md" : "AGENTS.md");
-          const canonical = [CLAUDE_MD_SECTION, managedBlock("", start, end, pointer).trimEnd()];
+          const canonical2 = [CLAUDE_MD_SECTION, managedBlock("", start, end, pointer).trimEnd()];
           const expected = ownership.files[file]?.blocks[start];
-          if (expected ? hash(block.text) !== expected : !canonical.includes(block.text.replace(/\r\n/g, "\n"))) {
+          if (expected ? hash(block.text) !== expected : !canonical2.includes(block.text.replace(/\r\n/g, "\n"))) {
             throw new Error(
               "The Mason instruction block was edited or is unrecognized; retained for manual cleanup."
             );
@@ -7376,7 +7937,7 @@ async function planLocalTeardown(root, selected) {
   if (setup) edits.push({ path: SETUP_PATH, before: setupBefore, after: json(setup) });
   if (automation)
     edits.push({ path: AUTOMATION_PATH, before: automationBefore, after: json(automation) });
-  const linked = (await workspace(root)).gitDir !== await fs23.realpath(
+  const linked = (await workspace(root)).gitDir !== await fs24.realpath(
     path25.resolve(root, (await git3(root, "rev-parse", "--git-common-dir")).trim())
   );
   if (linked && !setup) {
@@ -7455,7 +8016,7 @@ function summarizeTeardown(result) {
     ),
     ...result.diagnostics.map((item) => `  Retained ${item.path}: ${item.message}`),
     ...!result.changes.length ? ["No changes."] : [],
-    "Shared knowledge, repair evidence, ignore rules and the installed Mason command are retained.",
+    "Shared knowledge, repair evidence, ignore rules, the decision merge driver and the installed Mason command are retained.",
     ...result.scope === "project" && result.sharedInstructionsRetained ? [
       "Shared instruction cleanup is deferred while another host or incomplete removal needs inspection."
     ] : [],
@@ -7493,6 +8054,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) => ({
@@ -7523,6 +8085,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."
     };
   }
@@ -7597,6 +8160,7 @@ async function setupStatus(dir) {
     hosts: hosts2,
     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."
   };
@@ -7619,6 +8183,8 @@ function summarizeActivation(status) {
     lines.push(...state.updates.map((message) => "  Optional: " + message));
   }
   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");
 }
@@ -7736,6 +8302,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)
@@ -7759,6 +8326,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."
     };
@@ -7770,6 +8338,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.",
@@ -7844,12 +8413,12 @@ var init_setup = __esm({
 });
 
 // src/distribution/path.ts
-import fs24 from "fs/promises";
+import fs25 from "fs/promises";
 import os4 from "os";
 import path26 from "path";
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-import { createHash as createHash7, randomUUID as randomUUID7 } from "crypto";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+import { createHash as createHash8, randomUUID as randomUUID7 } from "crypto";
 import { z as z27 } from "zod";
 async function configurePath(bin, previous, save, options = {}) {
   const env = options.env ?? process.env, platform = options.platform ?? process.platform;
@@ -7897,7 +8466,7 @@ ${alreadyOnPath ? "" : `Add ${bin} to your PATH.
       );
       let login = candidates[2];
       for (const file of candidates)
-        if (await fs24.lstat(file).then(
+        if (await fs25.lstat(file).then(
           () => true,
           (error) => {
             if (hasErrorCode(error, "ENOENT")) return false;
@@ -7909,14 +8478,14 @@ ${alreadyOnPath ? "" : `Add ${bin} to your PATH.
         }
       profiles2 = [path26.join(userHome, ".bashrc"), login];
     }
-    const marker = `# >>> mason PATH ${createHash7("sha256").update(bin).digest("hex").slice(0, 12)} >>>`;
+    const marker = `# >>> mason PATH ${createHash8("sha256").update(bin).digest("hex").slice(0, 12)} >>>`;
     for (const profile of profiles2) {
-      const stat = await fs24.lstat(profile).catch((error) => {
+      const stat = await fs25.lstat(profile).catch((error) => {
         if (hasErrorCode(error, "ENOENT")) return null;
         throw error;
       });
-      const file = stat?.isSymbolicLink() ? await fs24.realpath(profile) : path26.resolve(profile);
-      const original = await fs24.readFile(file).catch((error) => {
+      const file = stat?.isSymbolicLink() ? await fs25.realpath(profile) : path26.resolve(profile);
+      const original = await fs25.readFile(file).catch((error) => {
         if (hasErrorCode(error, "ENOENT") && !stat) return null;
         throw error;
       });
@@ -7935,8 +8504,8 @@ ${alreadyOnPath ? "" : `Add ${bin} to your PATH.
         changes.push({ kind: "profile", file, block, created: original === null });
         await save(changes);
       }
-      await fs24.mkdir(path26.dirname(file), { recursive: true });
-      const handle = await fs24.open(file, original === null ? "ax+" : "a+", 384);
+      await fs25.mkdir(path26.dirname(file), { recursive: true });
+      const handle = await fs25.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}`);
@@ -7964,13 +8533,13 @@ async function removePath(changes) {
         await windowsPath("remove", change.entry, current, change.created);
         continue;
       }
-      const stat = await fs24.lstat(change.file).catch((error) => {
+      const stat = await fs25.lstat(change.file).catch((error) => {
         if (hasErrorCode(error, "ENOENT")) return null;
         throw error;
       });
       if (!stat) continue;
       if (!stat.isFile()) throw new Error("profile type changed");
-      const bytes = await fs24.readFile(change.file), text2 = bytes.toString("utf8");
+      const bytes = await fs25.readFile(change.file), text2 = bytes.toString("utf8");
       if (!Buffer.from(text2).equals(bytes)) throw new Error("profile encoding changed");
       const index = text2.indexOf(change.block);
       if (index < 0 || text2.indexOf(change.block, index + change.block.length) >= 0)
@@ -7981,7 +8550,7 @@ async function removePath(changes) {
       const temporary = change.file + ".mason-" + randomUUID7();
       try {
         if (stat.nlink > 1) throw new Error("profile has multiple hard links");
-        const handle = await fs24.open(temporary, "wx", stat.mode & 511);
+        const handle = await fs25.open(temporary, "wx", stat.mode & 511);
         try {
           await handle.writeFile(next);
           await handle.chmod(stat.mode & 511);
@@ -7990,12 +8559,12 @@ async function removePath(changes) {
         } finally {
           await handle.close();
         }
-        const current = await fs24.lstat(change.file);
-        if (!current.isFile() || current.ino !== stat.ino || !(await fs24.readFile(change.file)).equals(bytes))
+        const current = await fs25.lstat(change.file);
+        if (!current.isFile() || current.ino !== stat.ino || !(await fs25.readFile(change.file)).equals(bytes))
           throw new Error("profile changed during uninstall");
-        await fs24.rename(temporary, change.file);
+        await fs25.rename(temporary, change.file);
       } finally {
-        await fs24.rm(temporary, { force: true });
+        await fs25.rm(temporary, { force: true });
       }
     } catch (error) {
       warnings.push(
@@ -8052,7 +8621,7 @@ var init_path = __esm({
   "src/distribution/path.ts"() {
     "use strict";
     init_validation();
-    execute2 = promisify3(execFile3);
+    execute2 = promisify4(execFile4);
     pathChangeSchema = z27.discriminatedUnion("kind", [
       z27.object({
         kind: z27.literal("profile"),
@@ -8088,7 +8657,7 @@ __export(state_exports, {
 import os5 from "os";
 import path27 from "path";
 import { fileURLToPath } from "url";
-import fs25 from "fs/promises";
+import fs26 from "fs/promises";
 import { z as z28 } from "zod";
 async function readInstallation(home) {
   const raw = await readStoreJson(home, "install.json");
@@ -8097,7 +8666,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 fs25.realpath(home))
+  if (record.home !== await fs26.realpath(home))
     throw new Error("Invalid standalone installation receipt.");
   return record;
 }
@@ -8162,12 +8731,12 @@ var init_state = __esm({
 });
 
 // src/distribution/bundle.ts
-import fs26 from "fs/promises";
+import fs27 from "fs/promises";
 import path28 from "path";
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { z as z29 } from "zod";
 async function readBundle(root) {
-  const bytes = await fs26.readFile(await storePath(root, "bundle.json"));
+  const bytes = await fs27.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)) {
@@ -8197,7 +8766,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 fs26.readFile(await storePath(root, file))) !== bundle.manifest.files[file])
+        if (sha256(await fs27.readFile(await storePath(root, file))) !== bundle.manifest.files[file])
           throw new Error("Mason bundle checksum mismatch: " + file);
       })
     );
@@ -8224,7 +8793,7 @@ var init_bundle = __esm({
       nodeVersion: z29.string(),
       files: z29.record(digest2)
     }).strict();
-    sha256 = (bytes) => createHash8("sha256").update(bytes).digest("hex");
+    sha256 = (bytes) => createHash9("sha256").update(bytes).digest("hex");
   }
 });
 
@@ -8247,7 +8816,7 @@ var init_trust2 = __esm({
 });
 
 // src/distribution/runtime.ts
-import fs27 from "fs/promises";
+import fs28 from "fs/promises";
 import { unlinkSync } from "fs";
 import os6 from "os";
 import path29 from "path";
@@ -8258,13 +8827,13 @@ async function pruneUnusedVersions(home) {
   const candidates = [];
   const initial = await readInstallation(home);
   const initialKeep = /* @__PURE__ */ new Set([initial.current, initial.previous?.id, initial.pending?.id]);
-  for (const name of await fs27.readdir(versions)) {
+  for (const name of await fs28.readdir(versions)) {
     const retired = /^\.retired-([a-f0-9]{24})-[a-f0-9-]+$/.exec(name);
     const id = retired?.[1] ?? name;
     if (!/^[a-f0-9]{24}$/.test(id) || initialKeep.has(id)) continue;
     try {
       const directory3 = await storePath(home, `versions/${name}`);
-      await fs27.access(await storePath(directory3, "app/dist/mason-runtime.js"));
+      await fs28.access(await storePath(directory3, "app/dist/mason-runtime.js"));
       const bundle = await verifyBundle(directory3);
       if (bundle.manifestHash.slice(0, 24) === id && bundle.manifest.files["app/dist/mason-runtime.js"])
         candidates.push({ id, directory: directory3, retired: !!retired });
@@ -8277,7 +8846,7 @@ async function pruneUnusedVersions(home) {
     const record = await readInstallation(home);
     const keep = /* @__PURE__ */ new Set([record.current, record.previous?.id, record.pending?.id]);
     const directory3 = await storePath(home, "runtimes");
-    const leases = await fs27.readdir(directory3).catch((error) => {
+    const leases = await fs28.readdir(directory3).catch((error) => {
       if (hasErrorCode(error, "ENOENT")) return [];
       throw error;
     });
@@ -8293,7 +8862,7 @@ async function pruneUnusedVersions(home) {
           keep.add(lease.bundle);
         } catch (error) {
           if (error.code !== "ESRCH") return;
-          await fs27.rm(await storePath(home, `runtimes/${name}`), { force: true });
+          await fs28.rm(await storePath(home, `runtimes/${name}`), { force: true });
         }
       } catch {
         return;
@@ -8303,13 +8872,13 @@ async function pruneUnusedVersions(home) {
       if (keep.has(candidate.id)) continue;
       try {
         const retired = candidate.retired ? candidate.directory : await storePath(home, `versions/.retired-${candidate.id}-${randomUUID8()}`);
-        if (!candidate.retired) await fs27.rename(candidate.directory, retired);
+        if (!candidate.retired) await fs28.rename(candidate.directory, retired);
         garbage.push(retired);
       } catch {
       }
     }
   });
-  for (const directory3 of garbage) await fs27.rm(directory3, { recursive: true }).catch(() => {
+  for (const directory3 of garbage) await fs28.rm(directory3, { recursive: true }).catch(() => {
   });
 }
 var leaseSchema;
@@ -8331,13 +8900,13 @@ var init_runtime2 = __esm({
 });
 
 // src/distribution/sessions.ts
-import fs28 from "fs/promises";
+import fs29 from "fs/promises";
 import os7 from "os";
 import { randomUUID as randomUUID9 } from "crypto";
 import { z as z31 } from "zod";
 async function hasRunningMcp(home) {
   const directory3 = await storePath(home, "sessions");
-  const files = await fs28.readdir(directory3).catch((error) => {
+  const files = await fs29.readdir(directory3).catch((error) => {
     if (hasErrorCode(error, "ENOENT")) return [];
     throw error;
   });
@@ -8355,7 +8924,7 @@ async function hasRunningMcp(home) {
       } catch (error) {
         if (error.code !== "ESRCH") return true;
       }
-      await fs28.rm(await storePath(home, relative), { force: true });
+      await fs29.rm(await storePath(home, relative), { force: true });
     } catch {
       return true;
     }
@@ -8366,7 +8935,7 @@ async function registerMcp(home) {
   const name = `sessions/${randomUUID9()}.json`;
   await writeStoreJson(home, name, { pid: process.pid, host: os7.hostname() });
   return async () => {
-    await fs28.rm(await storePath(home, name), { force: true }).catch(() => {
+    await fs29.rm(await storePath(home, name), { force: true }).catch(() => {
     });
   };
 }
@@ -8391,27 +8960,27 @@ __export(install_exports2, {
   uninstallStandalone: () => uninstallStandalone,
   upgradeStandalone: () => upgradeStandalone
 });
-import fs29 from "fs/promises";
+import fs30 from "fs/promises";
 import os8 from "os";
 import path30 from "path";
-import { execFile as execFile4, spawn } from "child_process";
-import { promisify as promisify4 } from "util";
+import { execFile as execFile5, spawn } from "child_process";
+import { promisify as promisify5 } from "util";
 import { randomUUID as randomUUID10 } from "crypto";
 async function replace(file, content2, mode = 384) {
   const temp = file + ".tmp-" + randomUUID10();
   try {
-    await fs29.writeFile(temp, content2, { mode, flag: "wx" });
-    await fs29.rename(temp, file);
+    await fs30.writeFile(temp, content2, { mode, flag: "wx" });
+    await fs30.rename(temp, file);
   } finally {
-    await fs29.rm(temp, { force: true });
+    await fs30.rm(temp, { force: true });
   }
 }
 async function installStandalone(source, progress2, options = {}) {
   progress2?.step("Checking installation files and location");
   const bundle = await verifyBundle(source);
   const selectedHome = path30.resolve(defaultHome());
-  if (!options.stageOnly) await fs29.mkdir(selectedHome, { recursive: true });
-  const home = await fs29.realpath(selectedHome);
+  if (!options.stageOnly) await fs30.mkdir(selectedHome, { recursive: true });
+  const home = await fs30.realpath(selectedHome);
   if (options.stageOnly) {
     assertUpdatePolicy(
       await readInstallation(home),
@@ -8420,7 +8989,7 @@ async function installStandalone(source, progress2, options = {}) {
     );
     const destination = await storePath(home, "versions/" + bundle.manifestHash.slice(0, 24));
     await copyBundle(home, source, destination, bundle);
-    const { stdout } = await promisify4(execFile4)(
+    const { stdout } = await promisify5(execFile5)(
       path30.join(destination, process.platform === "win32" ? "node.exe" : "node"),
       [path30.join(destination, "app/dist/mason.js"), "--version"],
       { timeout: 3e4, windowsHide: true, env: { ...process.env, MASON_NO_AUTO_UPDATE: "1" } }
@@ -8445,19 +9014,19 @@ async function installLocked2(home, source, bundle, progress2, options, alreadyS
   if (options.stageOnly)
     assertUpdatePolicy(previous, bundle.manifest.version, options.policyRevision);
   if (!previous)
-    for (const file of await fs29.readdir(home)) {
+    for (const file of await fs30.readdir(home)) {
       if (file === ".install-lock") continue;
       const directory3 = path30.join(home, file);
-      const stat = await fs29.lstat(directory3);
-      if (!["versions", "bin"].includes(file) || !stat.isDirectory() || (await fs29.readdir(directory3)).length) {
+      const stat = await fs30.lstat(directory3);
+      if (!["versions", "bin"].includes(file) || !stat.isDirectory() || (await fs30.readdir(directory3)).length) {
         throw new Error("Mason installation directory is not empty and has no ownership receipt.");
       }
     }
   const selectedBin = path30.resolve(
     process.env.MASON_BIN_DIR ?? previous?.bin ?? (process.platform === "win32" ? path30.join(home, "bin") : path30.join(os8.homedir(), ".local/bin"))
   );
-  await fs29.mkdir(selectedBin, { recursive: true });
-  const bin = await fs29.realpath(selectedBin);
+  await fs30.mkdir(selectedBin, { recursive: true });
+  const bin = await fs30.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);
@@ -8501,7 +9070,7 @@ exec ${shQuote(path30.join(destination, "node"))} ${shQuote(path30.join(destinat
   };
   for (const [name, content2] of Object.entries(launchers)) {
     const file = await storePath(bin, name);
-    const old = await fs29.readFile(file, "utf8").catch((error) => {
+    const old = await fs30.readFile(file, "utf8").catch((error) => {
       if (hasErrorCode(error, "ENOENT")) return null;
       throw error;
     });
@@ -8513,7 +9082,7 @@ exec ${shQuote(path30.join(destination, "node"))} ${shQuote(path30.join(destinat
   );
   const checkRetired = async (name, expected) => {
     if (!launcherNames.includes(name)) throw new Error("Invalid owned launcher name.");
-    const actual = await fs29.readFile(await storePath(bin, name), "utf8").catch((error) => {
+    const actual = await fs30.readFile(await storePath(bin, name), "utf8").catch((error) => {
       if (hasErrorCode(error, "ENOENT")) return null;
       throw error;
     });
@@ -8556,7 +9125,7 @@ exec ${shQuote(path30.join(destination, "node"))} ${shQuote(path30.join(destinat
       await replace(await storePath(bin, name, true), content2, 493);
     for (const [name, expected] of retired) {
       await checkRetired(name, expected);
-      await fs29.rm(await storePath(bin, name), { force: true });
+      await fs30.rm(await storePath(bin, name), { force: true });
     }
     await writeStoreJson(home, "install.json", receipt);
   } catch (error) {
@@ -8589,7 +9158,7 @@ exec ${shQuote(path30.join(destination, "node"))} ${shQuote(path30.join(destinat
   };
 }
 async function copyBundle(home, source, destination, bundle) {
-  const exists2 = await fs29.lstat(destination).then(
+  const exists2 = await fs30.lstat(destination).then(
     () => true,
     (error) => {
       if (hasErrorCode(error, "ENOENT")) return false;
@@ -8601,16 +9170,16 @@ async function copyBundle(home, source, destination, bundle) {
     return;
   }
   const stage = await storePath(home, "versions/.install-" + randomUUID10(), true);
-  await fs29.mkdir(stage);
+  await fs30.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 fs29.copyFile(from, to);
-      await fs29.chmod(to, (await fs29.stat(from)).mode & 511);
+      await fs30.copyFile(from, to);
+      await fs30.chmod(to, (await fs30.stat(from)).mode & 511);
     }
     await verifyBundle(stage, bundle.manifestHash);
     try {
-      await fs29.rename(stage, destination);
+      await fs30.rename(stage, destination);
     } catch (error) {
       try {
         await verifyBundle(destination, bundle.manifestHash);
@@ -8619,7 +9188,7 @@ async function copyBundle(home, source, destination, bundle) {
       }
     }
   } finally {
-    await fs29.rm(stage, { recursive: true, force: true });
+    await fs30.rm(stage, { recursive: true, force: true });
   }
 }
 async function prepareStandaloneMcp(home) {
@@ -8766,7 +9335,7 @@ async function uninstallStandalone() {
     for (const [name, expected] of Object.entries(record.launchers)) {
       if (!launcherNames.includes(name)) throw new Error("Invalid owned launcher name.");
       const file = await storePath(record.bin, name);
-      const actual = await fs29.readFile(file, "utf8").catch((error) => {
+      const actual = await fs30.readFile(file, "utf8").catch((error) => {
         if (hasErrorCode(error, "ENOENT")) return null;
         throw error;
       });
@@ -8777,9 +9346,9 @@ async function uninstallStandalone() {
     if (process.platform === "win32")
       await replace(await storePath(home, ".uninstall-request.txt", true), token);
     for (const name of Object.keys(record.launchers))
-      await fs29.rm(await storePath(record.bin, name), { force: true });
+      await fs30.rm(await storePath(record.bin, name), { force: true });
   });
-  if (process.platform !== "win32") await fs29.rm(home, { recursive: true, force: true });
+  if (process.platform !== "win32") await fs30.rm(home, { recursive: true, force: true });
   return home;
 }
 var shQuote, psQuote, WINDOWS_BATCH_LAUNCHER, launcherNames;
@@ -8815,7 +9384,7 @@ __export(updates_exports, {
   updateSettings: () => updateSettings,
   updateStatus: () => updateStatus
 });
-import fs30 from "fs/promises";
+import fs31 from "fs/promises";
 import path31 from "path";
 import { spawn as spawn2 } from "child_process";
 import { randomUUID as randomUUID11 } from "crypto";
@@ -8952,7 +9521,7 @@ async function runAutomaticUpdate(home, dependencies = { fetchRelease: fetchVeri
       } catch (error) {
         status.error = error instanceof Error ? error.message : String(error);
       }
-      if (await fs30.access(path31.join(home, "install.json")).then(
+      if (await fs31.access(path31.join(home, "install.json")).then(
         () => true,
         () => false
       ))
@@ -9419,7 +9988,7 @@ var inputArgs = process.argv.slice(2);
 var managedLaunch = inputArgs[0] === "--setup-host";
 var setupHost = managedLaunch ? inputArgs.splice(0, 2)[1] : void 0;
 var [command, ...args] = inputArgs;
-var usage = `Mason ${"0.22.0"}
+var usage = `Mason ${"0.23.1"}
 
 Usage: mason <command> [options]
 
@@ -9436,6 +10005,8 @@ Usage: mason <command> [options]
   review --base <ref>         Review committed changes
   drift                      Check an optional architecture map
   mcp                        Run the MCP server (stdio)
+  merge-decision <base> <current> <incoming>
+                             Git merge driver for decision records (set by setup)
   upgrade [version]          Upgrade the standalone user installation
   updates [status|enable|disable|pin|unpin]
                              Manage automatic standalone updates
@@ -9456,9 +10027,9 @@ try {
     }
   }
   if (command === "internal-integration-version")
-    console.log(JSON.stringify({ protocol: 1, version: "0.22.0" }));
+    console.log(JSON.stringify({ protocol: 1, version: "0.23.1" }));
   else if (!command || ["--help", "-h", "help"].includes(command)) console.log(usage);
-  else if (["--version", "-v"].includes(command)) console.log("0.22.0");
+  else if (["--version", "-v"].includes(command)) console.log("0.23.1");
   else if (command === "internal-update") {
     if (args.length) throw new Error("internal-update takes no arguments.");
     const { currentInstallation: currentInstallation2 } = await Promise.resolve().then(() => (init_state(), state_exports));
@@ -9492,6 +10063,9 @@ ${installed.path.message}
 Automatic updates: ${policy}. Manage with mason updates.`
       );
     }
+  } else if (command === "merge-decision") {
+    const { runDecisionMerge: runDecisionMerge2 } = await Promise.resolve().then(() => (init_merge(), merge_exports));
+    process.exitCode = await runDecisionMerge2(args);
   } else if (command === "updates") {
     if (args.includes("--help"))
       console.log(