mason-context 0.19.1 → 0.20.1

package/dist/mason.js

@@ -10,33 +10,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/utils/paths.ts
-import path from "path";
-function normalizeRepoPath(value) {
-  const slash = value.replace(/\\/g, "/");
-  if (!slash || slash.includes("\0") || path.posix.isAbsolute(slash) || /^[A-Za-z]:/.test(slash)) return null;
-  if (slash.split("/").includes("..")) return null;
-  const normalized = path.posix.normalize(slash).replace(/\/$/, "");
-  return normalized === "." ? null : normalized;
-}
-function isWithinRoot(root, candidate) {
-  const relative = path.relative(root, candidate);
-  return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
-}
-function anchorMatches(anchor, file) {
-  const a = normalizeRepoPath(anchor);
-  const f = normalizeRepoPath(file);
-  return a !== null && f !== null && (a === f || f.startsWith(`${a}/`));
-}
-function matchingPaths(anchors, files) {
-  return [...new Set(files)].filter((file) => anchors.some((anchor) => anchorMatches(anchor, file)));
-}
-var init_paths = __esm({
-  "src/utils/paths.ts"() {
-    "use strict";
-  }
-});
-
 // src/utils/profile.ts
 import { AsyncLocalStorage } from "async_hooks";
 async function profilePhase(label, run) {
@@ -96,6 +69,33 @@ var init_git_read = __esm({
   }
 });
 
