mason-context 0.16.0 → 0.16.2

package/dist/mason-mcp.js

@@ -3136,7 +3136,7 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     exec11 = promisify12(execFile12);
-    engineVersion = true ? "0.16.0" : "development";
+    engineVersion = true ? "0.16.2" : "development";
     hash = (value) => createHash4("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
     internal = (file) => file === ".mason" || file === ".mason/reports" || file.startsWith(".mason/reports/");
@@ -3246,9 +3246,29 @@ var runtime_exports = {};
 __export(runtime_exports, {
   automate: () => automate,
   automationStatus: () => automationStatus,
+  observeReadOnlyTool: () => observeReadOnlyTool,
   summarize: () => summarize
 });
 import { randomUUID as randomUUID5 } from "crypto";
+async function observeReadOnlyTool(dir, event) {
+  const ws = await workspace(dir);
+  await withLock(ws.root, ws.directory, async () => {
+    const statePath = ws.directory + "/state.json";
+    const raw = await readStoreJson(ws.root, statePath);
+    if (raw === null) return;
+    const state = parseState(raw);
+    if (state.root !== ws.root || state.gitDir !== ws.gitDir || state.branch !== ws.branch) {
+      throw new Error("Automation state belongs to another branch or worktree; original evidence was retained.");
+    }
+    const session = event.host && event.sessionId ? state.sessions[hash([event.host, event.sessionId])] : null;
+    if (!session) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    session.lastUsed = now;
+    session.events[event.event] = { at: now, count: (session.events[event.event]?.count ?? 0) + 1 };
+    await writeStoreJson(ws.root, statePath, state);
+  });
+  return { root: ws.root, directory: ws.directory };
+}
 function summarize(report) {
   const open = report.findings.filter((f) => f.status !== "resolved");
   return [
@@ -3472,8 +3492,15 @@ var init_runtime = __esm({
 
 // src/automation/adapters.ts
 import { z as z9 } from "zod";
+function managedHookCommand(host, platform = process.platform) {
+  const command = `mason --setup-host ${host} auto hook --host ${host}`;
+  return platform === "win32" ? `cmd.exe /d /s /c "where mason >nul 2>nul & if errorlevel 1 (exit /b 0) else (${command})"` : `if command -v mason >/dev/null 2>&1; then ${command}; fi`;
+}
+function knownManagedHookCommands(host) {
+  return [managedHookCommand(host, "linux"), managedHookCommand(host, "win32"), `mason --setup-host ${host} auto hook --host ${host}`];
+}
 function hookConfig(host, command = "npx --no-install --package mason-context mason-auto") {
-  const handler = { type: "command", command: command + " hook --host " + host, timeout: 30 };
+  const handler = { type: "command", command: command === `mason --setup-host ${host} auto` ? managedHookCommand(host) : command + " hook --host " + host, timeout: 30 };
   return { hooks: Object.fromEntries(HOOK_EVENTS.map((name) => [
     name,
     [{ ...["PreToolUse", "PostToolUse"].includes(name) ? { matcher: ".*" } : {}, hooks: [{ ...handler }] }]
@@ -3602,7 +3629,7 @@ async function planAutomationInstall(root, host, command) {
   const previous = record.hosts[host]?.command;
   const ownershipText = await readText(root, OWNERSHIP_PATH);
   const pending = ownershipText === null ? [] : ownershipSchema.parse(JSON.parse(ownershipText)).files[file]?.hookCommands ?? [];
-  const owned = /* @__PURE__ */ new Set([previous, ...pending, newCommand]);
+  const owned = /* @__PURE__ */ new Set([previous, ...pending, newCommand, ...knownManagedHookCommands(host)]);
   const hooks = existing.hooks ?? {};
   for (const event of HOOK_EVENTS) {
     hooks[event] = (hooks[event] ?? []).map((group) => ({
@@ -3728,6 +3755,7 @@ var init_model = __esm({
 // src/setup/launcher.ts
 import { execFile as execFile13 } from "child_process";
 import { promisify as promisify13 } from "util";
+import fs16 from "fs/promises";
 function globalCommand(args, platform = process.platform) {
   return platform === "win32" ? { command: "cmd.exe", args: ["/d", "/s", "/c", "mason", ...args] } : { command: "mason", args };
 }
@@ -3752,7 +3780,7 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.16.0" : "development";
+    executingVersion = () => true ? "0.16.2" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host} auto`;
   }
@@ -3942,9 +3970,9 @@ var init_init = __esm({
 
 Mason provides recorded decisions and file impact over MCP. A concept map is optional.
 
-- Task, bug, or change request \u2192 \`get_context\` with the task text and known files: matching decisions, related tests, impact, and any available map entries.
+- 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.
-- Learned something the code cannot explain (a failed approach, an incident's cause, a workaround's reason, a review-settled convention) \u2192 \`save_decision\` with rationale, anchors, and any known owner, sources, and recorder. It creates a proposal immediately without setup or a map. Never invent attribution or record code-derivable facts, session trivia, or secrets.
+- 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.
 - Consult trust metadata before relying on entries: unknown or changed freshness requires inspection, and failed verification means the description must be corrected. Check approval too: proposals are suggestions, legacy records are unreviewed, and accepted decisions are recorded constraints subject to freshness checks. An accepted revision remains operative while a pending proposal is reviewed; keep both versions and their freshness distinct.
 - 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.
@@ -4537,7 +4565,7 @@ var init_evidence2 = __esm({
 });
 
 // src/review/review.ts
-import fs16 from "fs/promises";
+import fs17 from "fs/promises";
 import path22 from "path";
 import { execFile as execFile15 } from "child_process";
 import { promisify as promisify15 } from "util";
@@ -4617,7 +4645,7 @@ async function computeReview(rootDir, base, options = {}) {
     analyzed,
     async (relPath) => {
       try {
-        await fs16.access(path22.join(resolvedRoot, relPath));
+        await fs17.access(path22.join(resolvedRoot, relPath));
         return true;
       } catch {
         return false;
@@ -4751,16 +4779,204 @@ var init_onboarding = __esm({
   }
 });
 
+// src/impact/references.ts
+import path23 from "path";
+function templateEnd(content2, start) {
+  let i = start + 1, interpolation = 0;
+  while (i < content2.length) {
+    const c = content2[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (!interpolation) {
+      if (c === "`") return i + 1;
+      if (c === "$" && content2[i + 1] === "{") {
+        interpolation = 1;
+        i += 2;
+        continue;
+      }
+    } else {
+      if (c === "`") {
+        i = templateEnd(content2, i);
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        const quote = c;
+        for (i++; i < content2.length; i++) {
+          if (content2[i] === "\\") i++;
+          else if (content2[i] === quote) {
+            i++;
+            break;
+          }
+        }
+        continue;
+      }
+      if (content2.startsWith("//", i)) {
+        const end = content2.indexOf("\n", i + 2);
+        i = end < 0 ? content2.length : end;
+        continue;
+      }
+      if (content2.startsWith("/*", i)) {
+        const end = content2.indexOf("*/", i + 2);
+        i = end < 0 ? content2.length : end + 2;
+        continue;
+      }
+      if (c === "{") interpolation++;
+      if (c === "}") interpolation--;
+    }
+    i++;
+  }
+  return content2.length;
+}
+function tokens(content2) {
+  const result = [];
+  const re = /\/\/[^\n]*|\/\*[\s\S]*?(?:\*\/|$)|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|[\w$]+|[^\s]/g;
+  let match;
+  while (match = re.exec(content2)) {
+    const value = match[0];
+    if (value.startsWith("//") || value.startsWith("/*")) continue;
+    if (/^["'`]/.test(value)) {
+      if (value[0] === "`") {
+        re.lastIndex = templateEnd(content2, match.index);
+        result.push({ value: "<opaque>" });
+        continue;
+      }
+      result.push({ value: value.slice(1, -1), string: !value.includes("\\") && value[0] !== "`" });
+      if (!result.at(-1).string) result[result.length - 1] = { value: "<opaque>" };
+    } else result.push({ value });
+  }
+  return result;
+}
+function imports(content2) {
+  const ts = tokens(content2), found = [];
+  for (let i = 0; i < ts.length; i++) {
+    const t = ts[i];
+    if (t.string || ts[i - 1]?.value === ".") continue;
+    if (["require", "import"].includes(t.value) && ts[i + 1]?.value === "(" && ts[i + 2]?.string && ts[i + 3]?.value === ")") {
+      found.push(ts[i + 2].value);
+    }
+    if (!["import", "export"].includes(t.value) || ts[i + 1]?.value === "(") continue;
+    if (t.value === "import" && ts[i + 1]?.string) {
+      found.push(ts[i + 1].value);
+      continue;
+    }
+    for (let j = i + 1; j < Math.min(ts.length, i + 150); j++) {
+      if ([";", "=", "import", "export"].includes(ts[j].value) && !ts[j].string) break;
+      if (ts[j].value === "from" && !ts[j].string && ts[j + 1]?.string) {
+        found.push(ts[j + 1].value);
+        break;
+      }
+    }
+  }
+  return found;
+}
+function qualifiedName(ts, start) {
+  let name = "";
+  for (let i = start; i < ts.length; i++) {
+    if (ts[i].string || !/^[A-Za-z_$][\w$]*$/.test(ts[i].value)) break;
+    name += ts[i].value;
+    if (ts[i + 1]?.value !== "." || !/^[A-Za-z_$][\w$]*$/.test(ts[i + 2]?.value ?? "")) break;
+    name += ".";
+    i++;
+  }
+  return name;
+}
+function declaredSymbols(content2) {
+  const ts = tokens(content2);
+  const packageAt = ts.findIndex((t) => !t.string && t.value === "package");
+  if (packageAt < 0) return [];
+  const pkg = qualifiedName(ts, packageAt + 1), names = [];
+  let depth = 0;
+  for (let i = 0; i < ts.length; i++) {
+    if (ts[i].string) continue;
+    if (ts[i].value === "{") depth++;
+    if (ts[i].value === "}") depth--;
+    if (depth === 0 && ["class", "interface", "object", "enum", "typealias", "fun"].includes(ts[i].value) && /^[A-Za-z_$][\w$]*$/.test(ts[i + 1]?.value ?? "") && ts[i + 1].value !== "class") names.push(pkg + "." + ts[i + 1].value);
+  }
+  return names;
+}
+function jvmImports(content2) {
+  const ts = tokens(content2), result = [];
+  for (let i = 0; i < ts.length; i++) if (!ts[i].string && ts[i].value === "import") {
+    const name = qualifiedName(ts, i + (ts[i + 1]?.value === "static" ? 2 : 1));
+    if (name) result.push(name);
+  }
+  return result;
+}
+function resolveImport(file, specifier, available) {
+  if (!specifier.startsWith("./") && !specifier.startsWith("../")) return null;
+  const relative = path23.posix.normalize(path23.posix.join(path23.posix.dirname(file), specifier));
+  if (relative.startsWith("../")) return null;
+  if (available.has(relative)) return relative;
+  const ext = path23.posix.extname(relative);
+  const replacements = { ".js": [".ts", ".tsx"], ".mjs": [".mts"], ".cjs": [".cts"] };
+  const candidates = ext ? (replacements[ext] ?? []).map((e) => relative.slice(0, -ext.length) + e) : jsExtensions.flatMap((e) => [relative + e, relative + "/index" + e]);
+  const found = candidates.filter((f) => available.has(f));
+  return found.length === 1 ? found[0] : null;
+}
+function mentionsPath(content2, target) {
+  return new RegExp(`(?<![\\w./\\\\-])(?:\\./)?${escape(target)}(?![\\w./\\\\-])`).test(content2);
+}
+function createReferenceMatcher(targets, available, targetContents = /* @__PURE__ */ new Map()) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of available) {
+    const name = path23.posix.basename(file, path23.posix.extname(file));
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  const jvmTargets = new Map([...targetContents].filter(([file]) => /\.(?:kt|kts|java)$/.test(file)).map(([file, content2]) => [file, declaredSymbols(content2)]));
+  return (source) => {
+    if (targets.includes(source.path)) return [];
+    const resolved = new Set(jsExtensions.includes(path23.posix.extname(source.path)) ? imports(source.content).map((s) => resolveImport(source.path, s, available)).filter(Boolean) : []);
+    if (/\.(?:kt|kts|java)$/.test(source.path)) {
+      const imported = jvmImports(source.content);
+      for (const [target, symbols] of jvmTargets) if (symbols.some((symbol) => imported.some((name) => name === symbol || name.startsWith(symbol + ".")))) resolved.add(target);
+    }
+    const groups = /* @__PURE__ */ new Map();
+    const add = (evidence, match) => groups.set(evidence, [...groups.get(evidence) ?? [], match]);
+    for (const target of targets) {
+      if (resolved.has(target)) {
+        add("resolved-import", target);
+        continue;
+      }
+      if (mentionsPath(source.content, target)) {
+        add("explicit-path", target);
+        continue;
+      }
+      const ext = path23.posix.extname(target), name = path23.posix.basename(target, ext);
+      if (!/\.(?:[cm]?[jt]sx?|py|kt|java|go|rs|swift|rb|cs|cpp|c|h|hpp|dart|php)$/.test(ext) || name.startsWith(".") || name.length < 3 || genericNames.has(name.toLowerCase()) || counts.get(name) !== 1) continue;
+      if (word(name).test(source.content)) {
+        add("name-candidate", name);
+      }
+    }
+    return [...groups].map(([evidence, matches]) => ({ file: source.path, matches, kind: evidence === "resolved-import" ? "import" : "mention", evidence }));
+  };
+}
+function sortReferences(result) {
+  const rank = { "resolved-import": 0, "explicit-path": 1, "name-candidate": 2 };
+  return result.sort((a, b) => rank[a.evidence] - rank[b.evidence] || b.matches.length - a.matches.length || a.file.localeCompare(b.file));
+}
+var jsExtensions, genericNames, escape, word;
+var init_references = __esm({
+  "src/impact/references.ts"() {
+    "use strict";
+    jsExtensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
+    genericNames = /* @__PURE__ */ new Set(["index", "main", "app", "init", "config", "settings", "types", "utils", "test", "tests"]);
+    escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    word = (s) => new RegExp(`(?<![\\w$])${escape(s)}(?![\\w$])`);
+  }
+});
+
 // src/impact/impact.ts
 var impact_exports = {};
 __export(impact_exports, {
   analyzeImpact: () => analyzeImpact
 });
-import path23 from "path";
+import path24 from "path";
 import { execFile as execFile16 } from "child_process";
 import { promisify as promisify16 } from "util";
 async function analyzeImpact(rootDir, targetFiles) {
-  const resolvedRoot = path23.resolve(rootDir);
+  const resolvedRoot = path24.resolve(rootDir);
   const resolvedTargets = await resolveTargetFiles(resolvedRoot, targetFiles);
   const [cochange, references, tests] = await Promise.all([
     getCochangeFiles(resolvedRoot, resolvedTargets),
@@ -4837,52 +5053,24 @@ async function getCochangeFiles(rootDir, targetFiles) {
   })).filter((e) => e.cochangeRate >= 0.3 || e.sharedCommits >= 3).sort((a, b) => b.cochangeRate - a.cochangeRate).slice(0, 20);
 }
 async function getReferences(rootDir, targetFiles) {
-  const searchNames = /* @__PURE__ */ new Set();
-  for (const target of targetFiles) {
-    const basename = path23.basename(target).replace(/\.[^.]+$/, "");
-    searchNames.add(basename);
-  }
   const access = await createFileAccess(rootDir);
   const allSourceFiles = await access.list(SOURCE_GLOB);
-  const targetSet = new Set(targetFiles);
-  const filesToSearch = allSourceFiles.filter((f) => !targetSet.has(f));
-  const results = /* @__PURE__ */ new Map();
-  const importLine = /^\s*(import\b|from\b.*\bimport\b|const\b.*=\s*require\(|use\b|#include\b|require\s*\()/;
-  const batchSize = 50;
-  for (let i = 0; i < filesToSearch.length; i += batchSize) {
-    const batch = filesToSearch.slice(i, i + batchSize);
-    await Promise.all(
-      batch.map(async (file) => {
-        try {
-          const full = await access.read(file);
-          if (!full) return;
-          const content2 = full.content;
-          const lines = content2.split("\n");
-          for (const name of searchNames) {
-            const regex = new RegExp(`\\b${escapeRegex(name)}\\b`);
-            if (!regex.test(content2)) continue;
-            if (!results.has(file)) {
-              results.set(file, { matches: /* @__PURE__ */ new Set(), isImport: false });
-            }
-            const entry = results.get(file);
-            entry.matches.add(name);
-            if (!entry.isImport && lines.some((l) => regex.test(l) && importLine.test(l))) {
-              entry.isImport = true;
-            }
-          }
-        } catch {
-        }
-      })
-    );
+  const available = new Set(allSourceFiles);
+  const targetContents = /* @__PURE__ */ new Map();
+  for (const target of targetFiles) {
+    const source = await access.read(target);
+    if (source) {
+      available.add(target);
+      targetContents.set(target, source.content);
+    }
   }
-  return [...results.entries()].map(([file, { matches, isImport }]) => ({
-    file,
-    matches: [...matches],
-    kind: isImport ? "import" : "mention"
-  })).sort((a, b) => {
-    if (a.kind !== b.kind) return a.kind === "import" ? -1 : 1;
-    return b.matches.length - a.matches.length;
-  });
+  const match = createReferenceMatcher(targetFiles, available, targetContents);
+  const references = [];
+  for (let i = 0; i < allSourceFiles.length; i += 50) {
+    const batch = await Promise.all(allSourceFiles.slice(i, i + 50).map((file) => access.read(file)));
+    for (const source of batch) if (source) references.push(...match(source));
+  }
+  return sortReferences(references);
 }
 async function getRelatedTests(rootDir, targetFiles) {
   const testPatterns = [
@@ -4902,9 +5090,9 @@ async function getRelatedTests(rootDir, targetFiles) {
   const testFiles = await (await createFileAccess(rootDir)).list(testPatterns);
   const results = [];
   for (const target of targetFiles) {
-    const targetBaseName = path23.basename(target).replace(/\.[^.]+$/, "");
+    const targetBaseName = path24.basename(target).replace(/\.[^.]+$/, "");
     for (const testFile of testFiles) {
-      const testBaseName = path23.basename(testFile).replace(/\.[^.]+$/, "");
+      const testBaseName = path24.basename(testFile).replace(/\.[^.]+$/, "");
       const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
       if (sourceName === targetBaseName) {
         results.push({
@@ -4916,15 +5104,13 @@ async function getRelatedTests(rootDir, targetFiles) {
   }
   return results;
 }
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 var exec14;
 var init_impact = __esm({
   "src/impact/impact.ts"() {
     "use strict";
     init_files();
     init_paths();
+    init_references();
     exec14 = promisify16(execFile16);
   }
 });
@@ -4934,13 +5120,13 @@ var assemble_exports = {};
 __export(assemble_exports, {
   assembleContext: () => assembleContext
 });
-import path24 from "path";
-import fs17 from "fs/promises";
+import path25 from "path";
+import fs18 from "fs/promises";
 async function collectImpact(root, candidates) {
   const targets = /* @__PURE__ */ new Set();
   let sourceFiles;
   for (const candidate of sanitizeRepoPaths(candidates)) {
-    const stat = await fs17.stat(path24.join(root, candidate)).catch(() => null);
+    const stat = await fs18.stat(path25.join(root, candidate)).catch(() => null);
     if (stat?.isDirectory()) {
       sourceFiles ??= await (await createFileAccess(root)).list();
       for (const file of sourceFiles) {
@@ -4954,13 +5140,19 @@ async function collectImpact(root, candidates) {
   }
   if (!targets.size) return { impact: null, relatedTests: [] };
   const result = await analyzeImpact(root, [...targets]);
+  const referenceCandidatesOmitted = result.references.filter((r) => r.evidence === "name-candidate").length;
   return {
-    impact: { targets: result.targetFiles, cochange: result.cochange, references: result.references.slice(0, 10) },
+    impact: {
+      targets: result.targetFiles,
+      cochange: result.cochange,
+      references: result.references.filter((r) => r.evidence !== "name-candidate").slice(0, 10),
+      ...referenceCandidatesOmitted ? { referenceCandidatesOmitted } : {}
+    },
     relatedTests: [...new Set(result.tests.map((t) => t.file))]
   };
 }
 async function assembleContext(rootDir, task, files) {
-  const resolvedRoot = path24.resolve(rootDir);
+  const resolvedRoot = path25.resolve(rootDir);
   const mapState = await inspectSnapshot(resolvedRoot);
   const snapshot = mapState.snapshot;
   const store = await loadDecisionStore(resolvedRoot);
@@ -5161,7 +5353,7 @@ __export(observations_exports, {
   observeActivation: () => observeActivation,
   readObservation: () => readObservation
 });
-import fs18 from "fs/promises";
+import fs19 from "fs/promises";
 import { z as z18 } from "zod";
 function observationPath(directory, host, revision, version = executingVersion()) {
   return `${directory}/activation/${host}-${revision}-${hash(version).slice(0, 12)}.json`;
@@ -5177,9 +5369,9 @@ async function observeActivation(dir, event, options = {}) {
   const host = process.env.MASON_SETUP_HOST, revision = process.env.MASON_SETUP_REVISION;
   if (host !== "codex" && host !== "claude" || !revision || !process.env.MASON_SETUP_ROOT) return null;
   try {
-    const capturedDirectory = options.reportPath?.match(/^(\.mason\/reports\/automation\/[a-f0-9]{24})\/checks\//)?.[1];
-    const ws = capturedDirectory ? { root: await fs18.realpath(dir), directory: capturedDirectory } : await workspace(dir);
-    if (ws.root !== await fs18.realpath(process.env.MASON_SETUP_ROOT)) return null;
+    const capturedDirectory = options.directory?.match(/^\.mason\/reports\/automation\/[a-f0-9]{24}$/)?.[0] ?? options.reportPath?.match(/^(\.mason\/reports\/automation\/[a-f0-9]{24})\/checks\//)?.[1];
+    const ws = capturedDirectory ? { root: await fs19.realpath(dir), directory: capturedDirectory } : await workspace(dir);
+    if (ws.root !== await fs19.realpath(process.env.MASON_SETUP_ROOT)) return null;
     const setup = await loadSetup(ws.root);
     if (setup?.hosts[host]?.revision !== revision) return "Mason setup changed; restart the assistant to observe the current integration.";
     const directory = ws.directory + "/activation";
@@ -5265,7 +5457,7 @@ async function setupStatus(dir) {
       version: 1,
       status: pending.length ? "incomplete" : "not-configured",
       hosts: {},
-      next: pending.length ? "Setup did not finish. Rerun mason-auto setup --host " + pending[0] + " to resume using the retained original evidence." : "Run mason-auto setup --host codex or --host claude."
+      next: pending.length ? "Setup did not finish. Rerun mason-auto setup --host " + pending[0] + " to resume using the retained original evidence." : "Project hooks are inactive until local setup. Run mason setup --host codex or --host claude."
     };
   }
   const hosts = {};
@@ -5481,8 +5673,8 @@ __export(client_exports, {
 function createConfluenceClient(config, fetchFn = fetch) {
   const baseUrl = config.baseUrl.replace(/\/+$/, "");
   const auth = "Basic " + Buffer.from(`${config.email}:${config.apiToken}`).toString("base64");
-  async function call(method, path28, body) {
-    const res = await fetchFn(`${baseUrl}${path28}`, {
+  async function call(method, path29, body) {
+    const res = await fetchFn(`${baseUrl}${path29}`, {
       method,
       headers: {
         Authorization: auth,
@@ -5494,7 +5686,7 @@ function createConfluenceClient(config, fetchFn = fetch) {
     if (!res.ok) {
       const text2 = await res.text();
       throw new Error(
-        `Confluence ${method} ${path28} failed: ${res.status} ${res.statusText} \u2014 ${text2}`
+        `Confluence ${method} ${path29} failed: ${res.status} ${res.statusText} \u2014 ${text2}`
       );
     }
     if (res.status === 204) return null;
@@ -5595,28 +5787,28 @@ __export(config_exports2, {
   saveConfluenceConfig: () => saveConfluenceConfig,
   validateProvider: () => validateProvider
 });
-import fs19 from "fs/promises";
-import path25 from "path";
+import fs20 from "fs/promises";
+import path26 from "path";
 import os3 from "os";
 import { execFile as execFile17 } from "child_process";
 import { promisify as promisify17 } from "util";
 function configDir() {
-  return path25.join(os3.homedir(), ".mason");
+  return path26.join(os3.homedir(), ".mason");
 }
 function configFile() {
-  return path25.join(configDir(), "config.json");
+  return path26.join(configDir(), "config.json");
 }
 async function loadConfig() {
   try {
-    const raw = await fs19.readFile(configFile(), "utf-8");
+    const raw = await fs20.readFile(configFile(), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function saveConfig(config) {
-  await fs19.mkdir(configDir(), { recursive: true });
-  await fs19.writeFile(configFile(), JSON.stringify(config, null, 2), "utf-8");
+  await fs20.mkdir(configDir(), { recursive: true });
+  await fs20.writeFile(configFile(), JSON.stringify(config, null, 2), "utf-8");
 }
 function getDefaultModel(provider) {
   return DEFAULT_MODELS[provider];
@@ -5684,21 +5876,21 @@ var init_url = __esm({
 });
 
 // src/confluence/renderer.ts
-function escape(value) {
+function escape2(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function infoPanel(text2) {
-  return `<ac:structured-macro ac:name="info"><ac:rich-text-body><p>${escape(text2)}</p></ac:rich-text-body></ac:structured-macro>`;
+  return `<ac:structured-macro ac:name="info"><ac:rich-text-body><p>${escape2(text2)}</p></ac:rich-text-body></ac:structured-macro>`;
 }
 function featurePageTitle(prefix, name) {
   return `${prefix}${name}`;
 }
 function renderFeaturePage(options) {
-  const overviewBody = `<h2>What it does</h2><p>${escape(options.productDescription)}</p>`;
+  const overviewBody = `<h2>What it does</h2><p>${escape2(options.productDescription)}</p>`;
   const flowsBody = options.flowDescriptions.length ? `<h2>How it fits in</h2><ul>` + options.flowDescriptions.map(
-    (f) => `<li><strong>${escape(f.name)}</strong> \u2014 ${escape(f.description)}</li>`
+    (f) => `<li><strong>${escape2(f.name)}</strong> \u2014 ${escape2(f.description)}</li>`
   ).join("") + `</ul>` : "";
-  const navBody = `<p><ac:link><ri:page ri:content-title="${escape(options.indexPageTitle)}"/><ac:plain-text-link-body><![CDATA[Back to ${options.indexPageTitle}]]></ac:plain-text-link-body></ac:link></p>`;
+  const navBody = `<p><ac:link><ri:page ri:content-title="${escape2(options.indexPageTitle)}"/><ac:plain-text-link-body><![CDATA[Back to ${options.indexPageTitle}]]></ac:plain-text-link-body></ac:link></p>`;
   const footer = infoPanel(
     `Generated from code by Mason. This page is overwritten on each sync \u2014 edit the code, not the page.`
   );
@@ -5714,7 +5906,7 @@ function renderIndexPage(options) {
   }
   const list = `<h2>Features</h2><ul>` + options.featureTitles.map((name) => {
     const pageTitle = featurePageTitle(options.featurePrefix, name);
-    return `<li><ac:link><ri:page ri:content-title="${escape(pageTitle)}"/><ac:plain-text-link-body><![CDATA[${name}]]></ac:plain-text-link-body></ac:link></li>`;
+    return `<li><ac:link><ri:page ri:content-title="${escape2(pageTitle)}"/><ac:plain-text-link-body><![CDATA[${name}]]></ac:plain-text-link-body></ac:link></li>`;
   }).join("") + `</ul>`;
   const banner = infoPanel(
     `Generated from code by Mason. Maintained automatically \u2014 edit the code, not this page.`
@@ -5725,33 +5917,33 @@ function renderChangelogSection(section) {
   const segments = [];
   if (section.addedFeatures.length) {
     segments.push(
-      `<p><strong>Added features:</strong> ${section.addedFeatures.map(escape).join(", ")}</p>`
+      `<p><strong>Added features:</strong> ${section.addedFeatures.map(escape2).join(", ")}</p>`
     );
   }
   if (section.removedFeatures.length) {
     segments.push(
-      `<p><strong>Removed features:</strong> ${section.removedFeatures.map(escape).join(", ")}</p>`
+      `<p><strong>Removed features:</strong> ${section.removedFeatures.map(escape2).join(", ")}</p>`
     );
   }
   if (section.changedFeatures.length) {
     segments.push(
-      `<p><strong>Updated features:</strong> ${section.changedFeatures.map(escape).join(", ")}</p>`
+      `<p><strong>Updated features:</strong> ${section.changedFeatures.map(escape2).join(", ")}</p>`
     );
   }
   if (section.addedFlows.length) {
     segments.push(
-      `<p><strong>Added flows:</strong> ${section.addedFlows.map(escape).join(", ")}</p>`
+      `<p><strong>Added flows:</strong> ${section.addedFlows.map(escape2).join(", ")}</p>`
     );
   }
   if (section.removedFlows.length) {
     segments.push(
-      `<p><strong>Removed flows:</strong> ${section.removedFlows.map(escape).join(", ")}</p>`
+      `<p><strong>Removed flows:</strong> ${section.removedFlows.map(escape2).join(", ")}</p>`
     );
   }
   if (segments.length === 0) {
     segments.push(`<p><em>No meaningful changes detected.</em></p>`);
   }
-  return `<h3>${escape(section.syncedAt)}</h3>` + segments.join("");
+  return `<h3>${escape2(section.syncedAt)}</h3>` + segments.join("");
 }
 function renderChangelogPage(sections) {
   if (sections.length === 0) {
@@ -5776,21 +5968,21 @@ var init_renderer = __esm({
 });
 
 // src/confluence/diff.ts
-import fs20 from "fs/promises";
-import path26 from "path";
+import fs21 from "fs/promises";
+import path27 from "path";
 import { createHash as createHash5 } from "crypto";
 function hashDescription(description) {
   return createHash5("sha256").update(description, "utf8").digest("hex");
 }
 function syncStateDir(rootDir) {
-  return path26.join(rootDir, ".mason");
+  return path27.join(rootDir, ".mason");
 }
 function syncStatePath(rootDir) {
-  return path26.join(syncStateDir(rootDir), "confluence-sync.json");
+  return path27.join(syncStateDir(rootDir), "confluence-sync.json");
 }
 async function loadSyncState(rootDir) {
   try {
-    const raw = await fs20.readFile(syncStatePath(rootDir), "utf-8");
+    const raw = await fs21.readFile(syncStatePath(rootDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 2) return null;
     return parsed;
@@ -5799,8 +5991,8 @@ async function loadSyncState(rootDir) {
   }
 }
 async function saveSyncState(rootDir, state) {
-  await fs20.mkdir(syncStateDir(rootDir), { recursive: true });
-  await fs20.writeFile(
+  await fs21.mkdir(syncStateDir(rootDir), { recursive: true });
+  await fs21.writeFile(
     syncStatePath(rootDir),
     JSON.stringify(state, null, 2),
     "utf-8"
@@ -6354,8 +6546,8 @@ import { z as z19 } from "zod";
 
 // src/mcp/tools.ts
 init_repair();
-import fs21 from "fs/promises";
-import path27 from "path";
+import fs22 from "fs/promises";
+import path28 from "path";
 import { execFile as execFile19 } from "child_process";
 import { promisify as promisify19 } from "util";
 
@@ -7250,7 +7442,7 @@ async function buildContext(dir) {
   };
 }
 async function analyzeProject(dir) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const context = await buildContext(rootDir);
   const results = await runAll(context);
   const projectSnapshot = await detectProjectSnapshot(rootDir);
@@ -7305,7 +7497,7 @@ async function detectProjectSnapshot(rootDir) {
   const present = [];
   for (const file of buildFiles) {
     try {
-      await fs21.access(path27.join(rootDir, file));
+      await fs22.access(path28.join(rootDir, file));
       present.push(file);
     } catch {
     }
@@ -7347,7 +7539,7 @@ async function detectProjectSnapshot(rootDir) {
   const sourceFiles = await access.list();
   const fileCounts = {};
   for (const file of sourceFiles) {
-    const ext = path27.extname(file).slice(1);
+    const ext = path28.extname(file).slice(1);
     fileCounts[ext] = (fileCounts[ext] ?? 0) + 1;
   }
   return {
@@ -7358,7 +7550,7 @@ async function detectProjectSnapshot(rootDir) {
   };
 }
 async function getCodeSamples(dir, count3 = 15) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const samples = await sampleFiles(rootDir, count3);
   const output = {
     note: "These are previews (first ~60 lines). Read the file directly with your own tools to see it in full.",
@@ -7401,7 +7593,7 @@ async function unmappedContextResponse(rootDir) {
   });
 }
 async function getProjectStructure(dir) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const allFiles = await (await createFileAccess(rootDir)).list("**/*");
   const dirInfo = /* @__PURE__ */ new Map();
   for (const file of allFiles) {
@@ -7413,7 +7605,7 @@ async function getProjectStructure(dir) {
       }
       const info = dirInfo.get(dirPath);
       info.fileCount++;
-      const ext = path27.extname(file).slice(1);
+      const ext = path28.extname(file).slice(1);
       if (ext) {
         info.extensions.set(ext, (info.extensions.get(ext) ?? 0) + 1);
       }
@@ -7458,7 +7650,7 @@ async function buildChangedFilePreviews(rootDir, changedFiles) {
   return previews2;
 }
 async function getSnapshot(dir) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const snapshot = await loadSnapshot(rootDir);
   if (!snapshot) {
     return unmappedContextResponse(rootDir);
@@ -7559,7 +7751,7 @@ function driftHint(report) {
   return "Read the changed files under staleFeatures/staleFlows, update those entries (fold unmappedFiles into the right features), and call save_snapshot with only the affected entries \u2014 unchanged entries are preserved. Drop ghostFiles from any entries that reference them, and delete features/flows that no longer exist via save_snapshot's removeFeatures/removeFlows.";
 }
 async function checkDrift(dir) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const report = await computeDrift(rootDir);
   if (!report) {
     return JSON.stringify({
@@ -7590,7 +7782,7 @@ async function checkDrift(dir) {
   return JSON.stringify({ exists: true, ...report, verification, hint });
 }
 async function generateSnapshotBatch(dir, offset = 0, batchSize = DEFAULT_BATCH_SIZE, files) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const scoped = files !== void 0 && files.length > 0;
   const scopeFiles = scoped ? sanitizePaths(rootDir, files) : void 0;
   const batch = await prepareSnapshotBatch(dir, offset, batchSize, scopeFiles);
@@ -7637,7 +7829,7 @@ async function generateSnapshotBatch(dir, offset = 0, batchSize = DEFAULT_BATCH_
   );
 }
 async function saveSnapshotPartial(dir, batchId, offset, features, flows) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   for (const feat of Object.values(features)) {
     feat.files = sanitizePaths(rootDir, feat.files);
     if (feat.tests) feat.tests = sanitizePaths(rootDir, feat.tests);
@@ -7666,7 +7858,7 @@ async function saveSnapshotPartial(dir, batchId, offset, features, flows) {
   );
 }
 async function reduceSnapshot(dir) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const partials = await loadAllPartials(rootDir);
   if (partials.length === 0) {
     return JSON.stringify(
@@ -7728,7 +7920,7 @@ async function reduceSnapshot(dir) {
   );
 }
 async function fullAnalysis(dir) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const [analysis, structure, samples, testMap, snapshot] = await Promise.all([
     analyzeProject(dir),
     getProjectStructure(dir),
@@ -7757,7 +7949,7 @@ function sanitizePaths(rootDir, files) {
   return sanitizeRepoPaths(files);
 }
 async function saveSnapshotData(dir, features, flows, removeFeatures = [], removeFlows = []) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const gitHash = await getCurrentGitHash(rootDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const feat of Object.values(features)) {
@@ -7841,7 +8033,7 @@ async function saveSnapshotData(dir, features, flows, removeFeatures = [], remov
   });
 }
 async function getImpact(dir, files) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const { analyzeImpact: analyzeImpact2 } = await Promise.resolve().then(() => (init_impact(), impact_exports));
   const result = await analyzeImpact2(rootDir, files);
   return JSON.stringify(result, null, 2);
@@ -7850,7 +8042,7 @@ var VERIFY_DEFAULT_SAMPLE = 5;
 var VERIFY_MAX_FILES_PER_ENTRY = 8;
 var VERIFY_SKELETON_CHARS = 500;
 async function verifySnapshot(dir, sample = VERIFY_DEFAULT_SAMPLE) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const snapshot = await loadSnapshot(rootDir);
   if (!snapshot) {
     return JSON.stringify({
@@ -7915,7 +8107,7 @@ async function verifySnapshot(dir, sample = VERIFY_DEFAULT_SAMPLE) {
   });
 }
 async function saveVerification(dir, verdicts) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const snapshot = await loadSnapshot(rootDir);
   if (!snapshot) {
     return JSON.stringify({ exists: false, hint: "No concept map exists." });
@@ -7953,16 +8145,16 @@ async function saveVerification(dir, verdicts) {
   });
 }
 async function saveDecision(dir, input) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const { upsertDecision: upsertDecision2 } = await Promise.resolve().then(() => (init_decisions(), decisions_exports));
   const result = await upsertDecision2(rootDir, input);
   return JSON.stringify(result);
 }
 async function reviewDecision2(dir, input) {
-  return JSON.stringify(await reviewDecision(path27.resolve(dir), input));
+  return JSON.stringify(await reviewDecision(path28.resolve(dir), input));
 }
 async function getContext(dir, task, files) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const { assembleContext: assembleContext2 } = await Promise.resolve().then(() => (init_assemble(), assemble_exports));
   const bundle = await assembleContext2(rootDir, task, files);
   return JSON.stringify(bundle);
@@ -8004,7 +8196,7 @@ async function masonInit(dir, options = {}) {
     return JSON.stringify(await setupProject2(dir, options), null, 2);
   }
   if (options.host) throw new Error("host applies only to mode: setup.");
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const marker = await loadProjectMarker(rootDir);
   const { loadSetup: loadSetup2 } = await Promise.resolve().then(() => (init_model(), model_exports));
   const setup = await loadSetup2(rootDir);
@@ -8024,7 +8216,7 @@ async function masonInit(dir, options = {}) {
   );
 }
 async function masonCompleteInit(dir, options = {}) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const existing = await loadProjectMarker(rootDir);
   const features = await loadProjectFeatures(rootDir);
   const marker = {
@@ -8133,7 +8325,7 @@ async function masonSetConfluence(input) {
   );
 }
 async function exportToConfluenceTool(dir, overrides) {
-  const rootDir = path27.resolve(dir);
+  const rootDir = path28.resolve(dir);
   const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports2));
   const { exportToConfluence: exportToConfluence2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
   const config = await loadConfig2();
@@ -8171,7 +8363,7 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.16.0"
+      version: "0.16.2"
     },
     {
       instructions: 'Mason retrieves recorded decisions, file impact, and optional feature/flow maps. Use get_context with the task and known files, and get_impact before editing. Save learned rationale and constraints with save_decision; review and commit the local records through the project workflow. These tools work without initialization or a concept map. Consult trust and diagnostics: changed or unknown freshness needs source inspection, failed verification needs correction, and proposals are suggestions and legacy records are unreviewed. Accepted decisions are recorded team constraints, still subject to freshness checks. Use review_decision to prepare code evidence and record only authorized acceptance, reaffirmation, or retirement. Never invent a reviewer or treat these recorded identities as authenticated approval. mason_init returns documentation audit and committed-diff review findings with a quickstart guide. Use mode: "map" only when a full architecture map is requested. A missing map is not a setup failure; use decisions and source evidence. get_snapshot provides architecture navigation when a map is available. The mason-audit and mason-review CLIs also work without setup.'
@@ -8508,7 +8700,7 @@ function createMcpServer() {
   );
   server.tool(
     "get_impact",
-    "Trace the impact of changing files: historical co-change partners, references, and related tests. Deterministic, read-only, and usable without initialization, saved decisions, or a concept map.",
+    "Trace historical co-change partners, related tests, and references with evidence: resolved imports, explicit paths, or uncertain name candidates. Candidates are not proven dependencies. Deterministic and read-only; no initialization or concept map required.",
     {
       dir: z19.string().describe("Absolute path to the project root directory"),
       files: z19.array(z19.string()).describe("File paths or names to analyze (e.g., ['WeatherRepository.kt'] or ['src/services/auth.ts'])")