mason-context 0.16.1 → 0.16.3

package/dist/mason-mcp.js

@@ -685,87 +685,435 @@ var init_snapshot = __esm({
   }
 });
 
-// src/drift/drift.ts
-import fs3 from "fs/promises";
+// src/context/lexical.ts
 import path6 from "path";
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-function parseChanges(output) {
-  const fields = output.split("\0");
-  const changes = [];
-  for (let i = 0; i < fields.length && fields[i]; ) {
-    const code = fields[i++];
-    const first = fields[i++];
-    if (!first) break;
-    const second = /^[RC]/.test(code) ? fields[i++] : void 0;
-    const change = second ? code.startsWith("R") ? { status: "renamed", path: second, previousPath: first } : { status: "added", path: second } : { status: code === "A" ? "added" : code === "D" ? "deleted" : "modified", path: first };
-    if (change.path.startsWith(".mason/") && (!change.previousPath || change.previousPath.startsWith(".mason/"))) continue;
-    changes.push(change);
-  }
-  return changes;
+function tokenize(text2) {
+  return text2.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2 && !STOPWORDS.has(t));
 }
-function touchedPaths(changes) {
-  return [...new Set(changes.flatMap((c) => c.previousPath ? [c.previousPath, c.path] : [c.path]))].sort();
+function stem(token) {
+  return token.length > 3 && token.endsWith("s") ? token.slice(0, -1) : token;
 }
-async function getChangesWithStatus(resolvedRoot, fromHash, toHash = "HEAD") {
-  if (!fromHash || fromHash === "unknown" || fromHash.startsWith("-") || !toHash || toHash === "unknown" || toHash.startsWith("-")) return null;
-  try {
-    const { stdout } = await exec3("git", ["diff", "--name-status", "-z", "-M", fromHash, toHash, "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 });
-    return parseChanges(stdout);
-  } catch {
-    return null;
+function tokenSet(text2) {
+  return new Set(tokenize(text2).map(stem));
+}
+function scoreEntry(taskTokens, entry) {
+  const nameTokens = tokenSet(entry.name);
+  const descTokens = tokenSet(entry.description);
+  const fileTokens = tokenSet(entry.files.map((f) => path6.basename(f)).join(" "));
+  let score = 0;
+  for (const token of taskTokens) {
+    if (nameTokens.has(token)) score += 3;
+    else if (descTokens.has(token)) score += 1;
+    else if (fileTokens.has(token)) score += 1;
   }
+  return score;
 }
-async function getWorkingTree(resolvedRoot) {
-  try {
-    const [diff, untracked] = await Promise.all([
-      exec3("git", ["diff", "--name-status", "-z", "-M", "HEAD", "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }),
-      exec3("git", ["ls-files", "-z", "--others", "--exclude-standard"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 })
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersection = 0;
+  for (const token of a) if (b.has(token)) intersection++;
+  return intersection / (a.size + b.size - intersection);
+}
+var STOPWORDS;
+var init_lexical = __esm({
+  "src/context/lexical.ts"() {
+    "use strict";
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "and",
+      "or",
+      "of",
+      "to",
+      "in",
+      "on",
+      "for",
+      "with",
+      "how",
+      "does",
+      "do",
+      "is",
+      "are",
+      "was",
+      "what",
+      "where",
+      "which",
+      "why",
+      "when",
+      "who",
+      "i",
+      "we",
+      "my",
+      "our",
+      "you",
+      "your",
+      "it",
+      "its",
+      "this",
+      "that",
+      "these",
+      "those",
+      "can",
+      "could",
+      "should",
+      "would",
+      "will",
+      "want",
+      "need",
+      "please",
+      "about",
+      "into",
+      "from",
+      "when",
+      "there",
+      "any",
+      "all",
+      "some",
+      "not",
+      "but",
+      "also",
+      "just",
+      "like",
+      "get",
+      "make",
+      "use",
+      "new",
+      "work",
+      "works",
+      "working",
+      "implement",
+      "implemented",
+      "change",
+      "changed",
+      "file",
+      "files",
+      "code"
     ]);
-    const untrackedFiles = untracked.stdout.split("\0").filter((f) => f && !f.startsWith(".mason/"));
-    return { available: true, changedFiles: [.../* @__PURE__ */ new Set([...touchedPaths(parseChanges(diff.stdout)), ...untrackedFiles])].sort(), untrackedFiles };
-  } catch {
-    return { available: false, changedFiles: [], untrackedFiles: [] };
   }
-}
-async function countCommitsBehind(resolvedRoot, fromHash) {
-  if (!fromHash || fromHash === "unknown" || fromHash.startsWith("-")) return null;
+});
+
+// src/decisions/decisions.ts
+var decisions_exports = {};
+__export(decisions_exports, {
+  BODY_MAX_CHARS: () => BODY_MAX_CHARS,
+  BODY_RECOMMENDED_CHARS: () => BODY_RECOMMENDED_CHARS,
+  MAX_ACTIVE_DECISIONS: () => MAX_ACTIVE_DECISIONS,
+  TITLE_MAX_CHARS: () => TITLE_MAX_CHARS,
+  decisionBodySchema: () => decisionBodySchema,
+  decisionIdFor: () => decisionIdFor,
+  decisionTitleSchema: () => decisionTitleSchema,
+  findNearDuplicate: () => findNearDuplicate,
+  loadDecisionStore: () => loadDecisionStore,
+  loadDecisions: () => loadDecisions,
+  saveDecisionRecord: () => saveDecisionRecord,
+  upsertDecision: () => upsertDecision,
+  withDecisionWrite: () => withDecisionWrite
+});
+import fs3 from "fs/promises";
+import path7 from "path";
+import { createHash } from "crypto";
+import { z as z3 } from "zod";
+async function loadDecisionStore(rootDir) {
+  const records = [];
+  const diagnostics = [];
+  let entries;
   try {
-    const { stdout } = await exec3(
-      "git",
-      ["rev-list", "--count", `${fromHash}..HEAD`],
-      { cwd: resolvedRoot }
+    entries = await fs3.readdir(await storePath(rootDir, ".mason/decisions"));
+  } catch (error) {
+    if (error.code !== "ENOENT") diagnostics.push({ path: ".mason/decisions", message: String(error) });
+    return { records, diagnostics };
+  }
+  for (const entry of entries.sort()) {
+    if (!entry.endsWith(".json")) continue;
+    const relative = `.mason/decisions/${entry}`;
+    try {
+      const record = decisionSchema.parse(await readStoreJson(rootDir, relative));
+      if (entry !== `${record.id}.json`) throw new Error("Record id does not match its filename");
+      records.push(record);
+    } catch (error) {
+      diagnostics.push({ path: relative, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { records, diagnostics };
+}
+async function loadDecisions(rootDir) {
+  return (await loadDecisionStore(rootDir)).records;
+}
+async function saveDecisionRecord(rootDir, record) {
+  const validated = decisionSchema.parse(record);
+  await writeStoreJson(rootDir, `.mason/decisions/${validated.id}.json`, validated);
+}
+function decisionIdFor(title, body, existingIds) {
+  const fullSlug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  let slug = fullSlug.slice(0, 60);
+  if (fullSlug.length > 60 && fullSlug[60] !== "-") {
+    const boundary = slug.lastIndexOf("-");
+    if (boundary > 0) slug = slug.slice(0, boundary);
+  }
+  slug = slug.replace(/-+$/, "") || "decision";
+  if (!existingIds.has(slug)) return slug;
+  const suffix = createHash("sha1").update(title + body).digest("hex").slice(0, 6);
+  return `${slug}-${suffix}`;
+}
+function findNearDuplicate(candidate, existing) {
+  const candidateTokens = tokenSet(`${candidate.title} ${candidate.body}`);
+  const candidateFiles = new Set(candidate.files);
+  let best = null;
+  for (const record of existing) {
+    if (record.status !== "active") continue;
+    const similarity = jaccard(
+      candidateTokens,
+      tokenSet(`${record.title} ${record.body}`)
     );
-    const count3 = Number.parseInt(stdout.trim(), 10);
-    return Number.isNaN(count3) ? null : count3;
-  } catch {
-    return null;
+    const sharesFile = record.files.some((f) => candidateFiles.has(f));
+    const threshold = sharesFile ? DUPLICATE_JACCARD_WITH_SHARED_FILE : DUPLICATE_JACCARD;
+    if (similarity >= threshold && (!best || similarity > best.similarity)) {
+      best = { record, similarity };
+    }
   }
+  return best;
 }
-function collectMappedFiles(snapshot) {
-  const mappedFiles = /* @__PURE__ */ new Set();
-  for (const feature of Object.values(snapshot.features)) {
-    for (const f of feature.files) mappedFiles.add(f);
-    for (const t of feature.tests ?? []) mappedFiles.add(t);
+async function withDecisionWrite(root, operation) {
+  const lockPath = await storePath(root, ".mason/decisions/.write-lock", true);
+  let lock;
+  try {
+    lock = await fs3.open(lockPath, "wx", 384);
+  } catch (error) {
+    if (error.code === "EEXIST") return { status: "error", error: "Decision store is locked by another write. Retry after it finishes; an abandoned .mason/decisions/.write-lock must be removed only after confirming no writer is running." };
+    throw error;
   }
-  for (const flow of Object.values(snapshot.flows)) {
-    for (const f of flow.chain) mappedFiles.add(f);
+  try {
+    return await operation();
+  } finally {
+    await lock.close();
+    await fs3.unlink(lockPath);
   }
-  return mappedFiles;
 }
-async function findGhostFiles(resolvedRoot, mappedFiles) {
-  const ghosts = [];
-  for (const file of mappedFiles) {
-    try {
-      await fs3.access(path6.join(resolvedRoot, file));
-    } catch {
-      ghosts.push(file);
+async function upsertDecision(rootDir, input) {
+  const parsedTitle = decisionTitleSchema.safeParse(input.title), parsedBody = decisionBodySchema.safeParse(input.body);
+  if (!parsedTitle.success) return { status: "error", error: parsedTitle.error.issues[0].message };
+  if (!parsedBody.success) return { status: "error", error: parsedBody.error.issues[0].message };
+  const title = parsedTitle.data, body = parsedBody.data;
+  const attribution = attributionSchema.safeParse(input);
+  if (!attribution.success) return { status: "error", error: attribution.error.message };
+  if (input.id && input.supersedes) return { status: "error", error: "Use either id to revise or supersedes to replace a record, not both." };
+  return withDecisionWrite(rootDir, async () => {
+    const store = await loadDecisionStore(rootDir);
+    if (store.diagnostics.length) return { status: "error", error: "Repair malformed decision records before saving: " + store.diagnostics.map((d) => d.path).join(", ") };
+    const existing = store.records, byId = new Map(existing.map((r) => [r.id, r]));
+    const now = (/* @__PURE__ */ new Date()).toISOString(), head = await getCurrentGitHash(rootDir);
+    const warnings = [];
+    if (body.length > BODY_RECOMMENDED_CHARS) warnings.push(`body has ${body.length} characters, above the recommended ${BODY_RECOMMENDED_CHARS}; matching context and hooks include it in full. Keep the rule, reason, and exceptions concise; use sources for supporting references.`);
+    const files = sanitizeRepoPaths(input.files ?? []);
+    if (input.files && files.length < input.files.length) warnings.push("some anchor paths were outside the repo or duplicated and were dropped");
+    for (const file of files) {
+      try {
+        await fs3.access(path7.join(rootDir, file));
+      } catch {
+        warnings.push(`anchor file does not exist on disk: ${file}`);
+      }
     }
-  }
-  return ghosts.sort();
-}
+    const hint = "Saved locally for review and commit. Proposals are not accepted constraints; an existing accepted revision remains operative while its replacement is proposed. Use review_decision to inspect evidence and record an authorized acceptance or reaffirmation.";
+    if (input.id) {
+      const original = byId.get(input.id);
+      if (!original) return { status: "error", error: `no decision with id "${input.id}"` };
+      if (original.status !== "active") return { status: "error", error: "Archived records cannot be revised; create a new proposal." };
+      const record2 = importLegacy(original, now);
+      const content3 = decisionContent({
+        ...record2,
+        title,
+        body,
+        category: input.category,
+        files: input.files !== void 0 ? files : record2.files,
+        owner: attribution.data.owner === void 0 ? record2.owner : attribution.data.owner ?? void 0,
+        sources: attribution.data.sources ?? record2.sources
+      });
+      if (JSON.stringify(content3) === JSON.stringify(decisionContent(record2))) {
+        return {
+          status: "unchanged",
+          id: record2.id,
+          totalActive: existing.filter((r) => r.status === "active").length,
+          approval: decisionApproval(original),
+          warnings,
+          hint: "Unchanged content; no review or freshness stamp was written. Use review_decision for explicit re-verification."
+        };
+      }
+      const revision = record2.revision + 1;
+      const updated = {
+        ...record2,
+        ...content3,
+        owner: content3.owner,
+        updatedAt: now,
+        revision,
+        approval: "proposed",
+        history: [...record2.history, { kind: "revised", at: now, actor: attribution.data.actor, revision, content: content3, approval: "proposed", status: "active", refreshedHash: record2.refreshedHash }]
+      };
+      await saveDecisionRecord(rootDir, updated);
+      return { status: "updated", id: record2.id, totalActive: existing.filter((r) => r.status === "active").length, approval: "proposed", warnings, hint };
+    }
+    const old = input.supersedes ? byId.get(input.supersedes) : void 0;
+    if (input.supersedes && !old) return { status: "error", error: `no decision with id "${input.supersedes}" to supersede` };
+    if (old && (old.status !== "active" || decisionApproval(effectiveDecision(old)) === "accepted")) {
+      return { status: "error", error: "A proposal cannot supersede an accepted or archived record. Create and review the replacement separately, then explicitly retire the old decision with review_decision." };
+    }
+    if (!input.force) {
+      const duplicate = findNearDuplicate({ title, body, files }, existing);
+      if (duplicate) return { status: "duplicate_suspected", existing: duplicate.record, hint: `A similar decision exists ("${duplicate.record.title}"). Call save_decision with id="${duplicate.record.id}" to revise it, or force:true if distinct.` };
+    }
+    const id = decisionIdFor(title, body, new Set(byId.keys()));
+    if (byId.has(id)) return { status: "error", error: `Decision id collision: ${id}. Choose a distinct title or revise the existing record.` };
+    const content2 = decisionContent({ title, body, category: input.category, files, owner: attribution.data.owner ?? void 0, sources: attribution.data.sources ?? [] });
+    const record = {
+      ...content2,
+      version: 2,
+      id,
+      createdAt: now,
+      updatedAt: now,
+      refreshedHash: head,
+      status: "active",
+      approval: "proposed",
+      revision: 1,
+      history: [{ kind: "created", at: now, actor: attribution.data.actor, revision: 1, content: content2, approval: "proposed", status: "active", refreshedHash: head }]
+    };
+    await saveDecisionRecord(rootDir, record);
+    if (old) {
+      const imported = importLegacy(old, now);
+      await saveDecisionRecord(rootDir, {
+        ...imported,
+        status: "superseded",
+        supersededBy: id,
+        updatedAt: now,
+        history: [...imported.history, {
+          kind: "superseded",
+          at: now,
+          actor: attribution.data.actor,
+          note: `Replaced by proposal ${id}`,
+          revision: imported.revision,
+          content: decisionContent(imported),
+          approval: imported.approval,
+          status: "superseded",
+          refreshedHash: imported.refreshedHash
+        }]
+      });
+    }
+    const totalActive = existing.filter((r) => r.status === "active").length + (old ? 0 : 1);
+    const result = { status: old ? "superseded_and_created" : "created", id, totalActive, approval: "proposed", warnings, hint };
+    if (totalActive > MAX_ACTIVE_DECISIONS) {
+      result.pruneCandidates = existing.filter((r) => r.status !== "active").map((r) => r.id).slice(0, 10);
+      warnings.push(`${totalActive} active decisions exceeds the soft cap of ${MAX_ACTIVE_DECISIONS} \u2014 consider a cleanup PR (archived records first)`);
+    }
+    return result;
+  });
+}
+var TITLE_MAX_CHARS, BODY_RECOMMENDED_CHARS, BODY_MAX_CHARS, MAX_ACTIVE_DECISIONS, boundedText, decisionTitleSchema, decisionBodySchema, DUPLICATE_JACCARD, DUPLICATE_JACCARD_WITH_SHARED_FILE;
+var init_decisions = __esm({
+  "src/decisions/decisions.ts"() {
+    "use strict";
+    init_storage();
+    init_paths();
+    init_snapshot();
+    init_lexical();
+    init_provenance();
+    TITLE_MAX_CHARS = 80;
+    BODY_RECOMMENDED_CHARS = 1500;
+    BODY_MAX_CHARS = 2500;
+    MAX_ACTIVE_DECISIONS = 150;
+    boundedText = (field, max, hint) => z3.string({
+      errorMap: (issue, ctx) => ({ message: issue.code === "too_big" ? `${field} has ${ctx.data.length} characters; maximum is ${max} (${ctx.data.length - max} over). ${hint}` : ctx.defaultError })
+    }).trim().min(1, `${field} must be non-empty`).max(max);
+    decisionTitleSchema = boundedText("title", TITLE_MAX_CHARS, "Tighten it to a specific headline.");
+    decisionBodySchema = boundedText(
+      "body",
+      BODY_MAX_CHARS,
+      `Aim for ${BODY_RECOMMENDED_CHARS} characters or fewer. Preserve the rule, reason, and exceptions; put supporting references in sources.`
+    );
+    DUPLICATE_JACCARD = 0.5;
+    DUPLICATE_JACCARD_WITH_SHARED_FILE = 0.35;
+  }
+});
+
+// src/drift/drift.ts
+import fs4 from "fs/promises";
+import path8 from "path";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+function parseChanges(output) {
+  const fields = output.split("\0");
+  const changes = [];
+  for (let i = 0; i < fields.length && fields[i]; ) {
+    const code = fields[i++];
+    const first = fields[i++];
+    if (!first) break;
+    const second = /^[RC]/.test(code) ? fields[i++] : void 0;
+    const change = second ? code.startsWith("R") ? { status: "renamed", path: second, previousPath: first } : { status: "added", path: second } : { status: code === "A" ? "added" : code === "D" ? "deleted" : "modified", path: first };
+    if (change.path.startsWith(".mason/") && (!change.previousPath || change.previousPath.startsWith(".mason/"))) continue;
+    changes.push(change);
+  }
+  return changes;
+}
+function touchedPaths(changes) {
+  return [...new Set(changes.flatMap((c) => c.previousPath ? [c.previousPath, c.path] : [c.path]))].sort();
+}
+async function getChangesWithStatus(resolvedRoot, fromHash, toHash = "HEAD") {
+  if (!fromHash || fromHash === "unknown" || fromHash.startsWith("-") || !toHash || toHash === "unknown" || toHash.startsWith("-")) return null;
+  try {
+    const { stdout } = await exec3("git", ["diff", "--name-status", "-z", "-M", fromHash, toHash, "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 });
+    return parseChanges(stdout);
+  } catch {
+    return null;
+  }
+}
+async function getWorkingTree(resolvedRoot) {
+  try {
+    const [diff, untracked] = await Promise.all([
+      exec3("git", ["diff", "--name-status", "-z", "-M", "HEAD", "--"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }),
+      exec3("git", ["ls-files", "-z", "--others", "--exclude-standard"], { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 })
+    ]);
+    const untrackedFiles = untracked.stdout.split("\0").filter((f) => f && !f.startsWith(".mason/"));
+    return { available: true, changedFiles: [.../* @__PURE__ */ new Set([...touchedPaths(parseChanges(diff.stdout)), ...untrackedFiles])].sort(), untrackedFiles };
+  } catch {
+    return { available: false, changedFiles: [], untrackedFiles: [] };
+  }
+}
+async function countCommitsBehind(resolvedRoot, fromHash) {
+  if (!fromHash || fromHash === "unknown" || fromHash.startsWith("-")) return null;
+  try {
+    const { stdout } = await exec3(
+      "git",
+      ["rev-list", "--count", `${fromHash}..HEAD`],
+      { cwd: resolvedRoot }
+    );
+    const count3 = Number.parseInt(stdout.trim(), 10);
+    return Number.isNaN(count3) ? null : count3;
+  } catch {
+    return null;
+  }
+}
+function collectMappedFiles(snapshot) {
+  const mappedFiles = /* @__PURE__ */ new Set();
+  for (const feature of Object.values(snapshot.features)) {
+    for (const f of feature.files) mappedFiles.add(f);
+    for (const t of feature.tests ?? []) mappedFiles.add(t);
+  }
+  for (const flow of Object.values(snapshot.flows)) {
+    for (const f of flow.chain) mappedFiles.add(f);
+  }
+  return mappedFiles;
+}
+async function findGhostFiles(resolvedRoot, mappedFiles) {
+  const ghosts = [];
+  for (const file of mappedFiles) {
+    try {
+      await fs4.access(path8.join(resolvedRoot, file));
+    } catch {
+      ghosts.push(file);
+    }
+  }
+  return ghosts.sort();
+}
 async function computeDrift(rootDir) {
-  const root = path6.resolve(rootDir);
+  const root = path8.resolve(rootDir);
   const snapshot = await loadSnapshot(root);
   if (!snapshot) return null;
   const [headHash, workingTree] = await Promise.all([getCurrentGitHash(root), getWorkingTree(root)]);
@@ -1229,8 +1577,8 @@ var init_git = __esm({
 });
 
 // src/audit/docs.ts
-import fs4 from "fs/promises";
-import path7 from "path";
+import fs5 from "fs/promises";
+import path9 from "path";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify5 } from "util";
 async function isDirty(resolvedRoot, relPath) {
@@ -1249,7 +1597,7 @@ async function discoverDocs(resolvedRoot) {
   const docs = await Promise.all(DOC_CANDIDATES.map(async (candidate) => {
     let content2;
     try {
-      content2 = await fs4.readFile(path7.join(resolvedRoot, candidate), "utf-8");
+      content2 = await fs5.readFile(path9.join(resolvedRoot, candidate), "utf-8");
     } catch {
       return null;
     }
@@ -1297,11 +1645,11 @@ var init_types = __esm({
 });
 
 // src/audit/checks/deleted-reference.ts
-import fs5 from "fs/promises";
-import path8 from "path";
+import fs6 from "fs/promises";
+import path10 from "path";
 async function exists(absPath) {
   try {
-    await fs5.access(absPath);
+    await fs6.access(absPath);
     return true;
   } catch {
     return false;
@@ -1321,7 +1669,7 @@ async function checkDeletedReferences(ctx) {
       if (claim.path === ".mason" || claim.path.startsWith(".mason/")) {
         continue;
       }
-      if (await exists(path8.join(ctx.root, claim.path))) continue;
+      if (await exists(path10.join(ctx.root, claim.path))) continue;
       const anchor = { doc: doc.path, line: claim.line, excerpt: claim.excerpt };
       const renamedTo = renames.get(claim.path) ?? null;
       if (renamedTo) {
@@ -1357,14 +1705,14 @@ async function checkDeletedReferences(ctx) {
             deletedInCommit: deleted,
             everTracked: true,
             parentDirExists: await exists(
-              path8.join(ctx.root, path8.dirname(claim.path))
+              path10.join(ctx.root, path10.dirname(claim.path))
             )
           }
         });
         continue;
       }
       const parentDirExists = await exists(
-        path8.join(ctx.root, path8.dirname(claim.path))
+        path10.join(ctx.root, path10.dirname(claim.path))
       );
       if (!parentDirExists) continue;
       const issue = {
@@ -1395,14 +1743,14 @@ var init_deleted_reference = __esm({
 });
 
 // src/audit/inputs.ts
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import * as nativeFs from "fs";
-import path9 from "path";
+import path11 from "path";
 import { execFile as execFile6 } from "child_process";
 import { promisify as promisify6 } from "util";
 import fg2 from "fast-glob";
 async function auditInputPath(root, file) {
-  if (file === ".") return fs6.realpath(root);
+  if (file === ".") return fs7.realpath(root);
   try {
     return await storePath(root, file);
   } catch (error) {
@@ -1426,7 +1774,7 @@ async function auditGlob(root, patterns, options) {
   if (Array.isArray(patterns) && !patterns.length) return [];
   const directories = /* @__PURE__ */ new Set();
   const readdir2 = ((directory, opts, callback) => {
-    const relative = path9.relative(root, directory).split(path9.sep).join("/") || ".";
+    const relative = path11.relative(root, directory).split(path11.sep).join("/") || ".";
     directories.add(relative);
     if (directories.size > MAX_INPUTS) {
       callback(new Error(`${options.label} exceeds ${MAX_INPUTS.toLocaleString("en-US")} directories while inspecting ${relative}. Narrow this check's inputs.`));
@@ -1437,7 +1785,7 @@ async function auditGlob(root, patterns, options) {
     }, callback);
   });
   const lstat2 = ((file, callback) => {
-    const relative = path9.relative(root, file).split(path9.sep).join("/") || ".";
+    const relative = path11.relative(root, file).split(path11.sep).join("/") || ".";
     auditInputPath(root, relative).then(() => nativeFs.lstat(file, callback), callback);
   });
   const stream = fg2.stream(patterns, {
@@ -1519,8 +1867,8 @@ var init_inputs = __esm({
 
 // src/audit/checks/new-module.ts
 import fg3 from "fast-glob";
-import fs7 from "fs/promises";
-import path10 from "path";
+import fs8 from "fs/promises";
+import path12 from "path";
 function escapeRegExp(text2) {
   return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -1562,8 +1910,8 @@ async function moduleCandidates(root, combinedDocs) {
   const ignore = [...SOURCE_IGNORE, ...config.ignore ?? []];
   const sources = sourcePaths.filter((file) => !file.split("/").some((part) => part.startsWith(".")));
   const listSubdirs = async (dir) => {
-    const entries = await fs7.readdir(await auditInputPath(root, dir), { withFileTypes: true });
-    const dirs = entries.filter((entry) => (entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith(".") && !DIR_DENYLIST.has(entry.name)).map((entry) => path10.posix.join(dir, entry.name));
+    const entries = await fs8.readdir(await auditInputPath(root, dir), { withFileTypes: true });
+    const dirs = entries.filter((entry) => (entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith(".") && !DIR_DENYLIST.has(entry.name)).map((entry) => path12.posix.join(dir, entry.name));
     const ignored = await gitIgnoredPaths(root, dirs);
     const visible = new Set(dirs.filter((dir2) => !ignored.has(dir2) || sources.some((file) => file.startsWith(dir2 + "/"))));
     return (await auditGlob(root, dir === "." ? "*" : `${fg3.escapePath(dir)}/*`, {
@@ -1571,7 +1919,7 @@ async function moduleCandidates(root, combinedDocs) {
       onlyDirectories: true,
       label: "Module directory discovery",
       select: (file) => visible.has(file)
-    })).map((file) => path10.posix.basename(file));
+    })).map((file) => path12.posix.basename(file));
   };
   const countSourceFiles = async (dir) => {
     const files = sources.filter((file) => file.startsWith(dir + "/"));
@@ -1640,7 +1988,7 @@ var init_new_module = __esm({
 });
 
 // src/audit/checks/stale-count.ts
-import path11 from "path";
+import path13 from "path";
 async function countGradleModules(root) {
   for (const name of ["settings.gradle.kts", "settings.gradle"]) {
     const content2 = await readAuditInput(root, name);
@@ -1674,7 +2022,7 @@ async function countNpmWorkspaces(root) {
       return {
         actual: matched.length,
         countedFrom: "package.json workspaces",
-        members: matched.map((m) => path11.dirname(m)).sort()
+        members: matched.map((m) => path13.dirname(m)).sort()
       };
     }
   }
@@ -1705,7 +2053,7 @@ async function countNpmWorkspaces(root) {
       return {
         actual: matched.length,
         countedFrom: "pnpm-workspace.yaml",
-        members: matched.map((m) => path11.dirname(m)).sort()
+        members: matched.map((m) => path13.dirname(m)).sort()
       };
     }
   }
@@ -1727,8 +2075,8 @@ async function countCargoCrates(root) {
         ignore: ["**/target/**"],
         label: "Cargo workspace discovery"
       });
-      for (const m of matched) members.add(path11.dirname(m));
-    } else if (await readAuditInput(root, path11.posix.join(entry, "Cargo.toml")) !== null) {
+      for (const m of matched) members.add(path13.dirname(m));
+    } else if (await readAuditInput(root, path13.posix.join(entry, "Cargo.toml")) !== null) {
       members.add(entry);
     }
   }
@@ -1895,440 +2243,113 @@ function withoutAndroidReleaseValues(text2) {
 }
 async function releaseMetadataOnly(root, commit) {
   if (!commit.files.length || !commit.files.every((file) => /(^|\/)build\.gradle(?:\.kts)?$/.test(file))) return false;
-  try {
-    const parents = (await git(root, ["rev-list", "--parents", "-n", "1", commit.hash])).trim().split(/\s+/);
-    if (parents.length !== 2) return false;
-    for (const file of commit.files) {
-      const raw = await git(root, ["diff", "--raw", "-z", "--no-renames", "--no-ext-diff", "--no-textconv", parents[1], commit.hash, "--", file]);
-      if (!/^:(100644|100755) \1 [a-f0-9]+ [a-f0-9]+ M\0/.test(raw)) return false;
-      const [before, after] = await Promise.all([
-        git(root, ["show", parents[1] + ":" + file]),
-        git(root, ["show", commit.hash + ":" + file])
-      ]);
-      const previous = withoutAndroidReleaseValues(before);
-      if (previous === null || previous !== withoutAndroidReleaseValues(after)) return false;
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-var exec6;
-var init_release_metadata = __esm({
-  "src/audit/release-metadata.ts"() {
-    "use strict";
-    exec6 = promisify7(execFile7);
-  }
-});
-
-// src/audit/checks/deps-changed.ts
-async function checkDepsChanged(ctx) {
-  const result = emptyResult();
-  result.suppressedAdvisories = [];
-  const releaseOnly = /* @__PURE__ */ new Map();
-  for (const doc of ctx.docs) {
-    if (!doc.lastCommit) {
-      result.skipped.push({
-        check: "deps-changed",
-        doc: doc.path,
-        reason: `${doc.path} has no commit history`
-      });
-      continue;
-    }
-    if (doc.dirty) {
-      result.skipped.push({
-        check: "deps-changed",
-        doc: doc.path,
-        reason: `${doc.path} has uncommitted edits \u2013 suppressed while in flight`
-      });
-    }
-    const range = await commitsTouchingSince(
-      ctx.root,
-      doc.lastCommit.hash,
-      MANIFEST_PATHSPECS
-    );
-    if (range === null) {
-      result.skipped.push({
-        check: "deps-changed",
-        doc: doc.path,
-        reason: `${doc.path}: commit range unreachable (shallow clone?)`
-      });
-      continue;
-    }
-    const relevant = [];
-    for (const commit of range.commits) {
-      if (!releaseOnly.has(commit.hash) && releaseOnly.size < 100) {
-        releaseOnly.set(commit.hash, await releaseMetadataOnly(ctx.root, commit));
-      }
-      if (!releaseOnly.get(commit.hash)) relevant.push(commit);
-    }
-    range.commits = relevant;
-    range.total = relevant.length;
-    if (range.total === 0) continue;
-    const latest = range.commits[0];
-    (doc.dirty ? result.suppressedAdvisories : result.advisories).push({
-      type: "deps-changed",
-      message: `dependency manifests touched by ${range.total} commit${range.total === 1 ? "" : "s"} since ${doc.path} was last committed (latest: ${latest.hash.slice(0, 7)} "${latest.subject}")`,
-      anchor: { doc: doc.path, line: null, excerpt: null },
-      evidence: {
-        kind: "doc-behind-manifests",
-        docLastCommit: doc.lastCommit,
-        manifestCommits: range.commits.slice(0, MANIFEST_COMMITS_CAP),
-        totalCommits: range.total
-      }
-    });
-  }
-  return result;
-}
-var MANIFEST_COMMITS_CAP, MANIFEST_PATHSPECS;
-var init_deps_changed = __esm({
-  "src/audit/checks/deps-changed.ts"() {
-    "use strict";
-    init_release_metadata();
-    init_git();
-    init_checks();
-    MANIFEST_COMMITS_CAP = 10;
-    MANIFEST_PATHSPECS = [
-      ":(glob)**/package.json",
-      ":(glob)**/build.gradle.kts",
-      ":(glob)**/build.gradle",
-      "settings.gradle.kts",
-      "settings.gradle",
-      "gradle/libs.versions.toml",
-      ":(glob)**/Cargo.toml",
-      "go.mod",
-      "pyproject.toml",
-      "requirements.txt",
-      "Gemfile",
-      "composer.json"
-    ];
-  }
-});
-
-// src/context/lexical.ts
-import path12 from "path";
-function tokenize(text2) {
-  return text2.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2 && !STOPWORDS.has(t));
-}
-function stem(token) {
-  return token.length > 3 && token.endsWith("s") ? token.slice(0, -1) : token;
-}
-function tokenSet(text2) {
-  return new Set(tokenize(text2).map(stem));
-}
-function scoreEntry(taskTokens, entry) {
-  const nameTokens = tokenSet(entry.name);
-  const descTokens = tokenSet(entry.description);
-  const fileTokens = tokenSet(entry.files.map((f) => path12.basename(f)).join(" "));
-  let score = 0;
-  for (const token of taskTokens) {
-    if (nameTokens.has(token)) score += 3;
-    else if (descTokens.has(token)) score += 1;
-    else if (fileTokens.has(token)) score += 1;
-  }
-  return score;
-}
-function jaccard(a, b) {
-  if (a.size === 0 && b.size === 0) return 0;
-  let intersection = 0;
-  for (const token of a) if (b.has(token)) intersection++;
-  return intersection / (a.size + b.size - intersection);
-}
-var STOPWORDS;
-var init_lexical = __esm({
-  "src/context/lexical.ts"() {
-    "use strict";
-    STOPWORDS = /* @__PURE__ */ new Set([
-      "the",
-      "a",
-      "an",
-      "and",
-      "or",
-      "of",
-      "to",
-      "in",
-      "on",
-      "for",
-      "with",
-      "how",
-      "does",
-      "do",
-      "is",
-      "are",
-      "was",
-      "what",
-      "where",
-      "which",
-      "why",
-      "when",
-      "who",
-      "i",
-      "we",
-      "my",
-      "our",
-      "you",
-      "your",
-      "it",
-      "its",
-      "this",
-      "that",
-      "these",
-      "those",
-      "can",
-      "could",
-      "should",
-      "would",
-      "will",
-      "want",
-      "need",
-      "please",
-      "about",
-      "into",
-      "from",
-      "when",
-      "there",
-      "any",
-      "all",
-      "some",
-      "not",
-      "but",
-      "also",
-      "just",
-      "like",
-      "get",
-      "make",
-      "use",
-      "new",
-      "work",
-      "works",
-      "working",
-      "implement",
-      "implemented",
-      "change",
-      "changed",
-      "file",
-      "files",
-      "code"
-    ]);
-  }
-});
-
-// src/decisions/decisions.ts
-var decisions_exports = {};
-__export(decisions_exports, {
-  BODY_MAX_CHARS: () => BODY_MAX_CHARS,
-  MAX_ACTIVE_DECISIONS: () => MAX_ACTIVE_DECISIONS,
-  TITLE_MAX_CHARS: () => TITLE_MAX_CHARS,
-  decisionIdFor: () => decisionIdFor,
-  findNearDuplicate: () => findNearDuplicate,
-  loadDecisionStore: () => loadDecisionStore,
-  loadDecisions: () => loadDecisions,
-  saveDecisionRecord: () => saveDecisionRecord,
-  upsertDecision: () => upsertDecision,
-  withDecisionWrite: () => withDecisionWrite
-});
-import fs8 from "fs/promises";
-import path13 from "path";
-import { createHash } from "crypto";
-async function loadDecisionStore(rootDir) {
-  const records = [];
-  const diagnostics = [];
-  let entries;
-  try {
-    entries = await fs8.readdir(await storePath(rootDir, ".mason/decisions"));
-  } catch (error) {
-    if (error.code !== "ENOENT") diagnostics.push({ path: ".mason/decisions", message: String(error) });
-    return { records, diagnostics };
-  }
-  for (const entry of entries.sort()) {
-    if (!entry.endsWith(".json")) continue;
-    const relative = `.mason/decisions/${entry}`;
-    try {
-      const record = decisionSchema.parse(await readStoreJson(rootDir, relative));
-      if (entry !== `${record.id}.json`) throw new Error("Record id does not match its filename");
-      records.push(record);
-    } catch (error) {
-      diagnostics.push({ path: relative, message: error instanceof Error ? error.message : String(error) });
-    }
-  }
-  return { records, diagnostics };
-}
-async function loadDecisions(rootDir) {
-  return (await loadDecisionStore(rootDir)).records;
-}
-async function saveDecisionRecord(rootDir, record) {
-  const validated = decisionSchema.parse(record);
-  await writeStoreJson(rootDir, `.mason/decisions/${validated.id}.json`, validated);
-}
-function decisionIdFor(title, body, existingIds) {
-  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/, "");
-  if (!existingIds.has(slug)) return slug || "decision";
-  const suffix = createHash("sha1").update(title + body).digest("hex").slice(0, 6);
-  return `${slug}-${suffix}`;
-}
-function findNearDuplicate(candidate, existing) {
-  const candidateTokens = tokenSet(`${candidate.title} ${candidate.body}`);
-  const candidateFiles = new Set(candidate.files);
-  let best = null;
-  for (const record of existing) {
-    if (record.status !== "active") continue;
-    const similarity = jaccard(
-      candidateTokens,
-      tokenSet(`${record.title} ${record.body}`)
-    );
-    const sharesFile = record.files.some((f) => candidateFiles.has(f));
-    const threshold = sharesFile ? DUPLICATE_JACCARD_WITH_SHARED_FILE : DUPLICATE_JACCARD;
-    if (similarity >= threshold && (!best || similarity > best.similarity)) {
-      best = { record, similarity };
-    }
-  }
-  return best;
-}
-async function withDecisionWrite(root, operation) {
-  const lockPath = await storePath(root, ".mason/decisions/.write-lock", true);
-  let lock;
-  try {
-    lock = await fs8.open(lockPath, "wx", 384);
-  } catch (error) {
-    if (error.code === "EEXIST") return { status: "error", error: "Decision store is locked by another write. Retry after it finishes; an abandoned .mason/decisions/.write-lock must be removed only after confirming no writer is running." };
-    throw error;
-  }
-  try {
-    return await operation();
-  } finally {
-    await lock.close();
-    await fs8.unlink(lockPath);
-  }
-}
-async function upsertDecision(rootDir, input) {
-  const title = input.title.trim(), body = input.body.trim();
-  if (!title || !body) return { status: "error", error: "title and body must be non-empty" };
-  if (title.length > TITLE_MAX_CHARS) return { status: "error", error: `title exceeds ${TITLE_MAX_CHARS} chars \u2014 tighten it to a specific headline` };
-  if (body.length > BODY_MAX_CHARS) return { status: "error", error: `body exceeds ${BODY_MAX_CHARS} chars \u2014 record the decision, not the transcript` };
-  const attribution = attributionSchema.safeParse(input);
-  if (!attribution.success) return { status: "error", error: attribution.error.message };
-  if (input.id && input.supersedes) return { status: "error", error: "Use either id to revise or supersedes to replace a record, not both." };
-  return withDecisionWrite(rootDir, async () => {
-    const store = await loadDecisionStore(rootDir);
-    if (store.diagnostics.length) return { status: "error", error: "Repair malformed decision records before saving: " + store.diagnostics.map((d) => d.path).join(", ") };
-    const existing = store.records, byId = new Map(existing.map((r) => [r.id, r]));
-    const now = (/* @__PURE__ */ new Date()).toISOString(), head = await getCurrentGitHash(rootDir);
-    const warnings = [];
-    const files = sanitizeRepoPaths(input.files ?? []);
-    if (input.files && files.length < input.files.length) warnings.push("some anchor paths were outside the repo or duplicated and were dropped");
-    for (const file of files) {
-      try {
-        await fs8.access(path13.join(rootDir, file));
-      } catch {
-        warnings.push(`anchor file does not exist on disk: ${file}`);
-      }
-    }
-    const hint = "Saved locally for review and commit. Proposals are not accepted constraints; an existing accepted revision remains operative while its replacement is proposed. Use review_decision to inspect evidence and record an authorized acceptance or reaffirmation.";
-    if (input.id) {
-      const original = byId.get(input.id);
-      if (!original) return { status: "error", error: `no decision with id "${input.id}"` };
-      if (original.status !== "active") return { status: "error", error: "Archived records cannot be revised; create a new proposal." };
-      const record2 = importLegacy(original, now);
-      const content3 = decisionContent({
-        ...record2,
-        title,
-        body,
-        category: input.category,
-        files: input.files !== void 0 ? files : record2.files,
-        owner: attribution.data.owner === void 0 ? record2.owner : attribution.data.owner ?? void 0,
-        sources: attribution.data.sources ?? record2.sources
-      });
-      if (JSON.stringify(content3) === JSON.stringify(decisionContent(record2))) {
-        return {
-          status: "unchanged",
-          id: record2.id,
-          totalActive: existing.filter((r) => r.status === "active").length,
-          approval: decisionApproval(original),
-          warnings,
-          hint: "Unchanged content; no review or freshness stamp was written. Use review_decision for explicit re-verification."
-        };
-      }
-      const revision = record2.revision + 1;
-      const updated = {
-        ...record2,
-        ...content3,
-        owner: content3.owner,
-        updatedAt: now,
-        revision,
-        approval: "proposed",
-        history: [...record2.history, { kind: "revised", at: now, actor: attribution.data.actor, revision, content: content3, approval: "proposed", status: "active", refreshedHash: record2.refreshedHash }]
-      };
-      await saveDecisionRecord(rootDir, updated);
-      return { status: "updated", id: record2.id, totalActive: existing.filter((r) => r.status === "active").length, approval: "proposed", warnings, hint };
+  try {
+    const parents = (await git(root, ["rev-list", "--parents", "-n", "1", commit.hash])).trim().split(/\s+/);
+    if (parents.length !== 2) return false;
+    for (const file of commit.files) {
+      const raw = await git(root, ["diff", "--raw", "-z", "--no-renames", "--no-ext-diff", "--no-textconv", parents[1], commit.hash, "--", file]);
+      if (!/^:(100644|100755) \1 [a-f0-9]+ [a-f0-9]+ M\0/.test(raw)) return false;
+      const [before, after] = await Promise.all([
+        git(root, ["show", parents[1] + ":" + file]),
+        git(root, ["show", commit.hash + ":" + file])
+      ]);
+      const previous = withoutAndroidReleaseValues(before);
+      if (previous === null || previous !== withoutAndroidReleaseValues(after)) return false;
     }
-    const old = input.supersedes ? byId.get(input.supersedes) : void 0;
-    if (input.supersedes && !old) return { status: "error", error: `no decision with id "${input.supersedes}" to supersede` };
-    if (old && (old.status !== "active" || decisionApproval(effectiveDecision(old)) === "accepted")) {
-      return { status: "error", error: "A proposal cannot supersede an accepted or archived record. Create and review the replacement separately, then explicitly retire the old decision with review_decision." };
+    return true;
+  } catch {
+    return false;
+  }
+}
+var exec6;
+var init_release_metadata = __esm({
+  "src/audit/release-metadata.ts"() {
+    "use strict";
+    exec6 = promisify7(execFile7);
+  }
+});
+
+// src/audit/checks/deps-changed.ts
+async function checkDepsChanged(ctx) {
+  const result = emptyResult();
+  result.suppressedAdvisories = [];
+  const releaseOnly = /* @__PURE__ */ new Map();
+  for (const doc of ctx.docs) {
+    if (!doc.lastCommit) {
+      result.skipped.push({
+        check: "deps-changed",
+        doc: doc.path,
+        reason: `${doc.path} has no commit history`
+      });
+      continue;
     }
-    if (!input.force) {
-      const duplicate = findNearDuplicate({ title, body, files }, existing);
-      if (duplicate) return { status: "duplicate_suspected", existing: duplicate.record, hint: `A similar decision exists ("${duplicate.record.title}"). Call save_decision with id="${duplicate.record.id}" to revise it, or force:true if distinct.` };
+    if (doc.dirty) {
+      result.skipped.push({
+        check: "deps-changed",
+        doc: doc.path,
+        reason: `${doc.path} has uncommitted edits \u2013 suppressed while in flight`
+      });
     }
-    const id = decisionIdFor(title, body, new Set(byId.keys()));
-    if (byId.has(id)) return { status: "error", error: `Decision id collision: ${id}. Choose a distinct title or revise the existing record.` };
-    const content2 = decisionContent({ title, body, category: input.category, files, owner: attribution.data.owner ?? void 0, sources: attribution.data.sources ?? [] });
-    const record = {
-      ...content2,
-      version: 2,
-      id,
-      createdAt: now,
-      updatedAt: now,
-      refreshedHash: head,
-      status: "active",
-      approval: "proposed",
-      revision: 1,
-      history: [{ kind: "created", at: now, actor: attribution.data.actor, revision: 1, content: content2, approval: "proposed", status: "active", refreshedHash: head }]
-    };
-    await saveDecisionRecord(rootDir, record);
-    if (old) {
-      const imported = importLegacy(old, now);
-      await saveDecisionRecord(rootDir, {
-        ...imported,
-        status: "superseded",
-        supersededBy: id,
-        updatedAt: now,
-        history: [...imported.history, {
-          kind: "superseded",
-          at: now,
-          actor: attribution.data.actor,
-          note: `Replaced by proposal ${id}`,
-          revision: imported.revision,
-          content: decisionContent(imported),
-          approval: imported.approval,
-          status: "superseded",
-          refreshedHash: imported.refreshedHash
-        }]
+    const range = await commitsTouchingSince(
+      ctx.root,
+      doc.lastCommit.hash,
+      MANIFEST_PATHSPECS
+    );
+    if (range === null) {
+      result.skipped.push({
+        check: "deps-changed",
+        doc: doc.path,
+        reason: `${doc.path}: commit range unreachable (shallow clone?)`
       });
+      continue;
     }
-    const totalActive = existing.filter((r) => r.status === "active").length + (old ? 0 : 1);
-    const result = { status: old ? "superseded_and_created" : "created", id, totalActive, approval: "proposed", warnings, hint };
-    if (totalActive > MAX_ACTIVE_DECISIONS) {
-      result.pruneCandidates = existing.filter((r) => r.status !== "active").map((r) => r.id).slice(0, 10);
-      warnings.push(`${totalActive} active decisions exceeds the soft cap of ${MAX_ACTIVE_DECISIONS} \u2014 consider a cleanup PR (archived records first)`);
+    const relevant = [];
+    for (const commit of range.commits) {
+      if (!releaseOnly.has(commit.hash) && releaseOnly.size < 100) {
+        releaseOnly.set(commit.hash, await releaseMetadataOnly(ctx.root, commit));
+      }
+      if (!releaseOnly.get(commit.hash)) relevant.push(commit);
     }
-    return result;
-  });
+    range.commits = relevant;
+    range.total = relevant.length;
+    if (range.total === 0) continue;
+    const latest = range.commits[0];
+    (doc.dirty ? result.suppressedAdvisories : result.advisories).push({
+      type: "deps-changed",
+      message: `dependency manifests touched by ${range.total} commit${range.total === 1 ? "" : "s"} since ${doc.path} was last committed (latest: ${latest.hash.slice(0, 7)} "${latest.subject}")`,
+      anchor: { doc: doc.path, line: null, excerpt: null },
+      evidence: {
+        kind: "doc-behind-manifests",
+        docLastCommit: doc.lastCommit,
+        manifestCommits: range.commits.slice(0, MANIFEST_COMMITS_CAP),
+        totalCommits: range.total
+      }
+    });
+  }
+  return result;
 }
-var TITLE_MAX_CHARS, BODY_MAX_CHARS, MAX_ACTIVE_DECISIONS, DUPLICATE_JACCARD, DUPLICATE_JACCARD_WITH_SHARED_FILE;
-var init_decisions = __esm({
-  "src/decisions/decisions.ts"() {
+var MANIFEST_COMMITS_CAP, MANIFEST_PATHSPECS;
+var init_deps_changed = __esm({
+  "src/audit/checks/deps-changed.ts"() {
     "use strict";
-    init_storage();
-    init_paths();
-    init_snapshot();
-    init_lexical();
-    init_provenance();
-    TITLE_MAX_CHARS = 80;
-    BODY_MAX_CHARS = 1500;
-    MAX_ACTIVE_DECISIONS = 150;
-    DUPLICATE_JACCARD = 0.5;
-    DUPLICATE_JACCARD_WITH_SHARED_FILE = 0.35;
+    init_release_metadata();
+    init_git();
+    init_checks();
+    MANIFEST_COMMITS_CAP = 10;
+    MANIFEST_PATHSPECS = [
+      ":(glob)**/package.json",
+      ":(glob)**/build.gradle.kts",
+      ":(glob)**/build.gradle",
+      "settings.gradle.kts",
+      "settings.gradle",
+      "gradle/libs.versions.toml",
+      ":(glob)**/Cargo.toml",
+      "go.mod",
+      "pyproject.toml",
+      "requirements.txt",
+      "Gemfile",
+      "composer.json"
+    ];
   }
 });
 
@@ -2527,7 +2548,7 @@ var init_audit = __esm({
 import fs10 from "fs/promises";
 import path16 from "path";
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function findingId(finding) {
   const e = finding.evidence;
   let key;
@@ -2581,7 +2602,7 @@ async function stableAudit(root, checks, options = {}) {
 }
 async function prepareRepair(rootDir, checks = ALL_CHECKS, options = {}) {
   const root = await fs10.realpath(rootDir);
-  const selected = z3.array(checkSchema).nonempty().parse(checks);
+  const selected = z4.array(checkSchema).nonempty().parse(checks);
   const report = await stableAudit(root, selected, options);
   if (!report) throw new Error("No context files found to prepare a repair.");
   if (!report.gitAvailable) throw new Error("Readable Git history is required to prepare a repair.");
@@ -2672,7 +2693,7 @@ async function verifyRepair(rootDir, baselinePath, options = {}) {
     scope: "Original audit checks over current context files and repository evidence. Resolved means no longer detected by that check. Advisories require separate review; this is not a certification of documentation or application correctness."
   };
 }
-var checkSchema, commitSchema, anchorSchema, count, evidenceSchema, findingSchema, issueSchema, advisorySchema, checkResultSchema, reportSchema, baselineSchema, digest;
+var checkSchema, commitSchema, anchorSchema, count, evidenceSchema, findingSchema, issueSchema, advisorySchema, checkResultSchema, reportSchema, baselineSchema, digest, repairFindingSchema;
 var init_repair = __esm({
   "src/audit/repair.ts"() {
     "use strict";
@@ -2684,95 +2705,102 @@ var init_repair = __esm({
     init_files();
     init_paths();
     init_types();
-    checkSchema = z3.enum(["deleted-reference", "new-module", "stale-count", "dead-command", "deps-changed", "decision-anchor-drift"]);
-    commitSchema = z3.object({ hash: z3.string().regex(/^[a-f0-9]{40,64}$/), date: z3.string(), subject: z3.string() });
-    anchorSchema = z3.object({ doc: z3.string(), line: z3.number().int().positive().nullable(), excerpt: z3.string().nullable() });
-    count = z3.number().int().nonnegative();
-    evidenceSchema = z3.discriminatedUnion("kind", [
-      z3.object({
-        kind: z3.literal("missing-path"),
-        claimed: z3.string(),
-        renamedTo: z3.string().nullable(),
+    checkSchema = z4.enum(["deleted-reference", "new-module", "stale-count", "dead-command", "deps-changed", "decision-anchor-drift"]);
+    commitSchema = z4.object({ hash: z4.string().regex(/^[a-f0-9]{40,64}$/), date: z4.string(), subject: z4.string() });
+    anchorSchema = z4.object({ doc: z4.string(), line: z4.number().int().positive().nullable(), excerpt: z4.string().nullable() });
+    count = z4.number().int().nonnegative();
+    evidenceSchema = z4.discriminatedUnion("kind", [
+      z4.object({
+        kind: z4.literal("missing-path"),
+        claimed: z4.string(),
+        renamedTo: z4.string().nullable(),
         deletedInCommit: commitSchema.nullable(),
-        everTracked: z3.boolean(),
-        parentDirExists: z3.boolean()
+        everTracked: z4.boolean(),
+        parentDirExists: z4.boolean()
       }),
-      z3.object({
-        kind: z3.literal("unmentioned-dir"),
-        dir: z3.string(),
+      z4.object({
+        kind: z4.literal("unmentioned-dir"),
+        dir: z4.string(),
         sourceFileCount: count,
         firstCommit: commitSchema.nullable(),
-        checkedDocs: z3.array(z3.string())
+        checkedDocs: z4.array(z4.string())
       }),
-      z3.object({
-        kind: z3.literal("count-mismatch"),
+      z4.object({
+        kind: z4.literal("count-mismatch"),
         claimed: count,
         actual: count,
-        unit: z3.string(),
-        countedFrom: z3.string(),
-        members: z3.array(z3.string())
+        unit: z4.string(),
+        countedFrom: z4.string(),
+        members: z4.array(z4.string())
       }),
-      z3.object({
-        kind: z3.literal("missing-script"),
-        scriptName: z3.string(),
-        invocation: z3.string(),
-        manifestsChecked: z3.array(z3.string()),
-        availableScripts: z3.array(z3.string())
+      z4.object({
+        kind: z4.literal("missing-script"),
+        scriptName: z4.string(),
+        invocation: z4.string(),
+        manifestsChecked: z4.array(z4.string()),
+        availableScripts: z4.array(z4.string())
       }),
-      z3.object({
-        kind: z3.literal("doc-behind-manifests"),
+      z4.object({
+        kind: z4.literal("doc-behind-manifests"),
         docLastCommit: commitSchema,
-        manifestCommits: z3.array(commitSchema.extend({ files: z3.array(z3.string()) })),
+        manifestCommits: z4.array(commitSchema.extend({ files: z4.array(z4.string()) })),
         totalCommits: count
       }),
-      z3.object({
-        kind: z3.literal("decision-anchor"),
-        decisionId: z3.string(),
-        title: z3.string(),
-        changedFiles: z3.array(z3.string()),
-        refreshedHash: z3.string(),
-        provenance: z3.object({}).passthrough().optional()
+      z4.object({
+        kind: z4.literal("decision-anchor"),
+        decisionId: z4.string(),
+        title: z4.string(),
+        changedFiles: z4.array(z4.string()),
+        refreshedHash: z4.string(),
+        provenance: z4.object({}).passthrough().optional()
       })
     ]);
-    findingSchema = z3.object({ message: z3.string(), anchor: anchorSchema, evidence: evidenceSchema });
+    findingSchema = z4.object({ message: z4.string(), anchor: anchorSchema, evidence: evidenceSchema });
     issueSchema = findingSchema.extend({
-      type: z3.enum(["deleted-reference", "new-module", "stale-count", "dead-command"]),
-      confidence: z3.enum(["certain", "likely"])
+      type: z4.enum(["deleted-reference", "new-module", "stale-count", "dead-command"]),
+      confidence: z4.enum(["certain", "likely"])
     });
-    advisorySchema = findingSchema.extend({ type: z3.enum(["deps-changed", "decision-anchor-drift"]) });
-    checkResultSchema = z3.object({
-      issues: z3.array(issueSchema),
-      advisories: z3.array(advisorySchema),
-      suppressedAdvisories: z3.array(advisorySchema).optional(),
-      skipped: z3.array(z3.object({ check: z3.string(), reason: z3.string(), doc: z3.string().optional() }))
+    advisorySchema = findingSchema.extend({ type: z4.enum(["deps-changed", "decision-anchor-drift"]) });
+    checkResultSchema = z4.object({
+      issues: z4.array(issueSchema),
+      advisories: z4.array(advisorySchema),
+      suppressedAdvisories: z4.array(advisorySchema).optional(),
+      skipped: z4.array(z4.object({ check: z4.string(), reason: z4.string(), doc: z4.string().optional() }))
     });
-    reportSchema = z3.object({
-      version: z3.literal(1),
-      root: z3.string(),
-      gitAvailable: z3.literal(true),
+    reportSchema = z4.object({
+      version: z4.literal(1),
+      root: z4.string(),
+      gitAvailable: z4.literal(true),
       headHash: commitSchema.shape.hash,
-      checksRun: z3.array(checkSchema).nonempty(),
-      docs: z3.array(z3.object({
-        path: z3.enum(DOC_CANDIDATES),
+      checksRun: z4.array(checkSchema).nonempty(),
+      docs: z4.array(z4.object({
+        path: z4.enum(DOC_CANDIDATES),
         lastCommit: commitSchema.nullable(),
-        dirty: z3.boolean(),
+        dirty: z4.boolean(),
         lineCount: count
       })).nonempty(),
-      decisionsChecked: z3.boolean(),
-      clean: z3.boolean(),
-      issues: z3.array(issueSchema),
-      advisories: z3.array(advisorySchema),
-      suppressedAdvisories: z3.array(advisorySchema).optional(),
-      skippedChecks: z3.array(z3.object({ check: z3.string(), reason: z3.string(), doc: z3.string().optional() }))
+      decisionsChecked: z4.boolean(),
+      clean: z4.boolean(),
+      issues: z4.array(issueSchema),
+      advisories: z4.array(advisorySchema),
+      suppressedAdvisories: z4.array(advisorySchema).optional(),
+      skippedChecks: z4.array(z4.object({ check: z4.string(), reason: z4.string(), doc: z4.string().optional() }))
     });
-    baselineSchema = z3.object({
-      kind: z3.literal("mason-audit-repair"),
-      version: z3.literal(1),
-      createdAt: z3.string().datetime(),
+    baselineSchema = z4.object({
+      kind: z4.literal("mason-audit-repair"),
+      version: z4.literal(1),
+      createdAt: z4.string().datetime(),
       report: reportSchema,
-      digest: z3.string().regex(/^[a-f0-9]{64}$/)
+      digest: z4.string().regex(/^[a-f0-9]{64}$/)
     });
     digest = (value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+    repairFindingSchema = z4.object({
+      id: z4.string(),
+      original: z4.union([issueSchema, advisorySchema]),
+      status: z4.enum(["resolved", "unresolved", "review-required", "unverified"]),
+      reason: z4.string(),
+      current: z4.union([issueSchema, advisorySchema]).optional()
+    });
   }
 });
 
@@ -2865,134 +2893,101 @@ var init_files2 = __esm({
   }
 });
 
-// src/automation/execution.ts
-var execution_exports = {};
-__export(execution_exports, {
-  automationFailure: () => automationFailure,
-  executionStatus: () => executionStatus,
-  failureMessage: () => failureMessage,
-  recordExecution: () => recordExecution
-});
+// src/automation/store.ts
+import fs14 from "fs/promises";
 import os from "os";
-import { randomUUID as randomUUID4 } from "crypto";
-import { z as z6 } from "zod";
-function parseExecution(raw) {
-  try {
-    return executionSchema.parse(raw);
-  } catch (error) {
-    throw new Error("Invalid automation execution store; receipt history was retained.", { cause: error });
-  }
-}
-function automationFailure(error) {
-  const recorded = failureSchema.safeParse(error?.failure);
-  if (recorded.success) return recorded.data;
-  const message2 = (error instanceof Error ? error.message : String(error)).replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, 700);
-  const codes = /* @__PURE__ */ new Set();
-  let cause = error;
-  for (let i = 0; cause && i < 8; i++) {
-    codes.add(String(cause.code));
-    cause = cause.cause;
-  }
-  const code = codes.has("ENOSPC") || codes.has("EDQUOT") ? "storage-full" : /changed during|changed while|changed between/.test(message2) ? "inputs-changed" : /Automation is busy/.test(message2) ? "busy" : /not a git repository|unknown revision|bad revision|different history|unreachable/.test(message2) ? "history-unavailable" : error instanceof z6.ZodError || error instanceof SyntaxError || /Hook input|Expected one command|Unknown automation command|--host/.test(message2) ? "invalid-input" : /store|baseline|modified|symbolic link|Symlink|automation state|state belongs/.test(message2) ? "invalid-evidence" : [...codes].some((c) => /^E[A-Z]+$/.test(c)) ? "io-error" : "internal";
-  return { code, message: message2, retryable: ["inputs-changed", "storage-full", "busy", "io-error"].includes(code), receiptRecorded: false };
-}
-function failureMessage(error) {
-  const failure = automationFailure(error);
-  return `Mason automation unavailable [${failure.code}]; evidence capture/verification was not established. ${failure.message}` + (failure.receiptRecorded ? "" : " No durable failure receipt was recorded.");
-}
-async function recordExecution(root, directory, event, run) {
-  const file = directory + "/execution.json";
-  const raw = await readStoreJson(root, file);
-  const log = raw === null ? { version: 1, attempts: [], discardedAttempts: 0 } : parseExecution(raw);
-  for (const attempt2 of log.attempts) if (attempt2.status === "running") attempt2.status = "unknown";
-  log.discardedAttempts += Math.max(0, log.attempts.length - 31);
-  log.attempts = log.attempts.slice(-31);
-  const started = performance.now();
-  const attempt = {
-    id: randomUUID4(),
-    event,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    pid: process.pid,
-    host: os.hostname(),
-    status: "running"
-  };
-  log.attempts.push(attempt);
-  await writeStoreJson(root, file, log);
+import { z as z7 } from "zod";
+function parseState(raw) {
   try {
-    const result = await run();
-    Object.assign(attempt, {
-      status: "completed",
-      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      durationMs: performance.now() - started,
-      verificationStatus: result.report.status,
-      reportPath: result.report.reportPath
-    });
-    await writeStoreJson(root, file, log);
-    return result;
+    return stateSchema.parse(raw);
   } catch (error) {
-    const failure = automationFailure(error);
-    Object.assign(attempt, { status: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), durationMs: performance.now() - started, failure });
-    delete attempt.verificationStatus;
-    delete attempt.reportPath;
-    try {
-      await writeStoreJson(root, file, { ...log, attempts: log.attempts.map((a) => a === attempt ? { ...a, failure: { ...failure, receiptRecorded: true } } : a) });
-      failure.receiptRecorded = true;
-    } catch {
-    }
-    throw Object.assign(new Error(failure.message, { cause: error }), { failure });
+    throw new Error("Invalid automation state; original evidence was retained.", { cause: error });
   }
 }
-async function executionStatus(root, directory) {
-  const raw = await readStoreJson(root, directory + "/execution.json");
-  if (raw === null) return { status: "not-observed", attempts: [] };
-  const log = parseExecution(raw);
-  let lock = null;
-  if (log.attempts.some((attempt) => attempt.status === "running")) {
+async function withLock(root, directory, run, waitMs = 5e3) {
+  const file = await storePath(root, directory + "/lock", true);
+  const deadline = Date.now() + waitMs;
+  let handle;
+  while (!handle) {
     try {
-      lock = await readStoreJson(root, directory + "/lock");
-    } catch {
-    }
-  }
-  for (const attempt of log.attempts) {
-    if (attempt.status !== "running") continue;
-    let alive = false;
-    if (attempt.host === os.hostname() && lock?.pid === attempt.pid && lock.host === attempt.host) {
+      handle = await fs14.open(file, "wx", 384);
       try {
-        process.kill(attempt.pid, 0);
-        alive = true;
+        await handle.writeFile(JSON.stringify({ pid: process.pid, host: os.hostname() }));
       } catch (error) {
-        alive = error.code === "EPERM";
+        await handle.close().catch(() => {
+        });
+        handle = void 0;
+        await fs14.rm(file, { force: true }).catch(() => {
+        });
+        throw error;
+      }
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      try {
+        const owner = JSON.parse(await fs14.readFile(file, "utf8"));
+        if (owner.host === os.hostname() && Number.isInteger(owner.pid) && owner.pid > 0) {
+          try {
+            process.kill(owner.pid, 0);
+          } catch (probe) {
+            if (probe.code === "ESRCH") {
+              const reclaim = file + ".reclaim";
+              let guard;
+              try {
+                guard = await fs14.open(reclaim, "wx", 384);
+                const current = JSON.parse(await fs14.readFile(file, "utf8"));
+                if (current.pid === owner.pid && current.host === owner.host) await fs14.unlink(file);
+              } finally {
+                if (guard) {
+                  await guard.close();
+                  await fs14.rm(reclaim, { force: true });
+                }
+              }
+            }
+          }
+        }
+      } catch {
       }
+      if (Date.now() >= deadline) throw new Error("Automation is busy or its lock needs inspection: " + file);
+      await new Promise((resolve2) => setTimeout(resolve2, 40));
     }
-    if (!alive) attempt.status = "unknown";
   }
-  return { status: log.attempts.at(-1)?.status ?? "not-observed", attempts: log.attempts, discardedAttempts: log.discardedAttempts };
+  try {
+    return await run();
+  } finally {
+    await handle.close();
+    await fs14.unlink(file);
+  }
 }
-var failureSchema, attemptSchema, executionSchema;
-var init_execution = __esm({
-  "src/automation/execution.ts"() {
+var hostSchema, events, stateSchema;
+var init_store = __esm({
+  "src/automation/store.ts"() {
     "use strict";
     init_storage();
-    failureSchema = z6.object({
-      code: z6.enum(["inputs-changed", "storage-full", "busy", "invalid-input", "history-unavailable", "invalid-evidence", "io-error", "internal"]),
-      message: z6.string(),
-      retryable: z6.boolean(),
-      receiptRecorded: z6.boolean()
-    });
-    attemptSchema = z6.object({
-      id: z6.string(),
-      event: z6.string(),
-      startedAt: z6.string(),
-      finishedAt: z6.string().optional(),
-      durationMs: z6.number().nonnegative().optional(),
-      pid: z6.number().int().positive(),
-      host: z6.string(),
-      status: z6.enum(["running", "completed", "failed", "unknown"]),
-      verificationStatus: z6.string().optional(),
-      reportPath: z6.string().optional(),
-      failure: failureSchema.optional()
+    hostSchema = z7.enum(["claude", "codex"]);
+    events = ["session_start", "turn_start", "before_tool", "after_tool", "task_end"];
+    stateSchema = z7.object({
+      version: z7.literal(1),
+      root: z7.string(),
+      gitDir: z7.string(),
+      branch: z7.string(),
+      baselines: z7.array(z7.object({ path: z7.string(), at: z7.string(), event: z7.string(), fingerprint: z7.string() })).max(128),
+      sessions: z7.record(z7.object({
+        host: hostSchema,
+        seen: z7.string().nullable(),
+        continued: z7.boolean(),
+        initialIssues: z7.array(z7.string()),
+        initialDocs: z7.record(z7.string().nullable()),
+        lastUsed: z7.string(),
+        mutationObserved: z7.boolean(),
+        pending: z7.record(z7.string()),
+        coverageGaps: z7.array(z7.string()),
+        events: z7.record(z7.object({ at: z7.string(), count: z7.number().int().positive() }))
+      })),
+      updatedAt: z7.string(),
+      fingerprint: z7.string().nullable(),
+      latest: z7.string().nullable(),
+      analysis: z7.object({ id: z7.string(), fingerprint: z7.string(), completedAt: z7.number(), path: z7.string() }).optional()
     });
-    executionSchema = z6.object({ version: z6.literal(1), attempts: z6.array(attemptSchema).max(32), discardedAttempts: z6.number().int().nonnegative().default(0) });
   }
 });
 
@@ -3005,19 +3000,19 @@ __export(evidence_exports, {
   readInputs: () => readInputs,
   workspace: () => workspace
 });
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import path20 from "path";
 import { createHash as createHash4 } from "crypto";
 import { execFile as execFile12 } from "child_process";
 import { promisify as promisify12 } from "util";
 import fg5 from "fast-glob";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 async function git2(root, ...args) {
   return (await exec11("git", args, { cwd: root, maxBuffer: 16 * 1024 * 1024, timeout: 1e4 })).stdout;
 }
 async function workspace(dir) {
-  const root = await fs14.realpath((await git2(dir, "rev-parse", "--show-toplevel")).trim());
-  const gitDir = await fs14.realpath((await git2(root, "rev-parse", "--absolute-git-dir")).trim());
+  const root = await fs15.realpath((await git2(dir, "rev-parse", "--show-toplevel")).trim());
+  const gitDir = await fs15.realpath((await git2(root, "rev-parse", "--absolute-git-dir")).trim());
   let branch;
   try {
     branch = (await git2(root, "symbolic-ref", "--quiet", "HEAD")).trim();
@@ -3036,7 +3031,7 @@ async function readInputs(root) {
   const head = headText.trim();
   let shallow = null;
   try {
-    shallow = await fs14.readFile(path20.resolve(root, shallowPath.trim()), "utf8");
+    shallow = await fs15.readFile(path20.resolve(root, shallowPath.trim()), "utf8");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
@@ -3049,7 +3044,7 @@ async function readInputs(root) {
     docContents.push([file, text2]);
     for (const claim of text2 ? extractClaims(text2).paths : []) {
       if (internal(claim.path) || claim.path.startsWith(".mason/")) continue;
-      const exists2 = async (p) => fs14.access(path20.resolve(root, p)).then(() => true, () => false);
+      const exists2 = async (p) => fs15.access(path20.resolve(root, p)).then(() => true, () => false);
       claims.push([claim.path, await exists2(claim.path), await exists2(path20.dirname(claim.path))]);
     }
   }
@@ -3067,7 +3062,7 @@ async function readInputs(root) {
   }
   const needsWorkspaceScripts = rootScripts !== null && commandClaims.some((claim) => !rootScripts.includes(claim.scriptName));
   const decisionDirectory = await storePath(root, ".mason/decisions");
-  const decisionPresence = await fs14.lstat(decisionDirectory).then((stat) => stat.isDirectory() ? "directory" : "file", (error) => {
+  const decisionPresence = await fs15.lstat(decisionDirectory).then((stat) => stat.isDirectory() ? "directory" : "file", (error) => {
     if (error.code === "ENOENT") return "absent";
     throw error;
   });
@@ -3136,108 +3131,203 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     exec11 = promisify12(execFile12);
-    engineVersion = true ? "0.16.1" : "development";
+    engineVersion = true ? "0.16.3" : "development";
     hash = (value) => createHash4("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
     internal = (file) => file === ".mason" || file === ".mason/reports" || file.startsWith(".mason/reports/");
-    cacheSchema = z7.object({ version: z7.literal(1), entries: z7.record(z7.object({ key: z7.string(), result: checkResultSchema })), digest: z7.string() });
+    cacheSchema = z8.object({ version: z8.literal(1), entries: z8.record(z8.object({ key: z8.string(), result: checkResultSchema })), digest: z8.string() });
   }
 });
 
-// src/automation/store.ts
-import fs15 from "fs/promises";
+// src/automation/execution.ts
+var execution_exports = {};
+__export(execution_exports, {
+  automationFailure: () => automationFailure,
+  executionStatus: () => executionStatus,
+  failureMessage: () => failureMessage,
+  failureNotifications: () => failureNotifications,
+  hookFailureMessage: () => hookFailureMessage,
+  recordExecution: () => recordExecution
+});
 import os2 from "os";
-import { z as z8 } from "zod";
-function parseState(raw) {
+import fs16 from "fs/promises";
+import { randomUUID as randomUUID4 } from "crypto";
+import { z as z9 } from "zod";
+function parseExecution(raw) {
   try {
-    return stateSchema.parse(raw);
+    return executionSchema.parse(raw);
   } catch (error) {
-    throw new Error("Invalid automation state; original evidence was retained.", { cause: error });
+    throw new Error("Invalid automation execution store; receipt history was retained.", { cause: error });
   }
 }
-async function withLock(root, directory, run) {
-  const file = await storePath(root, directory + "/lock", true);
-  const deadline = Date.now() + 5e3;
-  let handle;
-  while (!handle) {
+function automationFailure(error) {
+  const recorded = failureSchema.safeParse(error?.failure);
+  if (recorded.success) return recorded.data;
+  const message2 = (error instanceof Error ? error.message : String(error)).replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, 700);
+  const codes = /* @__PURE__ */ new Set();
+  let cause = error;
+  for (let i = 0; cause && i < 8; i++) {
+    codes.add(String(cause.code));
+    cause = cause.cause;
+  }
+  const code = codes.has("ENOSPC") || codes.has("EDQUOT") ? "storage-full" : /changed during|changed while|changed between/.test(message2) ? "inputs-changed" : /Automation is busy/.test(message2) ? "busy" : /not a git repository|unknown revision|bad revision|different history|unreachable/.test(message2) ? "history-unavailable" : error instanceof z9.ZodError || error instanceof SyntaxError || /Hook input|Expected one command|Unknown automation command|--host/.test(message2) ? "invalid-input" : /store|baseline|modified|symbolic link|Symlink|automation state|state belongs/.test(message2) ? "invalid-evidence" : [...codes].some((c) => /^E[A-Z]+$/.test(c)) ? "io-error" : "internal";
+  return { code, message: message2, retryable: ["inputs-changed", "storage-full", "busy", "io-error"].includes(code), receiptRecorded: false };
+}
+function failureMessage(error) {
+  const failure = automationFailure(error);
+  return `Mason automation unavailable [${failure.code}]; evidence capture/verification was not established. ${failure.message}` + (failure.receiptRecorded ? "" : " No durable failure receipt was recorded.");
+}
+async function failureNotifications(root, directory) {
+  const raw = await readStoreJson(root, directory + "/notifications.json");
+  return raw === null ? { version: 1, sessions: {} } : notificationsSchema.parse(raw);
+}
+async function hookFailureMessage(dir, host, sessionId, error) {
+  const failure = automationFailure(error);
+  if (!failure.receiptRecorded) return failureMessage(error);
+  try {
+    const ws = await workspace(dir);
+    return await withLock(ws.root, ws.directory + "/notifications", async () => {
+      const notices = await failureNotifications(ws.root, ws.directory);
+      const key = hash([host, sessionId]), signature = hash([failure.code, failure.message]);
+      const previous = notices.sessions[key];
+      const execution = await executionStatus(ws.root, ws.directory);
+      const recovered = previous && execution.attempts.some((a) => a.status === "completed" && a.startedAt > previous.lastAt);
+      const repeat = previous?.signature === signature && !recovered;
+      notices.sessions[key] = {
+        signature,
+        code: failure.code,
+        message: failure.message,
+        count: repeat ? previous.count + 1 : 1,
+        lastAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      notices.sessions = Object.fromEntries(Object.entries(notices.sessions).sort(([, a], [, b]) => b.lastAt.localeCompare(a.lastAt)).slice(0, 32));
+      await writeStoreJson(ws.root, ws.directory + "/notifications.json", notices);
+      return repeat ? null : failureMessage(error) + " Repeated failures in this session are recorded in mason status --json.";
+    });
+  } catch {
+    return failureMessage(error);
+  }
+}
+async function refreshRunning(root, directory, attempts) {
+  for (const attempt of attempts) {
+    if (attempt.status !== "running") continue;
+    let alive = false;
     try {
-      handle = await fs15.open(file, "wx", 384);
-      try {
-        await handle.writeFile(JSON.stringify({ pid: process.pid, host: os2.hostname() }));
-      } catch (error) {
-        await handle.close().catch(() => {
-        });
-        handle = void 0;
-        await fs15.rm(file, { force: true }).catch(() => {
-        });
-        throw error;
+      const owner = await readStoreJson(root, attempt.lease ? leasePath(directory, attempt.id) : directory + "/lock");
+      if (attempt.host === os2.hostname() && owner?.pid === attempt.pid && owner.host === attempt.host) {
+        try {
+          process.kill(attempt.pid, 0);
+          alive = true;
+        } catch (error) {
+          alive = error.code === "EPERM";
+        }
       }
+    } catch {
+    }
+    if (!alive) attempt.status = "unknown";
+  }
+}
+async function editExecution(root, directory, edit) {
+  return withLock(root, directory + "/execution-lock", async () => {
+    const file = directory + "/execution.json";
+    const raw = await readStoreJson(root, file);
+    const log = raw === null ? { version: 1, attempts: [], discardedAttempts: 0 } : parseExecution(raw);
+    await refreshRunning(root, directory, log.attempts);
+    edit(log);
+    const finished = log.attempts.filter((a) => a.status !== "running");
+    const discard = new Set(finished.slice(0, Math.max(0, finished.length - 32)).map((a) => a.id));
+    log.discardedAttempts += discard.size;
+    log.attempts = log.attempts.filter((a) => !discard.has(a.id));
+    await writeStoreJson(root, file, log);
+  });
+}
+async function recordExecution(root, directory, event, run) {
+  const started = performance.now();
+  const attempt = {
+    id: randomUUID4(),
+    event,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pid: process.pid,
+    host: os2.hostname(),
+    status: "running",
+    lease: true
+  };
+  const owner = leasePath(directory, attempt.id);
+  const finish = async (changes) => editExecution(root, directory, (log) => {
+    const current = log.attempts.find((a) => a.id === attempt.id);
+    if (!current) throw new Error("Automation execution receipt disappeared; completion could not be recorded.");
+    Object.assign(current, changes, { finishedAt: (/* @__PURE__ */ new Date()).toISOString(), durationMs: performance.now() - started });
+  });
+  await writeStoreJson(root, owner, { pid: attempt.pid, host: attempt.host });
+  try {
+    await editExecution(root, directory, (log) => {
+      if (log.attempts.filter((a) => a.status === "running").length >= 128) throw new Error("Too many active automation executions; existing receipts were retained.");
+      log.attempts.push(attempt);
+    });
+    try {
+      const result = await run();
+      await finish({ status: "completed", verificationStatus: result.report.status, reportPath: result.report.reportPath });
+      return result;
     } catch (error) {
-      if (error.code !== "EEXIST") throw error;
+      const failure = automationFailure(error);
       try {
-        const owner = JSON.parse(await fs15.readFile(file, "utf8"));
-        if (owner.host === os2.hostname() && Number.isInteger(owner.pid) && owner.pid > 0) {
-          try {
-            process.kill(owner.pid, 0);
-          } catch (probe) {
-            if (probe.code === "ESRCH") {
-              const reclaim = file + ".reclaim";
-              let guard;
-              try {
-                guard = await fs15.open(reclaim, "wx", 384);
-                const current = JSON.parse(await fs15.readFile(file, "utf8"));
-                if (current.pid === owner.pid && current.host === owner.host) await fs15.unlink(file);
-              } finally {
-                if (guard) {
-                  await guard.close();
-                  await fs15.rm(reclaim, { force: true });
-                }
-              }
-            }
-          }
-        }
+        await finish({ status: "failed", failure: { ...failure, receiptRecorded: true } });
+        failure.receiptRecorded = true;
       } catch {
       }
-      if (Date.now() >= deadline) throw new Error("Automation is busy or its lock needs inspection: " + file);
-      await new Promise((resolve2) => setTimeout(resolve2, 40));
+      throw Object.assign(new Error(failure.message, { cause: error }), { failure });
     }
-  }
-  try {
-    return await run();
   } finally {
-    await handle.close();
-    await fs15.unlink(file);
+    await fs16.rm(await storePath(root, owner), { force: true }).catch(() => {
+    });
   }
 }
-var hostSchema, events, stateSchema;
-var init_store = __esm({
-  "src/automation/store.ts"() {
+async function executionStatus(root, directory) {
+  const raw = await readStoreJson(root, directory + "/execution.json");
+  if (raw === null) return { status: "not-observed", attempts: [] };
+  const log = parseExecution(raw);
+  await refreshRunning(root, directory, log.attempts);
+  const completed = [...log.attempts].reverse().find((a) => a.status === "completed");
+  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 };
+}
+var failureSchema, attemptSchema, executionSchema, notificationsSchema, leasePath;
+var init_execution = __esm({
+  "src/automation/execution.ts"() {
     "use strict";
+    init_store();
+    init_evidence();
     init_storage();
-    hostSchema = z8.enum(["claude", "codex"]);
-    events = ["session_start", "turn_start", "before_tool", "after_tool", "task_end"];
-    stateSchema = z8.object({
-      version: z8.literal(1),
-      root: z8.string(),
-      gitDir: z8.string(),
-      branch: z8.string(),
-      baselines: z8.array(z8.object({ path: z8.string(), at: z8.string(), event: z8.string(), fingerprint: z8.string() })).max(128),
-      sessions: z8.record(z8.object({
-        host: hostSchema,
-        seen: z8.string().nullable(),
-        continued: z8.boolean(),
-        initialIssues: z8.array(z8.string()),
-        initialDocs: z8.record(z8.string().nullable()),
-        lastUsed: z8.string(),
-        mutationObserved: z8.boolean(),
-        pending: z8.record(z8.string()),
-        coverageGaps: z8.array(z8.string()),
-        events: z8.record(z8.object({ at: z8.string(), count: z8.number().int().positive() }))
-      })),
-      updatedAt: z8.string(),
-      fingerprint: z8.string().nullable(),
-      latest: z8.string().nullable()
+    failureSchema = z9.object({
+      code: z9.enum(["inputs-changed", "storage-full", "busy", "invalid-input", "history-unavailable", "invalid-evidence", "io-error", "internal"]),
+      message: z9.string(),
+      retryable: z9.boolean(),
+      receiptRecorded: z9.boolean()
+    });
+    attemptSchema = z9.object({
+      id: z9.string().regex(/^[a-zA-Z0-9_-]+$/),
+      lease: z9.literal(true).optional(),
+      event: z9.string(),
+      startedAt: z9.string(),
+      finishedAt: z9.string().optional(),
+      durationMs: z9.number().nonnegative().optional(),
+      pid: z9.number().int().positive(),
+      host: z9.string(),
+      status: z9.enum(["running", "completed", "failed", "unknown"]),
+      verificationStatus: z9.string().optional(),
+      reportPath: z9.string().optional(),
+      failure: failureSchema.optional()
     });
+    executionSchema = z9.object({ version: z9.literal(1), attempts: z9.array(attemptSchema).max(160), discardedAttempts: z9.number().int().nonnegative().default(0) });
+    notificationsSchema = z9.object({ version: z9.literal(1), sessions: z9.record(z9.object({
+      signature: z9.string(),
+      code: failureSchema.shape.code,
+      message: z9.string(),
+      count: z9.number().int().positive(),
+      lastAt: z9.string()
+    })) });
+    leasePath = (directory, id) => `${directory}/executions/${id}.json`;
   }
 });
 
@@ -3246,9 +3336,30 @@ var runtime_exports = {};
 __export(runtime_exports, {
   automate: () => automate,
   automationStatus: () => automationStatus,
+  observeReadOnlyTool: () => observeReadOnlyTool,
   summarize: () => summarize
 });
 import { randomUUID as randomUUID5 } from "crypto";
+import { z as z10 } from "zod";
+async function observeReadOnlyTool(dir, event) {
+  const ws = await workspace(dir);
+  await withLock(ws.root, ws.directory, async () => {
+    const statePath = ws.directory + "/state.json";
+    const raw = await readStoreJson(ws.root, statePath);
+    if (raw === null) return;
+    const state = parseState(raw);
+    if (state.root !== ws.root || state.gitDir !== ws.gitDir || state.branch !== ws.branch) {
+      throw new Error("Automation state belongs to another branch or worktree; original evidence was retained.");
+    }
+    const session = event.host && event.sessionId ? state.sessions[hash([event.host, event.sessionId])] : null;
+    if (!session) return;
+    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, statePath, state);
+  });
+  return { root: ws.root, directory: ws.directory };
+}
 function summarize(report) {
   const open = report.findings.filter((f) => f.status !== "resolved");
   return [
@@ -3260,176 +3371,234 @@ function summarize(report) {
     "Keep original evidence. Address findings relevant to the authorized task; report unrelated findings and unresolved advisories without approving them."
   ].join("\n");
 }
+async function loadState(ws) {
+  const raw = await readStoreJson(ws.root, ws.directory + "/state.json");
+  const state = raw === null ? {
+    version: 1,
+    root: ws.root,
+    gitDir: ws.gitDir,
+    branch: ws.branch,
+    baselines: [],
+    sessions: {},
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fingerprint: null,
+    latest: null
+  } : parseState(raw);
+  if (state.root !== ws.root || state.gitDir !== ws.gitDir || state.branch !== ws.branch) {
+    throw new Error("Automation state belongs to another branch or worktree; original evidence was retained.");
+  }
+  return state;
+}
+async function sharedAnalysis(ws, state, inputs, startedAt) {
+  const pointer = state.analysis;
+  if (!pointer || pointer.fingerprint !== inputs.fingerprint || pointer.completedAt < startedAt) return null;
+  const stored = sharedSchema.parse(await readStoreJson(ws.root, pointer.path));
+  const a = stored.analysis;
+  if (stored.digest !== hash(a) || a.id !== pointer.id || a.fingerprint !== inputs.fingerprint || a.completedAt !== pointer.completedAt || a.report.root !== ws.root || a.report.branch !== ws.branch || a.report.head !== inputs.head || hash(a.report.baselinePaths) !== hash(state.baselines.map((b) => b.path))) {
+    throw new Error("Invalid shared automation evidence; run a new check.");
+  }
+  if (a.baselineDigest !== await baselineDigest(ws, state)) throw new Error("Repair baseline was modified; use the original baseline.");
+  return a;
+}
+async function verifyInputs(ws, inputs) {
+  const [after, currentWs] = await Promise.all([readInputs(ws.root), workspace(ws.root)]);
+  if (after.fingerprint !== inputs.fingerprint || currentWs.directory !== ws.directory) {
+    throw new Error("Repository inputs or branch changed during automation; no current verification was recorded. Retry on a stable checkout.");
+  }
+}
+async function computeAnalysis(ws, state, inputs, event) {
+  const baselines = [...state.baselines];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const empty = {
+    version: 1,
+    status: "unavailable",
+    root: ws.root,
+    branch: ws.branch,
+    head: inputs.head,
+    baselinePaths: [],
+    reportPath: "",
+    findings: [],
+    diagnostics: ["No AGENTS.md, CLAUDE.md, or .claude/CLAUDE.md exists. Documentation capture is unavailable; other Mason tools remain usable."],
+    checks: { ran: [], reused: [], skipped: [] },
+    counts: { resolved: 0, unresolved: 0, "review-required": 0, unverified: 0 },
+    capture: "unknown",
+    scope: SCOPE
+  };
+  if (!baselines.length && Object.values(inputs.docs).every((value) => value === null)) return { baselines, report: empty, cache: null };
+  if (ws.branch === "detached" && state.latest) {
+    const previous = await readStoreJson(ws.root, state.latest);
+    if (!previous?.head || !/^[a-f0-9]{40,64}$/.test(previous.head)) throw new Error("The previous detached checkout evidence is unavailable.");
+    try {
+      await git2(ws.root, "merge-base", "--is-ancestor", previous.head, inputs.head);
+    } catch {
+      throw new Error("Detached checkout moved to a different history; original repair evidence was retained. Inspect that baseline explicitly.");
+    }
+  }
+  let cached = null;
+  const diagnostics = [];
+  try {
+    cached = await readStoreJson(ws.root, ws.directory + "/cache.json");
+  } catch {
+    diagnostics.push("Unreadable automation cache; checks are being recomputed.");
+  }
+  const cache = checkCache(cached, inputs);
+  if (cache.diagnostic) diagnostics.push(cache.diagnostic);
+  const saveBaseline = async () => {
+    if (baselines.length >= 128) throw new Error("128 retained baselines need review; automatic capture stopped without discarding original evidence.");
+    const prepared = await prepareRepair(ws.root, ALL_CHECKS, cache.options);
+    baselines.push({ path: prepared.baselinePath, at: now, event: event.event, fingerprint: inputs.fingerprint });
+  };
+  if (!baselines.length) await saveBaseline();
+  const verifications = [];
+  for (const baseline of baselines) verifications.push(await verifyRepair(ws.root, baseline.path, cache.options));
+  const known = new Set(verifications.flatMap((v) => v.findings.map((f) => f.id)));
+  if (verifications.some((v) => v.newFindings.some((f) => !known.has(findingId(f))))) {
+    await saveBaseline();
+    verifications.push(await verifyRepair(ws.root, baselines.at(-1).path, cache.options));
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const verification of verifications) {
+    for (const finding of verification.findings) {
+      const previous = merged.get(finding.id);
+      if (!previous || priority[finding.status] > priority[previous.status]) merged.set(finding.id, finding);
+    }
+    diagnostics.push(...verification.diagnostics);
+  }
+  const counts = { resolved: 0, unresolved: 0, "review-required": 0, unverified: 0 };
+  for (const finding of merged.values()) counts[finding.status]++;
+  const report = {
+    version: 1,
+    status: diagnostics.length || verifications.some((v) => v.status === "incomplete") ? "incomplete" : counts.unresolved ? "issues-remain" : "verified",
+    root: ws.root,
+    branch: ws.branch,
+    head: inputs.head,
+    baselinePaths: baselines.map((b) => b.path),
+    reportPath: "",
+    findings: [...merged.values()],
+    diagnostics: [...new Set(diagnostics)],
+    checks: { ran: [...cache.ran], reused: [...cache.reused].filter((name) => !cache.ran.has(name)), skipped: verifications.at(-1).currentAudit?.skippedChecks ?? [] },
+    counts,
+    capture: "unknown",
+    scope: SCOPE
+  };
+  return { baselines, report, cache: cache.ran.size || cached === null || cache.diagnostic ? cache.serialize() : null };
+}
+async function analyze(ws, inputs, event, startedAt) {
+  return withLock(ws.root, ws.directory + "/analysis/" + inputs.fingerprint, async () => {
+    const before = await loadState(ws);
+    const shared = await sharedAnalysis(ws, before, inputs, startedAt);
+    if (shared) return { analysis: shared, shared: true };
+    const originalDigest = await baselineDigest(ws, before);
+    const computed = await computeAnalysis(ws, before, inputs, event);
+    await verifyInputs(ws, inputs);
+    if (originalDigest !== await baselineDigest(ws, before)) throw new Error("Repair baseline was modified during automation; original evidence must be inspected.");
+    const id = randomUUID5();
+    const analysis = analysisSchema.parse({
+      id,
+      fingerprint: inputs.fingerprint,
+      completedAt: Date.now(),
+      baselineDigest: await baselineDigest(ws, { ...before, baselines: computed.baselines }),
+      report: computed.report
+    });
+    const analysisPath = ws.directory + "/checks/analysis-" + inputs.fingerprint + ".json";
+    await withLock(ws.root, ws.directory, async () => {
+      const state = await loadState(ws);
+      if (hash(state.baselines) !== hash(before.baselines) || state.analysis?.id !== before.analysis?.id) {
+        throw new Error("Automation evidence changed during analysis; retry against the retained baselines.");
+      }
+      await writeStoreJson(ws.root, analysisPath, { analysis, digest: hash(analysis) });
+      if (computed.cache) await writeStoreJson(ws.root, ws.directory + "/cache.json", computed.cache);
+      state.baselines = computed.baselines;
+      state.analysis = { id, fingerprint: inputs.fingerprint, completedAt: analysis.completedAt, path: analysisPath };
+      await writeStoreJson(ws.root, ws.directory + "/state.json", state);
+    });
+    return { analysis, shared: false };
+  }, Math.max(0, 25e3 - (Date.now() - startedAt)));
+}
 async function automate(dir, event) {
+  const startedAt = Date.now();
   const ws = await workspace(dir);
-  return withLock(ws.root, ws.directory, () => recordExecution(ws.root, ws.directory, event.event, async () => {
+  return recordExecution(ws.root, ws.directory, event.event, async () => {
     const inputs = await readInputs(ws.root);
-    const statePath = ws.directory + "/state.json";
-    const raw = await readStoreJson(ws.root, statePath);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const state = raw === null ? {
-      version: 1,
-      root: ws.root,
-      gitDir: ws.gitDir,
-      branch: ws.branch,
-      baselines: [],
-      sessions: {},
-      updatedAt: now,
-      fingerprint: null,
-      latest: null
-    } : parseState(raw);
-    if (state.root !== ws.root || state.gitDir !== ws.gitDir || state.branch !== ws.branch) {
-      throw new Error("Automation state belongs to another branch or worktree; original evidence was retained.");
-    }
-    if (ws.branch === "detached" && state.latest) {
-      const previous = await readStoreJson(ws.root, state.latest);
-      if (!previous?.head || !/^[a-f0-9]{40,64}$/.test(previous.head)) throw new Error("The previous detached checkout evidence is unavailable.");
-      try {
-        await git2(ws.root, "merge-base", "--is-ancestor", previous.head, inputs.head);
-      } catch {
-        throw new Error("Detached checkout moved to a different history; original repair evidence was retained. Inspect that baseline explicitly.");
+    const result = await analyze(ws, inputs, event, startedAt);
+    if (result.shared) {
+      await verifyInputs(ws, inputs);
+      if (result.analysis.baselineDigest !== await baselineDigest(ws, await loadState(ws))) {
+        throw new Error("Repair baseline was modified during shared automation; original evidence must be inspected.");
       }
     }
-    const key = event.host && event.sessionId ? hash([event.host, event.sessionId]) : null;
-    const newSession = key !== null && !state.sessions[key];
-    if (key && !state.sessions[key]) {
-      const keys = Object.keys(state.sessions).sort((a, b) => state.sessions[a].lastUsed.localeCompare(state.sessions[b].lastUsed));
-      for (const expired of keys.slice(0, Math.max(0, keys.length - 31))) delete state.sessions[expired];
-      state.sessions[key] = {
-        host: event.host,
-        seen: null,
-        continued: false,
-        initialIssues: [],
-        initialDocs: inputs.docs,
-        lastUsed: now,
-        mutationObserved: false,
-        pending: {},
-        coverageGaps: [],
-        events: {}
-      };
-    }
-    const session = key ? state.sessions[key] : null;
-    if (session) {
-      session.lastUsed = now;
-      session.events[event.event] = { at: now, 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.");
-        session.pending[event.toolId] = inputs.fingerprint;
+    return withLock(ws.root, ws.directory, async () => {
+      const state = await loadState(ws);
+      if (state.analysis?.id !== result.analysis.id) throw new Error("Automation evidence changed during publication; retry against the current inputs.");
+      const report = structuredClone(result.analysis.report);
+      if (result.shared) report.checks = { ...report.checks, ran: [], reused: [.../* @__PURE__ */ new Set([...report.checks.ran, ...report.checks.reused])], shared: true };
+      report.reportPath = ws.directory + "/checks/" + randomUUID5() + ".json";
+      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];
+      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,
+          seen: null,
+          continued: false,
+          initialIssues: report.findings.filter((f) => f.status === "unresolved").map((f) => f.id),
+          initialDocs: inputs.docs,
+          lastUsed: now,
+          mutationObserved: false,
+          pending: {},
+          coverageGaps: [],
+          events: {}
+        };
       }
-      if (event.event === "after_tool" && event.mutating) {
-        session.mutationObserved = true;
-        if (!event.toolId || !session.pending[event.toolId]) {
-          const gap = "A tool completed without an observed matching pre-tool capture; pre-edit coverage is unknown.";
-          if (!session.coverageGaps.includes(gap)) session.coverageGaps.push(gap);
+      const session = key ? state.sessions[key] : null;
+      if (session) {
+        session.lastUsed = now;
+        session.events[event.event] = { at: now, 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.");
+          session.pending[event.toolId] = inputs.fingerprint;
         }
-        if (event.toolId) delete session.pending[event.toolId];
+        if (event.event === "after_tool" && event.mutating) {
+          session.mutationObserved = true;
+          if (!event.toolId || !session.pending[event.toolId]) {
+            const gap = "A tool completed without an observed matching pre-tool capture; pre-edit coverage is unknown.";
+            if (!session.coverageGaps.includes(gap)) session.coverageGaps.push(gap);
+          }
+          if (event.toolId) delete session.pending[event.toolId];
+        }
+        report.diagnostics.push(...session.coverageGaps);
+        if (session.coverageGaps.length && report.status !== "unavailable") report.status = "incomplete";
+        report.capture = report.status !== "unavailable" && !session.coverageGaps.length && (session.events.session_start || session.events.before_tool) ? "observed" : "unknown";
       }
-    }
-    if (!state.baselines.length && Object.values(inputs.docs).every((value) => value === null)) {
-      const report2 = {
-        version: 1,
-        status: "unavailable",
-        root: ws.root,
-        branch: ws.branch,
-        head: inputs.head,
-        baselinePaths: [],
-        reportPath: ws.directory + "/checks/" + randomUUID5() + ".json",
-        findings: [],
-        diagnostics: ["No AGENTS.md, CLAUDE.md, or .claude/CLAUDE.md exists. Documentation capture is unavailable; other Mason tools remain usable."],
-        checks: { ran: [], reused: [], skipped: [] },
-        counts: { resolved: 0, unresolved: 0, "review-required": 0, unverified: 0 },
-        capture: "unknown",
-        scope: SCOPE
-      };
-      const notify2 = !session || session.seen !== "no-docs";
-      if (session) session.seen = "no-docs";
-      state.fingerprint = inputs.fingerprint;
-      state.latest = report2.reportPath;
-      state.updatedAt = now;
-      await writeStoreJson(ws.root, report2.reportPath, report2);
-      await writeStoreJson(ws.root, statePath, state);
-      return { report: report2, message: notify2 ? summarize(report2) : null, continueOnce: false };
-    }
-    let cached = null;
-    const diagnostics = [];
-    try {
-      cached = await readStoreJson(ws.root, ws.directory + "/cache.json");
-    } catch {
-      diagnostics.push("Unreadable automation cache; checks are being recomputed.");
-    }
-    const cache = checkCache(cached, inputs);
-    if (cache.diagnostic) diagnostics.push(cache.diagnostic);
-    const saveBaseline = async () => {
-      if (state.baselines.length >= 128) throw new Error("128 retained baselines need review; automatic capture stopped without discarding original evidence.");
-      const prepared = await prepareRepair(ws.root, ALL_CHECKS, cache.options);
-      state.baselines.push({ path: prepared.baselinePath, at: now, event: event.event, fingerprint: inputs.fingerprint });
-    };
-    if (!state.baselines.length) await saveBaseline();
-    const verifications = [];
-    for (const baseline of state.baselines) verifications.push(await verifyRepair(ws.root, baseline.path, cache.options));
-    const known = new Set(verifications.flatMap((v) => v.findings.map((f) => f.id)));
-    if (verifications.some((v) => v.newFindings.some((f) => !known.has(findingId(f))))) {
-      await saveBaseline();
-      verifications.push(await verifyRepair(ws.root, state.baselines.at(-1).path, cache.options));
-    }
-    const merged = /* @__PURE__ */ new Map();
-    for (const verification of verifications) {
-      for (const finding of verification.findings) {
-        const previous = merged.get(finding.id);
-        if (!previous || priority[finding.status] > priority[previous.status]) merged.set(finding.id, finding);
+      const signature = hash([report.status, report.findings, report.diagnostics, report.checks.skipped]);
+      const relevant = report.findings.some((f) => f.status === "unresolved" && session && (!session.initialIssues.includes(f.id) || session.initialDocs[f.original.anchor.doc] !== inputs.docs[f.original.anchor.doc]));
+      const continueOnce = event.event === "task_end" && !!session?.mutationObserved && relevant && !session.continued && !event.stopHookActive;
+      const notify = !session || newSession || signature !== session.seen || continueOnce;
+      if (session) {
+        session.seen = signature;
+        if (continueOnce) session.continued = true;
       }
-      diagnostics.push(...verification.diagnostics);
-    }
-    if (newSession && session) session.initialIssues = [...merged.values()].filter((f) => f.status === "unresolved").map((f) => f.id);
-    const current = verifications.at(-1).currentAudit;
-    const counts = { resolved: 0, unresolved: 0, "review-required": 0, unverified: 0 };
-    for (const finding of merged.values()) counts[finding.status]++;
-    if (session) diagnostics.push(...session.coverageGaps);
-    const capture = session && !session.coverageGaps.length && (session.events.session_start || session.events.before_tool) ? "observed" : "unknown";
-    const after = await readInputs(ws.root);
-    const currentWs = await workspace(ws.root);
-    if (after.fingerprint !== inputs.fingerprint || currentWs.directory !== ws.directory) {
-      throw new Error("Repository inputs or branch changed during automation; no current verification was recorded. Retry on a stable checkout.");
-    }
-    const report = {
-      version: 1,
-      status: diagnostics.length || verifications.some((v) => v.status === "incomplete") ? "incomplete" : counts.unresolved ? "issues-remain" : "verified",
-      root: ws.root,
-      branch: ws.branch,
-      head: inputs.head,
-      baselinePaths: state.baselines.map((b) => b.path),
-      reportPath: ws.directory + "/checks/" + randomUUID5() + ".json",
-      findings: [...merged.values()],
-      diagnostics: [...new Set(diagnostics)],
-      checks: { ran: [...cache.ran], reused: [...cache.reused].filter((name) => !cache.ran.has(name)), skipped: current?.skippedChecks ?? [] },
-      counts,
-      capture,
-      scope: SCOPE
-    };
-    const signature = hash([report.status, report.findings, report.diagnostics, report.checks.skipped]);
-    const relevant = report.findings.some((f) => f.status === "unresolved" && session && (!session.initialIssues.includes(f.id) || session.initialDocs[f.original.anchor.doc] !== inputs.docs[f.original.anchor.doc]));
-    const continueOnce = event.event === "task_end" && !!session?.mutationObserved && relevant && !session.continued && !event.stopHookActive;
-    const notify = !session || newSession || signature !== session.seen || continueOnce;
-    if (session) {
-      session.seen = signature;
-      if (continueOnce) session.continued = true;
-    }
-    const persistReport = !state.latest || state.fingerprint !== inputs.fingerprint || notify || event.event === "task_end";
-    if (!persistReport) report.reportPath = state.latest;
-    state.updatedAt = now;
-    state.fingerprint = inputs.fingerprint;
-    state.latest = report.reportPath;
-    if (persistReport) await writeStoreJson(ws.root, report.reportPath, report);
-    if (cache.ran.size || cached === null || cache.diagnostic) await writeStoreJson(ws.root, ws.directory + "/cache.json", cache.serialize());
-    await writeStoreJson(ws.root, statePath, state);
-    return { report, message: notify ? summarize(report) : null, continueOnce };
-  }));
+      const persistReport = !state.latest || state.fingerprint !== inputs.fingerprint || notify || event.event === "task_end";
+      if (!persistReport) report.reportPath = state.latest;
+      state.updatedAt = now;
+      state.fingerprint = inputs.fingerprint;
+      state.latest = report.reportPath;
+      if (persistReport) await writeStoreJson(ws.root, report.reportPath, report);
+      await writeStoreJson(ws.root, ws.directory + "/state.json", state);
+      return { report, message: notify ? summarize(report) : null, continueOnce };
+    });
+  });
 }
 async function automationStatus(dir) {
   const ws = await workspace(dir);
   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");
-  if (raw === null) return { version: 1, status: execution.status === "not-observed" ? "not-observed" : "unavailable", root: ws.root, branch: ws.branch, baselinePaths: [], hosts: {}, execution };
+  if (raw === null) return { version: 1, status: execution.status === "not-observed" ? "not-observed" : "unavailable", root: ws.root, branch: ws.branch, baselinePaths: [], hosts: {}, execution, notifications };
   const state = parseState(raw);
   if (state.root !== ws.root || state.gitDir !== ws.gitDir || state.branch !== ws.branch) throw new Error("Automation state belongs to another workspace.");
   const inputs = await readInputs(ws.root);
@@ -3451,10 +3620,11 @@ async function automationStatus(dir) {
     verificationStatus: unfinished ? "unavailable" : latest?.status ?? "unavailable",
     hosts,
     execution,
+    notifications,
     note: "Observed events do not prove all tool paths are intercepted. Run check to verify the retained evidence."
   };
 }
-var SCOPE, priority, cleanText;
+var SCOPE, priority, cleanText, analysisSchema, sharedSchema, baselineDigest;
 var init_runtime = __esm({
   "src/automation/runtime.ts"() {
     "use strict";
@@ -3467,13 +3637,49 @@ var init_runtime = __esm({
     SCOPE = "Documentation audit evidence only. Hook receipts show observed events, not complete interception. Resolved claims no longer fail their checks; advisories need separate review. Repair only within the user's task authorization.";
     priority = { resolved: 0, "review-required": 1, unresolved: 2, unverified: 3 };
     cleanText = (text2) => text2.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, 250);
+    analysisSchema = z10.object({
+      id: z10.string(),
+      fingerprint: z10.string(),
+      completedAt: z10.number(),
+      baselineDigest: z10.string(),
+      report: z10.object({
+        version: z10.literal(1),
+        status: z10.enum(["verified", "issues-remain", "incomplete", "unavailable"]),
+        root: z10.string(),
+        branch: z10.string(),
+        head: z10.string(),
+        baselinePaths: z10.array(z10.string()),
+        reportPath: z10.string(),
+        findings: z10.array(repairFindingSchema),
+        diagnostics: z10.array(z10.string()),
+        checks: z10.object({
+          ran: z10.array(z10.string()),
+          reused: z10.array(z10.string()),
+          skipped: z10.array(z10.object({ check: z10.string(), reason: z10.string(), doc: z10.string().optional() }))
+        }),
+        counts: z10.object({ resolved: z10.number(), unresolved: z10.number(), "review-required": z10.number(), unverified: z10.number() }),
+        capture: z10.enum(["observed", "unknown"]),
+        scope: z10.string()
+      })
+    });
+    sharedSchema = z10.object({ analysis: analysisSchema, digest: z10.string() });
+    baselineDigest = async (ws, state) => hash(await Promise.all(
+      state.baselines.map(async (b) => [b.path, await readStoreJson(ws.root, b.path)])
+    ));
   }
 });
 
 // src/automation/adapters.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
+function managedHookCommand(host, platform = process.platform) {
+  const command = `mason --setup-host ${host} 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`;
+}
+function knownManagedHookCommands(host) {
+  return [managedHookCommand(host, "linux"), managedHookCommand(host, "win32"), `mason --setup-host ${host} auto hook --host ${host}`];
+}
 function hookConfig(host, command = "npx --no-install --package mason-context mason-auto") {
-  const handler = { type: "command", command: command + " hook --host " + host, timeout: 30 };
+  const handler = { type: "command", command: command === `mason --setup-host ${host} auto` ? managedHookCommand(host) : command + " hook --host " + host, timeout: 30 };
   return { hooks: Object.fromEntries(HOOK_EVENTS.map((name) => [
     name,
     [{ ...["PreToolUse", "PostToolUse"].includes(name) ? { matcher: ".*" } : {}, hooks: [{ ...handler }] }]
@@ -3486,15 +3692,15 @@ var init_adapters = __esm({
     init_execution();
     init_runtime();
     init_store();
-    inputSchema = z9.object({
-      cwd: z9.string().min(1),
-      session_id: z9.string().min(1).max(500),
-      hook_event_name: z9.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"]),
-      tool_name: z9.string().optional(),
-      tool_use_id: z9.string().max(500).optional(),
-      tool_input: z9.unknown().optional(),
-      stop_hook_active: z9.boolean().optional(),
-      permission_mode: z9.string().optional()
+    inputSchema = z11.object({
+      cwd: z11.string().min(1),
+      session_id: z11.string().min(1).max(500),
+      hook_event_name: z11.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"]),
+      tool_name: z11.string().optional(),
+      tool_use_id: z11.string().max(500).optional(),
+      tool_input: z11.unknown().optional(),
+      stop_hook_active: z11.boolean().optional(),
+      permission_mode: z11.string().optional()
     });
     HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"];
   }
@@ -3510,7 +3716,7 @@ __export(ownership_exports, {
   ownershipEdit: () => ownershipEdit,
   ownershipSchema: () => ownershipSchema
 });
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 import { parse } from "smol-toml";
 function blockSpan(text2, start, end) {
   const starts = text2.split(start).length - 1, ends = text2.split(end).length - 1;
@@ -3561,15 +3767,15 @@ var init_ownership = __esm({
       ["<!-- mason:agents:start -->", "<!-- mason:agents:end -->"],
       ["# mason:mcp:start", "# mason:mcp:end"]
     ];
-    fileSchema = z10.object({
-      created: z10.boolean(),
-      initialHash: z10.string(),
-      blocks: z10.record(z10.string()),
-      mcpHash: z10.string().optional(),
-      hookCommands: z10.array(z10.string()).optional(),
-      hooks: z10.record(z10.array(z10.string())).optional()
+    fileSchema = z12.object({
+      created: z12.boolean(),
+      initialHash: z12.string(),
+      blocks: z12.record(z12.string()),
+      mcpHash: z12.string().optional(),
+      hookCommands: z12.array(z12.string()).optional(),
+      hooks: z12.record(z12.array(z12.string())).optional()
     });
-    ownershipSchema = z10.object({ version: z10.literal(1), files: z10.record(fileSchema) });
+    ownershipSchema = z12.object({ version: z12.literal(1), files: z12.record(fileSchema) });
   }
 });
 
@@ -3584,7 +3790,7 @@ __export(install_exports, {
   planAutomationInstall: () => planAutomationInstall,
   recordSchema: () => recordSchema
 });
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 async function installationRecord(root) {
   return recordSchema.parse(await readStoreJson(root, AUTOMATION_PATH) ?? { version: 1, hosts: {} });
 }
@@ -3602,7 +3808,7 @@ async function planAutomationInstall(root, host, command) {
   const previous = record.hosts[host]?.command;
   const ownershipText = await readText(root, OWNERSHIP_PATH);
   const pending = ownershipText === null ? [] : ownershipSchema.parse(JSON.parse(ownershipText)).files[file]?.hookCommands ?? [];
-  const owned = /* @__PURE__ */ new Set([previous, ...pending, newCommand]);
+  const owned = /* @__PURE__ */ new Set([previous, ...pending, newCommand, ...knownManagedHookCommands(host)]);
   const hooks = existing.hooks ?? {};
   for (const event of HOOK_EVENTS) {
     hooks[event] = (hooks[event] ?? []).map((group) => ({
@@ -3665,9 +3871,9 @@ var init_install = __esm({
     init_store();
     init_files2();
     init_ownership();
-    groupSchema = z11.object({ hooks: z11.array(z11.object({ type: z11.string(), command: z11.string().optional() }).passthrough()) }).passthrough();
-    automationConfigSchema = z11.object({ hooks: z11.record(z11.array(groupSchema)).optional() }).passthrough();
-    recordSchema = z11.object({ version: z11.literal(1), hosts: z11.record(z11.object({ command: z11.string() })) });
+    groupSchema = z13.object({ hooks: z13.array(z13.object({ type: z13.string(), command: z13.string().optional() }).passthrough()) }).passthrough();
+    automationConfigSchema = z13.object({ hooks: z13.record(z13.array(groupSchema)).optional() }).passthrough();
+    recordSchema = z13.object({ version: z13.literal(1), hosts: z13.record(z13.object({ command: z13.string() })) });
     AUTOMATION_PATH = ".mason/local/automation.json";
     configPath = (host) => host === "claude" ? ".claude/settings.json" : ".codex/hooks.json";
   }
@@ -3682,7 +3888,7 @@ __export(model_exports, {
   setupHostSchema: () => setupHostSchema,
   setupSchema: () => setupSchema
 });
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 async function loadSetup(root) {
   const raw = await readStoreJson(root, SETUP_PATH);
   if (raw === null) return null;
@@ -3700,27 +3906,27 @@ var init_model = __esm({
   "src/setup/model.ts"() {
     "use strict";
     init_storage();
-    setupHostSchema = z12.object({
-      configuredVersion: z12.string(),
-      revision: z12.string().uuid(),
-      fingerprint: z12.string(),
-      mcpFingerprint: z12.string(),
-      instructions: z12.array(z12.string())
+    setupHostSchema = z14.object({
+      configuredVersion: z14.string(),
+      revision: z14.string().uuid(),
+      fingerprint: z14.string(),
+      mcpFingerprint: z14.string(),
+      instructions: z14.array(z14.string())
     });
-    setupSchema = z12.object({ version: z12.literal(2), hosts: z12.object({
+    setupSchema = z14.object({ version: z14.literal(2), hosts: z14.object({
       codex: setupHostSchema.optional(),
       claude: setupHostSchema.optional()
     }) });
     SETUP_PATH = ".mason/local/setup.json";
-    receiptSchema = z12.object({
-      version: z12.literal(1),
-      host: z12.enum(["codex", "claude"]),
-      status: z12.enum(["installing", "configured"]),
-      initialReportPath: z12.string(),
-      initialBaselinePaths: z12.array(z12.string()),
-      root: z12.string(),
-      revision: z12.string().uuid(),
-      configuredAt: z12.string().optional()
+    receiptSchema = z14.object({
+      version: z14.literal(1),
+      host: z14.enum(["codex", "claude"]),
+      status: z14.enum(["installing", "configured"]),
+      initialReportPath: z14.string(),
+      initialBaselinePaths: z14.array(z14.string()),
+      root: z14.string(),
+      revision: z14.string().uuid(),
+      configuredAt: z14.string().optional()
     });
   }
 });
@@ -3728,6 +3934,7 @@ var init_model = __esm({
 // src/setup/launcher.ts
 import { execFile as execFile13 } from "child_process";
 import { promisify as promisify13 } from "util";
+import fs17 from "fs/promises";
 function globalCommand(args, platform = process.platform) {
   return platform === "win32" ? { command: "cmd.exe", args: ["/d", "/s", "/c", "mason", ...args] } : { command: "mason", args };
 }
@@ -3752,7 +3959,7 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.16.1" : "development";
+    executingVersion = () => true ? "0.16.3" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host} auto`;
   }
@@ -3770,7 +3977,7 @@ __export(config_exports, {
 });
 import { isDeepStrictEqual } from "util";
 import { parse as parse2, stringify } from "smol-toml";
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 async function instructionEdits(root, host) {
   const found = await Promise.all(DOC_CANDIDATES.map(async (file) => ({ path: file, text: await readText(root, file) })));
   const existing = found.find((f) => f.text !== null);
@@ -3886,7 +4093,7 @@ var init_config = __esm({
     init_install();
     init_files2();
     init_launcher();
-    object = z13.record(z13.unknown());
+    object = z15.record(z15.unknown());
     mcpPath = (host) => host === "codex" ? ".codex/config.toml" : ".mcp.json";
     TOML_START = "# mason:mcp:start";
     TOML_END = "# mason:mcp:end";
@@ -3896,7 +4103,7 @@ var init_config = __esm({
 });
 
 // src/mcp/init.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 async function loadProjectMarker(rootDir) {
   const raw = await readStoreJson(rootDir, ".mason/local/project.json");
   if (raw === null) return null;
@@ -3904,8 +4111,8 @@ async function loadProjectMarker(rootDir) {
   return { ...marker, features: await loadProjectFeatures(rootDir) };
 }
 async function loadProjectFeatures(rootDir) {
-  const config = z14.record(z14.unknown()).parse(await readStoreJson(rootDir, ".mason/config.json") ?? {});
-  return z14.object({ confluence: z14.boolean().optional() }).passthrough().parse(config.features ?? {});
+  const config = z16.record(z16.unknown()).parse(await readStoreJson(rootDir, ".mason/config.json") ?? {});
+  return z16.object({ confluence: z16.boolean().optional() }).passthrough().parse(config.features ?? {});
 }
 async function saveProjectMarker(rootDir, marker) {
   const { ancillaryEdits: ancillaryEdits2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -3917,8 +4124,8 @@ async function projectMarkerEdits(rootDir, marker) {
   const edits = [{ path: file, before: await readText(rootDir, file), after: JSON.stringify(local, null, 2) + "\n" }];
   if (features && Object.keys(features).length) {
     const configPath2 = ".mason/config.json", before = await readText(rootDir, configPath2);
-    const config = z14.record(z14.unknown()).parse(JSON.parse(before ?? "{}"));
-    config.features = { ...z14.record(z14.unknown()).parse(config.features ?? {}), ...features };
+    const config = z16.record(z16.unknown()).parse(JSON.parse(before ?? "{}"));
+    config.features = { ...z16.record(z16.unknown()).parse(config.features ?? {}), ...features };
     edits.push({ path: configPath2, before, after: JSON.stringify(config, null, 2) + "\n" });
   }
   return edits;
@@ -3932,10 +4139,10 @@ var init_init = __esm({
     "use strict";
     init_storage();
     init_files2();
-    markerSchema = z14.object({
-      version: z14.literal(1),
-      initializedAt: z14.string(),
-      features: z14.object({ confluence: z14.boolean().optional() }).passthrough().optional()
+    markerSchema = z16.object({
+      version: z16.literal(1),
+      initializedAt: z16.string(),
+      features: z16.object({ confluence: z16.boolean().optional() }).passthrough().optional()
     }).passthrough();
     CLAUDE_MD_SECTION = `<!-- mason:start -->
 ## Mason project knowledge
@@ -4129,7 +4336,7 @@ var init_types2 = __esm({
 });
 
 // src/review/evidence/vitest.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 function parseVitest(raw, sourceRoot) {
   const report = schema.parse(raw);
   const findings = [], diagnostics = [];
@@ -4178,24 +4385,24 @@ var init_vitest = __esm({
     "use strict";
     init_paths2();
     init_types2();
-    count2 = z15.number().int().nonnegative();
-    schema = z15.object({
-      success: z15.boolean(),
+    count2 = z17.number().int().nonnegative();
+    schema = z17.object({
+      success: z17.boolean(),
       numTotalTests: count2,
       numPassedTests: count2,
       numFailedTests: count2,
       numPendingTests: count2,
       numTodoTests: count2,
       numFailedTestSuites: count2,
-      testResults: z15.array(z15.object({
-        name: z15.string().min(1),
-        status: z15.enum(["passed", "failed"]),
-        message: z15.string().optional(),
-        assertionResults: z15.array(z15.object({
-          fullName: z15.string(),
-          status: z15.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
-          failureMessages: z15.array(z15.string()).nullable().optional(),
-          location: z15.object({ line: count2, column: count2 }).nullable().optional()
+      testResults: z17.array(z17.object({
+        name: z17.string().min(1),
+        status: z17.enum(["passed", "failed"]),
+        message: z17.string().optional(),
+        assertionResults: z17.array(z17.object({
+          fullName: z17.string(),
+          status: z17.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
+          failureMessages: z17.array(z17.string()).nullable().optional(),
+          location: z17.object({ line: count2, column: count2 }).nullable().optional()
         }))
       }))
     });
@@ -4203,7 +4410,7 @@ var init_vitest = __esm({
 });
 
 // src/review/evidence/sarif.ts
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 function parseSarif(raw, sourceRoot) {
   const report = schema2.parse(raw), findings = [], diagnostics = [];
   let active = 0, suppressed = 0, absent = 0, unresolved = 0;
@@ -4294,29 +4501,29 @@ var init_sarif = __esm({
     "use strict";
     init_paths2();
     init_types2();
-    index = z16.number().int().nonnegative();
-    artifact = z16.object({ uri: z16.string().optional(), uriBaseId: z16.string().optional(), index: index.optional() });
-    message = z16.object({ text: z16.string().optional(), markdown: z16.string().optional(), id: z16.string().optional(), arguments: z16.array(z16.string()).optional() });
-    level = z16.enum(["error", "warning", "note", "none"]);
-    location = z16.object({ physicalLocation: z16.object({ artifactLocation: artifact.optional(), region: z16.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
-    schema2 = z16.object({
-      version: z16.literal("2.1.0"),
-      runs: z16.array(z16.object({
-        tool: z16.object({ driver: z16.object({ name: z16.string().min(1), rules: z16.array(z16.object({ id: z16.string(), defaultConfiguration: z16.object({ level: level.optional() }).optional(), messageStrings: z16.record(message).optional() })).optional(), globalMessageStrings: z16.record(message).optional() }) }),
-        invocations: z16.array(z16.object({ executionSuccessful: z16.boolean(), commandLine: z16.string().optional(), toolExecutionNotifications: z16.array(z16.object({ level: level.optional(), message })).optional() })).optional(),
-        versionControlProvenance: z16.array(z16.object({ revisionId: z16.string().optional() })).optional(),
-        originalUriBaseIds: z16.record(artifact).optional(),
-        artifacts: z16.array(z16.object({ location: artifact.optional() })).optional(),
-        results: z16.array(z16.object({
-          ruleId: z16.string().optional(),
+    index = z18.number().int().nonnegative();
+    artifact = z18.object({ uri: z18.string().optional(), uriBaseId: z18.string().optional(), index: index.optional() });
+    message = z18.object({ text: z18.string().optional(), markdown: z18.string().optional(), id: z18.string().optional(), arguments: z18.array(z18.string()).optional() });
+    level = z18.enum(["error", "warning", "note", "none"]);
+    location = z18.object({ physicalLocation: z18.object({ artifactLocation: artifact.optional(), region: z18.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
+    schema2 = z18.object({
+      version: z18.literal("2.1.0"),
+      runs: z18.array(z18.object({
+        tool: z18.object({ driver: z18.object({ name: z18.string().min(1), rules: z18.array(z18.object({ id: z18.string(), defaultConfiguration: z18.object({ level: level.optional() }).optional(), messageStrings: z18.record(message).optional() })).optional(), globalMessageStrings: z18.record(message).optional() }) }),
+        invocations: z18.array(z18.object({ executionSuccessful: z18.boolean(), commandLine: z18.string().optional(), toolExecutionNotifications: z18.array(z18.object({ level: level.optional(), message })).optional() })).optional(),
+        versionControlProvenance: z18.array(z18.object({ revisionId: z18.string().optional() })).optional(),
+        originalUriBaseIds: z18.record(artifact).optional(),
+        artifacts: z18.array(z18.object({ location: artifact.optional() })).optional(),
+        results: z18.array(z18.object({
+          ruleId: z18.string().optional(),
           ruleIndex: index.optional(),
           message,
           level: level.optional(),
-          kind: z16.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
-          baselineState: z16.enum(["new", "unchanged", "updated", "absent"]).optional(),
-          suppressions: z16.array(z16.object({ kind: z16.enum(["inSource", "external"]), status: z16.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
-          locations: z16.array(location).optional(),
-          relatedLocations: z16.array(location).optional()
+          kind: z18.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
+          baselineState: z18.enum(["new", "unchanged", "updated", "absent"]).optional(),
+          suppressions: z18.array(z18.object({ kind: z18.enum(["inSource", "external"]), status: z18.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
+          locations: z18.array(location).optional(),
+          relatedLocations: z18.array(location).optional()
         })).optional()
       }))
     });
@@ -4325,7 +4532,7 @@ var init_sarif = __esm({
 
 // src/review/evidence.ts
 import path21 from "path";
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 function relativeArtifact(root, file) {
   const relative = path21.isAbsolute(file) ? path21.relative(root, file) : file;
   const normalized = normalizeRepoPath(relative);
@@ -4366,7 +4573,7 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
     let manifest, raw;
     try {
       manifest = relativeArtifact(root, supplied);
-      raw = z17.object({ version: z17.literal(1), checks: z17.array(z17.unknown()) }).parse(await readStoreJson(root, manifest));
+      raw = z19.object({ version: z19.literal(1), checks: z19.array(z19.unknown()) }).parse(await readStoreJson(root, manifest));
     } catch (error) {
       output.diagnostics.push(`${supplied}: ${String(error)}`);
       continue;
@@ -4519,25 +4726,25 @@ var init_evidence2 = __esm({
     init_vitest();
     init_sarif();
     init_types2();
-    checkSchema2 = z17.object({
-      id: z17.string().min(1).max(100),
-      kind: z17.enum(["tests", "static-analysis", "security", "complexity", "duplication"]),
-      tool: z17.string().min(1).max(200),
-      command: z17.string().min(1).max(2e3),
-      commit: z17.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
-      workingTreeClean: z17.boolean().optional(),
-      source: z17.string().max(2e3).optional(),
-      sourceRoot: z17.string().min(1).max(4e3).optional(),
-      status: z17.enum(["completed", "skipped", "unavailable"]).default("completed"),
-      reason: z17.string().min(1).max(2e3).optional(),
-      exitCode: z17.number().int().nullable().optional(),
-      report: z17.object({ format: z17.enum(["vitest-json", "sarif"]), path: z17.string().min(1).max(4e3) }).optional()
+    checkSchema2 = z19.object({
+      id: z19.string().min(1).max(100),
+      kind: z19.enum(["tests", "static-analysis", "security", "complexity", "duplication"]),
+      tool: z19.string().min(1).max(200),
+      command: z19.string().min(1).max(2e3),
+      commit: z19.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
+      workingTreeClean: z19.boolean().optional(),
+      source: z19.string().max(2e3).optional(),
+      sourceRoot: z19.string().min(1).max(4e3).optional(),
+      status: z19.enum(["completed", "skipped", "unavailable"]).default("completed"),
+      reason: z19.string().min(1).max(2e3).optional(),
+      exitCode: z19.number().int().nullable().optional(),
+      report: z19.object({ format: z19.enum(["vitest-json", "sarif"]), path: z19.string().min(1).max(4e3) }).optional()
     });
   }
 });
 
 // src/review/review.ts
-import fs16 from "fs/promises";
+import fs18 from "fs/promises";
 import path22 from "path";
 import { execFile as execFile15 } from "child_process";
 import { promisify as promisify15 } from "util";
@@ -4617,7 +4824,7 @@ async function computeReview(rootDir, base, options = {}) {
     analyzed,
     async (relPath) => {
       try {
-        await fs16.access(path22.join(resolvedRoot, relPath));
+        await fs18.access(path22.join(resolvedRoot, relPath));
         return true;
       } catch {
         return false;
@@ -5093,12 +5300,12 @@ __export(assemble_exports, {
   assembleContext: () => assembleContext
 });
 import path25 from "path";
-import fs17 from "fs/promises";
+import fs19 from "fs/promises";
 async function collectImpact(root, candidates) {
   const targets = /* @__PURE__ */ new Set();
   let sourceFiles;
   for (const candidate of sanitizeRepoPaths(candidates)) {
-    const stat = await fs17.stat(path25.join(root, candidate)).catch(() => null);
+    const stat = await fs19.stat(path25.join(root, candidate)).catch(() => null);
     if (stat?.isDirectory()) {
       sourceFiles ??= await (await createFileAccess(root)).list();
       for (const file of sourceFiles) {
@@ -5325,8 +5532,8 @@ __export(observations_exports, {
   observeActivation: () => observeActivation,
   readObservation: () => readObservation
 });
-import fs18 from "fs/promises";
-import { z as z18 } from "zod";
+import fs20 from "fs/promises";
+import { z as z20 } from "zod";
 function observationPath(directory, host, revision, version = executingVersion()) {
   return `${directory}/activation/${host}-${revision}-${hash(version).slice(0, 12)}.json`;
 }
@@ -5341,9 +5548,9 @@ async function observeActivation(dir, event, options = {}) {
   const host = process.env.MASON_SETUP_HOST, revision = process.env.MASON_SETUP_REVISION;
   if (host !== "codex" && host !== "claude" || !revision || !process.env.MASON_SETUP_ROOT) return null;
   try {
-    const capturedDirectory = options.reportPath?.match(/^(\.mason\/reports\/automation\/[a-f0-9]{24})\/checks\//)?.[1];
-    const ws = capturedDirectory ? { root: await fs18.realpath(dir), directory: capturedDirectory } : await workspace(dir);
-    if (ws.root !== await fs18.realpath(process.env.MASON_SETUP_ROOT)) return null;
+    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 fs20.realpath(dir), directory: capturedDirectory } : await workspace(dir);
+    if (ws.root !== await fs20.realpath(process.env.MASON_SETUP_ROOT)) return null;
     const setup = await loadSetup(ws.root);
     if (setup?.hosts[host]?.revision !== revision) return "Mason setup changed; restart the assistant to observe the current integration.";
     const directory = ws.directory + "/activation";
@@ -5391,19 +5598,19 @@ var init_observations = __esm({
     init_storage();
     init_model();
     init_launcher();
-    observationSchema = z18.object({
-      version: z18.literal(1),
-      masonVersion: z18.string(),
-      root: z18.string(),
-      revision: z18.string(),
-      host: z18.enum(["codex", "claude"]),
-      contextCalls: z18.number().int().nonnegative(),
-      lastContextAt: z18.string().optional(),
-      sessions: z18.record(z18.object({
-        events: z18.array(z18.enum(events)),
-        at: z18.string(),
-        verificationStatus: z18.string().optional(),
-        reportPath: z18.string().optional()
+    observationSchema = z20.object({
+      version: z20.literal(1),
+      masonVersion: z20.string(),
+      root: z20.string(),
+      revision: z20.string(),
+      host: z20.enum(["codex", "claude"]),
+      contextCalls: z20.number().int().nonnegative(),
+      lastContextAt: z20.string().optional(),
+      sessions: z20.record(z20.object({
+        events: z20.array(z20.enum(events)),
+        at: z20.string(),
+        verificationStatus: z20.string().optional(),
+        reportPath: z20.string().optional()
       }))
     });
   }
@@ -5429,7 +5636,7 @@ async function setupStatus(dir) {
       version: 1,
       status: pending.length ? "incomplete" : "not-configured",
       hosts: {},
-      next: pending.length ? "Setup did not finish. Rerun mason-auto setup --host " + pending[0] + " to resume using the retained original evidence." : "Run mason-auto setup --host codex or --host claude."
+      next: pending.length ? "Setup did not finish. Rerun mason-auto setup --host " + pending[0] + " to resume using the retained original evidence." : "Project hooks are inactive until local setup. Run mason setup --host codex or --host claude."
     };
   }
   const hosts = {};
@@ -5759,7 +5966,7 @@ __export(config_exports2, {
   saveConfluenceConfig: () => saveConfluenceConfig,
   validateProvider: () => validateProvider
 });
-import fs19 from "fs/promises";
+import fs21 from "fs/promises";
 import path26 from "path";
 import os3 from "os";
 import { execFile as execFile17 } from "child_process";
@@ -5772,15 +5979,15 @@ function configFile() {
 }
 async function loadConfig() {
   try {
-    const raw = await fs19.readFile(configFile(), "utf-8");
+    const raw = await fs21.readFile(configFile(), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function saveConfig(config) {
-  await fs19.mkdir(configDir(), { recursive: true });
-  await fs19.writeFile(configFile(), JSON.stringify(config, null, 2), "utf-8");
+  await fs21.mkdir(configDir(), { recursive: true });
+  await fs21.writeFile(configFile(), JSON.stringify(config, null, 2), "utf-8");
 }
 function getDefaultModel(provider) {
   return DEFAULT_MODELS[provider];
@@ -5940,7 +6147,7 @@ var init_renderer = __esm({
 });
 
 // src/confluence/diff.ts
-import fs20 from "fs/promises";
+import fs22 from "fs/promises";
 import path27 from "path";
 import { createHash as createHash5 } from "crypto";
 function hashDescription(description) {
@@ -5954,7 +6161,7 @@ function syncStatePath(rootDir) {
 }
 async function loadSyncState(rootDir) {
   try {
-    const raw = await fs20.readFile(syncStatePath(rootDir), "utf-8");
+    const raw = await fs22.readFile(syncStatePath(rootDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 2) return null;
     return parsed;
@@ -5963,8 +6170,8 @@ async function loadSyncState(rootDir) {
   }
 }
 async function saveSyncState(rootDir, state) {
-  await fs20.mkdir(syncStateDir(rootDir), { recursive: true });
-  await fs20.writeFile(
+  await fs22.mkdir(syncStateDir(rootDir), { recursive: true });
+  await fs22.writeFile(
     syncStatePath(rootDir),
     JSON.stringify(state, null, 2),
     "utf-8"
@@ -6512,13 +6719,14 @@ var init_sync = __esm({
 
 // src/mcp/server.ts
 init_provenance();
+init_decisions();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z19 } from "zod";
+import { z as z21 } from "zod";
 
 // src/mcp/tools.ts
 init_repair();
-import fs21 from "fs/promises";
+import fs23 from "fs/promises";
 import path28 from "path";
 import { execFile as execFile19 } from "child_process";
 import { promisify as promisify19 } from "util";
@@ -7124,14 +7332,14 @@ init_files();
 import { createHash as createHash3 } from "crypto";
 import { execFile as execFile11 } from "child_process";
 import { promisify as promisify11 } from "util";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var exec10 = promisify11(execFile11);
-var requestSchema = z4.object({
-  id: z4.string().regex(/^[a-zA-Z0-9_-]+$/),
-  action: z4.enum(["prepare", "accept", "reaffirm", "retire"]).default("prepare"),
-  reviewer: z4.string().trim().min(1).max(200).optional(),
-  note: z4.string().trim().min(1).max(1500).optional(),
-  reviewToken: z4.string().regex(/^[a-f0-9]{64}$/).optional()
+var requestSchema = z5.object({
+  id: z5.string().regex(/^[a-zA-Z0-9_-]+$/),
+  action: z5.enum(["prepare", "accept", "reaffirm", "retire"]).default("prepare"),
+  reviewer: z5.string().trim().min(1).max(200).optional(),
+  note: z5.string().trim().min(1).max(1500).optional(),
+  reviewToken: z5.string().regex(/^[a-f0-9]{64}$/).optional()
 });
 async function reviewState(root, record) {
   const [headHash, workingTree, changes] = await Promise.all([
@@ -7355,16 +7563,16 @@ ${JSON.stringify({ partials }, null, 2)}`;
 init_storage();
 init_snapshot();
 import fs12 from "fs/promises";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var DIRECTORY = ".mason/partial-snapshots";
-var partialSchema = z5.object({
-  batchId: z5.string().regex(/^[a-zA-Z0-9_-]+$/),
-  offset: z5.number().int().nonnegative(),
-  features: z5.record(featureSchema),
-  flows: z5.record(flowSchema),
-  savedAt: z5.string()
+var partialSchema = z6.object({
+  batchId: z6.string().regex(/^[a-zA-Z0-9_-]+$/),
+  offset: z6.number().int().nonnegative(),
+  features: z6.record(featureSchema),
+  flows: z6.record(flowSchema),
+  savedAt: z6.string()
 });
-var scopeSchema = z5.object({ files: z5.array(z5.string()), savedAt: z5.string() });
+var scopeSchema = z6.object({ files: z6.array(z6.string()), savedAt: z6.string() });
 async function savePartial(rootDir, partial) {
   if (!/^[a-zA-Z0-9_-]+$/.test(partial.batchId)) throw new Error(`Invalid batchId: ${partial.batchId}`);
   await writeStoreJson(rootDir, `${DIRECTORY}/${partial.batchId}.json`, partialSchema.parse(partial));
@@ -7469,7 +7677,7 @@ async function detectProjectSnapshot(rootDir) {
   const present = [];
   for (const file of buildFiles) {
     try {
-      await fs21.access(path28.join(rootDir, file));
+      await fs23.access(path28.join(rootDir, file));
       present.push(file);
     } catch {
     }
@@ -8335,7 +8543,7 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.16.1"
+      version: "0.16.3"
     },
     {
       instructions: 'Mason retrieves recorded decisions, file impact, and optional feature/flow maps. Use get_context with the task and known files, and get_impact before editing. Save learned rationale and constraints with save_decision; review and commit the local records through the project workflow. These tools work without initialization or a concept map. Consult trust and diagnostics: changed or unknown freshness needs source inspection, failed verification needs correction, and proposals are suggestions and legacy records are unreviewed. Accepted decisions are recorded team constraints, still subject to freshness checks. Use review_decision to prepare code evidence and record only authorized acceptance, reaffirmation, or retirement. Never invent a reviewer or treat these recorded identities as authenticated approval. mason_init returns documentation audit and committed-diff review findings with a quickstart guide. Use mode: "map" only when a full architecture map is requested. A missing map is not a setup failure; use decisions and source evidence. get_snapshot provides architecture navigation when a map is available. The mason-audit and mason-review CLIs also work without setup.'
@@ -8345,11 +8553,11 @@ function createMcpServer() {
     "mason_init",
     "Inspect this project now: returns documentation audit findings, committed-diff review findings, decision/map status, and a quickstart playbook. Quickstart and map modes are read-only and deterministic. Explicit mode: setup configures MCP, instructions and lifecycle hooks to use mason on PATH while retaining original audit evidence; use it only when the user requests setup. Optional host selects codex or claude. Optional base selects the review comparison; evidence imports CI manifests with check outcomes, commit freshness, and links to changed files and accepted decisions. mode: map returns the full Map-Reduce build workflow. Repeat calls refresh findings even after setup.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      mode: z19.enum(["quickstart", "map", "setup"]).optional().default("quickstart").describe("Quickstart inspects without edits; map requests an architecture build; setup installs the shared onboarding flow."),
-      host: z19.enum(["codex", "claude"]).optional().describe("Assistant to configure in setup mode; inferred only when unambiguous."),
-      base: z19.string().optional().describe("Git ref for committed-diff review. Defaults to the first available main branch ref."),
-      evidence: z19.array(z19.string()).max(10).optional().describe("Repository-local CI evidence manifests to include in the review. Imports Vitest JSON and SARIF without executing check commands.")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      mode: z21.enum(["quickstart", "map", "setup"]).optional().default("quickstart").describe("Quickstart inspects without edits; map requests an architecture build; setup installs the shared onboarding flow."),
+      host: z21.enum(["codex", "claude"]).optional().describe("Assistant to configure in setup mode; inferred only when unambiguous."),
+      base: z21.string().optional().describe("Git ref for committed-diff review. Defaults to the first available main branch ref."),
+      evidence: z21.array(z21.string()).max(10).optional().describe("Repository-local CI evidence manifests to include in the review. Imports Vitest JSON and SARIF without executing check commands.")
     },
     async ({ dir, mode, host, base, evidence }) => {
       const result = await masonInit(dir, { mode, host, base, evidence });
@@ -8360,8 +8568,8 @@ function createMcpServer() {
     "mason_automation",
     "Inspect installed automation and observed host events, or resume/check retained documentation repair evidence across sessions. status is read-only; check saves local baselines and verification reports without editing source or approving advisories. Returns concise results with a full report path. Works without a map.",
     {
-      dir: z19.string().describe("Absolute path to the project directory"),
-      action: z19.enum(["status", "check"]).describe("Inspect configuration and receipts, or capture/resume and verify original audit evidence.")
+      dir: z21.string().describe("Absolute path to the project directory"),
+      action: z21.enum(["status", "check"]).describe("Inspect configuration and receipts, or capture/resume and verify original audit evidence.")
     },
     async ({ dir, action }) => ({ content: [{ type: "text", text: await masonAutomation(dir, action) }] })
   );
@@ -8369,10 +8577,10 @@ function createMcpServer() {
     "mason_repair",
     "Track documentation repairs against original audit evidence. prepare saves a local baseline and returns a scoped work order; verify reads that baseline and reports resolved, unresolved, review-required, unverified, and new findings. Suppressed advisories remain unresolved. Does not edit documentation or approve decisions. No map required.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      action: z19.enum(["prepare", "verify"]),
-      baselinePath: z19.string().optional().describe("Original baseline path returned by prepare; required for verify."),
-      checks: z19.array(z19.enum(["deleted-reference", "new-module", "stale-count", "dead-command", "deps-changed", "decision-anchor-drift"])).min(1).optional().describe("Optional audit check subset for prepare. Verification always uses the original checks.")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      action: z21.enum(["prepare", "verify"]),
+      baselinePath: z21.string().optional().describe("Original baseline path returned by prepare; required for verify."),
+      checks: z21.array(z21.enum(["deleted-reference", "new-module", "stale-count", "dead-command", "deps-changed", "decision-anchor-drift"])).min(1).optional().describe("Optional audit check subset for prepare. Verification always uses the original checks.")
     },
     async ({ dir, action, baselinePath, checks }) => {
       const result = await masonRepair(dir, { action, baselinePath, checks });
@@ -8383,8 +8591,8 @@ function createMcpServer() {
     "mason_complete_init",
     "Record assistant instruction setup locally in ignored .mason/local/project.json, with feature settings in shared .mason/config.json. Other tools work without this marker. Repeated calls preserve the original setup time and existing settings; pass confluenceConfigured only to change that setting.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      confluenceConfigured: z19.boolean().optional().describe("Set the Confluence setup status; omit to preserve the existing value")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      confluenceConfigured: z21.boolean().optional().describe("Set the Confluence setup status; omit to preserve the existing value")
     },
     async ({ dir, confluenceConfigured }) => {
       const result = await masonCompleteInit(dir, { confluenceConfigured });
@@ -8395,11 +8603,11 @@ function createMcpServer() {
     "mason_set_confluence",
     "Configure Confluence credentials. Two-step flow: (1) call without `spaceKey` to validate the credentials and receive a list of available spaces \u2014 relay them to the user. (2) call again with the same `baseUrl`/`email`/`apiToken` plus the chosen `spaceKey` to persist. Credentials are stored in `~/.mason/config.json`. Warn the user that the API token will be visible in chat history before they paste it.",
     {
-      baseUrl: z19.string().describe("Confluence base URL. Accepts `acme`, `acme.atlassian.net`, or `https://acme.atlassian.net` (normalized automatically)."),
-      email: z19.string().describe("User's Atlassian account email"),
-      apiToken: z19.string().describe("API token from id.atlassian.com/manage-profile/security/api-tokens"),
-      spaceKey: z19.string().optional().describe("Confluence space key. Omit on the first call to list available spaces."),
-      parentPageId: z19.string().optional().describe("Optional parent page ID under which Mason's index page is created")
+      baseUrl: z21.string().describe("Confluence base URL. Accepts `acme`, `acme.atlassian.net`, or `https://acme.atlassian.net` (normalized automatically)."),
+      email: z21.string().describe("User's Atlassian account email"),
+      apiToken: z21.string().describe("API token from id.atlassian.com/manage-profile/security/api-tokens"),
+      spaceKey: z21.string().optional().describe("Confluence space key. Omit on the first call to list available spaces."),
+      parentPageId: z21.string().optional().describe("Optional parent page ID under which Mason's index page is created")
     },
     async ({ baseUrl, email, apiToken, spaceKey, parentPageId }) => {
       const result = await masonSetConfluence({
@@ -8416,7 +8624,7 @@ function createMcpServer() {
     "full_analysis",
     "One-shot orientation for a project WITHOUT a concept map (get_snapshot returned exists:false). Returns git history stats, project structure with file counts, curated code sample previews (~60 lines each), and test-to-source mapping. On a mapped project, prefer get_snapshot \u2014 it is cheaper and answers feature/architecture questions directly.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory")
+      dir: z21.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await fullAnalysis(dir);
@@ -8429,7 +8637,7 @@ function createMcpServer() {
     "analyze_project",
     "Run git history analysis on a codebase. Returns commit convention patterns, stale directories, and frequently changed files. These are aggregate stats across hundreds of commits that would be expensive to compute manually.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory")
+      dir: z21.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await analyzeProject(dir);
@@ -8442,8 +8650,8 @@ function createMcpServer() {
     "get_code_samples",
     "Get previews (first ~60 lines) of representative source files from the codebase. Includes entry points, config files, hot files (frequently changed), test examples, and one file per directory for breadth. Read files natively for full content.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      count: z19.number().optional().default(15).describe("Maximum number of files to sample (default: 15)")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      count: z21.number().optional().default(15).describe("Maximum number of files to sample (default: 15)")
     },
     async ({ dir, count: count3 }) => {
       const result = await getCodeSamples(dir, count3);
@@ -8456,7 +8664,7 @@ function createMcpServer() {
     "get_snapshot",
     "Return the optional feature-to-file architecture map with drift and trust evidence. If no map exists, returns exists:false plus project structure, Git signals, and test pairs. Decision capture, get_context, and get_impact still work. No initialization required.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory")
+      dir: z21.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await getSnapshot(dir);
@@ -8469,9 +8677,9 @@ function createMcpServer() {
     "get_context",
     "Assemble task context: matching decisions with rationale, approval, owner, sources, last review, and freshness, plus related tests, file impact, and any available map entries. Proposals are suggestions; legacy records are unreviewed; accepted decisions are constraints subject to freshness. No initialization or map required. Pass task and optional files. map.status and diagnostics preserve missing or invalid knowledge. Impact covers up to three unique files, expanding directory anchors.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      task: z19.string().describe("The task, bug, or change request in natural language \u2014 e.g. 'add rate limiting to the API client' or a ticket description"),
-      files: z19.array(z19.string()).optional().describe("Optional file paths already known to be involved (e.g. from a diff or stack trace). Entries containing them are boosted above pure text matches.")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      task: z21.string().describe("The task, bug, or change request in natural language \u2014 e.g. 'add rate limiting to the API client' or a ticket description"),
+      files: z21.array(z21.string()).optional().describe("Optional file paths already known to be involved (e.g. from a diff or stack trace). Entries containing them are boosted above pure text matches.")
     },
     async ({ dir, task, files }) => {
       const result = await getContext(dir, task, files);
@@ -8487,10 +8695,10 @@ function createMcpServer() {
     "generate_snapshot_batch",
     "Map step of the concept-map build. Returns one batch of source files (skeletons of every file in the batch plus a few deeper-read bodies for grounding), along with a system prompt instructing you to derive features and flows for ONLY this batch. Call repeatedly with the returned `nextOffset` until it is null, calling `save_partial_snapshot` between each call. Use product-natural feature names so partials merge cleanly in the reduce step.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      offset: z19.number().int().optional().describe("0-indexed file offset to start the batch at. Omit on the first call; pass the `nextOffset` from the previous response for subsequent calls."),
-      batchSize: z19.number().int().optional().describe("Files per batch. Defaults to 50."),
-      files: z19.array(z19.string()).optional().describe("Scope the batch walk to this explicit file list \u2014 e.g. the drift set from mason_check_drift (changedFiles + unmappedFiles). Pass the SAME list on every batch call of one refresh run. Triggers refresh mode: reduce_snapshot will merge the partials into the existing map instead of rebuilding it.")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      offset: z21.number().int().optional().describe("0-indexed file offset to start the batch at. Omit on the first call; pass the `nextOffset` from the previous response for subsequent calls."),
+      batchSize: z21.number().int().optional().describe("Files per batch. Defaults to 50."),
+      files: z21.array(z21.string()).optional().describe("Scope the batch walk to this explicit file list \u2014 e.g. the drift set from mason_check_drift (changedFiles + unmappedFiles). Pass the SAME list on every batch call of one refresh run. Triggers refresh mode: reduce_snapshot will merge the partials into the existing map instead of rebuilding it.")
     },
     async ({ dir, offset, batchSize, files }) => {
       const result = await generateSnapshotBatch(dir, offset, batchSize, files);
@@ -8503,23 +8711,23 @@ function createMcpServer() {
     "save_partial_snapshot",
     "Persist the partial concept map you derived for one batch. Call this once per batch, with the `batchId` from the `generate_snapshot_batch` response. Partials accumulate in `.mason/partial-snapshots/` and are merged in the reduce step.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      batchId: z19.string().describe("The `batchId` returned by `generate_snapshot_batch`."),
-      offset: z19.number().int().describe("The `offset` returned by `generate_snapshot_batch`. Used to order partials in the reduce step."),
-      features: z19.record(
-        z19.object({
-          description: z19.string(),
-          files: z19.array(z19.string()),
-          tests: z19.array(z19.string()).optional(),
-          type: z19.enum(["capability", "infrastructure"]).optional().describe(
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      batchId: z21.string().describe("The `batchId` returned by `generate_snapshot_batch`."),
+      offset: z21.number().int().describe("The `offset` returned by `generate_snapshot_batch`. Used to order partials in the reduce step."),
+      features: z21.record(
+        z21.object({
+          description: z21.string(),
+          files: z21.array(z21.string()),
+          tests: z21.array(z21.string()).optional(),
+          type: z21.enum(["capability", "infrastructure"]).optional().describe(
             '"capability" (user-facing functionality) or "infrastructure" (internal plumbing with no end user \u2014 DI/service wiring, config, logging, adapters). Defaults to "capability".'
           )
         })
       ).describe("Partial features for this batch only \u2014 files outside the batch will be added by other partials."),
-      flows: z19.record(
-        z19.object({
-          description: z19.string(),
-          chain: z19.array(z19.string())
+      flows: z21.record(
+        z21.object({
+          description: z21.string(),
+          chain: z21.array(z21.string())
         })
       ).describe("Partial flows whose entire chain is in this batch. Cross-batch flows are reconstructed in reduce.")
     },
@@ -8534,7 +8742,7 @@ function createMcpServer() {
     "reduce_snapshot",
     "Reduce step of the concept-map build. Returns every partial snapshot plus a system prompt asking you to merge them into one coherent project-wide map. Resolve platform variants into single product features, dedupe near-duplicates, and ensure no file is dropped. After producing the unified map, call `save_snapshot` to persist it (this also clears the partials).",
     {
-      dir: z19.string().describe("Absolute path to the project root directory")
+      dir: z21.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await reduceSnapshot(dir);
@@ -8547,25 +8755,25 @@ function createMcpServer() {
     "save_snapshot",
     "Save a concept-to-files map as a persistent project snapshot. Maps feature names and data flows to the files that implement them. Persists across conversations \u2014 future sessions can call get_snapshot to instantly find relevant files. No API key needed \u2014 you are the LLM generating the map.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      features: z19.record(
-        z19.object({
-          description: z19.string().describe("One-line description of the feature"),
-          files: z19.array(z19.string()).describe("File paths that implement this feature"),
-          tests: z19.array(z19.string()).optional().describe("Test file paths for this feature"),
-          type: z19.enum(["capability", "infrastructure"]).optional().describe(
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      features: z21.record(
+        z21.object({
+          description: z21.string().describe("One-line description of the feature"),
+          files: z21.array(z21.string()).describe("File paths that implement this feature"),
+          tests: z21.array(z21.string()).optional().describe("Test file paths for this feature"),
+          type: z21.enum(["capability", "infrastructure"]).optional().describe(
             'Classification: "capability" for user-facing functionality, "infrastructure" for internal plumbing with no end user (DI/service wiring, config, logging, adapters). Capabilities are published to Confluence; infrastructure stays in the AI concept map only. Defaults to "capability".'
           )
         })
       ).describe("Map of feature names to their implementing files"),
-      flows: z19.record(
-        z19.object({
-          description: z19.string().describe("One-line description of the flow"),
-          chain: z19.array(z19.string()).describe("Ordered list of file paths showing data/call flow")
+      flows: z21.record(
+        z21.object({
+          description: z21.string().describe("One-line description of the flow"),
+          chain: z21.array(z21.string()).describe("Ordered list of file paths showing data/call flow")
         })
       ).describe("Map of flow names to ordered file chains"),
-      removeFeatures: z19.array(z19.string()).optional().describe("Feature names to delete from the existing map \u2014 for features that were renamed or no longer exist. Applied before merging; only meaningful on incremental saves."),
-      removeFlows: z19.array(z19.string()).optional().describe("Flow names to delete from the existing map. Applied before merging; only meaningful on incremental saves.")
+      removeFeatures: z21.array(z21.string()).optional().describe("Feature names to delete from the existing map \u2014 for features that were renamed or no longer exist. Applied before merging; only meaningful on incremental saves."),
+      removeFlows: z21.array(z21.string()).optional().describe("Flow names to delete from the existing map. Applied before merging; only meaningful on incremental saves.")
     },
     async ({ dir, features, flows, removeFeatures, removeFlows }) => {
       const result = await saveSnapshotData(
@@ -8584,17 +8792,17 @@ function createMcpServer() {
     "save_decision",
     "Capture or revise a decision proposal with rationale, anchors, optional owner, sources, and a known actor. No setup or map required. Writes a local record and preserves content history. Changes create a pending proposal while the last accepted revision remains operative; unchanged content does not re-verify or refresh it. Use review_decision for authorized acceptance or reaffirmation. A proposal cannot supersede a record with an operative accepted revision; review its replacement and retire the original separately.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      title: z19.string().max(80).describe("Short, specific headline \u2014 becomes the stable record id"),
-      body: z19.string().max(1500).describe("The knowledge itself: what was tried/decided, why, and what to avoid. Must contain information NOT derivable by reading the code."),
-      category: z19.enum(["decision", "gotcha", "deprecation", "convention"]),
-      files: z19.array(z19.string()).optional().describe("Repo-relative files or directory prefixes this applies to. Matching is shared by retrieval, hooks, review, and drift checking; changes flag the decision for re-verification."),
-      id: z19.string().optional().describe("Existing id to revise. Changed content becomes a proposal; unchanged content leaves the review and freshness untouched."),
-      supersedes: z19.string().optional().describe("Id of an unreviewed record or proposal with no accepted revision to replace. Operative accepted decisions require separate review and retirement."),
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      title: decisionTitleSchema.describe(`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.`),
+      category: z21.enum(["decision", "gotcha", "deprecation", "convention"]),
+      files: z21.array(z21.string()).optional().describe("Repo-relative files or directory prefixes this applies to. Matching is shared by retrieval, hooks, review, and drift checking; changes flag the decision for re-verification."),
+      id: z21.string().optional().describe("Existing id to revise. Changed content becomes a proposal; unchanged content leaves the review and freshness untouched."),
+      supersedes: z21.string().optional().describe("Id of an unreviewed record or proposal with no accepted revision to replace. Operative accepted decisions require separate review and retirement."),
       owner: attributionSchema.shape.owner.describe("Responsible person or team, when known. Null clears it. Required for acceptance."),
       sources: attributionSchema.shape.sources.describe("Known PR, issue, incident, discussion, or document references. Omit to preserve; [] clears. At least one is required for acceptance."),
       actor: attributionSchema.shape.actor.describe("Known person or agent recording this revision. Omit if unknown; do not infer from Git identity."),
-      force: z19.boolean().optional().describe("Save even when a near-duplicate was detected")
+      force: z21.boolean().optional().describe("Save even when a near-duplicate was detected")
     },
     async ({ dir, title, body, category, files, id, supersedes, force, owner, sources, actor }) => {
       const result = await saveDecision(dir, {
@@ -8616,12 +8824,12 @@ function createMcpServer() {
     "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. Then record accept, reaffirm, or retire with that 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: z19.string().describe("Absolute path to the project root directory"),
-      id: z19.string().regex(/^[a-zA-Z0-9_-]+$/).describe("Decision id from get_context or save_decision"),
-      action: z19.enum(["prepare", "accept", "reaffirm", "retire"]).optional().default("prepare").describe("Prepare is read-only. Other actions record an explicitly authorized review."),
-      reviewer: z19.string().trim().min(1).max(200).optional().describe("Identity of the actual reviewer; required for a verdict. Never invent one."),
-      note: z19.string().trim().min(1).max(1500).optional().describe("Review rationale; required for a verdict. Cite evidence for the decision."),
-      reviewToken: z19.string().regex(/^[a-f0-9]{64}$/).optional().describe("Token from the prepared review; rejects stale record or code revisions")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      id: z21.string().regex(/^[a-zA-Z0-9_-]+$/).describe("Decision id from get_context or save_decision"),
+      action: z21.enum(["prepare", "accept", "reaffirm", "retire"]).optional().default("prepare").describe("Prepare is read-only. Other actions record an explicitly authorized review."),
+      reviewer: z21.string().trim().min(1).max(200).optional().describe("Identity of the actual reviewer; required for a verdict. Never invent one."),
+      note: z21.string().trim().min(1).max(1500).optional().describe("Review rationale; required for a verdict. Cite evidence for the decision."),
+      reviewToken: z21.string().regex(/^[a-f0-9]{64}$/).optional().describe("Token from the prepared review; rejects stale record or code revisions")
     },
     async ({ dir, ...input }) => {
       const result = await reviewDecision2(dir, input);
@@ -8632,7 +8840,7 @@ function createMcpServer() {
     "mason_check_drift",
     "Check how far the concept map has drifted from HEAD. Deterministic (git + filesystem, no LLM). Returns which features/flows are stale and the changed files behind them, new source files not yet mapped, ghost files (mapped but deleted), renames, and a `recommendation`: `up-to-date` (nothing to do), `incremental` (update just the stale entries via save_snapshot), or `full-rebuild` (re-run the Map-Reduce build). Call this before trusting the map in a long session, or periodically to keep the map and any synced wikis fresh.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory")
+      dir: z21.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await checkDrift(dir);
@@ -8645,8 +8853,8 @@ function createMcpServer() {
     "verify_snapshot",
     "Spot-check the concept map's CORRECTNESS (drift checks freshness; this checks entries were right to begin with). Returns a sample of entries \u2014 always the never-verified and least-recently-verified first \u2014 with skeletons of their claimed files, for you to judge whether the files actually implement what the entry claims. Report verdicts back via save_verification. Run periodically, or after an automated refresh wrote entries no human reviewed.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      sample: z19.number().int().optional().describe("Entries to sample (default 5)")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      sample: z21.number().int().optional().describe("Entries to sample (default 5)")
     },
     async ({ dir, sample }) => {
       const result = await verifySnapshot(dir, sample);
@@ -8657,11 +8865,11 @@ function createMcpServer() {
     "save_verification",
     "Record verify_snapshot verdicts. Entries judged ok are stamped verifiedAt; failures are flagged verificationFailed with your note and surface in get_context, get_snapshot, and mason_check_drift until corrected. Verdict notes are required for failures.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      verdicts: z19.record(
-        z19.object({
-          ok: z19.boolean(),
-          note: z19.string().optional().describe("One line on what's wrong \u2014 required when ok is false")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      verdicts: z21.record(
+        z21.object({
+          ok: z21.boolean(),
+          note: z21.string().optional().describe("One line on what's wrong \u2014 required when ok is false")
         })
       ).describe("Entry name \u2192 verdict, exactly as returned by verify_snapshot")
     },
@@ -8674,8 +8882,8 @@ function createMcpServer() {
     "get_impact",
     "Trace historical co-change partners, related tests, and references with evidence: resolved imports, explicit paths, or uncertain name candidates. Candidates are not proven dependencies. Deterministic and read-only; no initialization or concept map required.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      files: z19.array(z19.string()).describe("File paths or names to analyze (e.g., ['WeatherRepository.kt'] or ['src/services/auth.ts'])")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      files: z21.array(z21.string()).describe("File paths or names to analyze (e.g., ['WeatherRepository.kt'] or ['src/services/auth.ts'])")
     },
     async ({ dir, files }) => {
       const result = await getImpact(dir, files);
@@ -8688,12 +8896,12 @@ function createMcpServer() {
     "export_to_confluence",
     "Sync the project's concept map to Confluence as product-readable wiki pages: an index page, one page per feature (PM-language descriptions, no file paths), and a changelog page. Mason replaces managed page bodies; manual edits to those bodies are overwritten. Requires `mason_set_confluence` to have been called first.",
     {
-      dir: z19.string().describe("Absolute path to the project root directory"),
-      spaceKey: z19.string().optional().describe("Override the configured space key"),
-      parentPageId: z19.string().optional().describe("Override the configured parent page ID"),
-      indexPageTitle: z19.string().optional().describe("Title of the index page (default: 'Mason \u2014 System Map')"),
-      changelogPageTitle: z19.string().optional().describe("Title of the changelog page (default: 'Mason \u2014 Changelog')"),
-      featurePagePrefix: z19.string().optional().describe("Prefix for each feature page title (default: 'Feature: ')")
+      dir: z21.string().describe("Absolute path to the project root directory"),
+      spaceKey: z21.string().optional().describe("Override the configured space key"),
+      parentPageId: z21.string().optional().describe("Override the configured parent page ID"),
+      indexPageTitle: z21.string().optional().describe("Title of the index page (default: 'Mason \u2014 System Map')"),
+      changelogPageTitle: z21.string().optional().describe("Title of the changelog page (default: 'Mason \u2014 Changelog')"),
+      featurePagePrefix: z21.string().optional().describe("Prefix for each feature page title (default: 'Feature: ')")
     },
     async ({ dir, spaceKey, parentPageId, indexPageTitle, changelogPageTitle, featurePagePrefix }) => {
       const result = await exportToConfluenceTool(dir, {