+// src/utils/paths.ts
+import path from "path";
+function normalizeRepoPath(value) {
+  const slash = value.replace(/\\/g, "/");
+  if (!slash || slash.includes("\0") || path.posix.isAbsolute(slash) || /^[A-Za-z]:/.test(slash)) return null;
+  if (slash.split("/").includes("..")) return null;
+  const normalized = path.posix.normalize(slash).replace(/\/$/, "");
+  return normalized === "." ? null : normalized;
+}
+function isWithinRoot(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function anchorMatches(anchor, file) {
+  const a = normalizeRepoPath(anchor);
+  const f = normalizeRepoPath(file);
+  return a !== null && f !== null && (a === f || f.startsWith(`${a}/`));
+}
+function matchingPaths(anchors, files) {
+  return [...new Set(files)].filter((file) => anchors.some((anchor) => anchorMatches(anchor, file)));
+}
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+  }
+});
+
 // src/audit/types.ts
 var types_exports = {};
 __export(types_exports, {
@@ -146,9 +146,9 @@ async function readBoundedFile(file, maxBytes) {
 async function loadProjectConfig(root) {
   try {
     const canonicalRoot = await fs.realpath(root);
-    const configPath2 = await fs.realpath(path2.join(root, ".mason/config.json"));
-    if (!isWithinRoot(canonicalRoot, configPath2)) throw new Error("Project configuration resolves outside the repository");
-    const raw = await readBoundedFile(configPath2, 64 * 1024);
+    const configPath3 = await fs.realpath(path2.join(root, ".mason/config.json"));
+    if (!isWithinRoot(canonicalRoot, configPath3)) throw new Error("Project configuration resolves outside the repository");
+    const raw = await readBoundedFile(configPath3, 64 * 1024);
     if (raw === null) throw new Error("Project configuration is not a regular file or exceeds 64 KiB");
     const value = JSON.parse(raw);
     if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Expected a configuration object");
@@ -347,139 +347,6 @@ var init_storage = __esm({
   }
 });
 
-// src/utils/store-lock.ts
-import fs3 from "fs/promises";
-import os from "os";
-async function lockDiagnostic(file) {
-  let reason2;
-  try {
-    const owner = JSON.parse(await fs3.readFile(file, "utf8"));
-    if (!owner || typeof owner.host !== "string" || !Number.isInteger(owner.pid) || owner.pid <= 0) {
-      reason2 = "Lock owner data is incomplete or malformed.";
-    } else if (owner.host !== os.hostname()) {
-      reason2 = "The lock belongs to another host; its process cannot be checked locally.";
-    } else {
-      try {
-        process.kill(owner.pid, 0);
-        reason2 = `Local owner PID ${owner.pid} is still running.`;
-      } catch (error) {
-        reason2 = error.code === "ESRCH" ? `Local owner PID ${owner.pid} has exited, but lock recovery has not completed.` : `Local owner PID ${owner.pid} could not be checked.`;
-      }
-    }
-  } catch (error) {
-    reason2 = error instanceof SyntaxError ? "Lock owner data is incomplete or malformed." : "Lock owner data could not be read; the lock may have changed.";
-  }
-  if (await fs3.lstat(file + ".reclaim").then(() => true, () => false)) {
-    reason2 += " A recovery guard also needs inspection: " + file + ".reclaim.";
-  }
-  return reason2 + " Retry if a writer is active. For manual recovery, stop all Mason writers for this checkout, confirm they have exited (including other hosts), then remove only confirmed abandoned lock and lock.reclaim files. See docs/reference.md#snapshot-repairs-and-verification.";
-}
-async function withStoreLock(root, directory, run, waitMs = 5e3, label = "Mason store") {
-  const file = await storePath(root, directory + "/lock", true);
-  const deadline = Date.now() + waitMs;
-  let handle;
-  while (!handle) {
-    try {
-      handle = await fs3.open(file, "wx", 384);
-      try {
-        await handle.writeFile(JSON.stringify({ pid: process.pid, host: os.hostname() }));
-      } catch (error) {
-        await handle.close().catch(() => {
-        });
-        handle = void 0;
-        await fs3.rm(file, { force: true }).catch(() => {
-        });
-        throw error;
-      }
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      try {
-        const owner = JSON.parse(await fs3.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 fs3.open(reclaim, "wx", 384);
-                const current = JSON.parse(await fs3.readFile(file, "utf8"));
-                if (current.pid === owner.pid && current.host === owner.host) await fs3.unlink(file);
-              } finally {
-                if (guard) {
-                  await guard.close();
-                  await fs3.rm(reclaim, { force: true });
-                }
-              }
-            }
-          }
-        }
-      } catch {
-      }
-      if (Date.now() >= deadline) throw new Error(label + " is busy or its lock needs inspection: " + file + ". " + await lockDiagnostic(file));
-      await new Promise((resolve) => setTimeout(resolve, 40));
-    }
-  }
-  try {
-    return await run();
-  } finally {
-    await handle.close();
-    await fs3.unlink(file);
-  }
-}
-var init_store_lock = __esm({
-  "src/utils/store-lock.ts"() {
-    "use strict";
-    init_storage();
-  }
-});
-
-// src/automation/store.ts
-import { z } from "zod";
-function parseState(raw) {
-  try {
-    return stateSchema.parse(raw);
-  } catch (error) {
-    throw new Error("Invalid automation state; original evidence was retained.", { cause: error });
-  }
-}
-function withLock(root, directory, run, waitMs = 5e3) {
-  return withStoreLock(root, directory, run, waitMs, "Automation");
-}
-var hostSchema, events, stateSchema;
-var init_store = __esm({
-  "src/automation/store.ts"() {
-    "use strict";
-    init_store_lock();
-    hostSchema = z.enum(["claude", "codex"]);
-    events = ["session_start", "turn_start", "before_tool", "after_tool", "task_end"];
-    stateSchema = z.object({
-      version: z.literal(1),
-      root: z.string(),
-      gitDir: z.string(),
-      branch: z.string(),
-      baselines: z.array(z.object({ path: z.string(), at: z.string(), event: z.string(), fingerprint: z.string() })).max(128),
-      sessions: z.record(z.object({
-        host: hostSchema,
-        seen: z.string().nullable(),
-        continued: z.boolean(),
-        initialIssues: z.array(z.string()),
-        initialDocs: z.record(z.string().nullable()),
-        lastUsed: z.string(),
-        mutationObserved: z.boolean(),
-        pending: z.record(z.string()),
-        coverageGaps: z.array(z.string()),
-        events: z.record(z.object({ at: z.string(), count: z.number().int().positive() }))
-      })),
-      updatedAt: z.string(),
-      fingerprint: z.string().nullable(),
-      latest: z.string().nullable(),
-      analysis: z.object({ id: z.string(), fingerprint: z.string(), completedAt: z.number(), path: z.string() }).optional()
-    });
-  }
-});
-
 // src/audit/inspection.ts
 import fg2 from "fast-glob";
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
@@ -532,12 +399,12 @@ var init_inspection = __esm({
 });
 
 // src/audit/inputs.ts
-import fs4 from "fs/promises";
+import fs3 from "fs/promises";
 import * as nativeFs from "fs";
 import path5 from "path";
 import fg3 from "fast-glob";
 async function auditInputPath(root, file) {
-  if (file === ".") return fs4.realpath(root);
+  if (file === ".") return fs3.realpath(root);
   try {
     return await storePath(root, file);
   } catch (error) {
@@ -560,15 +427,15 @@ async function readAuditInput(root, file) {
 async function auditGlob(root, patterns, options) {
   if (Array.isArray(patterns) && !patterns.length) return [];
   const directories = /* @__PURE__ */ new Set();
-  const readdir2 = ((directory, opts, callback) => {
-    const relative = path5.relative(root, directory).split(path5.sep).join("/") || ".";
+  const readdir2 = ((directory2, opts, callback) => {
+    const relative = path5.relative(root, directory2).split(path5.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.`));
       return;
     }
     auditInputPath(root, relative).then(() => {
-      nativeFs.readdir(directory, opts, callback);
+      nativeFs.readdir(directory2, opts, callback);
     }, callback);
   });
   const lstat2 = ((file, callback) => {
@@ -698,25 +565,25 @@ function commandClaims(line, lineNo, cwd, shell = false) {
     if (text2.startsWith("#") || /^(?:echo|printf)\b/.test(text2)) continue;
     const cd = text2.match(/^cd\s+(.+)$/);
     if (cd) {
-      const directory = literal(cd[1]);
-      cwd = directory === null || cwd === null || /\s/.test(directory) && !/^["']/.test(cd[1]) ? null : path6.posix.join(cwd ?? ".", directory);
+      const directory2 = literal(cd[1]);
+      cwd = directory2 === null || cwd === null || /\s/.test(directory2) && !/^["']/.test(cd[1]) ? null : path6.posix.join(cwd ?? ".", directory2);
       continue;
     }
     for (const match of text2.matchAll(COMMAND)) {
       const flags = match[2].trim();
       const selector = flags.match(/^(?:--prefix|--dir|-C)(?:\s+|=)(.+)$/);
-      let directory = cwd;
+      let directory2 = cwd;
       let scopeUnknown;
       if (shell && match.index !== 0 || match[3].startsWith("-")) scopeUnknown = "Unsupported shell wrapper or options before the script.";
       if (selector) {
         const selected = literal(selector[1]);
-        directory = selected === null || cwd === null ? null : path6.posix.join(cwd ?? ".", selected);
+        directory2 = selected === null || cwd === null ? null : path6.posix.join(cwd ?? ".", selected);
       } else if (flags) scopeUnknown = "Unsupported package-manager options before run: " + flags;
       const tail = text2.slice(match.index + match[0].length).split(/\s--(?:\s|$)/)[0];
       if (/(?:^|\s)(?:--workspace(?:s)?|-w|--filter|-F|--prefix|--dir|-C|--if-present)(?:\s|=|$)/.test(tail)) {
         scopeUnknown = "Package selection or conditional options after the script need review.";
       }
-      if (/[|()]/.test(text2) || /\b(?:pushd|popd|if|for|while)\b/.test(text2) || directory === null) {
+      if (/[|()]/.test(text2) || /\b(?:pushd|popd|if|for|while)\b/.test(text2) || directory2 === null) {
         scopeUnknown = "The command's working directory or shell control flow could not be resolved.";
       }
       claims.push({
@@ -724,7 +591,7 @@ function commandClaims(line, lineNo, cwd, shell = false) {
         invocation: match[0],
         excerpt: match[0],
         line: lineNo,
-        ...directory !== void 0 && directory !== null ? { directory } : {},
+        ...directory2 !== void 0 && directory2 !== null ? { directory: directory2 } : {},
         ...scopeUnknown ? { scopeUnknown } : {}
       });
     }
@@ -1131,7 +998,7 @@ var init_git = __esm({
 });
 
 // src/audit/docs.ts
-import fs5 from "fs/promises";
+import fs4 from "fs/promises";
 import path7 from "path";
 import fg5 from "fast-glob";
 async function dirtyDocs(resolvedRoot, files) {
@@ -1203,7 +1070,7 @@ async function localDocPaths(root) {
   for (const dir of [".", ".claude"]) {
     let entries;
     try {
-      entries = await fs5.readdir(await auditInputPath(root, dir), { withFileTypes: true });
+      entries = await fs4.readdir(await auditInputPath(root, dir), { withFileTypes: true });
     } catch (error) {
       if (error.code === "ENOENT") continue;
       throw error;
@@ -1267,27 +1134,27 @@ var init_docs = __esm({
 });
 
 // src/audit/scope.ts
-import fs6 from "fs/promises";
+import fs5 from "fs/promises";
 import path8 from "path";
-function scopedPath(directory, value) {
+function scopedPath(directory2, value) {
   if (path8.posix.isAbsolute(value) || value.includes("\\") || /[\x00-\x1f]/.test(value)) return null;
-  const resolved = path8.posix.normalize(path8.posix.join(directory, value));
+  const resolved = path8.posix.normalize(path8.posix.join(directory2, value));
   return resolved === ".." || resolved.startsWith("../") ? null : resolved;
 }
 function pathClaimScope(doc, claim) {
-  const directory = claim.relativeTo === "document" ? path8.posix.dirname(doc) : documentScope(doc);
-  const local = scopedPath(directory, claim.path);
+  const directory2 = claim.relativeTo === "document" ? path8.posix.dirname(doc) : documentScope(doc);
+  const local = scopedPath(directory2, claim.path);
   if (!local) return null;
-  const candidates = claim.relativeTo === "document" || directory === "." ? [local] : [...new Set([local, scopedPath(".", claim.path)].filter((p) => p !== null))];
+  const candidates = claim.relativeTo === "document" || directory2 === "." ? [local] : [...new Set([local, scopedPath(".", claim.path)].filter((p) => p !== null))];
   return {
-    basis: claim.relativeTo === "document" ? "document-link" : directory === "." ? "repository" : "document",
-    directory,
+    basis: claim.relativeTo === "document" ? "document-link" : directory2 === "." ? "repository" : "document",
+    directory: directory2,
     candidates
   };
 }
 async function pathExists(root, file) {
   try {
-    await fs6.access(await auditInputPath(root, file));
+    await fs5.access(await auditInputPath(root, file));
     return true;
   } catch (error) {
     if (["ENOENT", "ENOTDIR"].includes(error.code ?? "")) return false;
@@ -1308,6 +1175,100 @@ var init_scope = __esm({
   }
 });
 
+// src/utils/store-lock.ts
+import fs6 from "fs/promises";
+import os from "os";
+async function lockDiagnostic(file) {
+  let reason2;
+  try {
+    const owner = JSON.parse(await fs6.readFile(file, "utf8"));
+    if (!owner || typeof owner.host !== "string" || !Number.isInteger(owner.pid) || owner.pid <= 0) {
+      reason2 = "Lock owner data is incomplete or malformed.";
+    } else if (owner.host !== os.hostname()) {
+      reason2 = "The lock belongs to another host; its process cannot be checked locally.";
+    } else {
+      try {
+        process.kill(owner.pid, 0);
+        reason2 = `Local owner PID ${owner.pid} is still running.`;
+      } catch (error) {
+        reason2 = error.code === "ESRCH" ? `Local owner PID ${owner.pid} has exited, but lock recovery has not completed.` : `Local owner PID ${owner.pid} could not be checked.`;
+      }
+    }
+  } catch (error) {
+    reason2 = error instanceof SyntaxError ? "Lock owner data is incomplete or malformed." : "Lock owner data could not be read; the lock may have changed.";
+  }
+  if (await fs6.lstat(file + ".reclaim").then(() => true, () => false)) {
+    reason2 += " A recovery guard also needs inspection: " + file + ".reclaim.";
+  }
+  return reason2 + " Retry if a writer is active. For manual recovery, stop all Mason writers for this checkout, confirm they have exited (including other hosts), then remove only confirmed abandoned lock and lock.reclaim files. See docs/reference.md#snapshot-repairs-and-verification.";
+}
+async function withStoreLock(root, directory2, run, waitMs = 5e3, label = "Mason store") {
+  const file = await storePath(root, directory2 + "/lock", true);
+  const deadline = Date.now() + waitMs;
+  let handle;
+  while (!handle) {
+    try {
+      handle = await fs6.open(file, "wx", 384);
+    } catch (error) {
+      if (process.platform === "win32" && error.code === "EPERM") {
+        if (Date.now() >= deadline) throw error;
+        await new Promise((resolve) => setTimeout(resolve, 40));
+        continue;
+      }
+      if (error.code !== "EEXIST") throw error;
+      try {
+        const owner = JSON.parse(await fs6.readFile(file, "utf8"));
+        if (owner.host === os.hostname() && Number.isInteger(owner.pid) && owner.pid > 0) {
+          try {
+            process.kill(owner.pid, 0);
+          } catch (probe) {
+            if (probe.code === "ESRCH") {
+              const reclaim = file + ".reclaim";
+              let guard;
+              try {
+                guard = await fs6.open(reclaim, "wx", 384);
+                const current = JSON.parse(await fs6.readFile(file, "utf8"));
+                if (current.pid === owner.pid && current.host === owner.host) await fs6.unlink(file);
+              } finally {
+                if (guard) {
+                  await guard.close();
+                  await fs6.rm(reclaim, { force: true });
+                }
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      if (Date.now() >= deadline) throw new Error(label + " is busy or its lock needs inspection: " + file + ". " + await lockDiagnostic(file));
+      await new Promise((resolve) => setTimeout(resolve, 40));
+    }
+    if (handle) {
+      try {
+        await handle.writeFile(JSON.stringify({ pid: process.pid, host: os.hostname() }));
+      } catch (error) {
+        await handle.close().catch(() => {
+        });
+        await fs6.rm(file, { force: true }).catch(() => {
+        });
+        throw error;
+      }
+    }
+  }
+  try {
+    return await run();
+  } finally {
+    await handle.close();
+    await fs6.unlink(file);
+  }
+}
+var init_store_lock = __esm({
+  "src/utils/store-lock.ts"() {
+    "use strict";
+    init_storage();
+  }
+});
+
 // src/snapshot/lock.ts
 var init_lock = __esm({
   "src/snapshot/lock.ts"() {
@@ -1394,7 +1355,7 @@ var init_test_map = __esm({
 
 // src/snapshot/snapshot.ts
 import path10 from "path";
-import { z as z2 } from "zod";
+import { z } from "zod";
 async function inspectSnapshot(rootDir) {
   try {
     const raw = await readStoreJson(rootDir, ".mason/snapshot.json");
@@ -1428,30 +1389,30 @@ var init_snapshot = __esm({
     init_lock();
     init_paths();
     init_test_map();
-    repoPath = z2.string().refine((value) => normalizeRepoPath(value) !== null, "Expected a relative repository path");
+    repoPath = z.string().refine((value) => normalizeRepoPath(value) !== null, "Expected a relative repository path");
     verificationFields = {
-      refreshedHash: z2.string().optional(),
-      verifiedAt: z2.string().optional(),
-      verifiedHash: z2.string().optional(),
-      verificationToken: z2.string().optional(),
-      verificationFailed: z2.boolean().optional(),
-      verificationNote: z2.string().optional()
+      refreshedHash: z.string().optional(),
+      verifiedAt: z.string().optional(),
+      verifiedHash: z.string().optional(),
+      verificationToken: z.string().optional(),
+      verificationFailed: z.boolean().optional(),
+      verificationNote: z.string().optional()
     };
-    featureSchema = z2.object({
-      description: z2.string(),
-      files: z2.array(repoPath),
-      tests: z2.array(repoPath).optional(),
-      type: z2.enum(["capability", "infrastructure"]).optional(),
+    featureSchema = z.object({
+      description: z.string(),
+      files: z.array(repoPath),
+      tests: z.array(repoPath).optional(),
+      type: z.enum(["capability", "infrastructure"]).optional(),
       ...verificationFields
     }).passthrough();
-    flowSchema = z2.object({ description: z2.string(), chain: z2.array(repoPath), ...verificationFields }).passthrough();
-    snapshotSchema = z2.object({
-      version: z2.literal(2),
-      createdAt: z2.string(),
-      updatedAt: z2.string(),
-      gitHash: z2.string(),
-      features: z2.record(featureSchema),
-      flows: z2.record(flowSchema)
+    flowSchema = z.object({ description: z.string(), chain: z.array(repoPath), ...verificationFields }).passthrough();
+    snapshotSchema = z.object({
+      version: z.literal(2),
+      createdAt: z.string(),
+      updatedAt: z.string(),
+      gitHash: z.string(),
+      features: z.record(featureSchema),
+      flows: z.record(flowSchema)
     }).passthrough();
   }
 });
@@ -1897,19 +1858,19 @@ async function commandInputs(root, docs) {
   const resolutions = [];
   for (const doc of docs) for (const claim of doc.claims.commands) {
     const base = documentScope(doc.path);
-    const directory = scopedPath(base, claim.directory ?? ".");
+    const directory2 = scopedPath(base, claim.directory ?? ".");
     const scope = {
       basis: claim.directory === void 0 ? "document" : "explicit",
-      directory: directory ?? base,
+      directory: directory2 ?? base,
       candidates: []
     };
     const resolution = { doc: doc.path, claim, scope, manifest: null, scripts: [], elsewhere: [] };
     resolutions.push(resolution);
-    if (claim.scopeUnknown || directory === null) {
+    if (claim.scopeUnknown || directory2 === null) {
       resolution.problem = claim.scopeUnknown ?? "The command's directory leaves the repository.";
       continue;
     }
-    let cursor = directory;
+    let cursor = directory2;
     while (true) {
       const manifest = path15.posix.join(cursor, "package.json");
       scope.candidates.push(manifest);
@@ -1925,7 +1886,7 @@ async function commandInputs(root, docs) {
       cursor = path15.posix.dirname(cursor);
     }
     if (!resolution.manifest && !resolution.problem) {
-      resolution.problem = `No package.json for the command's scope (${directory}).`;
+      resolution.problem = `No package.json for the command's scope (${directory2}).`;
     }
     if (resolution.problem || resolution.scripts.includes(claim.scriptName) || claim.directory !== void 0) continue;
     inventory ??= await commandManifests(root);
@@ -2263,7 +2224,7 @@ var init_trust = __esm({
 });
 
 // src/decisions/provenance.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 function decisionContent(record) {
   return {
     title: record.title,
@@ -2327,67 +2288,67 @@ var init_provenance = __esm({
     "use strict";
     init_paths();
     init_trust();
-    text = (max) => z3.string().trim().min(1).max(max);
-    decisionSourceSchema = z3.object({
-      kind: z3.enum(["pull_request", "issue", "incident", "discussion", "document", "other"]),
+    text = (max) => z2.string().trim().min(1).max(max);
+    decisionSourceSchema = z2.object({
+      kind: z2.enum(["pull_request", "issue", "incident", "discussion", "document", "other"]),
       reference: text(1e3),
       note: text(500).optional()
     }).strict();
-    attributionSchema = z3.object({
+    attributionSchema = z2.object({
       owner: text(200).nullable().optional(),
-      sources: z3.array(decisionSourceSchema).max(20).optional(),
+      sources: z2.array(decisionSourceSchema).max(20).optional(),
       actor: text(200).optional()
     });
-    contentSchema = z3.object({
-      title: z3.string().min(1),
-      body: z3.string().min(1),
-      category: z3.enum(["decision", "gotcha", "deprecation", "convention"]),
-      files: z3.array(z3.string().refine((f) => normalizeRepoPath(f) !== null)),
+    contentSchema = z2.object({
+      title: z2.string().min(1),
+      body: z2.string().min(1),
+      category: z2.enum(["decision", "gotcha", "deprecation", "convention"]),
+      files: z2.array(z2.string().refine((f) => normalizeRepoPath(f) !== null)),
       owner: text(200).optional(),
-      sources: z3.array(decisionSourceSchema).max(20)
+      sources: z2.array(decisionSourceSchema).max(20)
     });
-    approvalSchema = z3.enum(["unreviewed", "proposed", "accepted"]);
-    statusSchema = z3.enum(["active", "superseded", "retired"]);
-    reviewEvidenceSchema = z3.object({
-      baseHash: z3.string(),
-      headHash: z3.string(),
-      historyAvailable: z3.boolean(),
-      changedFiles: z3.array(z3.string()),
-      localChanges: z3.array(z3.string())
+    approvalSchema = z2.enum(["unreviewed", "proposed", "accepted"]);
+    statusSchema = z2.enum(["active", "superseded", "retired"]);
+    reviewEvidenceSchema = z2.object({
+      baseHash: z2.string(),
+      headHash: z2.string(),
+      historyAvailable: z2.boolean(),
+      changedFiles: z2.array(z2.string()),
+      localChanges: z2.array(z2.string())
     });
-    eventSchema = z3.object({
-      kind: z3.enum(["imported", "created", "revised", "accepted", "reaffirmed", "retired", "superseded"]),
-      at: z3.string().datetime(),
+    eventSchema = z2.object({
+      kind: z2.enum(["imported", "created", "revised", "accepted", "reaffirmed", "retired", "superseded"]),
+      at: z2.string().datetime(),
       actor: text(200).optional(),
       note: text(1500).optional(),
-      revision: z3.number().int().positive(),
+      revision: z2.number().int().positive(),
       content: contentSchema,
       approval: approvalSchema,
       status: statusSchema,
-      refreshedHash: z3.string(),
+      refreshedHash: z2.string(),
       evidence: reviewEvidenceSchema.optional()
     });
-    legacySchema = z3.object({
-      version: z3.literal(1),
-      id: z3.string().regex(/^[a-zA-Z0-9_-]+$/),
-      title: z3.string().min(1),
-      body: z3.string().min(1),
+    legacySchema = z2.object({
+      version: z2.literal(1),
+      id: z2.string().regex(/^[a-zA-Z0-9_-]+$/),
+      title: z2.string().min(1),
+      body: z2.string().min(1),
       category: contentSchema.shape.category,
       files: contentSchema.shape.files,
-      createdAt: z3.string(),
-      updatedAt: z3.string(),
-      refreshedHash: z3.string(),
-      status: z3.enum(["active", "superseded"]),
-      supersededBy: z3.string().optional()
+      createdAt: z2.string(),
+      updatedAt: z2.string(),
+      refreshedHash: z2.string(),
+      status: z2.enum(["active", "superseded"]),
+      supersededBy: z2.string().optional()
     }).passthrough();
     currentSchema = legacySchema.extend({
-      version: z3.literal(2),
+      version: z2.literal(2),
       status: statusSchema,
       approval: approvalSchema,
-      revision: z3.number().int().positive(),
+      revision: z2.number().int().positive(),
       owner: text(200).optional(),
-      sources: z3.array(decisionSourceSchema).max(20),
-      history: z3.array(eventSchema).min(1)
+      sources: z2.array(decisionSourceSchema).max(20),
+      history: z2.array(eventSchema).min(1)
     }).superRefine((record, ctx) => {
       const invalid = (message2) => ctx.addIssue({ code: "custom", message: message2 });
       const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
@@ -2417,7 +2378,7 @@ var init_provenance = __esm({
       }
       if (!previous || !same(previous.content, decisionContent(record)) || previous.approval !== record.approval || previous.status !== record.status || previous.revision !== record.revision || previous.refreshedHash !== record.refreshedHash) invalid("Decision does not match the final history event");
     });
-    decisionSchema = z3.union([legacySchema, currentSchema]);
+    decisionSchema = z2.union([legacySchema, currentSchema]);
   }
 });
 
@@ -2425,7 +2386,7 @@ var init_provenance = __esm({
 import fs9 from "fs/promises";
 import path18 from "path";
 import { createHash } from "crypto";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 async function loadDecisionStore(rootDir) {
   const records = [];
   const diagnostics = [];
@@ -2461,7 +2422,7 @@ var init_decisions = __esm({
     TITLE_MAX_CHARS = 80;
     BODY_RECOMMENDED_CHARS = 1500;
     BODY_MAX_CHARS = 2500;
-    boundedText = (field, max, hint) => z4.string({
+    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.");
@@ -2594,7 +2555,7 @@ var init_checks = __esm({
 
 // src/audit/findings.ts
 import { createHash as createHash2 } from "crypto";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 function findingId(finding) {
   const e = finding.evidence;
   let key;
@@ -2625,84 +2586,241 @@ var init_findings = __esm({
   "src/audit/findings.ts"() {
     "use strict";
     digest = (value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex");
-    checkSchema = z5.enum(["deleted-reference", "new-module", "stale-count", "dead-command", "deps-changed", "decision-anchor-drift"]);
-    commitSchema = z5.object({ hash: z5.string().regex(/^[a-f0-9]{40,64}$/), date: z5.string(), subject: z5.string() });
-    anchorSchema = z5.object({ doc: z5.string(), line: z5.number().int().positive().nullable(), excerpt: z5.string().nullable() });
-    count = z5.number().int().nonnegative();
-    scopeSchema = z5.object({
-      basis: z5.enum(["repository", "document", "document-link", "explicit"]),
-      directory: z5.string(),
-      candidates: z5.array(z5.string())
+    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();
+    scopeSchema = z4.object({
+      basis: z4.enum(["repository", "document", "document-link", "explicit"]),
+      directory: z4.string(),
+      candidates: z4.array(z4.string())
     });
-    evidenceSchema = z5.discriminatedUnion("kind", [
-      z5.object({
-        kind: z5.literal("missing-path"),
-        claimed: z5.string(),
-        renamedTo: z5.string().nullable(),
+    evidenceSchema = z4.discriminatedUnion("kind", [
+      z4.object({
+        kind: z4.literal("missing-path"),
+        claimed: z4.string(),
+        renamedTo: z4.string().nullable(),
         deletedInCommit: commitSchema.nullable(),
-        everTracked: z5.boolean(),
-        parentDirExists: z5.boolean(),
-        resolvedPath: z5.string().optional(),
+        everTracked: z4.boolean(),
+        parentDirExists: z4.boolean(),
+        resolvedPath: z4.string().optional(),
         scope: scopeSchema.optional()
       }),
-      z5.object({
-        kind: z5.literal("unmentioned-dir"),
-        dir: z5.string(),
+      z4.object({
+        kind: z4.literal("unmentioned-dir"),
+        dir: z4.string(),
         sourceFileCount: count,
         firstCommit: commitSchema.nullable(),
-        checkedDocs: z5.array(z5.string())
+        checkedDocs: z4.array(z4.string())
       }),
-      z5.object({
-        kind: z5.literal("count-mismatch"),
+      z4.object({
+        kind: z4.literal("count-mismatch"),
         claimed: count,
         actual: count,
-        unit: z5.string(),
-        countedFrom: z5.string(),
-        members: z5.array(z5.string())
+        unit: z4.string(),
+        countedFrom: z4.string(),
+        members: z4.array(z4.string())
       }),
-      z5.object({
-        kind: z5.literal("missing-script"),
-        scriptName: z5.string(),
-        invocation: z5.string(),
-        manifestsChecked: z5.array(z5.string()),
-        availableScripts: z5.array(z5.string()),
+      z4.object({
+        kind: z4.literal("missing-script"),
+        scriptName: z4.string(),
+        invocation: z4.string(),
+        manifestsChecked: z4.array(z4.string()),
+        availableScripts: z4.array(z4.string()),
         scope: scopeSchema.optional()
       }),
-      z5.object({
-        kind: z5.literal("doc-behind-manifests"),
+      z4.object({
+        kind: z4.literal("doc-behind-manifests"),
         docLastCommit: commitSchema,
-        manifestCommits: z5.array(commitSchema.extend({ files: z5.array(z5.string()) })),
+        manifestCommits: z4.array(commitSchema.extend({ files: z4.array(z4.string()) })),
         totalCommits: count,
-        matches: z5.array(z5.object({ dependency: z5.string(), manifest: z5.string(), before: z5.string().nullable(), after: z5.string().nullable(), line: z5.number().int().positive(), excerpt: z5.string() })).optional(),
-        matchingIncomplete: z5.boolean().optional()
+        matches: z4.array(z4.object({ dependency: z4.string(), manifest: z4.string(), before: z4.string().nullable(), after: z4.string().nullable(), line: z4.number().int().positive(), excerpt: z4.string() })).optional(),
+        matchingIncomplete: z4.boolean().optional()
       }),
-      z5.object({
-        kind: z5.literal("decision-anchor"),
-        decisionId: z5.string(),
-        title: z5.string(),
-        changedFiles: z5.array(z5.string()),
-        refreshedHash: z5.string(),
-        provenance: z5.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 = z5.object({ message: z5.string(), anchor: anchorSchema, evidence: evidenceSchema });
+    findingSchema = z4.object({ message: z4.string(), anchor: anchorSchema, evidence: evidenceSchema });
     issueSchema = findingSchema.extend({
-      type: z5.enum(["deleted-reference", "new-module", "stale-count", "dead-command"]),
-      confidence: z5.enum(["certain", "likely"])
+      type: z4.enum(["deleted-reference", "new-module", "stale-count", "dead-command"]),
+      confidence: z4.enum(["certain", "likely"])
     });
-    advisorySchema = findingSchema.extend({ type: checkSchema, resolution: z5.enum(["recheck", "informational"]).optional() });
-    checkResultSchema = z5.object({
-      issues: z5.array(issueSchema),
-      advisories: z5.array(advisorySchema),
-      suppressedAdvisories: z5.array(advisorySchema).optional(),
-      skipped: z5.array(z5.object({ check: z5.string(), reason: z5.string(), doc: z5.string().optional() }))
+    advisorySchema = findingSchema.extend({ type: checkSchema, resolution: z4.enum(["recheck", "informational"]).optional() });
+    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() }))
+    });
+  }
+});
+
+// src/automation/notifications.ts
+import { z as z5 } from "zod";
+function condition(finding) {
+  const source = finding.current ?? finding.original;
+  const e = source.evidence;
+  const id = e.kind === "decision-anchor" ? digest([source.type, source.anchor.doc, e.decisionId]) : finding.id;
+  const result = { level: "confidence" in source ? 2 : 1, facts: [] };
+  switch (e.kind) {
+    case "count-mismatch":
+      result.magnitude = Math.abs(e.actual - e.claimed);
+      break;
+    case "unmentioned-dir":
+      result.magnitude = e.sourceFileCount;
+      break;
+    case "decision-anchor":
+      result.facts = [...e.changedFiles].sort();
+      break;
+    case "doc-behind-manifests":
+      result.facts = (e.matches ?? []).map((m) => JSON.stringify([m.manifest, m.dependency, m.after])).sort();
+      break;
+  }
+  return { id, condition: result };
+}
+function notificationConditions(findings) {
+  const active = findings.filter((f) => f.status !== "resolved");
+  const currentIds = new Set(active.filter((f) => f.current).map((f) => condition(f).id));
+  const result = {};
+  for (const f of active) {
+    const value = condition(f);
+    if (!f.current && currentIds.has(value.id)) continue;
+    const previous = result[value.id];
+    result[value.id] = previous ? {
+      level: Math.max(previous.level, value.condition.level),
+      facts: [.../* @__PURE__ */ new Set([...previous.facts, ...value.condition.facts])].sort(),
+      ...previous.magnitude !== void 0 || value.condition.magnitude !== void 0 ? { magnitude: Math.max(previous.magnitude ?? 0, value.condition.magnitude ?? 0) } : {}
+    } : value.condition;
+  }
+  return result;
+}
+function createNotificationState(findings, head) {
+  return { version: 1, baselineHead: head, baseline: notificationConditions(findings), delivered: {}, cleared: [] };
+}
+function worsened(current, previous) {
+  return !previous || current.level > previous.level || (current.magnitude ?? 0) > (previous.magnitude ?? 0) || current.facts.some((fact) => !previous.facts.includes(fact));
+}
+function completionFindings(state, findings) {
+  const current = notificationConditions(findings);
+  const cleared = new Set(state.cleared);
+  const resolvedIds = new Set(findings.filter((f) => f.status === "resolved").map((f) => condition(f).id));
+  for (const id of Object.keys(state.baseline)) if (resolvedIds.has(id) && !current[id]) cleared.add(id);
+  state.cleared = [...cleared];
+  const selected = [];
+  const selectedIds = /* @__PURE__ */ new Set();
+  const delivered = { ...state.delivered };
+  for (const finding of findings) {
+    const value = condition(finding);
+    const previous = state.delivered[value.id];
+    value.condition = current[value.id] ?? value.condition;
+    if (finding.status === "unverified" || !finding.current && finding.status !== "resolved") {
+      continue;
+    }
+    if (finding.status === "resolved") {
+      if (!current[value.id]) delete delivered[value.id];
+      continue;
+    }
+    const eligible = cleared.has(value.id) || worsened(value.condition, state.baseline[value.id]);
+    if (!eligible) continue;
+    if (!selectedIds.has(value.id) && worsened(value.condition, previous)) {
+      selectedIds.add(value.id);
+      const source = finding.current;
+      selected.push(source.evidence.kind === "decision-anchor" ? { ...finding, current: { ...source, evidence: { ...source.evidence, changedFiles: value.condition.facts } } } : finding);
+      if (selected.length <= MAX_COMPLETION_FINDINGS) delivered[value.id] = value.condition;
+    }
+  }
+  state.delivered = delivered;
+  return selected;
+}
+function completionSummary(findings, reportPath) {
+  if (!findings.length) return null;
+  const safe = (value) => value.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, 250);
+  return [
+    `Mason: ${findings.length} new or worsened finding(s) since the retained baseline.`,
+    ...findings.slice(0, MAX_COMPLETION_FINDINGS).map((f) => {
+      const source = f.current ?? f.original;
+      const detail = source.evidence.kind === "decision-anchor" ? `Changes to ${source.evidence.changedFiles.join(", ")} may affect decision "${source.evidence.title}". Inspect the diff if relevant; acceptance is not required.` : source.message;
+      return `[${f.status === "unresolved" ? "issue" : "advisory"}] ${safe(source.anchor.doc)}: ${safe(detail)}`;
+    }),
+    ...findings.length > MAX_COMPLETION_FINDINGS ? [`${findings.length - MAX_COMPLETION_FINDINGS} more in the report; pending later feedback.`] : [],
+    `Evidence: ${reportPath}. Explicit audit: mason_automation(action: "check").`,
+    "Inspect findings within the authorized work. Concurrent changes may also contribute; this summary does not establish who introduced them."
+  ].join("\n");
+}
+var conditionSchema, MAX_COMPLETION_FINDINGS, notificationStateSchema;
+var init_notifications = __esm({
+  "src/automation/notifications.ts"() {
+    "use strict";
+    init_findings();
+    conditionSchema = z5.object({
+      level: z5.number(),
+      facts: z5.array(z5.string()),
+      magnitude: z5.number().optional()
+    });
+    MAX_COMPLETION_FINDINGS = 4;
+    notificationStateSchema = z5.object({
+      version: z5.literal(1),
+      baselineHead: z5.string(),
+      baseline: z5.record(conditionSchema),
+      delivered: z5.record(conditionSchema),
+      cleared: z5.array(z5.string())
+    });
+  }
+});
+
+// src/automation/store.ts
+import { z as z6 } from "zod";
+function parseState(raw) {
+  try {
+    return stateSchema.parse(raw);
+  } catch (error) {
+    throw new Error("Invalid automation state; original evidence was retained.", { cause: error });
+  }
+}
+function withLock(root, directory2, run, waitMs = 5e3) {
+  return withStoreLock(root, directory2, run, waitMs, "Automation");
+}
+var hostSchema, events, stateSchema;
+var init_store = __esm({
+  "src/automation/store.ts"() {
+    "use strict";
+    init_store_lock();
+    init_notifications();
+    hostSchema = z6.enum(["claude", "codex"]);
+    events = ["session_start", "turn_start", "before_tool", "after_tool", "task_end"];
+    stateSchema = z6.object({
+      version: z6.literal(1),
+      root: z6.string(),
+      gitDir: z6.string(),
+      branch: z6.string(),
+      baselines: z6.array(z6.object({ path: z6.string(), at: z6.string(), event: z6.string(), fingerprint: z6.string() })).max(128),
+      sessions: z6.record(z6.object({
+        host: hostSchema,
+        lastUsed: z6.string(),
+        notifiedDiagnostics: z6.array(z6.string()).default([]),
+        pending: z6.record(z6.string()),
+        coverageGaps: z6.array(z6.string()),
+        events: z6.record(z6.object({ at: z6.string(), count: z6.number().int().positive() }))
+      })),
+      updatedAt: z6.string(),
+      fingerprint: z6.string().nullable(),
+      latest: z6.string().nullable(),
+      notifications: notificationStateSchema.optional(),
+      agentNotifications: notificationStateSchema.optional(),
+      analysis: z6.object({ id: z6.string(), fingerprint: z6.string(), completedAt: z6.number(), path: z6.string() }).optional()
     });
   }
 });
 
 // src/audit/advisory-review.ts
 import fs10 from "fs/promises";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 async function readRecord(root, id) {
   const raw = await readStoreJson(root, recordPath(id));
   if (raw === null) return null;
@@ -2848,41 +2966,41 @@ var init_advisory_review = __esm({
     init_decisions();
     init_drift2();
     git2 = async (root, ...args2) => (await (["log", "ls-tree", "ls-files", "merge-base"].includes(args2[0]) ? inspectionGit : execGit)(args2, { cwd: root, timeout: 1e4, maxBuffer: 8 * 1024 * 1024 })).stdout;
-    hashSchema = z6.string().regex(/^[a-f0-9]{64}$/);
-    commitSchema2 = z6.string().regex(/^[a-f0-9]{40,64}$/);
-    evidenceSchema2 = z6.object({
+    hashSchema = z7.string().regex(/^[a-f0-9]{64}$/);
+    commitSchema2 = z7.string().regex(/^[a-f0-9]{40,64}$/);
+    evidenceSchema2 = z7.object({
       head: commitSchema2,
       fingerprint: hashSchema,
-      scope: z6.array(z6.string()).min(1).max(1e3),
-      tree: z6.string().max(2 * 1024 * 1024),
+      scope: z7.array(z7.string()).min(1).max(1e3),
+      tree: z7.string().max(2 * 1024 * 1024),
       lastScopeCommit: commitSchema2,
-      paths: z6.array(z6.object({ path: z6.string(), exists: z6.boolean() })).max(1e3)
+      paths: z7.array(z7.object({ path: z7.string(), exists: z7.boolean() })).max(1e3)
     });
-    dismissalReasonSchema = z6.enum(["no-dependency-claims", "unrelated-manifest-change"]);
-    eventSchema2 = z6.object({
-      at: z6.string().datetime(),
-      reviewer: z6.string().trim().min(1).max(200).optional(),
-      note: z6.string().trim().min(1).max(2500),
-      outcome: z6.enum(["addressed", "inapplicable", "deferred", "dismissed"]),
+    dismissalReasonSchema = z7.enum(["no-dependency-claims", "unrelated-manifest-change"]);
+    eventSchema2 = z7.object({
+      at: z7.string().datetime(),
+      reviewer: z7.string().trim().min(1).max(200).optional(),
+      note: z7.string().trim().min(1).max(2500),
+      outcome: z7.enum(["addressed", "inapplicable", "deferred", "dismissed"]),
       reasonCode: dismissalReasonSchema.optional(),
       finding: advisorySchema.refine((finding) => finding.evidence.kind !== "decision-anchor", "Decision findings use decision reviews"),
       evidence: evidenceSchema2
     });
-    recordSchema = z6.object({ version: z6.literal(1), id: hashSchema, events: z6.array(eventSchema2).min(1).max(200), digest: hashSchema });
-    reviewSummarySchema = z6.object({
+    recordSchema = z7.object({ version: z7.literal(1), id: hashSchema, events: z7.array(eventSchema2).min(1).max(200), digest: hashSchema });
+    reviewSummarySchema = z7.object({
       id: hashSchema,
-      status: z6.enum(["current", "reopened", "deferred", "unverified"]),
-      reason: z6.string(),
-      recordPath: z6.string().optional(),
-      reviewer: z6.string().optional(),
-      note: z6.string().optional(),
-      outcome: z6.enum(["addressed", "inapplicable", "deferred", "accepted", "reaffirmed", "retired", "dismissed"]).optional(),
-      reviewedHead: z6.string().optional()
+      status: z7.enum(["current", "reopened", "deferred", "unverified"]),
+      reason: z7.string(),
+      recordPath: z7.string().optional(),
+      reviewer: z7.string().optional(),
+      note: z7.string().optional(),
+      outcome: z7.enum(["addressed", "inapplicable", "deferred", "accepted", "reaffirmed", "retired", "dismissed"]).optional(),
+      reviewedHead: z7.string().optional()
     });
-    advisoryReviewRequest = z6.object({
-      baselinePath: z6.string().min(1),
+    advisoryReviewRequest = z7.object({
+      baselinePath: z7.string().min(1),
       findingId: hashSchema,
-      action: z6.enum(["prepare", "addressed", "inapplicable", "deferred", "dismiss"]).default("prepare"),
+      action: z7.enum(["prepare", "addressed", "inapplicable", "deferred", "dismiss"]).default("prepare"),
       reasonCode: dismissalReasonSchema.optional(),
       reviewer: eventSchema2.shape.reviewer.optional(),
       note: eventSchema2.shape.note.optional(),
@@ -2987,7 +3105,7 @@ var init_audit = __esm({
 import fs12 from "fs/promises";
 import path21 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function recheckable(finding) {
   return !("confidence" in finding) && finding.resolution === "recheck" && ["deleted-reference", "dead-command", "new-module"].includes(finding.type) && ["missing-path", "missing-script", "unmentioned-dir"].includes(finding.evidence.kind);
 }
@@ -3055,7 +3173,7 @@ async function withRepairSession(root, options, run, validate, cachedAudit) {
 }
 async function prepareOriginal(rootDir, checks, options, session) {
   const root = await fs12.realpath(rootDir);
-  const selected = z7.array(checkSchema).nonempty().parse(checks);
+  const selected = z8.array(checkSchema).nonempty().parse(checks);
   const report = await (session ? session.audit(selected) : 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.");
@@ -3196,42 +3314,42 @@ var init_repair = __esm({
     init_findings();
     init_advisory_review();
     init_findings();
-    count2 = z7.number().int().nonnegative();
-    reportSchema = z7.object({
-      version: z7.literal(1),
-      root: z7.string(),
-      gitAvailable: z7.literal(true),
+    count2 = z8.number().int().nonnegative();
+    reportSchema = z8.object({
+      version: z8.literal(1),
+      root: z8.string(),
+      gitAvailable: z8.literal(true),
       headHash: commitSchema.shape.hash,
-      checksRun: z7.array(checkSchema).nonempty(),
-      docs: z7.array(z7.object({
-        path: z7.string().refine((value) => normalizeRepoPath(value) === value),
-        scope: z7.string().optional(),
-        kind: z7.enum(["instructions", "readme", "guide"]).optional(),
+      checksRun: z8.array(checkSchema).nonempty(),
+      docs: z8.array(z8.object({
+        path: z8.string().refine((value) => normalizeRepoPath(value) === value),
+        scope: z8.string().optional(),
+        kind: z8.enum(["instructions", "readme", "guide"]).optional(),
         lastCommit: commitSchema.nullable(),
-        dirty: z7.boolean(),
+        dirty: z8.boolean(),
         lineCount: count2
       })).nonempty(),
-      decisionsChecked: z7.boolean(),
-      clean: z7.boolean(),
-      excludedChecks: z7.array(z7.object({ check: checkSchema, doc: z7.string() })).optional(),
-      issues: z7.array(issueSchema),
-      advisories: z7.array(advisorySchema),
-      suppressedAdvisories: z7.array(advisorySchema).optional(),
-      skippedChecks: z7.array(z7.object({ check: z7.string(), reason: z7.string(), doc: z7.string().optional() }))
+      decisionsChecked: z8.boolean(),
+      clean: z8.boolean(),
+      excludedChecks: z8.array(z8.object({ check: checkSchema, doc: z8.string() })).optional(),
+      issues: z8.array(issueSchema),
+      advisories: z8.array(advisorySchema),
+      suppressedAdvisories: z8.array(advisorySchema).optional(),
+      skippedChecks: z8.array(z8.object({ check: z8.string(), reason: z8.string(), doc: z8.string().optional() }))
     });
-    baselineSchema = z7.object({
-      kind: z7.literal("mason-audit-repair"),
-      version: z7.literal(1),
-      createdAt: z7.string().datetime(),
+    baselineSchema = z8.object({
+      kind: z8.literal("mason-audit-repair"),
+      version: z8.literal(1),
+      createdAt: z8.string().datetime(),
       report: reportSchema,
-      digest: z7.string().regex(/^[a-f0-9]{64}$/)
+      digest: z8.string().regex(/^[a-f0-9]{64}$/)
     });
-    repairFindingSchema = z7.object({
-      id: z7.string(),
-      original: z7.union([issueSchema, advisorySchema]),
-      status: z7.enum(["resolved", "unresolved", "review-required", "unverified"]),
-      reason: z7.string(),
-      current: z7.union([issueSchema, advisorySchema]).optional(),
+    repairFindingSchema = z8.object({
+      id: z8.string(),
+      original: z8.union([issueSchema, advisorySchema]),
+      status: z8.enum(["resolved", "unresolved", "review-required", "unverified"]),
+      reason: z8.string(),
+      current: z8.union([issueSchema, advisorySchema]).optional(),
       review: reviewSummarySchema.optional()
     });
   }
@@ -3242,7 +3360,7 @@ import fs13 from "fs/promises";
 import path22 from "path";
 import { createHash as createHash3 } from "crypto";
 import fg7 from "fast-glob";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 async function git3(root, ...args2) {
   return profilePhase("automation.git", async () => (await execGit(args2, { cwd: root, maxBuffer: 16 * 1024 * 1024, timeout: 1e4 })).stdout);
 }
@@ -3385,18 +3503,248 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     init_advisory_review();
-    engineVersion = true ? "0.19.1" : "development";
+    engineVersion = true ? "0.20.1" : "development";
     hash = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
-    cacheSchema = z8.object({ version: z8.literal(1), entries: z8.record(z8.object({ key: z8.string(), result: checkResultSchema })), digest: z8.string() });
+    cacheSchema = z9.object({ version: z9.literal(1), entries: z9.record(z9.object({ key: z9.string(), result: checkResultSchema })), digest: z9.string() });
+  }
+});
+
+// src/automation/usefulness.ts
+import fs14 from "fs/promises";
+import { z as z10 } from "zod";
+async function enabled(root) {
+  const raw = await readStoreJson(root, configPath);
+  return raw !== null && configSchema.parse(raw).enabled;
+}
+async function configureUsefulness(dir, value, options = {}) {
+  const ws = await workspace(dir);
+  const configured = await withStoreLock(ws.root, directory, async () => {
+    if (options.onlyIfUnset) {
+      const existing = await readStoreJson(ws.root, configPath);
+      if (existing !== null) return configSchema.parse(existing).enabled;
+    }
+    const ignore = await storePath(ws.root, directory + "/.gitignore", true);
+    try {
+      await fs14.writeFile(ignore, "*\n", { flag: "wx", mode: 384 });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    await writeStoreJson(ws.root, configPath, { version: 1, enabled: value });
+    return value;
+  });
+  return { enabled: configured, storage: directory, note: "Local only. Disabling retains prior observations." };
+}
+async function observeUsefulness(root, event, report, agent, completion, elapsedMs, observedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!event.host || !event.sessionId || !await enabled(root)) return;
+  const ws = await workspace(root);
+  await withStoreLock(ws.root, directory, async () => {
+    if (!await enabled(root)) return;
+    const raw = await readStoreJson(root, statePath(ws));
+    const state = raw === null ? empty() : stateSchema2.parse(raw);
+    const now = observedAt;
+    const key = hash([event.host, event.sessionId]);
+    const session = state.sessions[key] ??= {
+      host: event.host,
+      updatedAt: now,
+      checks: 0,
+      checkMs: 0,
+      findings: {},
+      decisions: [],
+      retrievalObserved: false,
+      receiptIds: [],
+      reportPath: report.reportPath,
+      truncated: false
+    };
+    const newer = now >= session.updatedAt;
+    if (newer) {
+      session.updatedAt = now;
+      session.reportPath = report.reportPath;
+    }
+    session.checks++;
+    session.checkMs += Math.max(0, elapsedMs);
+    if (newer) {
+      if (event.event === "task_end") session.endedAt = now;
+      else delete session.endedAt;
+    }
+    let latestFindings = [];
+    if (!newer && [...agent.slice(0, 4), ...completion.slice(0, 4)].some((f) => !session.findings[f.id])) {
+      try {
+        if (!session.reportPath.startsWith(ws.directory + "/checks/")) throw new Error("Unexpected report path");
+        latestFindings = z10.object({ findings: z10.array(z10.object({ id: z10.string(), status: findingSchema2.shape.status })) }).parse(await readStoreJson(root, session.reportPath)).findings;
+      } catch {
+      }
+    }
+    for (const [channel, findings] of [["agent", agent], ["completion", completion]]) {
+      for (const finding of findings.slice(0, 4)) {
+        if (!session.findings[finding.id] && Object.keys(session.findings).length >= 200) {
+          session.truncated = true;
+          continue;
+        }
+        const saved = session.findings[finding.id] ??= {
+          type: finding.original.type,
+          channels: [],
+          status: newer ? finding.status : latestFindings.find((f) => f.id === finding.id)?.status ?? "unknown",
+          deliveredAt: now,
+          observedAt: newer ? now : session.updatedAt
+        };
+        if (!saved.channels.includes(channel)) saved.channels.push(channel);
+      }
+    }
+    for (const [id, saved] of Object.entries(session.findings)) {
+      if (now < saved.observedAt) continue;
+      const current = report.findings.find((f) => f.id === id);
+      saved.status = current?.status ?? "unknown";
+      saved.observedAt = now;
+    }
+    if (event.retrievedDecisionIds !== void 0 && event.toolId) {
+      const receipt = hash([event.toolId]);
+      if (!session.receiptIds.includes(receipt)) {
+        session.retrievalObserved = true;
+        const decisions = [.../* @__PURE__ */ new Set([...session.decisions, ...event.retrievedDecisionIds.map((id) => hash([id]))])];
+        if (decisions.length > 200) session.truncated = true;
+        session.decisions = decisions.slice(0, 200);
+        session.receiptIds = [...session.receiptIds, receipt].slice(-200);
+      }
+    }
+    const keys = Object.keys(state.sessions).sort((a, b) => state.sessions[b].updatedAt.localeCompare(state.sessions[a].updatedAt));
+    for (const key2 of keys.slice(50)) delete state.sessions[key2];
+    await writeStoreJson(root, statePath(ws), state);
+  });
+}
+async function rateUsefulness(dir, sessionId, findingId2, rating) {
+  const ws = await workspace(dir);
+  return withStoreLock(ws.root, directory, async () => {
+    const state = stateSchema2.parse(await readStoreJson(ws.root, statePath(ws)));
+    const finding = state.sessions[sessionId]?.findings[findingId2];
+    if (!finding) throw new Error("Unknown retained session or finding; inspect mason stats --json.");
+    finding.rating = usefulnessRating.parse(rating);
+    await writeStoreJson(ws.root, statePath(ws), state);
+    return { session: sessionId, finding: findingId2, rating };
+  });
+}
+async function usefulnessStatus(dir, sessionId) {
+  const ws = await workspace(dir);
+  const raw = await readStoreJson(ws.root, statePath(ws));
+  const state = raw === null ? empty() : stateSchema2.parse(raw);
+  if (sessionId !== void 0 && !Object.hasOwn(state.sessions, sessionId)) throw new Error("Unknown retained session; inspect mason stats --json for session IDs.");
+  const sessions = Object.entries(state.sessions).filter(([id]) => sessionId === void 0 || id === sessionId).sort(([, a], [, b]) => b.updatedAt.localeCompare(a.updatedAt)).map(([id, s]) => ({
+    id,
+    ...s,
+    receiptIds: void 0,
+    delivered: Object.keys(s.findings).length,
+    resolved: Object.values(s.findings).filter((f) => f.status === "resolved").length,
+    unknown: Object.values(s.findings).filter((f) => f.status === "unknown" || f.status === "unverified").length,
+    open: Object.values(s.findings).filter((f) => f.status === "unresolved" || f.status === "review-required").length,
+    ratings: Object.fromEntries(usefulnessRating.options.map((rating) => [rating, Object.values(s.findings).filter((f) => f.rating === rating).length])),
+    deferred: Object.values(s.findings).filter((f) => f.rating === "deferred").length,
+    retrievedDecisions: s.retrievalObserved ? s.decisions.length : null,
+    application: "unknown",
+    modelTokens: null
+  }));
+  const sum = (pick) => sessions.reduce((total, s) => total + pick(s), 0);
+  const retrievalObservedSessions = sessions.filter((s) => s.retrievalObserved).length;
+  return {
+    version: 1,
+    enabled: await enabled(ws.root),
+    branch: ws.branch,
+    sessionId: sessionId ?? null,
+    summary: {
+      sessions: sessions.length,
+      delivered: sum((s) => s.delivered),
+      resolved: sum((s) => s.resolved),
+      open: sum((s) => s.open),
+      unknown: sum((s) => s.unknown),
+      ratings: Object.fromEntries(usefulnessRating.options.map((rating) => [rating, sum((s) => s.ratings[rating])])),
+      retrievedDecisions: retrievalObservedSessions ? sum((s) => s.retrievedDecisions ?? 0) : null,
+      retrievalObservedSessions,
+      checks: sum((s) => s.checks),
+      checkMs: sum((s) => s.checkMs),
+      truncatedSessions: sessions.filter((s) => s.truncated).length,
+      application: "unknown",
+      modelTokens: null
+    },
+    note: "Counts sum distinct findings and returned records within each retained session; the same item may appear in multiple sessions. Status reflects the last observed check, not a fresh verification. Up to 50 sessions and 200 findings/records per session are retained. Resolution after a notice does not establish causation. Ratings are supplied feedback, not authenticated judgments. Lesson application, later-session reuse and model-token cost are unknown.",
+    sessions
+  };
+}
+function summarizeUsefulness(result) {
+  const s = result.summary;
+  return [
+    `Mason stats \u2014 tracking ${result.enabled ? "enabled" : "disabled"} (local only)`,
+    `${s.sessions} retained session(s)${result.sessionId ? " selected" : " in this branch"}. Counts are summed per session.`,
+    `Findings: ${s.delivered} delivered; ${s.resolved} observed resolved; ${s.open} open; ${s.unknown} unknown.`,
+    `Feedback: ${s.ratings.helpful} helpful; ${s.ratings["already-knew"]} already knew; ${s.ratings.irrelevant} irrelevant; ${s.ratings.deferred} deferred.`,
+    `Decision records returned: ${s.retrievedDecisions ?? "unknown"} (${s.retrievalObservedSessions}/${s.sessions} sessions with retrieval receipts); application unknown.`,
+    `Automation: ${(s.checkMs / 1e3).toFixed(2)} seconds across ${s.checks} observations; model-token cost unknown.`,
+    ...s.truncatedSessions ? [`${s.truncatedSessions} session(s) have truncated observations.`] : [],
+    ...result.sessionId ? result.sessions.flatMap((session) => [
+      `Session ${session.id} (${session.host}) \u2014 ${session.endedAt ? "last observed stop " + session.endedAt : "no final stop observed"}`,
+      `Evidence: ${session.reportPath}`,
+      ...Object.entries(session.findings).map(([id, f]) => `  ${id}: ${f.type}; ${f.status}; ${f.channels.join("/")}${f.rating ? "; rated " + f.rating : ""}`)
+    ]) : [s.sessions ? "Use --json for session IDs, then --session <id> for details." : "No retained sessions observed."],
+    "Last observed checks only. Resolution after a notice does not prove Mason caused it."
+  ].join("\n");
+}
+function retrievedDecisions(tool, response) {
+  if (!/(?:^|__)mason__get_context$/.test(tool ?? "")) return void 0;
+  try {
+    let value = typeof response === "string" ? JSON.parse(response) : response;
+    if (value?.isError) return void 0;
+    if (Array.isArray(value?.content)) {
+      const text2 = value.content.find((item) => item?.type === "text" && typeof item.text === "string")?.text;
+      if (!text2) return void 0;
+      value = JSON.parse(text2);
+    }
+    if (!value || typeof value.decisions !== "object" || !value.decisions || Array.isArray(value.decisions)) return void 0;
+    return Object.keys(value.decisions).filter((id) => /^[a-zA-Z0-9_-]{1,200}$/.test(id)).slice(0, 200);
+  } catch {
+    return void 0;
+  }
+}
+var directory, configPath, configSchema, usefulnessRating, findingSchema2, sessionSchema, stateSchema2, empty, statePath;
+var init_usefulness = __esm({
+  "src/automation/usefulness.ts"() {
+    "use strict";
+    init_evidence();
+    init_storage();
+    init_store_lock();
+    directory = ".mason/local/usefulness";
+    configPath = directory + "/config.json";
+    configSchema = z10.object({ version: z10.literal(1), enabled: z10.boolean() });
+    usefulnessRating = z10.enum(["helpful", "already-knew", "irrelevant", "deferred"]);
+    findingSchema2 = z10.object({
+      type: z10.string(),
+      channels: z10.array(z10.enum(["agent", "completion"])),
+      status: z10.enum(["resolved", "unresolved", "review-required", "unverified", "unknown"]),
+      deliveredAt: z10.string(),
+      observedAt: z10.string(),
+      rating: usefulnessRating.optional()
+    });
+    sessionSchema = z10.object({
+      host: z10.string(),
+      updatedAt: z10.string(),
+      endedAt: z10.string().optional(),
+      checks: z10.number(),
+      checkMs: z10.number(),
+      findings: z10.record(findingSchema2),
+      decisions: z10.array(z10.string()),
+      retrievalObserved: z10.boolean(),
+      receiptIds: z10.array(z10.string()),
+      reportPath: z10.string(),
+      truncated: z10.boolean()
+    });
+    stateSchema2 = z10.object({ version: z10.literal(1), sessions: z10.record(sessionSchema) });
+    empty = () => ({ version: 1, sessions: {} });
+    statePath = (ws) => `${directory}/${hash([ws.root, ws.gitDir, ws.branch]).slice(0, 24)}.json`;
   }
 });
 
 // src/automation/execution.ts
 import os2 from "os";
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import { randomUUID as randomUUID3 } from "crypto";
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 function parseExecution(raw) {
   try {
     return executionSchema.parse(raw);
@@ -3414,15 +3762,15 @@ function automationFailure(error) {
     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";
+  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 z11.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");
+async function failureNotifications(root, directory2) {
+  const raw = await readStoreJson(root, directory2 + "/notifications.json");
   return raw === null ? { version: 1, sessions: {} } : notificationsSchema.parse(raw);
 }
 async function hookFailureMessage(dir, host, sessionId, error) {
@@ -3452,12 +3800,12 @@ async function hookFailureMessage(dir, host, sessionId, error) {
     return failureMessage(error);
   }
 }
-async function refreshRunning(root, directory, attempts) {
+async function refreshRunning(root, directory2, attempts) {
   for (const attempt of attempts) {
     if (attempt.status !== "running") continue;
     let alive = false;
     try {
-      const owner = await readStoreJson(root, attempt.lease ? leasePath(directory, attempt.id) : directory + "/lock");
+      const owner = await readStoreJson(root, attempt.lease ? leasePath(directory2, attempt.id) : directory2 + "/lock");
       if (attempt.host === os2.hostname() && owner?.pid === attempt.pid && owner.host === attempt.host) {
         try {
           process.kill(attempt.pid, 0);
@@ -3471,12 +3819,12 @@ async function refreshRunning(root, directory, attempts) {
     if (!alive) attempt.status = "unknown";
   }
 }
-async function editExecution(root, directory, edit) {
-  return withLock(root, directory + "/execution-lock", async () => {
-    const file = directory + "/execution.json";
+async function editExecution(root, directory2, edit) {
+  return withLock(root, directory2 + "/execution-lock", async () => {
+    const file = directory2 + "/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);
+    await refreshRunning(root, directory2, 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));
@@ -3485,7 +3833,7 @@ async function editExecution(root, directory, edit) {
     await writeStoreJson(root, file, log);
   });
 }
-async function recordExecution(root, directory, event, run) {
+async function recordExecution(root, directory2, event, run) {
   const started = performance.now();
   const attempt = {
     id: randomUUID3(),
@@ -3496,15 +3844,15 @@ async function recordExecution(root, directory, event, run) {
     status: "running",
     lease: true
   };
-  const owner = leasePath(directory, attempt.id);
-  const finish = async (changes) => editExecution(root, directory, (log) => {
+  const owner = leasePath(directory2, attempt.id);
+  const finish = async (changes) => editExecution(root, directory2, (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) => {
+    await editExecution(root, directory2, (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);
     });
@@ -3522,15 +3870,15 @@ async function recordExecution(root, directory, event, run) {
       throw Object.assign(new Error(failure.message, { cause: error }), { failure });
     }
   } finally {
-    await fs14.rm(await storePath(root, owner), { force: true }).catch(() => {
+    await fs15.rm(await storePath(root, owner), { force: true }).catch(() => {
     });
   }
 }
-async function executionStatus(root, directory) {
-  const raw = await readStoreJson(root, directory + "/execution.json");
+async function executionStatus(root, directory2) {
+  const raw = await readStoreJson(root, directory2 + "/execution.json");
   if (raw === null) return { status: "not-observed", attempts: [] };
   const log = parseExecution(raw);
-  await refreshRunning(root, directory, log.attempts);
+  await refreshRunning(root, directory2, 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";
@@ -3543,46 +3891,108 @@ var init_execution = __esm({
     init_store();
     init_evidence();
     init_storage();
-    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()
+    failureSchema = z11.object({
+      code: z11.enum(["inputs-changed", "storage-full", "busy", "invalid-input", "history-unavailable", "invalid-evidence", "io-error", "internal"]),
+      message: z11.string(),
+      retryable: z11.boolean(),
+      receiptRecorded: z11.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(),
+    attemptSchema = z11.object({
+      id: z11.string().regex(/^[a-zA-Z0-9_-]+$/),
+      lease: z11.literal(true).optional(),
+      event: z11.string(),
+      startedAt: z11.string(),
+      finishedAt: z11.string().optional(),
+      durationMs: z11.number().nonnegative().optional(),
+      pid: z11.number().int().positive(),
+      host: z11.string(),
+      status: z11.enum(["running", "completed", "failed", "unknown"]),
+      verificationStatus: z11.string().optional(),
+      reportPath: z11.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(),
+    executionSchema = z11.object({ version: z11.literal(1), attempts: z11.array(attemptSchema).max(160), discardedAttempts: z11.number().int().nonnegative().default(0) });
+    notificationsSchema = z11.object({ version: z11.literal(1), sessions: z11.record(z11.object({
+      signature: z11.string(),
       code: failureSchema.shape.code,
-      message: z9.string(),
-      count: z9.number().int().positive(),
-      lastAt: z9.string()
+      message: z11.string(),
+      count: z11.number().int().positive(),
+      lastAt: z11.string()
     })) });
-    leasePath = (directory, id) => `${directory}/executions/${id}.json`;
+    leasePath = (directory2, id) => `${directory2}/executions/${id}.json`;
+  }
+});
+
+// src/decisions/pending.ts
+var pending_exports = {};
+__export(pending_exports, {
+  pendingKnowledge: () => pendingKnowledge
+});
+async function pendingKnowledge(root, now = Date.now()) {
+  try {
+    const [store, status] = await Promise.all([
+      loadDecisionStore(root),
+      execGit(
+        ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ".mason/decisions"],
+        { cwd: root, timeout: 1e4, maxBuffer: 1024 * 1024 }
+      )
+    ]);
+    const changed = /* @__PURE__ */ new Set();
+    const entries = status.stdout.split("\0");
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry) continue;
+      const file = entry.slice(3);
+      if (/^\.mason\/decisions\/[^/]+\.json$/.test(file)) changed.add(file);
+      if (/[RC]/.test(entry.slice(0, 2))) i++;
+    }
+    const records = new Map(store.records.map((record) => [`.mason/decisions/${record.id}.json`, record]));
+    const age = (at) => {
+      const time = at ? Date.parse(at) : NaN;
+      return Number.isFinite(time) ? `${Math.max(0, Math.floor((now - time) / 864e5))} days` : "unknown age";
+    };
+    const safe = (value) => value.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ");
+    const list = (items) => items.slice(0, 5).map(safe).join("; ") + (items.length > 5 ? `; ${items.length - 5} more` : "");
+    const proposals = store.records.filter((record) => record.status === "active" && decisionApproval(record) === "proposed").map((record) => {
+      const history = record.version === 2 ? record.history : [];
+      let lastReview = -1;
+      history.forEach((event, index2) => {
+        if (event.kind === "accepted" || event.kind === "reaffirmed") lastReview = index2;
+      });
+      const since = history.slice(lastReview + 1).find((event) => event.kind === "created" || event.kind === "revised")?.at ?? record.createdAt;
+      return { record, since };
+    }).sort((a, b) => {
+      const timestamp = (value) => Number.isFinite(Date.parse(value)) ? Date.parse(value) : Infinity;
+      return timestamp(a.since) - timestamp(b.since) || a.record.id.localeCompare(b.record.id);
+    });
+    const lines = [];
+    if (changed.size) lines.push(`${changed.size} uncommitted decision record(s): ${list([...changed].sort().map((file) => `${file} (saved-record age: ${age(records.get(file)?.updatedAt)})`))}.`);
+    if (proposals.length) lines.push(`${proposals.length} proposal(s) awaiting review (oldest first): ${list(proposals.map(({ record, since }) => `.mason/decisions/${record.id}.json (${age(since)})`))}.`);
+    if (store.diagnostics.length) lines.push(`${store.diagnostics.length} decision record(s) could not be read; pending knowledge summary is incomplete.`);
+    return lines.length ? `Mason pending knowledge:
+${lines.join("\n")}
+Informational only; review and commit through the normal project workflow. No approval is implied.` : null;
+  } catch {
+    return "Mason pending knowledge: unavailable; decision records or Git status could not be read.";
+  }
+}
+var init_pending = __esm({
+  "src/decisions/pending.ts"() {
+    "use strict";
+    init_git_read();
+    init_decisions();
+    init_provenance();
   }
 });
 
 // src/automation/runtime.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 async function observeReadOnlyTool(dir, event) {
   const ws = await profilePhase("automation.workspace", () => workspace(dir));
   await withLock(ws.root, ws.directory, async () => {
-    const statePath = ws.directory + "/state.json";
-    const raw = await readStoreJson(ws.root, statePath);
+    const statePath2 = ws.directory + "/state.json";
+    const raw = await readStoreJson(ws.root, statePath2);
     if (raw === null) return;
     const state = parseState(raw);
     if (state.root !== ws.root || state.gitDir !== ws.gitDir || state.branch !== ws.branch) {
@@ -3593,7 +4003,7 @@ async function observeReadOnlyTool(dir, event) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     session.lastUsed = now;
     session.events[event.event] = { at: now, count: (session.events[event.event]?.count ?? 0) + 1 };
-    await writeStoreJson(ws.root, statePath, state);
+    await writeStoreJson(ws.root, statePath2, state);
   });
   return { root: ws.root, directory: ws.directory };
 }
@@ -3608,7 +4018,7 @@ function summarize(report) {
     }),
     ...open.length > 4 ? [`${open.length - 4} more findings in the report.`] : [],
     ...report.diagnostics.slice(0, 2).map(cleanText),
-    `Evidence: ${report.reportPath}. Resume/check with mason_automation(action: "check") or mason-auto check.`,
+    `Evidence: ${report.reportPath}. Resume/check with mason_automation(action: "check") or mason check.`,
     "Keep original evidence. Address findings relevant to the authorized task; report unrelated findings with a brief scope reason and suggested follow-up. Use review_advisory for authorized assessments; otherwise leave advisories open without approving them."
   ].join("\n");
 }
@@ -3667,7 +4077,7 @@ async function verifyInputs(ws, inputs) {
 async function computeAnalysis(ws, state, inputs, event, previousAudit, cacheDiagnostic) {
   const baselines = [...state.baselines];
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const empty = {
+  const empty2 = {
     version: 1,
     status: "unavailable",
     root: ws.root,
@@ -3684,7 +4094,7 @@ async function computeAnalysis(ws, state, inputs, event, previousAudit, cacheDia
   };
   if (!baselines.length && Object.values(inputs.docs).every((value) => value === null)) {
     await verifyInputs(ws, inputs);
-    return { baselines, report: empty, cache: null };
+    return { baselines, report: empty2, cache: null };
   }
   if (ws.branch === "detached" && state.latest) {
     const previous = await readStoreJson(ws.root, state.latest);
@@ -3786,7 +4196,7 @@ async function analyze(ws, inputs, event, startedAt) {
 async function automate(dir, event) {
   const startedAt = Date.now();
   const ws = await profilePhase("automation.workspace", () => workspace(dir));
-  return recordExecution(ws.root, ws.directory, event.event, () => withRepositoryInspection(ws.root, async () => {
+  const output = await recordExecution(ws.root, ws.directory, event.event, () => withRepositoryInspection(ws.root, async () => {
     const inputs = await readInputs(ws.root);
     const result = await profilePhase("automation.analysis", () => analyze(ws, inputs, event, startedAt));
     if (result.shared) {
@@ -3799,6 +4209,19 @@ async function automate(dir, event) {
       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 (!state.notifications) {
+        let baseline = { findings: report.findings, head: report.head };
+        if (state.latest) {
+          try {
+            const previous = z12.object({ findings: z12.array(repairFindingSchema), head: z12.string() }).safeParse(await readStoreJson(ws.root, state.latest));
+            if (!previous.success) throw new Error("Unsupported saved report");
+            baseline = previous.data;
+          } catch {
+            report.diagnostics.push("The saved notification baseline could not be read; initialized from the current audit. Original repair evidence is retained. Run an explicit check for all outstanding findings.");
+          }
+        }
+        state.notifications = createNotificationState(baseline.findings, baseline.head);
+      }
       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/" + randomUUID4() + ".json";
       const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -3811,12 +4234,8 @@ async function automate(dir, event) {
         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,
+          notifiedDiagnostics: [],
           lastUsed: now,
-          mutationObserved: false,
           pending: {},
           coverageGaps: [],
           events: {}
@@ -3831,7 +4250,6 @@ async function automate(dir, event) {
           session.pending[event.toolId] = inputs.fingerprint;
         }
         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 in this checkout; pre-edit coverage is unknown. The tool may have changed checkouts; captures are kept separately for each worktree.";
             if (!session.coverageGaps.includes(gap)) session.coverageGaps.push(gap);
@@ -3842,31 +4260,45 @@ async function automate(dir, event) {
         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";
       }
-      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";
+      const selected = session && event.event === "task_end" ? completionFindings(state.notifications, report.findings) : [];
+      state.agentNotifications ??= { ...structuredClone(state.notifications), delivered: {} };
+      const feedback = session && ["turn_start", "after_tool"].includes(event.event) ? completionFindings(state.agentNotifications, report.findings) : [];
+      const diagnostics = session ? report.diagnostics.filter((d) => !session.notifiedDiagnostics.includes(d)).slice(0, 2) : [];
+      if (session) session.notifiedDiagnostics = [.../* @__PURE__ */ new Set([
+        ...session.notifiedDiagnostics.filter((d) => report.diagnostics.includes(d)),
+        ...diagnostics
+      ])];
+      const message2 = !session ? summarize(report) : [
+        completionSummary(selected, report.reportPath),
+        completionSummary(feedback, report.reportPath),
+        ...diagnostics.length ? [`Mason: verification limited. ${diagnostics.slice(0, 2).map(cleanText).join(" ")} Evidence: ${report.reportPath}.`] : []
+      ].filter(Boolean).join("\n") || null;
+      const notify = message2 !== null;
+      const persistReport = !state.latest || state.fingerprint !== inputs.fingerprint || notify || newSession || 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 };
+      return { report, message: message2, observedAt: now, delivery: { agent: feedback.slice(0, 4), completion: selected.slice(0, 4) } };
     }));
   }));
+  try {
+    await observeUsefulness(ws.root, event, output.report, output.delivery.agent, output.delivery.completion, Date.now() - startedAt, output.observedAt);
+  } catch {
+    if (event.event === "task_end") output.message = [output.message, "Mason: local usefulness tracking unavailable; inspect mason stats --json."].filter(Boolean).join("\n");
+  }
+  return output;
 }
 async function automationStatus(dir) {
+  const { pendingKnowledge: pendingKnowledge2 } = await Promise.resolve().then(() => (init_pending(), pending_exports));
   const ws = await profilePhase("automation.workspace", () => workspace(dir));
+  const knowledge = await pendingKnowledge2(ws.root);
   const execution = await executionStatus(ws.root, ws.directory);
   const notifications = await failureNotifications(ws.root, ws.directory);
   const raw = await readStoreJson(ws.root, ws.directory + "/state.json");
-  if (raw === null) return { version: 1, status: execution.status === "not-observed" ? "not-observed" : "unavailable", root: ws.root, branch: ws.branch, baselinePaths: [], hosts: {}, execution, notifications };
+  if (raw === null) return { version: 1, status: execution.status === "not-observed" ? "not-observed" : "unavailable", root: ws.root, branch: ws.branch, baselinePaths: [], hosts: {}, execution, notifications, knowledge };
   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);
@@ -3889,6 +4321,8 @@ async function automationStatus(dir) {
     hosts: hosts2,
     execution,
     notifications,
+    knowledge,
+    notificationBaselineHead: state.notifications?.baselineHead ?? null,
     note: "Observed events do not prove all tool paths are intercepted. Run check to verify the retained evidence."
   };
 }
@@ -3896,6 +4330,8 @@ var SCOPE, priority, cleanText, analysisSchema, sharedSchema, baselineDigest;
 var init_runtime = __esm({
   "src/automation/runtime.ts"() {
     "use strict";
+    init_usefulness();
+    init_notifications();
     init_profile();
     init_inspection();
     init_execution();
@@ -3907,34 +4343,34 @@ var init_runtime = __esm({
     SCOPE = "Documentation audit evidence only. Hook receipts show observed events, not complete interception. Resolved findings no longer fail their checks or have a recorded assessment covering current evidence. Repair and review only within the user's task authorization.";
     priority = { resolved: 0, "review-required": 1, unresolved: 2, unverified: 3 };
     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(),
+    analysisSchema = z12.object({
+      id: z12.string(),
+      fingerprint: z12.string(),
+      completedAt: z12.number(),
+      baselineDigest: z12.string(),
       currentAudit: reportSchema.nullable().optional(),
-      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() })),
-          auditReused: z10.boolean().optional()
+      report: z12.object({
+        version: z12.literal(1),
+        status: z12.enum(["verified", "issues-remain", "incomplete", "unavailable"]),
+        root: z12.string(),
+        branch: z12.string(),
+        head: z12.string(),
+        baselinePaths: z12.array(z12.string()),
+        reportPath: z12.string(),
+        findings: z12.array(repairFindingSchema),
+        diagnostics: z12.array(z12.string()),
+        checks: z12.object({
+          ran: z12.array(z12.string()),
+          reused: z12.array(z12.string()),
+          skipped: z12.array(z12.object({ check: z12.string(), reason: z12.string(), doc: z12.string().optional() })),
+          auditReused: z12.boolean().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()
+        counts: z12.object({ resolved: z12.number(), unresolved: z12.number(), "review-required": z12.number(), unverified: z12.number() }),
+        capture: z12.enum(["observed", "unknown"]),
+        scope: z12.string()
       })
     });
-    sharedSchema = z10.object({ analysis: analysisSchema, digest: z10.string() });
+    sharedSchema = z12.object({ analysis: analysisSchema, digest: z12.string() });
     baselineDigest = async (ws, state) => profilePhase("automation.baselines", async () => hash(await Promise.all(
       state.baselines.map(async (b) => [b.path, await readStoreJson(ws.root, b.path)])
     )));
@@ -3942,12 +4378,12 @@ var init_runtime = __esm({
 });
 
 // src/automation/hook-root.ts
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 import path23 from "path";
 async function repositoryRoot(dir) {
   if (!path23.isAbsolute(dir)) throw new Error("Hook input working directory must be absolute.");
   try {
-    return await fs15.realpath((await git3(dir, "rev-parse", "--show-toplevel")).trim());
+    return await fs16.realpath((await git3(dir, "rev-parse", "--show-toplevel")).trim());
   } catch (error) {
     if (error.code === "ENOENT" || /not a git repository/.test(String(error.stderr))) return null;
     throw error;
@@ -3975,8 +4411,8 @@ var init_hook_root = __esm({
 });
 
 // src/setup/model.ts
-import { z as z11 } from "zod";
-import fs16 from "fs/promises";
+import { z as z13 } from "zod";
+import fs17 from "fs/promises";
 import path24 from "path";
 async function loadSetup(root) {
   const raw = await readStoreJson(root, SETUP_PATH);
@@ -3986,20 +4422,20 @@ async function loadSetup(root) {
 async function effectiveSetup(root) {
   const local = await loadSetup(root);
   if (local) return { root, setup: local };
-  const common = await fs16.realpath(path24.resolve(root, (await git3(root, "rev-parse", "--git-common-dir")).trim()));
-  const own = await fs16.realpath((await git3(root, "rev-parse", "--absolute-git-dir")).trim());
+  const common = await fs17.realpath(path24.resolve(root, (await git3(root, "rev-parse", "--git-common-dir")).trim()));
+  const own = await fs17.realpath((await git3(root, "rev-parse", "--absolute-git-dir")).trim());
   if (common === own) return { root, setup: null };
   const primary = (await git3(root, "worktree", "list", "--porcelain", "-z")).split("\0\0")[0].split("\0");
   const candidate = primary.find((field) => field.startsWith("worktree "))?.slice(9);
   if (!candidate || primary.includes("bare")) return { root, setup: null };
   let inheritedRoot;
   try {
-    inheritedRoot = await fs16.realpath((await git3(candidate, "rev-parse", "--show-toplevel")).trim());
+    inheritedRoot = await fs17.realpath((await git3(candidate, "rev-parse", "--show-toplevel")).trim());
   } catch (error) {
     if (/must be run in a work tree/.test(String(error.stderr))) return { root, setup: null };
     throw error;
   }
-  const inheritedCommon = await fs16.realpath(path24.resolve(
+  const inheritedCommon = await fs17.realpath(path24.resolve(
     inheritedRoot,
     (await git3(inheritedRoot, "rev-parse", "--git-common-dir")).trim()
   ));
@@ -4009,8 +4445,8 @@ async function effectiveSetup(root) {
   if (inactive && setup) for (const host of inactiveHostsSchema.parse(inactive).hosts) delete setup.hosts[host];
   return { root: inheritedRoot, setup };
 }
-async function loadSetupReceipt(root, directory, host) {
-  const raw = await readStoreJson(root, directory + "/setup-" + host + ".json");
+async function loadSetupReceipt(root, directory2, host) {
+  const raw = await readStoreJson(root, directory2 + "/setup-" + host + ".json");
   if (raw === null) return null;
   const receipt = receiptSchema.parse(raw);
   if (receipt.root !== root || receipt.host !== host) throw new Error("Setup receipt belongs to another installation.");
@@ -4022,29 +4458,29 @@ var init_model = __esm({
     "use strict";
     init_evidence();
     init_storage();
-    setupHostSchema = z11.object({
-      configuredVersion: z11.string(),
-      revision: z11.string().uuid(),
-      fingerprint: z11.string(),
-      mcpFingerprint: z11.string(),
-      instructions: z11.array(z11.string())
+    setupHostSchema = z13.object({
+      configuredVersion: z13.string(),
+      revision: z13.string().uuid(),
+      fingerprint: z13.string(),
+      mcpFingerprint: z13.string(),
+      instructions: z13.array(z13.string())
     });
-    setupSchema = z11.object({ version: z11.literal(2), hosts: z11.object({
+    setupSchema = z13.object({ version: z13.literal(2), hosts: z13.object({
       codex: setupHostSchema.optional(),
       claude: setupHostSchema.optional()
     }) });
     SETUP_PATH = ".mason/local/setup.json";
     INACTIVE_HOSTS_PATH = ".mason/local/inactive-hosts.json";
-    inactiveHostsSchema = z11.object({ version: z11.literal(1), hosts: z11.array(z11.enum(["claude", "codex"])) });
-    receiptSchema = z11.object({
-      version: z11.literal(1),
-      host: z11.enum(["codex", "claude"]),
-      status: z11.enum(["installing", "configured"]),
-      initialReportPath: z11.string(),
-      initialBaselinePaths: z11.array(z11.string()),
-      root: z11.string(),
-      revision: z11.string().uuid(),
-      configuredAt: z11.string().optional()
+    inactiveHostsSchema = z13.object({ version: z13.literal(1), hosts: z13.array(z13.enum(["claude", "codex"])) });
+    receiptSchema = z13.object({
+      version: z13.literal(1),
+      host: z13.enum(["codex", "claude"]),
+      status: z13.enum(["installing", "configured"]),
+      initialReportPath: z13.string(),
+      initialBaselinePaths: z13.array(z13.string()),
+      root: z13.string(),
+      revision: z13.string().uuid(),
+      configuredAt: z13.string().optional()
     });
   }
 });
@@ -4062,7 +4498,7 @@ __export(launcher_exports, {
 });
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 function globalCommand(args2, platform = process.platform) {
   return platform === "win32" ? { command: "cmd.exe", args: ["/d", "/s", "/c", "mason", ...args2] } : { command: "mason", args: args2 };
 }
@@ -4082,7 +4518,7 @@ async function installedCommand() {
   }
 }
 async function prepareLaunch(host, options = {}) {
-  const root = await fs17.realpath((await git3(options.dir ?? process.cwd(), "rev-parse", "--show-toplevel")).trim());
+  const root = await fs18.realpath((await git3(options.dir ?? process.cwd(), "rev-parse", "--show-toplevel")).trim());
   const entry = (await effectiveSetup(root)).setup?.hosts[host];
   process.env.MASON_SETUP_ROOT = root;
   process.env.MASON_SETUP_HOST = host;
@@ -4105,7 +4541,7 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.19.1" : "development";
+    executingVersion = () => true ? "0.20.1" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host} auto`;
   }
@@ -4118,13 +4554,13 @@ __export(observations_exports, {
   observeActivation: () => observeActivation,
   readObservation: () => readObservation
 });
-import fs18 from "fs/promises";
-import { z as z12 } from "zod";
-function observationPath(directory, host, revision, version = executingVersion()) {
-  return `${directory}/activation/${host}-${revision}-${hash(version).slice(0, 12)}.json`;
+import fs19 from "fs/promises";
+import { z as z14 } from "zod";
+function observationPath(directory2, host, revision, version = executingVersion()) {
+  return `${directory2}/activation/${host}-${revision}-${hash(version).slice(0, 12)}.json`;
 }
-async function readObservation(root, directory, host, revision, version = executingVersion()) {
-  const raw = await readStoreJson(root, observationPath(directory, host, revision, version));
+async function readObservation(root, directory2, host, revision, version = executingVersion()) {
+  const raw = await readStoreJson(root, observationPath(directory2, host, revision, version));
   if (raw === null) return null;
   const record = observationSchema.parse(raw);
   if (record.root !== root || record.host !== host || record.revision !== revision || record.masonVersion !== version) throw new Error("Activation receipt belongs to another installation.");
@@ -4141,12 +4577,12 @@ async function observeActivation(dir, event, options = {}) {
       return inactiveSetupMessage();
     }
     const capturedDirectory = options.directory?.match(/^\.mason\/reports\/automation\/[a-f0-9]{24}$/)?.[0] ?? options.reportPath?.match(/^(\.mason\/reports\/automation\/[a-f0-9]{24})\/checks\//)?.[1];
-    const ws = capturedDirectory ? { root: await fs18.realpath(dir), directory: capturedDirectory } : await workspace(dir);
-    if (ws.root !== await fs18.realpath(process.env.MASON_SETUP_ROOT)) return null;
+    const ws = capturedDirectory ? { root: await fs19.realpath(dir), directory: capturedDirectory } : await workspace(dir);
+    if (ws.root !== await fs19.realpath(process.env.MASON_SETUP_ROOT)) return null;
     const { setup } = await effectiveSetup(ws.root);
     if (setup?.hosts[host]?.revision !== revision) return "Mason setup changed; restart the assistant to observe the current integration.";
-    const directory = ws.directory + "/activation";
-    await withLock(ws.root, directory, async () => {
+    const directory2 = ws.directory + "/activation";
+    await withLock(ws.root, directory2, async () => {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const record = await readObservation(ws.root, ws.directory, host, revision) ?? {
         version: 1,
@@ -4190,26 +4626,26 @@ var init_observations = __esm({
     init_storage();
     init_model();
     init_launcher();
-    observationSchema = z12.object({
-      version: z12.literal(1),
-      masonVersion: z12.string(),
-      root: z12.string(),
-      revision: z12.string(),
-      host: z12.enum(["codex", "claude"]),
-      contextCalls: z12.number().int().nonnegative(),
-      lastContextAt: z12.string().optional(),
-      sessions: z12.record(z12.object({
-        events: z12.array(z12.enum(events)),
-        at: z12.string(),
-        verificationStatus: z12.string().optional(),
-        reportPath: z12.string().optional()
+    observationSchema = z14.object({
+      version: z14.literal(1),
+      masonVersion: z14.string(),
+      root: z14.string(),
+      revision: z14.string(),
+      host: z14.enum(["codex", "claude"]),
+      contextCalls: z14.number().int().nonnegative(),
+      lastContextAt: z14.string().optional(),
+      sessions: z14.record(z14.object({
+        events: z14.array(z14.enum(events)),
+        at: z14.string(),
+        verificationStatus: z14.string().optional(),
+        reportPath: z14.string().optional()
       }))
     });
   }
 });
 
 // src/automation/adapters.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 function normalizeHook(host, raw) {
   hostSchema.parse(host);
   const input = inputSchema.parse(raw);
@@ -4220,7 +4656,7 @@ function normalizeHook(host, raw) {
     sessionId: input.session_id,
     toolId: input.tool_use_id,
     mutating: !!input.tool_name && !readOnly,
-    stopHookActive: input.stop_hook_active || input.permission_mode === "plan"
+    ...input.hook_event_name === "PostToolUse" ? { retrievedDecisionIds: retrievedDecisions(input.tool_name, input.tool_response) } : {}
   } };
 }
 async function runAutomationHook(host, stdin, options = {}) {
@@ -4258,7 +4694,7 @@ async function runAutomationHook(host, stdin, options = {}) {
     if (warning) result.message = [result.message, warning].filter(Boolean).join("\n");
     if (!result.message) return null;
     if (name === "Stop") {
-      return result.continueOnce ? { decision: "block", reason: result.message } : { systemMessage: result.message };
+      return { systemMessage: result.message };
     }
     return { hookSpecificOutput: { hookEventName: name, additionalContext: result.message } };
   } catch (error) {
@@ -4277,7 +4713,7 @@ function knownManagedHookCommands(host) {
 function compatibleManagedHookCommands(host, platform = process.platform) {
   return [managedHookCommand(host, platform), `mason --setup-host ${host} auto hook --host ${host}`];
 }
-function hookConfig(host, command2 = "npx --no-install --package mason-context mason-auto") {
+function hookConfig(host, command2 = "npx --no-install --package mason-context mason auto") {
   const handler = { type: "command", command: command2 === `mason --setup-host ${host} auto` ? managedHookCommand(host) : command2 + " hook --host " + host, timeout: 30 };
   return { hooks: Object.fromEntries(HOOK_EVENTS.map((name) => [
     name,
@@ -4288,19 +4724,21 @@ var inputSchema, lifecycle, HOOK_EVENTS;
 var init_adapters = __esm({
   "src/automation/adapters.ts"() {
     "use strict";
+    init_usefulness();
     init_execution();
     init_runtime();
     init_store();
     init_hook_root();
-    inputSchema = z13.object({
-      cwd: z13.string().min(1),
-      session_id: z13.string().min(1).max(500),
-      hook_event_name: z13.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"]),
-      tool_name: z13.string().optional(),
-      tool_use_id: z13.string().max(500).optional(),
-      tool_input: z13.unknown().optional(),
-      stop_hook_active: z13.boolean().optional(),
-      permission_mode: z13.string().optional()
+    inputSchema = z15.object({
+      cwd: z15.string().min(1),
+      session_id: z15.string().min(1).max(500),
+      hook_event_name: z15.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"]),
+      tool_name: z15.string().optional(),
+      tool_use_id: z15.string().max(500).optional(),
+      tool_response: z15.unknown().optional(),
+      tool_input: z15.unknown().optional(),
+      stop_hook_active: z15.boolean().optional(),
+      permission_mode: z15.string().optional()
     });
     lifecycle = {
       SessionStart: "session_start",
@@ -4320,7 +4758,7 @@ __export(files_exports, {
   managedBlock: () => managedBlock,
   readText: () => readText
 });
-import fs19 from "fs/promises";
+import fs20 from "fs/promises";
 import path25 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 async function readText(root, file) {
@@ -4350,14 +4788,14 @@ async function applyEdit(root, edit) {
   if (edit.after === null) {
     const file2 = await storePath(root, edit.path);
     if (await readText(root, edit.path) !== edit.before) throw new Error("Input changed during removal: " + edit.path);
-    await fs19.unlink(file2);
+    await fs20.unlink(file2);
     return true;
   }
   const file = await storePath(root, edit.path, true);
   const temporary = path25.join(path25.dirname(file), ".mason-setup-" + randomUUID5() + ".tmp");
   try {
-    const mode = await fs19.stat(file).then((s) => s.mode & 511, () => 384);
-    const handle = await fs19.open(temporary, "wx", mode);
+    const mode = await fs20.stat(file).then((s) => s.mode & 511, () => 384);
+    const handle = await fs20.open(temporary, "wx", mode);
     try {
       await handle.writeFile(edit.after, "utf8");
       await handle.sync();
@@ -4365,10 +4803,10 @@ async function applyEdit(root, edit) {
       await handle.close();
     }
     if (await readText(root, edit.path) !== edit.before) throw new Error("Integration input changed during update: " + edit.path);
-    await fs19.rename(temporary, file);
+    await fs20.rename(temporary, file);
     return true;
   } finally {
-    await fs19.rm(temporary, { force: true });
+    await fs20.rm(temporary, { force: true });
   }
 }
 var init_files2 = __esm({
@@ -4389,7 +4827,7 @@ __export(ownership_exports, {
   ownershipEdit: () => ownershipEdit,
   ownershipSchema: () => ownershipSchema
 });
-import { z as z14 } from "zod";
+import { z as z16 } 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;
@@ -4440,30 +4878,30 @@ var init_ownership = __esm({
       ["<!-- mason:agents:start -->", "<!-- mason:agents:end -->"],
       ["# mason:mcp:start", "# mason:mcp:end"]
     ];
-    fileSchema = z14.object({
-      created: z14.boolean(),
-      initialHash: z14.string(),
-      blocks: z14.record(z14.string()),
-      mcpHash: z14.string().optional(),
-      hookCommands: z14.array(z14.string()).optional(),
-      hooks: z14.record(z14.array(z14.string())).optional()
+    fileSchema = z16.object({
+      created: z16.boolean(),
+      initialHash: z16.string(),
+      blocks: z16.record(z16.string()),
+      mcpHash: z16.string().optional(),
+      hookCommands: z16.array(z16.string()).optional(),
+      hooks: z16.record(z16.array(z16.string())).optional()
     });
-    ownershipSchema = z14.object({ version: z14.literal(1), files: z14.record(fileSchema) });
+    ownershipSchema = z16.object({ version: z16.literal(1), files: z16.record(fileSchema) });
   }
 });
 
 // src/mcp/init.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 var markerSchema, CLAUDE_MD_SECTION, ASSISTANT_SETUP, QUICKSTART_PLAYBOOK, MAP_PLAYBOOK;
 var init_init = __esm({
   "src/mcp/init.ts"() {
     "use strict";
     init_storage();
     init_files2();
-    markerSchema = z15.object({
-      version: z15.literal(1),
-      initializedAt: z15.string(),
-      features: z15.object({ confluence: z15.boolean().optional() }).passthrough().optional()
+    markerSchema = z17.object({
+      version: z17.literal(1),
+      initializedAt: z17.string(),
+      features: z17.object({ confluence: z17.boolean().optional() }).passthrough().optional()
     }).passthrough();
     CLAUDE_MD_SECTION = `<!-- mason:start -->
 ## Mason project knowledge
@@ -4472,9 +4910,10 @@ Mason provides recorded decisions and file impact over MCP. A concept map is opt
 
 - Task, bug, change request, or investigation of why the project works this way \u2192 \`get_context\` with the task text and known files: matching decisions, related tests, impact, and any available map entries.
 - Before editing a file \u2192 \`get_impact\` to check references, tests, and historical change partners.
-- Investigation or correction reveals a reusable project lesson \u2192 \`save_decision\` before finishing. Capture only the lasting constraint and reason, with anchors and known sources, owner, and recorder. This creates a proposal; never infer approval. Preserve uncertain causes and unknown attribution. Route project lessons here; keep personal preferences in agent memory. Skip code summaries, current checkout status, temporary task permissions, session trivia, and secrets. No qualifying lesson means no record.
+- Investigation or correction reveals a reusable project lesson \u2192 \`save_decision\` as soon as the lesson is supported by evidence; do not wait for implementation, task completion, or merge. Record the established observation now and identify unimplemented remedies as tentative. Capture only the lasting constraint and reason, with anchors and known sources, owner, and recorder. This creates a proposal; never infer approval. Preserve uncertain causes and unknown attribution. Route project lessons here; keep personal preferences in agent memory. Skip code summaries, current checkout status, temporary task permissions, session trivia, and secrets. No qualifying lesson means no record.
 - Before saving, compare the lesson with matching \`get_context\` records and any pending proposal. If new evidence changes the same lesson's assumptions, scope, or recommended action, revise it with \`save_decision(id: existingId)\`, including when it is accepted. Preserve supported rationale and sources, replace obsolete instructions, and add the new evidence. Create a separate record for a genuinely distinct lesson; skip unchanged restatements. Revision preserves history and leaves the accepted version operative until authorized review.
 - Consult trust metadata before relying on entries: unknown or changed freshness requires inspection, stale or unknown map verification requires a fresh evidence review, and a recorded failed verdict means the description must be corrected. Check approval too: proposals are suggestions, legacy records are unreviewed, and accepted decisions are recorded constraints subject to freshness checks. An accepted revision remains operative while a pending proposal is reviewed; keep both versions and their freshness distinct.
+- Asked to review pending project knowledge \u2192 \`mason_automation(action: "status")\` lists pending proposals and uncommitted records. For ordinary tasks, inspect matching proposals through \`get_context\`; do not request acceptance merely because a proposal exists.
 - Asked to review or re-verify a decision \u2192 \`review_decision\` first to inspect content, sources, history, and code changes. Record acceptance, reaffirmation, or retirement only when authorized by the user or a cited team review, with the actual reviewer and reason. Never infer approval from unchanged code. Review and commit the local record through the normal project workflow.
 - For an architectural overview, use \`get_snapshot\` if a map is available. If \`map.status\` is missing or invalid, use available decisions and source evidence; do not start building a map unless requested.
 - \`mason_init\` returns documentation audit and committed-diff review results, plus a short setup guide. Pass \`evidence\` with local CI manifest paths to include test and analysis results; the CLI equivalent is \`mason-review --evidence <manifest>\`. State skipped, unavailable, stale, or unknown checks explicitly. Related accepted decisions identify review context, not proven violations.
@@ -4484,13 +4923,13 @@ Mason provides recorded decisions and file impact over MCP. A concept map is opt
 
 - For a dependency advisory, \`review_advisory(action: "dismiss", baselinePath, findingId, reasonCode, note)\` records a one-step dismissal without reviewer or token. Use \`no-dependency-claims\` for a document with no dependency claims (reopens on document content changes), or \`unrelated-manifest-change\` for reviewed changes that do not affect its guidance (reopens on document or manifest changes). Keep the relevant scope committed; commit the dismissal to share it. This never approves a decision.
 
-- When Mason automation is installed, use \`mason_automation(action: "status")\` to inspect configured hooks and observed events, and \`mason_automation(action: "check")\` to resume its retained repair evidence. CLI fallback: \`mason-auto status\` / \`mason-auto check\`. Preserve existing baselines across sessions. Automatic checks do not authorize unrelated repairs or approve advisories.
+- When Mason automation is installed, use \`mason_automation(action: "status")\` to inspect configured hooks and observed events, and \`mason_automation(action: "check")\` to resume its retained repair evidence. CLI fallback: \`mason status\` / \`mason check\`. Preserve existing baselines across sessions. Automatic checks do not authorize unrelated repairs or approve advisories.
 
 Inspect source for what the retrieved context does not answer.
 <!-- mason:end -->`;
     ASSISTANT_SETUP = `UNIFIED SETUP
-When the user requests Mason setup, call mason_init again with mode: "setup" and host: "codex" or "claude" for the assistant being configured. This uses the same engine as mason-auto setup: retain the initial audit before instruction edits, use the installed mason command on PATH, merge project MCP configuration and hooks, update marker-delimited instructions and Git ignore rules, and record setup. A concept map is optional.
-If the user only requested inspection or review, report findings without running setup. The setup result distinguishes configured from observed activation. Explain the host's native trust step and request a new session; never trust hooks on the user's behalf or claim activation from generated configuration alone. After a normal task finishes, mason_automation(action: "status") or mason-auto status reports observed context use and hook events. Existing findings remain reviewable; setup does not approve advisories or manufacture decisions.
+When the user requests Mason setup, call mason_init again with mode: "setup" and host: "codex" or "claude" for the assistant being configured. This uses the same engine as mason setup: retain the initial audit before instruction edits, use the installed mason command on PATH, merge project MCP configuration and hooks, update marker-delimited instructions and Git ignore rules, and record setup. A concept map is optional.
+If the user only requested inspection or review, report findings without running setup. The setup result distinguishes configured from observed activation. Explain the host's native trust step and request a new session; never trust hooks on the user's behalf or claim activation from generated configuration alone. After a normal task finishes, mason_automation(action: "status") or mason status reports observed context use and hook events. Existing findings remain reviewable; setup does not approve advisories or manufacture decisions.
 
 The managed project guidance is:
 ${CLAUDE_MD_SECTION}`;
@@ -4498,7 +4937,7 @@ ${CLAUDE_MD_SECTION}`;
 
 1. Explain the actionable findings with their source evidence. Separate audit issues, advisories, and skipped checks. The review covers committed changes from the merge base to HEAD; workingTree paths are not included in that review. An unavailable or empty check is not proof that the project is correct. Use the CLI for full output if a summary is truncated.
 2. Address findings within the user's requested scope. Setup alone authorizes Mason host configuration, hooks, instructions, and ignore rules; rewriting existing project claims requires repair scope. If repair is authorized, call \`mason_repair(dir, action: "prepare")\` before editing; it saves the full original findings even when this summary is truncated. Inspect relevant source, make grounded edits, then call \`mason_repair(dir, action: "verify", baselinePath)\` with that same baseline, including after any final doc commit. Report resolved, unresolved, review-required, unverified, and new findings. Keep suppressed advisories visible even when setup has already dirtied a doc. Do not invent a decision just to populate the store.
-3. When the task reveals a real lesson or constraint, compare matching \`get_context\` records first. If its assumptions, scope, or recommended action changed, revise that record using \`save_decision(id: existingId)\`; create a separate record for a genuinely distinct lesson and skip unchanged restatements. Include title, body, category, anchors, and known owner/source/actor information. Preserve supported rationale and sources, replace obsolete instructions, and add new evidence. Missing attribution can be added later. The tool writes a local proposal; editing it preserves revision history and requires a new acceptance, while any earlier accepted revision remains operative. An unchanged save never refreshes its evidence. When decision review is requested, \`review_decision\` prepares the record and code evidence before any authorized verdict. Review and commit records through the normal workflow. Retrieve it on the next relevant task with \`get_context(dir, task, files)\`.
+3. Capture a supported lesson as soon as it is established; do not wait for implementation, task completion, or merge. Keep unimplemented remedies tentative. When the task reveals a real lesson or constraint, compare matching \`get_context\` records first. If its assumptions, scope, or recommended action changed, revise that record using \`save_decision(id: existingId)\`; create a separate record for a genuinely distinct lesson and skip unchanged restatements. Include title, body, category, anchors, and known owner/source/actor information. Preserve supported rationale and sources, replace obsolete instructions, and add new evidence. Missing attribution can be added later. The tool writes a local proposal; editing it preserves revision history and requires a new acceptance, while any earlier accepted revision remains operative. An unchanged save never refreshes its evidence. When decision review is requested, \`review_decision\` prepares the record and code evidence before any authorized verdict. Review and commit records through the normal workflow. Retrieve it on the next relevant task with \`get_context(dir, task, files)\`.
 
 ${ASSISTANT_SETUP}
 
@@ -4551,7 +4990,7 @@ __export(config_exports, {
 });
 import { isDeepStrictEqual } from "util";
 import { parse as parse2, stringify } from "smol-toml";
-import { z as z16 } from "zod";
+import { z as z18 } 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);
@@ -4610,7 +5049,7 @@ async function mcpEdit(root, host) {
   return { path: file, before, after };
 }
 async function hookEdits(root, host) {
-  const file = configPath(host), before = await readText(root, file);
+  const file = configPath2(host), before = await readText(root, file);
   const { planAutomationInstall: planAutomationInstall2 } = await Promise.resolve().then(() => (init_install(), install_exports));
   const plan = await planAutomationInstall2(root, host, hookCommand(host));
   return [
@@ -4638,7 +5077,7 @@ async function inspectHostConfig(root, host, plannedMcp) {
   const text2 = plannedMcp ?? await readText(root, mcpPath(host));
   const config = host === "codex" ? parse2(text2 ?? "") : object.parse(JSON.parse(text2 ?? "{}"));
   const servers = host === "codex" ? config.mcp_servers : config.mcpServers;
-  const hooks = automationConfigSchema.parse(JSON.parse(await readText(root, configPath(host)) ?? "{}"));
+  const hooks = automationConfigSchema.parse(JSON.parse(await readText(root, configPath2(host)) ?? "{}"));
   const expected = hookConfig(host, hookCommand(host));
   const compatible = compatibleManagedHookCommands(host);
   const mcp = servers?.mason === void 0 ? null : object.parse(servers.mason);
@@ -4662,7 +5101,7 @@ var init_config = __esm({
     init_install();
     init_files2();
     init_launcher();
-    object = z16.record(z16.unknown());
+    object = z18.record(z18.unknown());
     mcpPath = (host) => host === "codex" ? ".codex/config.toml" : ".mcp.json";
     TOML_START = "# mason:mcp:start";
     TOML_END = "# mason:mcp:end";
@@ -4676,13 +5115,13 @@ var install_exports = {};
 __export(install_exports, {
   AUTOMATION_PATH: () => AUTOMATION_PATH,
   automationConfigSchema: () => automationConfigSchema,
-  configPath: () => configPath,
+  configPath: () => configPath2,
   installAutomation: () => installAutomation,
   installedAutomation: () => installedAutomation,
   planAutomationInstall: () => planAutomationInstall,
   recordSchema: () => recordSchema2
 });
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 async function installationRecord(root) {
   return recordSchema2.parse(await readStoreJson(root, AUTOMATION_PATH) ?? { version: 1, hosts: {} });
 }
@@ -4691,7 +5130,7 @@ async function installAutomation(dir, host, command2) {
   return withLock(ws.root, ".mason/reports/setup-lock", () => installLocked(ws.root, host, command2));
 }
 async function planAutomationInstall(root, host, command2) {
-  const file = configPath(host);
+  const file = configPath2(host);
   const before = await readText(root, file);
   const existing = automationConfigSchema.parse(JSON.parse(before ?? "{}"));
   const record = await installationRecord(root);
@@ -4731,7 +5170,7 @@ async function installLocked(root, host, command2) {
     status: "configured",
     command: newCommand,
     events: HOOK_EVENTS,
-    next: host === "codex" ? "Review/trust these hooks using Codex /hooks and start a new session. mason-auto status reports observed events separately from configuration." : "Start a new Claude Code session. mason-auto status reports observed events separately from configuration.",
+    next: host === "codex" ? "Review/trust these hooks using Codex /hooks and start a new session. mason status reports observed events separately from configuration." : "Start a new Claude Code session. mason status reports observed events separately from configuration.",
     note: "Install mason-context in the project before using the default command. Ignore .mason/reports/ to keep local evidence out of commits. Hooks preserve evidence and suggest scoped repairs; they do not approve edits or decisions."
   };
 }
@@ -4742,10 +5181,10 @@ async function installedAutomation(dir) {
   for (const host of ["claude", "codex"]) {
     const expected = record.hosts[host];
     if (!expected) continue;
-    const current = automationConfigSchema.parse(await readStoreJson(ws.root, configPath(host)) ?? {});
+    const current = automationConfigSchema.parse(await readStoreJson(ws.root, configPath2(host)) ?? {});
     const configuredEvents = HOOK_EVENTS.filter((event) => current.hooks?.[event]?.some((group) => group.hooks.some((handler) => handler.type === "command" && handler.command === expected.command)));
     result[host] = {
-      configPath: configPath(host),
+      configPath: configPath2(host),
       configuredEvents,
       status: current.disableAllHooks === true ? "disabled" : configuredEvents.length === HOOK_EVENTS.length ? "configured" : "incomplete",
       runtime: "Host version, trust, policy, and tool coverage still determine execution; inspect observed events."
@@ -4753,7 +5192,7 @@ async function installedAutomation(dir) {
   }
   return result;
 }
-var groupSchema, automationConfigSchema, recordSchema2, AUTOMATION_PATH, configPath;
+var groupSchema, automationConfigSchema, recordSchema2, AUTOMATION_PATH, configPath2;
 var init_install = __esm({
   "src/automation/install.ts"() {
     "use strict";
@@ -4763,11 +5202,11 @@ var init_install = __esm({
     init_store();
     init_files2();
     init_ownership();
-    groupSchema = z17.object({ hooks: z17.array(z17.object({ type: z17.string(), command: z17.string().optional() }).passthrough()) }).passthrough();
-    automationConfigSchema = z17.object({ hooks: z17.record(z17.array(groupSchema)).optional() }).passthrough();
-    recordSchema2 = z17.object({ version: z17.literal(1), hosts: z17.record(z17.object({ command: z17.string() })) });
+    groupSchema = z19.object({ hooks: z19.array(z19.object({ type: z19.string(), command: z19.string().optional() }).passthrough()) }).passthrough();
+    automationConfigSchema = z19.object({ hooks: z19.record(z19.array(groupSchema)).optional() }).passthrough();
+    recordSchema2 = z19.object({ version: z19.literal(1), hosts: z19.record(z19.object({ command: z19.string() })) });
     AUTOMATION_PATH = ".mason/local/automation.json";
-    configPath = (host) => host === "claude" ? ".claude/settings.json" : ".codex/hooks.json";
+    configPath2 = (host) => host === "claude" ? ".claude/settings.json" : ".codex/hooks.json";
   }
 });
 
@@ -4778,11 +5217,11 @@ __export(teardown_exports, {
   teardownProject: () => teardownProject
 });
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
-import fs20 from "fs/promises";
+import fs21 from "fs/promises";
 import path26 from "path";
 import { parse as parse3, stringify as stringify2 } from "smol-toml";
 import fg8 from "fast-glob";
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 async function planTeardown(root, selected) {
   const edits = [], diagnostics = [];
   const inputs = /* @__PURE__ */ new Map();
@@ -4801,7 +5240,7 @@ async function planTeardown(root, selected) {
   const ownership = ownershipBefore === null ? { version: 1, files: {} } : ownershipSchema.parse(JSON.parse(ownershipBefore));
   const setupBefore = await read(SETUP_PATH);
   const setup = setupBefore === null ? null : setupSchema.parse(JSON.parse(setupBefore));
-  const linked = (await workspace(root)).gitDir !== await fs20.realpath(
+  const linked = (await workspace(root)).gitDir !== await fs21.realpath(
     path26.resolve(root, (await git3(root, "rev-parse", "--git-common-dir")).trim())
   );
   const inactiveBefore = linked && !setup ? await read(INACTIVE_HOSTS_PATH) : null;
@@ -4810,16 +5249,16 @@ async function planTeardown(root, selected) {
   const automation = automationBefore === null ? null : recordSchema2.parse(JSON.parse(automationBefore));
   const commands2 = (host) => new Set([
     automation?.hosts[host]?.command,
-    ...ownership.files[configPath(host)]?.hookCommands ?? [],
+    ...ownership.files[configPath2(host)]?.hookCommands ?? [],
     ...knownManagedHookCommands(host),
     hookConfig(host, hookCommand(host)).hooks.SessionStart[0].hooks[0].command,
     hookConfig(host).hooks.SessionStart[0].hooks[0].command
   ].filter((command2) => !!command2));
   const possibleHook = (command2, host) => commands2(host).has(command2) || /\bmason(?:-auto|-hook)?\b/.test(command2);
-  const add = (file, before, after, empty) => {
-    edits.push({ path: file, before, after: ownership.files[file]?.created && (empty || ownership.files[file].initialHash === hash(before)) ? null : after });
+  const add = (file, before, after, empty2) => {
+    edits.push({ path: file, before, after: ownership.files[file]?.created && (empty2 || ownership.files[file].initialHash === hash(before)) ? null : after });
   };
-  let remainingHost = hosts.some((host) => !selected.includes(host) && (setup?.hosts[host] || automation?.hosts[host] || ownership.files[mcpPath(host)] || ownership.files[configPath(host)]));
+  let remainingHost = hosts.some((host) => !selected.includes(host) && (setup?.hosts[host] || automation?.hosts[host] || ownership.files[mcpPath(host)] || ownership.files[configPath2(host)]));
   for (const host of hosts.filter((host2) => !selected.includes(host2))) {
     await attempt(mcpPath(host), async () => {
       const text2 = await read(mcpPath(host));
@@ -4827,8 +5266,8 @@ async function planTeardown(root, selected) {
       const servers = object2.parse((host === "codex" ? config.mcp_servers : config.mcpServers) ?? {});
       remainingHost ||= servers.mason !== void 0;
     });
-    await attempt(configPath(host), async () => {
-      const config = automationConfigSchema.parse(JSON.parse(await read(configPath(host)) ?? "{}"));
+    await attempt(configPath2(host), async () => {
+      const config = automationConfigSchema.parse(JSON.parse(await read(configPath2(host)) ?? "{}"));
       remainingHost ||= Object.values(config.hooks ?? {}).some((groups) => groups.some((group) => group.hooks.some((handler) => handler.command && possibleHook(handler.command, host))));
     });
   }
@@ -4870,7 +5309,7 @@ async function planTeardown(root, selected) {
       if (!isDeepStrictEqual2(parsed, desired)) throw new Error("Removing the marked block would change other TOML settings; retained for manual cleanup.");
       add(mcpFile, before, after, !after.trim());
     });
-    const hookFile = configPath(host);
+    const hookFile = configPath2(host);
     await attempt(hookFile, async () => {
       const before = await read(hookFile);
       if (before === null) return;
@@ -4938,7 +5377,7 @@ async function planTeardown(root, selected) {
     if (!remainingHost) await attempt(".mason/local/project.json", async () => {
       const before = await read(".mason/local/project.json");
       if (before === null) return;
-      z18.object({ version: z18.literal(1), initializedAt: z18.string() }).strict().parse(JSON.parse(before));
+      z20.object({ version: z20.literal(1), initializedAt: z20.string() }).strict().parse(JSON.parse(before));
       cleanup.push({ path: ".mason/local/project.json", before, after: null });
     });
     if (!diagnostics.length) {
@@ -4946,7 +5385,7 @@ async function planTeardown(root, selected) {
         if (setup) delete setup.hosts[host];
         if (automation) delete automation.hosts[host];
         delete ownership.files[mcpPath(host)];
-        delete ownership.files[configPath(host)];
+        delete ownership.files[configPath2(host)];
       }
       if (!remainingHost) for (const file of DOC_CANDIDATES) delete ownership.files[file];
       if (setupBefore !== null) cleanup.push({
@@ -5019,7 +5458,7 @@ var init_teardown = __esm({
     init_model();
     init_ownership();
     hosts = ["codex", "claude"];
-    object2 = z18.record(z18.unknown());
+    object2 = z20.record(z20.unknown());
     json = (value) => JSON.stringify(value, null, 2) + "\n";
   }
 });
@@ -5146,7 +5585,7 @@ var init_types2 = __esm({
 });
 
 // src/review/evidence/vitest.ts
-import { z as z19 } from "zod";
+import { z as z21 } from "zod";
 function parseVitest(raw, sourceRoot) {
   const report = schema.parse(raw);
   const findings = [], diagnostics = [];
@@ -5195,24 +5634,24 @@ var init_vitest = __esm({
     "use strict";
     init_paths2();
     init_types2();
-    count3 = z19.number().int().nonnegative();
-    schema = z19.object({
-      success: z19.boolean(),
+    count3 = z21.number().int().nonnegative();
+    schema = z21.object({
+      success: z21.boolean(),
       numTotalTests: count3,
       numPassedTests: count3,
       numFailedTests: count3,
       numPendingTests: count3,
       numTodoTests: count3,
       numFailedTestSuites: count3,
-      testResults: z19.array(z19.object({
-        name: z19.string().min(1),
-        status: z19.enum(["passed", "failed"]),
-        message: z19.string().optional(),
-        assertionResults: z19.array(z19.object({
-          fullName: z19.string(),
-          status: z19.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
-          failureMessages: z19.array(z19.string()).nullable().optional(),
-          location: z19.object({ line: count3, column: count3 }).nullable().optional()
+      testResults: z21.array(z21.object({
+        name: z21.string().min(1),
+        status: z21.enum(["passed", "failed"]),
+        message: z21.string().optional(),
+        assertionResults: z21.array(z21.object({
+          fullName: z21.string(),
+          status: z21.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
+          failureMessages: z21.array(z21.string()).nullable().optional(),
+          location: z21.object({ line: count3, column: count3 }).nullable().optional()
         }))
       }))
     });
@@ -5220,7 +5659,7 @@ var init_vitest = __esm({
 });
 
 // src/review/evidence/sarif.ts
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 function parseSarif(raw, sourceRoot) {
   const report = schema2.parse(raw), findings = [], diagnostics = [];
   let active = 0, suppressed = 0, absent = 0, unresolved = 0;
@@ -5311,29 +5750,29 @@ var init_sarif = __esm({
     "use strict";
     init_paths2();
     init_types2();
-    index = z20.number().int().nonnegative();
-    artifact = z20.object({ uri: z20.string().optional(), uriBaseId: z20.string().optional(), index: index.optional() });
-    message = z20.object({ text: z20.string().optional(), markdown: z20.string().optional(), id: z20.string().optional(), arguments: z20.array(z20.string()).optional() });
-    level = z20.enum(["error", "warning", "note", "none"]);
-    location = z20.object({ physicalLocation: z20.object({ artifactLocation: artifact.optional(), region: z20.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
-    schema2 = z20.object({
-      version: z20.literal("2.1.0"),
-      runs: z20.array(z20.object({
-        tool: z20.object({ driver: z20.object({ name: z20.string().min(1), rules: z20.array(z20.object({ id: z20.string(), defaultConfiguration: z20.object({ level: level.optional() }).optional(), messageStrings: z20.record(message).optional() })).optional(), globalMessageStrings: z20.record(message).optional() }) }),
-        invocations: z20.array(z20.object({ executionSuccessful: z20.boolean(), commandLine: z20.string().optional(), toolExecutionNotifications: z20.array(z20.object({ level: level.optional(), message })).optional() })).optional(),
-        versionControlProvenance: z20.array(z20.object({ revisionId: z20.string().optional() })).optional(),
-        originalUriBaseIds: z20.record(artifact).optional(),
-        artifacts: z20.array(z20.object({ location: artifact.optional() })).optional(),
-        results: z20.array(z20.object({
-          ruleId: z20.string().optional(),
+    index = z22.number().int().nonnegative();
+    artifact = z22.object({ uri: z22.string().optional(), uriBaseId: z22.string().optional(), index: index.optional() });
+    message = z22.object({ text: z22.string().optional(), markdown: z22.string().optional(), id: z22.string().optional(), arguments: z22.array(z22.string()).optional() });
+    level = z22.enum(["error", "warning", "note", "none"]);
+    location = z22.object({ physicalLocation: z22.object({ artifactLocation: artifact.optional(), region: z22.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
+    schema2 = z22.object({
+      version: z22.literal("2.1.0"),
+      runs: z22.array(z22.object({
+        tool: z22.object({ driver: z22.object({ name: z22.string().min(1), rules: z22.array(z22.object({ id: z22.string(), defaultConfiguration: z22.object({ level: level.optional() }).optional(), messageStrings: z22.record(message).optional() })).optional(), globalMessageStrings: z22.record(message).optional() }) }),
+        invocations: z22.array(z22.object({ executionSuccessful: z22.boolean(), commandLine: z22.string().optional(), toolExecutionNotifications: z22.array(z22.object({ level: level.optional(), message })).optional() })).optional(),
+        versionControlProvenance: z22.array(z22.object({ revisionId: z22.string().optional() })).optional(),
+        originalUriBaseIds: z22.record(artifact).optional(),
+        artifacts: z22.array(z22.object({ location: artifact.optional() })).optional(),
+        results: z22.array(z22.object({
+          ruleId: z22.string().optional(),
           ruleIndex: index.optional(),
           message,
           level: level.optional(),
-          kind: z20.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
-          baselineState: z20.enum(["new", "unchanged", "updated", "absent"]).optional(),
-          suppressions: z20.array(z20.object({ kind: z20.enum(["inSource", "external"]), status: z20.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
-          locations: z20.array(location).optional(),
-          relatedLocations: z20.array(location).optional()
+          kind: z22.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
+          baselineState: z22.enum(["new", "unchanged", "updated", "absent"]).optional(),
+          suppressions: z22.array(z22.object({ kind: z22.enum(["inSource", "external"]), status: z22.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
+          locations: z22.array(location).optional(),
+          relatedLocations: z22.array(location).optional()
         })).optional()
       }))
     });
@@ -5341,7 +5780,7 @@ var init_sarif = __esm({
 });
 
 // src/review/evidence/check.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "zod";
 function parseCheck(raw, sourceRoot) {
   const report = schema3.parse(raw);
   const diagnostics = [], findings = [];
@@ -5381,17 +5820,17 @@ var init_check = __esm({
     "use strict";
     init_paths2();
     init_types2();
-    schema3 = z21.object({
-      version: z21.literal(1),
-      commit: z21.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).optional(),
-      results: z21.array(z21.object({
-        name: z21.string().min(1).max(1e3),
-        status: z21.enum(["passed", "failed", "skipped"]),
-        message: z21.string().max(1e5).optional(),
-        locations: z21.array(z21.object({
-          file: z21.string().min(1).max(4e3),
-          line: z21.number().int().positive().optional(),
-          column: z21.number().int().positive().optional()
+    schema3 = z23.object({
+      version: z23.literal(1),
+      commit: z23.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).optional(),
+      results: z23.array(z23.object({
+        name: z23.string().min(1).max(1e3),
+        status: z23.enum(["passed", "failed", "skipped"]),
+        message: z23.string().max(1e5).optional(),
+        locations: z23.array(z23.object({
+          file: z23.string().min(1).max(4e3),
+          line: z23.number().int().positive().optional(),
+          column: z23.number().int().positive().optional()
         })).max(100).default([])
       })).max(1e5)
     });
@@ -5400,7 +5839,7 @@ var init_check = __esm({
 
 // src/review/evidence.ts
 import path27 from "path";
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 function relativeArtifact(root, file) {
   const relative = path27.isAbsolute(file) ? path27.relative(root, file) : file;
   const normalized = normalizeRepoPath(relative);
@@ -5441,7 +5880,7 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
     let manifest, raw;
     try {
       manifest = relativeArtifact(root, supplied);
-      raw = z22.object({ version: z22.literal(1), checks: z22.array(z22.unknown()) }).parse(await readStoreJson(root, manifest));
+      raw = z24.object({ version: z24.literal(1), checks: z24.array(z24.unknown()) }).parse(await readStoreJson(root, manifest));
     } catch (error) {
       output.diagnostics.push(`${supplied}: ${String(error)}`);
       continue;
@@ -5596,31 +6035,31 @@ var init_evidence2 = __esm({
     init_sarif();
     init_check();
     init_types2();
-    checkSchema2 = z22.object({
-      id: z22.string().min(1).max(100),
-      kind: z22.enum(["tests", "static-analysis", "security", "complexity", "duplication", "documentation"]),
-      tool: z22.string().min(1).max(200),
-      command: z22.string().min(1).max(2e3),
-      commit: z22.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
-      workingTreeClean: z22.boolean().optional(),
-      source: z22.string().max(2e3).optional(),
-      sourceRoot: z22.string().min(1).max(4e3).optional(),
-      status: z22.enum(["completed", "skipped", "unavailable"]).default("completed"),
-      reason: z22.string().min(1).max(2e3).optional(),
-      exitCode: z22.number().int().nullable().optional(),
-      environment: z22.object({
-        toolVersion: z22.string().min(1).max(200),
-        runtime: z22.string().min(1).max(200).optional(),
-        platform: z22.string().min(1).max(200).optional(),
-        configuration: z22.array(z22.string().min(1).max(4e3)).max(100).optional()
+    checkSchema2 = z24.object({
+      id: z24.string().min(1).max(100),
+      kind: z24.enum(["tests", "static-analysis", "security", "complexity", "duplication", "documentation"]),
+      tool: z24.string().min(1).max(200),
+      command: z24.string().min(1).max(2e3),
+      commit: z24.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
+      workingTreeClean: z24.boolean().optional(),
+      source: z24.string().max(2e3).optional(),
+      sourceRoot: z24.string().min(1).max(4e3).optional(),
+      status: z24.enum(["completed", "skipped", "unavailable"]).default("completed"),
+      reason: z24.string().min(1).max(2e3).optional(),
+      exitCode: z24.number().int().nullable().optional(),
+      environment: z24.object({
+        toolVersion: z24.string().min(1).max(200),
+        runtime: z24.string().min(1).max(200).optional(),
+        platform: z24.string().min(1).max(200).optional(),
+        configuration: z24.array(z24.string().min(1).max(4e3)).max(100).optional()
       }).optional(),
-      report: z22.object({ format: z22.enum(["vitest-json", "sarif", "mason-check-json"]), path: z22.string().min(1).max(4e3) }).optional()
+      report: z24.object({ format: z24.enum(["vitest-json", "sarif", "mason-check-json"]), path: z24.string().min(1).max(4e3) }).optional()
     });
   }
 });
 
 // src/review/review.ts
-import fs21 from "fs/promises";
+import fs22 from "fs/promises";
 import path28 from "path";
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
@@ -5700,7 +6139,7 @@ async function computeReview(rootDir, base, options = {}) {
     analyzed,
     async (relPath) => {
       try {
-        await fs21.access(path28.join(resolvedRoot, relPath));
+        await fs22.access(path28.join(resolvedRoot, relPath));
         return true;
       } catch {
         return false;
@@ -5855,7 +6294,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." : "Project hooks are inactive until local setup. Run mason setup --host codex or --host claude."
+      next: pending.length ? "Setup did not finish. Rerun mason 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 hosts2 = {};
@@ -5889,7 +6328,7 @@ async function setupStatus(dir) {
     if (!mcp || !hooks || !instructionsCurrent || !configured) pending.push("Rerun setup to reconcile project configuration; inspect any disabled host settings.");
     if (!observation?.contextCalls) pending.push("Start a new assistant session and request task context through Mason's get_context tool.");
     if (!complete) pending.push("Review/trust the host configuration, then complete a normal task to observe the full hook lifecycle.");
-    if (automation.status === "unavailable") pending.push("The latest automation attempt did not establish verification. Run mason-auto check and inspect its diagnostics.");
+    if (automation.status === "unavailable") pending.push("The latest automation attempt did not establish verification. Run mason check and inspect its diagnostics.");
     const healthy = installed.available && mcp && hooks && instructionsCurrent && configured && automation.status !== "unavailable";
     hosts2[host] = {
       status: healthy ? complete && observation?.contextCalls ? "active" : "pending" : "attention",
@@ -6023,6 +6462,11 @@ async function setupProject(dir, options = {}) {
     options.progress?.step("Checking configuration and retained findings");
     const checked = await automate(ws.root, { event: "turn_start" });
     const configured = await inspectHostConfig(ws.root, host, void 0);
+    const stats = await configureUsefulness(ws.root, true, { onlyIfUnset: true }).catch(() => ({
+      enabled: null,
+      storage: ".mason/local/usefulness",
+      note: "Local stats unavailable. Inspect mason stats --json, or use mason stats --disable to reset the preference. Existing observations were retained."
+    }));
     await writeStoreJson(ws.root, receiptPath, {
       version: 1,
       host,
@@ -6045,6 +6489,7 @@ async function setupProject(dir, options = {}) {
       findings,
       reportPath: checked.report.reportPath,
       activation: await setupStatus(ws.root),
+      stats,
       next: configured.disabled || configured.mcpDisabled ? "Mason hooks or MCP are disabled in project configuration. Review that setting before activation." : host === "codex" ? "Review/trust this project's MCP configuration and hooks in Codex (/hooks in the CLI), then start a new session and give it a normal task." : "Approve the project MCP server in Claude Code, then start a new session and give it a normal task."
     };
   });
@@ -6056,18 +6501,20 @@ function summarizeSetup(result) {
     "  MCP server and lifecycle hooks use mason from PATH.",
     "  Project instructions updated; original audit evidence retained.",
     `  ${result.changedFiles.length} files changed.`,
+    result.stats.enabled === null ? result.stats.note : result.stats.enabled ? "Local stats enabled: metadata stays in .mason/local/usefulness/; nothing is uploaded. View with mason stats; disable with mason stats --disable." : "Local stats remain disabled by your saved preference. Enable with mason stats --enable.",
     `Initial audit: ${audit.status}${"counts" in audit ? `; ${audit.counts.issues} issues, ${audit.counts.advisories + audit.counts.suppressedAdvisories} advisories` : ""}.`,
     ..."issues" in audit ? audit.issues.slice(0, 3).map((f) => "  " + f.message) : [],
     `Original evidence: ${result.initialReportPath}`,
     "Activation: " + result.activation.status + ".",
     result.next,
     "If the assistant cannot find mason, restart the desktop app so it picks up PATH.",
-    "After the task finishes, run mason-auto status. Configuration alone does not establish activation."
+    "After the task finishes, run mason status. Configuration alone does not establish activation."
   ].join("\n");
 }
 var init_setup = __esm({
   "src/setup/setup.ts"() {
     "use strict";
+    init_usefulness();
     init_evidence();
     init_store();
     init_runtime();
@@ -6084,13 +6531,13 @@ var init_setup = __esm({
 });
 
 // src/distribution/path.ts
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import os3 from "os";
 import path29 from "path";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify5 } from "util";
 import { createHash as createHash4, randomUUID as randomUUID7 } from "crypto";
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 async function configurePath(bin, previous, save, options = {}) {
   const env = options.env ?? process.env, platform = options.platform ?? process.platform;
   const changes = [...previous];
@@ -6125,7 +6572,7 @@ ${alreadyOnPath ? "" : `Add ${bin} to your PATH.
     else {
       const candidates = [".bash_profile", ".bash_login", ".profile"].map((name) => path29.join(userHome, name));
       let login = candidates[2];
-      for (const file of candidates) if (await fs22.lstat(file).then(() => true, (error) => {
+      for (const file of candidates) if (await fs23.lstat(file).then(() => true, (error) => {
         if (error.code === "ENOENT") return false;
         throw error;
       })) {
@@ -6136,12 +6583,12 @@ ${alreadyOnPath ? "" : `Add ${bin} to your PATH.
     }
     const marker = `# >>> mason PATH ${createHash4("sha256").update(bin).digest("hex").slice(0, 12)} >>>`;
     for (const profile of profiles2) {
-      const stat = await fs22.lstat(profile).catch((error) => {
+      const stat = await fs23.lstat(profile).catch((error) => {
         if (error.code === "ENOENT") return null;
         throw error;
       });
-      const file = stat?.isSymbolicLink() ? await fs22.realpath(profile) : path29.resolve(profile);
-      const original = await fs22.readFile(file).catch((error) => {
+      const file = stat?.isSymbolicLink() ? await fs23.realpath(profile) : path29.resolve(profile);
+      const original = await fs23.readFile(file).catch((error) => {
         if (error.code === "ENOENT" && !stat) return null;
         throw error;
       });
@@ -6156,8 +6603,8 @@ ${alreadyOnPath ? "" : `Add ${bin} to your PATH.
         changes.push({ kind: "profile", file, block, created: original === null });
         await save(changes);
       }
-      await fs22.mkdir(path29.dirname(file), { recursive: true });
-      const handle = await fs22.open(file, original === null ? "ax+" : "a+", 384);
+      await fs23.mkdir(path29.dirname(file), { recursive: true });
+      const handle = await fs23.open(file, original === null ? "ax+" : "a+", 384);
       try {
         if (!(await handle.readFile()).equals(original ?? Buffer.alloc(0))) throw new Error(`Shell profile changed during installation: ${profile}`);
         await handle.writeFile(block);
@@ -6181,13 +6628,13 @@ async function removePath(changes) {
         await windowsPath("remove", change.entry, current, change.created);
         continue;
       }
-      const stat = await fs22.lstat(change.file).catch((error) => {
+      const stat = await fs23.lstat(change.file).catch((error) => {
         if (error.code === "ENOENT") return null;
         throw error;
       });
       if (!stat) continue;
       if (!stat.isFile()) throw new Error("profile type changed");
-      const bytes = await fs22.readFile(change.file), text2 = bytes.toString("utf8");
+      const bytes = await fs23.readFile(change.file), text2 = bytes.toString("utf8");
       if (!Buffer.from(text2).equals(bytes)) throw new Error("profile encoding changed");
       const index2 = text2.indexOf(change.block);
       if (index2 < 0 || text2.indexOf(change.block, index2 + change.block.length) >= 0) throw new Error("PATH block was edited or removed");
@@ -6197,7 +6644,7 @@ async function removePath(changes) {
       const temporary = change.file + ".mason-" + randomUUID7();
       try {
         if (stat.nlink > 1) throw new Error("profile has multiple hard links");
-        const handle = await fs22.open(temporary, "wx", stat.mode & 511);
+        const handle = await fs23.open(temporary, "wx", stat.mode & 511);
         try {
           await handle.writeFile(next);
           await handle.chmod(stat.mode & 511);
@@ -6206,11 +6653,11 @@ async function removePath(changes) {
         } finally {
           await handle.close();
         }
-        const current = await fs22.lstat(change.file);
-        if (!current.isFile() || current.ino !== stat.ino || !(await fs22.readFile(change.file)).equals(bytes)) throw new Error("profile changed during uninstall");
-        await fs22.rename(temporary, change.file);
+        const current = await fs23.lstat(change.file);
+        if (!current.isFile() || current.ino !== stat.ino || !(await fs23.readFile(change.file)).equals(bytes)) throw new Error("profile changed during uninstall");
+        await fs23.rename(temporary, change.file);
       } finally {
-        await fs22.rm(temporary, { force: true });
+        await fs23.rm(temporary, { force: true });
       }
     } catch (error) {
       warnings.push(`Retained PATH setting ${change.kind === "profile" ? change.file : change.entry}: ${error instanceof Error ? error.message : String(error)}`);
@@ -6252,9 +6699,9 @@ var init_path = __esm({
   "src/distribution/path.ts"() {
     "use strict";
     execute2 = promisify5(execFile5);
-    pathChangeSchema = z23.discriminatedUnion("kind", [
-      z23.object({ kind: z23.literal("profile"), file: z23.string(), block: z23.string(), created: z23.boolean() }),
-      z23.object({ kind: z23.literal("windows"), entry: z23.string(), created: z23.boolean() })
+    pathChangeSchema = z25.discriminatedUnion("kind", [
+      z25.object({ kind: z25.literal("profile"), file: z25.string(), block: z25.string(), created: z25.boolean() }),
+      z25.object({ kind: z25.literal("windows"), entry: z25.string(), created: z25.boolean() })
     ]);
     quote = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
     normalizeWindowsEntry = (value) => path29.win32.normalize(value.trim().replace(/^"(.*)"$/, "$1")).replace(/[\\/]+$/, "").toLowerCase();
@@ -6282,13 +6729,13 @@ __export(state_exports, {
 import os4 from "os";
 import path30 from "path";
 import { fileURLToPath } from "url";
-import fs23 from "fs/promises";
-import { z as z24 } from "zod";
+import fs24 from "fs/promises";
+import { z as z26 } from "zod";
 async function readInstallation(home) {
   const raw = await readStoreJson(home, "install.json");
   if (!raw) throw new Error("Run this command from a standalone installation. npm users can upgrade with npm.");
   const record = recordSchema3.parse(raw);
-  if (record.home !== await fs23.realpath(home)) throw new Error("Invalid standalone installation receipt.");
+  if (record.home !== await fs24.realpath(home)) throw new Error("Invalid standalone installation receipt.");
   return record;
 }
 function standaloneLocation() {
@@ -6323,38 +6770,38 @@ var init_state = __esm({
     "use strict";
     init_storage();
     init_path();
-    releaseVersion = z24.string().regex(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/);
-    bundleId = z24.string().regex(/^[a-f0-9]{24}$/);
-    updatePolicySchema = z24.object({
-      enabled: z24.boolean(),
-      revision: z24.string(),
+    releaseVersion = z26.string().regex(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/);
+    bundleId = z26.string().regex(/^[a-f0-9]{24}$/);
+    updatePolicySchema = z26.object({
+      enabled: z26.boolean(),
+      revision: z26.string(),
       pinnedVersion: releaseVersion.optional(),
-      mirror: z24.string().optional()
+      mirror: z26.string().optional()
     });
-    recordSchema3 = z24.object({
-      format: z24.literal(1),
-      home: z24.string(),
-      bin: z24.string(),
+    recordSchema3 = z26.object({
+      format: z26.literal(1),
+      home: z26.string(),
+      bin: z26.string(),
       current: bundleId,
       version: releaseVersion,
-      launchers: z24.record(z24.string()),
-      previousLaunchers: z24.record(z24.string()).optional(),
-      pathChanges: z24.array(pathChangeSchema).optional(),
+      launchers: z26.record(z26.string()),
+      previousLaunchers: z26.record(z26.string()).optional(),
+      pathChanges: z26.array(pathChangeSchema).optional(),
       updates: updatePolicySchema.optional(),
-      previous: z24.object({ id: bundleId, version: releaseVersion }).optional(),
-      pending: z24.object({ id: bundleId, version: releaseVersion, policyRevision: z24.string() }).optional()
+      previous: z26.object({ id: bundleId, version: releaseVersion }).optional(),
+      pending: z26.object({ id: bundleId, version: releaseVersion, policyRevision: z26.string() }).optional()
     });
     defaultHome = () => process.env.MASON_HOME ?? (process.platform === "win32" ? path30.join(process.env.LOCALAPPDATA ?? os4.homedir(), "Mason") : path30.join(os4.homedir(), ".local/share/mason"));
   }
 });
 
 // src/distribution/bundle.ts
-import fs24 from "fs/promises";
+import fs25 from "fs/promises";
 import path31 from "path";
 import { createHash as createHash5 } from "crypto";
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 async function readBundle(root) {
-  const bytes = await fs24.readFile(await storePath(root, "bundle.json"));
+  const bytes = await fs25.readFile(await storePath(root, "bundle.json"));
   const manifest = bundleSchema.parse(JSON.parse(bytes.toString("utf8")));
   const windows = manifest.target.startsWith("win32-");
   for (const file of Object.keys(manifest.files)) {
@@ -6362,7 +6809,7 @@ async function readBundle(root) {
       throw new Error("Unsafe path in Mason bundle: " + file);
     }
   }
-  for (const required of [windows ? "node.exe" : "node", "app/package.json", "app/dist/mason.js", "app/dist/mason-auto.js", "app/dist/mason-mcp.js"]) {
+  for (const required of [windows ? "node.exe" : "node", "app/package.json", "app/dist/mason.js", "app/dist/mason-mcp.js"]) {
     if (!manifest.files[required]) throw new Error("Incomplete Mason bundle: " + required);
   }
   return { manifest, manifestHash: sha256(bytes) };
@@ -6373,7 +6820,7 @@ async function verifyBundle(root, expectedHash) {
   if (bundle.manifest.target !== `${process.platform}-${process.arch}`) throw new Error("Mason bundle is for another platform. Install this platform's bundle and rerun setup.");
   const files = Object.keys(bundle.manifest.files);
   for (let i = 0; i < files.length; i += 8) await Promise.all(files.slice(i, i + 8).map(async (file) => {
-    if (sha256(await fs24.readFile(await storePath(root, file))) !== bundle.manifest.files[file]) throw new Error("Mason bundle checksum mismatch: " + file);
+    if (sha256(await fs25.readFile(await storePath(root, file))) !== bundle.manifest.files[file]) throw new Error("Mason bundle checksum mismatch: " + file);
   }));
   return bundle;
 }
@@ -6383,40 +6830,56 @@ var init_bundle = __esm({
     "use strict";
     init_storage();
     targets = ["darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "win32-arm64", "win32-x64"];
-    digest2 = z25.string().regex(/^[a-f0-9]{64}$/);
-    bundleSchema = z25.object({
-      format: z25.literal(1),
-      version: z25.string().regex(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/),
-      target: z25.enum(targets),
-      nodeVersion: z25.string(),
-      files: z25.record(digest2)
+    digest2 = z27.string().regex(/^[a-f0-9]{64}$/);
+    bundleSchema = z27.object({
+      format: z27.literal(1),
+      version: z27.string().regex(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/),
+      target: z27.enum(targets),
+      nodeVersion: z27.string(),
+      files: z27.record(digest2)
     }).strict();
     sha256 = (bytes) => createHash5("sha256").update(bytes).digest("hex");
   }
 });
 
+// src/distribution/trust.ts
+import tls from "tls";
+function releaseRequestError(error) {
+  const cause = error instanceof Error ? error.cause : void 0;
+  const code = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : void 0;
+  const detail = code ?? (error instanceof Error ? error.message : String(error));
+  const certificateError = code && /CERT|SELF_SIGNED|UNABLE_TO_VERIFY_LEAF_SIGNATURE/.test(code);
+  const hint = certificateError ? " Check that your company's CA certificate is trusted by your operating system, or provide its PEM file with NODE_EXTRA_CA_CERTS." : " Check network and proxy access to GitHub.";
+  return new Error(`Could not check the latest Mason release on GitHub (${detail}).${hint}`, { cause: error });
+}
+var init_trust2 = __esm({
+  "src/distribution/trust.ts"() {
+    "use strict";
+  }
+});
+
 // src/distribution/runtime.ts
-import fs25 from "fs/promises";
+import fs26 from "fs/promises";
 import { unlinkSync } from "fs";
 import os5 from "os";
 import path32 from "path";
 import { randomUUID as randomUUID8 } from "crypto";
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 async function pruneUnusedVersions(home) {
   const versions = await storePath(home, "versions");
   const candidates = [];
   const initial = await readInstallation(home);
   const initialKeep = /* @__PURE__ */ new Set([initial.current, initial.previous?.id, initial.pending?.id]);
-  for (const name of await fs25.readdir(versions)) {
+  for (const name of await fs26.readdir(versions)) {
     const retired = /^\.retired-([a-f0-9]{24})-[a-f0-9-]+$/.exec(name);
     const id = retired?.[1] ?? name;
     if (!/^[a-f0-9]{24}$/.test(id) || initialKeep.has(id)) continue;
     try {
-      const directory = await storePath(home, `versions/${name}`);
-      await fs25.access(await storePath(directory, "app/dist/mason-runtime.js"));
-      const bundle = await verifyBundle(directory);
+      const directory2 = await storePath(home, `versions/${name}`);
+      await fs26.access(await storePath(directory2, "app/dist/mason-runtime.js"));
+      const bundle = await verifyBundle(directory2);
       if (bundle.manifestHash.slice(0, 24) === id && bundle.manifest.files["app/dist/mason-runtime.js"])
-        candidates.push({ id, directory, retired: !!retired });
+        candidates.push({ id, directory: directory2, retired: !!retired });
     } catch {
     }
   }
@@ -6425,8 +6888,8 @@ async function pruneUnusedVersions(home) {
   await withLock(home, ".install-lock", async () => {
     const record = await readInstallation(home);
     const keep = /* @__PURE__ */ new Set([record.current, record.previous?.id, record.pending?.id]);
-    const directory = await storePath(home, "runtimes");
-    const leases = await fs25.readdir(directory).catch((error) => {
+    const directory2 = await storePath(home, "runtimes");
+    const leases = await fs26.readdir(directory2).catch((error) => {
       if (error.code === "ENOENT") return [];
       throw error;
     });
@@ -6442,7 +6905,7 @@ async function pruneUnusedVersions(home) {
           keep.add(lease.bundle);
         } catch (error) {
           if (error.code !== "ESRCH") return;
-          await fs25.rm(await storePath(home, `runtimes/${name}`), { force: true });
+          await fs26.rm(await storePath(home, `runtimes/${name}`), { force: true });
         }
       } catch {
         return;
@@ -6452,13 +6915,13 @@ async function pruneUnusedVersions(home) {
       if (keep.has(candidate.id)) continue;
       try {
         const retired = candidate.retired ? candidate.directory : await storePath(home, `versions/.retired-${candidate.id}-${randomUUID8()}`);
-        if (!candidate.retired) await fs25.rename(candidate.directory, retired);
+        if (!candidate.retired) await fs26.rename(candidate.directory, retired);
         garbage.push(retired);
       } catch {
       }
     }
   });
-  for (const directory of garbage) await fs25.rm(directory, { recursive: true }).catch(() => {
+  for (const directory2 of garbage) await fs26.rm(directory2, { recursive: true }).catch(() => {
   });
 }
 var leaseSchema;
@@ -6469,18 +6932,19 @@ var init_runtime2 = __esm({
     init_storage();
     init_state();
     init_bundle();
-    leaseSchema = z26.object({ pid: z26.number().int().positive(), host: z26.string(), bundle: z26.string().regex(/^[a-f0-9]{24}$/) });
+    init_trust2();
+    leaseSchema = z28.object({ pid: z28.number().int().positive(), host: z28.string(), bundle: z28.string().regex(/^[a-f0-9]{24}$/) });
   }
 });
 
 // src/distribution/sessions.ts
-import fs26 from "fs/promises";
+import fs27 from "fs/promises";
 import os6 from "os";
 import { randomUUID as randomUUID9 } from "crypto";
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 async function hasRunningMcp(home) {
-  const directory = await storePath(home, "sessions");
-  const files = await fs26.readdir(directory).catch((error) => {
+  const directory2 = await storePath(home, "sessions");
+  const files = await fs27.readdir(directory2).catch((error) => {
     if (error.code === "ENOENT") return [];
     throw error;
   });
@@ -6498,7 +6962,7 @@ async function hasRunningMcp(home) {
       } catch (error) {
         if (error.code !== "ESRCH") return true;
       }
-      await fs26.rm(await storePath(home, relative), { force: true });
+      await fs27.rm(await storePath(home, relative), { force: true });
     } catch {
       return true;
     }
@@ -6509,7 +6973,7 @@ async function registerMcp(home) {
   const name = `sessions/${randomUUID9()}.json`;
   await writeStoreJson(home, name, { pid: process.pid, host: os6.hostname() });
   return async () => {
-    await fs26.rm(await storePath(home, name), { force: true }).catch(() => {
+    await fs27.rm(await storePath(home, name), { force: true }).catch(() => {
     });
   };
 }
@@ -6518,7 +6982,7 @@ var init_sessions = __esm({
   "src/distribution/sessions.ts"() {
     "use strict";
     init_storage();
-    leaseSchema2 = z27.object({ pid: z27.number().int().positive(), host: z27.string() });
+    leaseSchema2 = z29.object({ pid: z29.number().int().positive(), host: z29.string() });
   }
 });
 
@@ -6533,7 +6997,7 @@ __export(install_exports2, {
   uninstallStandalone: () => uninstallStandalone,
   upgradeStandalone: () => upgradeStandalone
 });
-import fs27 from "fs/promises";
+import fs28 from "fs/promises";
 import os7 from "os";
 import path33 from "path";
 import { execFile as execFile6, spawn } from "child_process";
@@ -6542,18 +7006,18 @@ import { randomUUID as randomUUID10 } from "crypto";
 async function replace(file, content2, mode = 384) {
   const temp = file + ".tmp-" + randomUUID10();
   try {
-    await fs27.writeFile(temp, content2, { mode, flag: "wx" });
-    await fs27.rename(temp, file);
+    await fs28.writeFile(temp, content2, { mode, flag: "wx" });
+    await fs28.rename(temp, file);
   } finally {
-    await fs27.rm(temp, { force: true });
+    await fs28.rm(temp, { force: true });
   }
 }
 async function installStandalone(source, progress2, options = {}) {
   progress2?.step("Checking installation files and location");
   const bundle = await verifyBundle(source);
   const selectedHome = path33.resolve(defaultHome());
-  if (!options.stageOnly) await fs27.mkdir(selectedHome, { recursive: true });
-  const home = await fs27.realpath(selectedHome);
+  if (!options.stageOnly) await fs28.mkdir(selectedHome, { recursive: true });
+  const home = await fs28.realpath(selectedHome);
   if (options.stageOnly) {
     assertUpdatePolicy(await readInstallation(home), bundle.manifest.version, options.policyRevision);
     const destination = await storePath(home, "versions/" + bundle.manifestHash.slice(0, 24));
@@ -6576,17 +7040,17 @@ async function installLocked2(home, source, bundle, progress2, options, alreadyS
   const raw = await readStoreJson(home, "install.json");
   const previous = raw === null ? null : recordSchema3.parse(raw);
   if (options.stageOnly) assertUpdatePolicy(previous, bundle.manifest.version, options.policyRevision);
-  if (!previous) for (const file of await fs27.readdir(home)) {
+  if (!previous) for (const file of await fs28.readdir(home)) {
     if (file === ".install-lock") continue;
-    const directory = path33.join(home, file);
-    const stat = await fs27.lstat(directory);
-    if (!["versions", "bin"].includes(file) || !stat.isDirectory() || (await fs27.readdir(directory)).length) {
+    const directory2 = path33.join(home, file);
+    const stat = await fs28.lstat(directory2);
+    if (!["versions", "bin"].includes(file) || !stat.isDirectory() || (await fs28.readdir(directory2)).length) {
       throw new Error("Mason installation directory is not empty and has no ownership receipt.");
     }
   }
   const selectedBin = path33.resolve(process.env.MASON_BIN_DIR ?? previous?.bin ?? (process.platform === "win32" ? path33.join(home, "bin") : path33.join(os7.homedir(), ".local/bin")));
-  await fs27.mkdir(selectedBin, { recursive: true });
-  const bin = await fs27.realpath(selectedBin);
+  await fs28.mkdir(selectedBin, { recursive: true });
+  const bin = await fs28.realpath(selectedBin);
   if (previous && (previous.home !== home || previous.bin !== bin)) throw new Error("Installation paths differ from the existing Mason receipt.");
   const id = bundle.manifestHash.slice(0, 24);
   const destination = await storePath(home, "versions/" + id);
@@ -6618,7 +7082,7 @@ exec ${shQuote(path33.join(destination, "node"))} ${shQuote(path33.join(destinat
 ` };
   for (const [name, content2] of Object.entries(launchers)) {
     const file = await storePath(bin, name);
-    const old = await fs27.readFile(file, "utf8").catch((error) => {
+    const old = await fs28.readFile(file, "utf8").catch((error) => {
       if (error.code === "ENOENT") return null;
       throw error;
     });
@@ -6627,7 +7091,7 @@ exec ${shQuote(path33.join(destination, "node"))} ${shQuote(path33.join(destinat
   const retired = Object.entries({ ...previous?.previousLaunchers, ...previous?.launchers }).filter(([name]) => !(name in launchers));
   const checkRetired = async (name, expected) => {
     if (!launcherNames.includes(name)) throw new Error("Invalid owned launcher name.");
-    const actual = await fs27.readFile(await storePath(bin, name), "utf8").catch((error) => {
+    const actual = await fs28.readFile(await storePath(bin, name), "utf8").catch((error) => {
       if (error.code === "ENOENT") return null;
       throw error;
     });
@@ -6662,7 +7126,7 @@ exec ${shQuote(path33.join(destination, "node"))} ${shQuote(path33.join(destinat
     for (const [name, content2] of Object.entries(launchers)) await replace(await storePath(bin, name, true), content2, 493);
     for (const [name, expected] of retired) {
       await checkRetired(name, expected);
-      await fs27.rm(await storePath(bin, name), { force: true });
+      await fs28.rm(await storePath(bin, name), { force: true });
     }
     await writeStoreJson(home, "install.json", receipt);
   } catch (error) {
@@ -6681,7 +7145,7 @@ exec ${shQuote(path33.join(destination, "node"))} ${shQuote(path33.join(destinat
   return { home, bin, version: bundle.manifest.version, previousVersion: previous?.version, path: pathResult };
 }
 async function copyBundle(home, source, destination, bundle) {
-  const exists = await fs27.lstat(destination).then(() => true, (error) => {
+  const exists = await fs28.lstat(destination).then(() => true, (error) => {
     if (error.code === "ENOENT") return false;
     throw error;
   });
@@ -6690,16 +7154,16 @@ async function copyBundle(home, source, destination, bundle) {
     return;
   }
   const stage = await storePath(home, "versions/.install-" + randomUUID10(), true);
-  await fs27.mkdir(stage);
+  await fs28.mkdir(stage);
   try {
     for (const file of ["bundle.json", ...Object.keys(bundle.manifest.files)]) {
       const from = await storePath(source, file), to = await storePath(stage, file, true);
-      await fs27.copyFile(from, to);
-      await fs27.chmod(to, (await fs27.stat(from)).mode & 511);
+      await fs28.copyFile(from, to);
+      await fs28.chmod(to, (await fs28.stat(from)).mode & 511);
     }
     await verifyBundle(stage, bundle.manifestHash);
     try {
-      await fs27.rename(stage, destination);
+      await fs28.rename(stage, destination);
     } catch (error) {
       try {
         await verifyBundle(destination, bundle.manifestHash);
@@ -6708,7 +7172,7 @@ async function copyBundle(home, source, destination, bundle) {
       }
     }
   } finally {
-    await fs27.rm(stage, { recursive: true, force: true });
+    await fs28.rm(stage, { recursive: true, force: true });
   }
 }
 async function prepareStandaloneMcp(home) {
@@ -6768,6 +7232,8 @@ async function upgradeStandalone(version, progress2) {
       method: "HEAD",
       redirect: "follow",
       signal: AbortSignal.timeout(3e4)
+    }).catch((error) => {
+      throw releaseRequestError(error);
     });
     if (!response.ok) throw new Error(`Latest release request failed (HTTP ${response.status}).`);
     selected = new URL(response.url).pathname.split("/").pop()?.replace(/^v/, "");
@@ -6825,7 +7291,7 @@ async function uninstallStandalone() {
     for (const [name, expected] of Object.entries(record.launchers)) {
       if (!launcherNames.includes(name)) throw new Error("Invalid owned launcher name.");
       const file = await storePath(record.bin, name);
-      const actual = await fs27.readFile(file, "utf8").catch((error) => {
+      const actual = await fs28.readFile(file, "utf8").catch((error) => {
         if (error.code === "ENOENT") return null;
         throw error;
       });
@@ -6833,9 +7299,9 @@ async function uninstallStandalone() {
     }
     for (const warning of await removePath(record.pathChanges ?? [])) console.error(warning);
     if (process.platform === "win32") await replace(await storePath(home, ".uninstall-request.txt", true), token);
-    for (const name of Object.keys(record.launchers)) await fs27.rm(await storePath(record.bin, name), { force: true });
+    for (const name of Object.keys(record.launchers)) await fs28.rm(await storePath(record.bin, name), { force: true });
   });
-  if (process.platform !== "win32") await fs27.rm(home, { recursive: true, force: true });
+  if (process.platform !== "win32") await fs28.rm(home, { recursive: true, force: true });
   return home;
 }
 var shQuote, psQuote, WINDOWS_BATCH_LAUNCHER, launcherNames;
@@ -6848,6 +7314,7 @@ var init_install2 = __esm({
     init_path();
     init_state();
     init_sessions();
+    init_trust2();
     init_state();
     shQuote = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
     psQuote = (s) => "'" + s.replace(/'/g, "''") + "'";
@@ -6869,11 +7336,11 @@ __export(updates_exports, {
   updateSettings: () => updateSettings,
   updateStatus: () => updateStatus
 });
-import fs28 from "fs/promises";
+import fs29 from "fs/promises";
 import path34 from "path";
 import { spawn as spawn2 } from "child_process";
 import { randomUUID as randomUUID11 } from "crypto";
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 async function boundedDownload(url) {
   const response = await fetch(url, { signal: AbortSignal.timeout(15e3), redirect: "follow" });
   if (!response.ok || !response.body) throw new Error(`Update metadata request failed (HTTP ${response.status}).`);
@@ -6976,7 +7443,7 @@ async function runAutomaticUpdate(home, dependencies = { fetchRelease: fetchVeri
     } catch (error) {
       status.error = error instanceof Error ? error.message : String(error);
     }
-    if (await fs28.access(path34.join(home, "install.json")).then(() => true, () => false)) await writeStoreJson(home, "update-status.json", status);
+    if (await fs29.access(path34.join(home, "install.json")).then(() => true, () => false)) await writeStoreJson(home, "update-status.json", status);
   }, 0);
 }
 async function scheduleAutomaticUpdate() {
@@ -7086,14 +7553,14 @@ var init_updates = __esm({
     CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
     RELEASE_AGE_MS = 24 * 60 * 60 * 1e3;
     releaseBase = "https://github.com/adrianczuczka/mason/releases";
-    releaseListSchema = z28.array(z28.object({ tag_name: z28.string(), draft: z28.boolean(), prerelease: z28.boolean(), published_at: z28.string().nullable() }));
-    updateManifestSchema = z28.object({
-      format: z28.literal(1),
-      version: z28.string().regex(/^\d+\.\d+\.\d+$/),
-      publishedAt: z28.string().datetime(),
-      assets: z28.record(z28.string().regex(/^[a-f0-9]{64}$/))
+    releaseListSchema = z30.array(z30.object({ tag_name: z30.string(), draft: z30.boolean(), prerelease: z30.boolean(), published_at: z30.string().nullable() }));
+    updateManifestSchema = z30.object({
+      format: z30.literal(1),
+      version: z30.string().regex(/^\d+\.\d+\.\d+$/),
+      publishedAt: z30.string().datetime(),
+      assets: z30.record(z30.string().regex(/^[a-f0-9]{64}$/))
     }).strict();
-    statusSchema2 = z28.object({ lastAttempt: z28.number(), availableVersion: z28.string().optional(), error: z28.string().optional() });
+    statusSchema2 = z30.object({ lastAttempt: z30.number(), availableVersion: z30.string().optional(), error: z30.string().optional() });
   }
 });
 
@@ -7101,6 +7568,7 @@ var init_updates = __esm({
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/automation/cli.ts
+init_usefulness();
 init_execution();
 init_runtime();
 init_adapters();
@@ -7172,13 +7640,27 @@ Keeps shared knowledge, repair evidence, ignore rules and the Mason installation
 Edited or ambiguous entries are retained for manual cleanup. Restart assistants
 after teardown. Run mason setup --host codex or --host claude to reconnect.
 Exit 0: complete/no-op. Exit 2: cleanup needs attention (also in dry runs).`;
-var USAGE = `Usage: mason-auto <setup|teardown|install|config|status|check|hook> [options]
+var STATS_USAGE = `Usage: mason stats [options]
+
+Show aggregate local observations, or inspect one session.
+
+  --enable | --disable       Enable/disable collection (setup enables it)
+  --json                     Include session/finding IDs and evidence paths
+  --dir <path>               Project directory (defaults to cwd)
+  --session <id>             Filter to one retained session
+  --session <id> --finding <id> --rating helpful|already-knew|irrelevant|deferred
+                             Supply feedback without changing audit status
+
+No uploads. Observed resolution does not establish causation.`;
+var USAGE = `Usage: mason auto <setup|teardown|install|config|status|check|hook|stats> [options]
 
   setup [--host claude|codex]  Connect MCP, instructions and hooks to mason on PATH; retain the initial audit
   teardown [--host claude|codex] Disconnect one host or all project hosts; retain knowledge and evidence
   install --host claude|codex  Merge lifecycle hooks into this project's host config
   config --host claude|codex   Print the host config without writing
   status                      Read configured hooks and observed runtime events
+  stats                       Aggregate local observations; --enable/--disable to configure
+                              Rate with --session <id> --finding <id> --rating helpful|already-knew|irrelevant|deferred
   check                       Capture/resume and verify retained audit evidence
   hook --host claude|codex     Handle host JSON on stdin
 
@@ -7199,7 +7681,12 @@ var parseCli = (argv) => parseArgs({ args: argv, allowPositionals: true, options
   json: { type: "boolean" },
   help: { type: "boolean", short: "h" },
   "dry-run": { type: "boolean" },
-  profile: { type: "boolean" }
+  profile: { type: "boolean" },
+  enable: { type: "boolean" },
+  disable: { type: "boolean" },
+  session: { type: "string" },
+  finding: { type: "string" },
+  rating: { type: "string" }
 } });
 function isHookCommand(argv) {
   try {
@@ -7219,12 +7706,14 @@ async function runAutomationCli(argv, stdin = "", io = defaultIo, options = {})
   try {
     const { values, positionals } = parseCli(argv);
     if (values.help || !positionals.length) {
-      io.out(positionals[0] === "teardown" ? TEARDOWN_USAGE : USAGE);
+      io.out(positionals[0] === "teardown" ? TEARDOWN_USAGE : positionals[0] === "stats" ? STATS_USAGE : USAGE);
       return 0;
     }
     if (positionals.length !== 1) throw new Error("Expected one command.");
     [action] = positionals;
     if (values.profile && !["check", "hook"].includes(action)) throw new Error("--profile applies only to check/hook.");
+    const trackingOptions = [values.enable, values.disable, values.session, values.finding, values.rating].some((v) => v !== void 0);
+    if (trackingOptions && action !== "stats") throw new Error("Tracking options apply only to stats.");
     const measured = (run) => values.profile ? withProfile(run, io.err) : run();
     const dir = values.dir ?? process.cwd();
     if (values["dry-run"] !== void 0 && action !== "teardown") throw new Error("--dry-run applies only to teardown.");
@@ -7261,11 +7750,26 @@ async function runAutomationCli(argv, stdin = "", io = defaultIo, options = {})
       return 0;
     }
     if (values.host || values.command) throw new Error("--host and --command apply only to install/config/hook.");
+    if (action === "stats") {
+      const configuring = values.enable !== void 0 || values.disable !== void 0;
+      const rating = values.finding !== void 0 || values.rating !== void 0;
+      if (values.enable !== void 0 && values.disable !== void 0 || configuring && (rating || values.session !== void 0)) throw new Error("Choose tracking configuration or session inspection/feedback separately.");
+      if (rating && (!values.session || !values.finding || !values.rating)) throw new Error("Rating requires --session, --finding, and --rating.");
+      if (configuring) {
+        const result2 = await configureUsefulness(dir, !!values.enable);
+        io.out(values.json ? JSON.stringify(result2, null, 2) : `Local stats ${result2.enabled ? "enabled" : "disabled"}. Existing observations retained. View with mason stats.`);
+        return 0;
+      }
+      if (rating) await rateUsefulness(dir, values.session, values.finding, usefulnessRating.parse(values.rating));
+      const result = await usefulnessStatus(dir, values.session);
+      io.out(values.json ? JSON.stringify(result, null, 2) : summarizeUsefulness(result));
+      return 0;
+    }
     if (action === "status") {
       const { setupStatus: setupStatus2, summarizeActivation: summarizeActivation2 } = await Promise.resolve().then(() => (init_status(), status_exports));
       const setup = await setupStatus2(dir);
       const result = { ...await automationStatus(dir), configured: await installedAutomation(dir), setup };
-      io.out(values.json || !process.stdout.isTTY ? JSON.stringify(result, null, 2) : summarizeActivation2(setup));
+      io.out(values.json || !process.stdout.isTTY ? JSON.stringify(result, null, 2) : [summarizeActivation2(setup), result.knowledge].filter(Boolean).join("\n\n"));
       return 0;
     }
     if (action !== "check") throw new Error("Unknown automation command: " + action);
@@ -7290,13 +7794,15 @@ var inputArgs = process.argv.slice(2);
 var managedLaunch = inputArgs[0] === "--setup-host";
 var setupHost = managedLaunch ? inputArgs.splice(0, 2)[1] : void 0;
 var [command, ...args] = inputArgs;
-var usage = `Mason ${"0.19.1"}
+var usage = `Mason ${"0.20.1"}
 
 Usage: mason <command> [options]
 
   setup --host codex|claude   Connect this project to your assistant
   teardown [--host codex|claude] Disconnect project integrations; retain knowledge
   status                     Show configuration, observed use and verification
+  stats                      Show local stats and feedback
+  auto                       Configure and run lifecycle hooks
   check                      Resume and verify retained documentation findings
   audit                      Audit project instructions
   review --base <ref>         Review committed changes
@@ -7308,7 +7814,7 @@ Usage: mason <command> [options]
   rollback                   Restore and pin the previous standalone version
   uninstall                  Remove that installation; retain project data
 
-Use mason <command> --help for options. npm users can keep using mason-auto,
+Use mason <command> --help for options. npm users can also use
 mason-audit, mason-review, mason-drift, mason-hook and mason-mcp.`;
 var progress;
 try {
@@ -7319,9 +7825,9 @@ try {
       await prepareLaunch2(setupHost, { allowInactive: command === "mcp" });
     }
   }
-  if (command === "internal-integration-version") console.log(JSON.stringify({ protocol: 1, version: "0.19.1" }));
+  if (command === "internal-integration-version") console.log(JSON.stringify({ protocol: 1, version: "0.20.1" }));
   else if (!command || ["--help", "-h", "help"].includes(command)) console.log(usage);
-  else if (["--version", "-v"].includes(command)) console.log("0.19.1");
+  else if (["--version", "-v"].includes(command)) console.log("0.20.1");
   else if (command === "internal-update") {
     if (args.length) throw new Error("internal-update takes no arguments.");
     const { currentInstallation: currentInstallation2 } = await Promise.resolve().then(() => (init_state(), state_exports));
@@ -7390,7 +7896,7 @@ Automatic updates: ${status.effective ? "enabled" : "inactive"} (preference: ${s
         process.exitCode = await upgradeStandalone2(args[0], progress);
       } else console.log((process.platform === "win32" ? "Finishing installation cleanup after runtime exit: " : "Removed standalone installation: ") + await uninstallStandalone2() + ". Project configuration and knowledge were retained. Reinstall Mason to use its integrations.");
     }
-  } else if (["setup", "teardown", "status", "check", "auto"].includes(command)) {
+  } else if (["setup", "teardown", "status", "check", "stats", "auto"].includes(command)) {
     const forwarded = command === "auto" ? args : [command, ...args];
     let input = "";
     if (isHookCommand(forwarded) && !process.stdin.isTTY) for await (const chunk of process.stdin) {