mason-context 0.15.0 → 0.16.1

package/dist/mason-mcp.js

@@ -2832,7 +2832,13 @@ function managedBlock(text2, start, end, body) {
 async function applyEdit(root, edit) {
   const current = await readText(root, edit.path);
   if (current === edit.after) return false;
-  if (current !== edit.before) throw new Error("Setup input changed during installation: " + edit.path + ". Rerun setup to resume.");
+  if (current !== edit.before) throw new Error("Integration input changed during update: " + edit.path + ". Rerun the requested command to resume.");
+  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 fs13.unlink(file2);
+    return true;
+  }
   const file = await storePath(root, edit.path, true);
   const temporary = path19.join(path19.dirname(file), ".mason-setup-" + randomUUID3() + ".tmp");
   try {
@@ -2844,7 +2850,7 @@ async function applyEdit(root, edit) {
     } finally {
       await handle.close();
     }
-    if (await readText(root, edit.path) !== edit.before) throw new Error("Setup input changed during installation: " + edit.path);
+    if (await readText(root, edit.path) !== edit.before) throw new Error("Integration input changed during update: " + edit.path);
     await fs13.rename(temporary, file);
     return true;
   } finally {
@@ -3130,7 +3136,7 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     exec11 = promisify12(execFile12);
-    engineVersion = true ? "0.15.0" : "development";
+    engineVersion = true ? "0.16.1" : "development";
     hash = (value) => createHash4("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
     internal = (file) => file === ".mason" || file === ".mason/reports" || file.startsWith(".mason/reports/");
@@ -3494,6 +3500,79 @@ var init_adapters = __esm({
   }
 });
 
+// src/setup/ownership.ts
+var ownership_exports = {};
+__export(ownership_exports, {
+  BLOCKS: () => BLOCKS,
+  OWNERSHIP_PATH: () => OWNERSHIP_PATH,
+  blockSpan: () => blockSpan,
+  completedHookOwnership: () => completedHookOwnership,
+  ownershipEdit: () => ownershipEdit,
+  ownershipSchema: () => ownershipSchema
+});
+import { z as z10 } 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;
+  if (!starts && !ends) return null;
+  const from = text2.indexOf(start), to = text2.indexOf(end) + end.length;
+  if (starts !== 1 || ends !== 1 || to <= from) throw new Error("Ambiguous Mason markers; inspect the marked block manually.");
+  return { from, to, text: text2.slice(from, to) };
+}
+async function ownershipEdit(root, edits, hookCommands = {}) {
+  const before = await readText(root, OWNERSHIP_PATH);
+  const record = before === null ? { version: 1, files: {} } : ownershipSchema.parse(JSON.parse(before));
+  for (const edit of edits) {
+    const previous = record.files[edit.path];
+    const entry = {
+      created: edit.before === null || (previous?.created ?? false),
+      initialHash: edit.before === null || previous?.initialHash === hash(edit.before) ? hash(edit.after) : previous?.initialHash ?? hash(edit.after),
+      blocks: Object.fromEntries(BLOCKS.flatMap(([start, end]) => {
+        const block = blockSpan(edit.after, start, end);
+        return block ? [[start, hash(block.text)]] : [];
+      }))
+    };
+    const mcp = edit.path === ".codex/config.toml" ? parse(edit.after).mcp_servers?.mason : edit.path === ".mcp.json" ? JSON.parse(edit.after).mcpServers?.mason : void 0;
+    const hooks = edit.path === ".codex/hooks.json" || edit.path === ".claude/settings.json" ? JSON.parse(edit.after).hooks : void 0;
+    record.files[edit.path] = {
+      ...entry,
+      ...mcp === void 0 ? {} : { mcpHash: hash(mcp) },
+      ...hookCommands[edit.path] ? { hookCommands: [.../* @__PURE__ */ new Set([...previous?.hookCommands ?? [], hookCommands[edit.path]])] } : {},
+      ...hooks === void 0 ? {} : { hooks: Object.fromEntries(Object.entries(hooks).map(([event, groups]) => [event, groups.flatMap((group) => group.hooks.map(hash))])) }
+    };
+  }
+  return { path: OWNERSHIP_PATH, before, after: JSON.stringify(record, null, 2) + "\n" };
+}
+async function completedHookOwnership(root, file, command) {
+  const before = await readText(root, OWNERSHIP_PATH);
+  const record = ownershipSchema.parse(JSON.parse(before ?? "null"));
+  record.files[file].hookCommands = [command];
+  return { path: OWNERSHIP_PATH, before, after: JSON.stringify(record, null, 2) + "\n" };
+}
+var OWNERSHIP_PATH, BLOCKS, fileSchema, ownershipSchema;
+var init_ownership = __esm({
+  "src/setup/ownership.ts"() {
+    "use strict";
+    init_evidence();
+    init_files2();
+    OWNERSHIP_PATH = ".mason/local/integration.json";
+    BLOCKS = [
+      ["<!-- mason:start -->", "<!-- mason:end -->"],
+      ["<!-- mason:agents:start -->", "<!-- mason:agents:end -->"],
+      ["# mason:mcp:start", "# mason:mcp:end"]
+    ];
+    fileSchema = z10.object({
+      created: z10.boolean(),
+      initialHash: z10.string(),
+      blocks: z10.record(z10.string()),
+      mcpHash: z10.string().optional(),
+      hookCommands: z10.array(z10.string()).optional(),
+      hooks: z10.record(z10.array(z10.string())).optional()
+    });
+    ownershipSchema = z10.object({ version: z10.literal(1), files: z10.record(fileSchema) });
+  }
+});
+
 // src/automation/install.ts
 var install_exports = {};
 __export(install_exports, {
@@ -3502,24 +3581,28 @@ __export(install_exports, {
   configPath: () => configPath,
   installAutomation: () => installAutomation,
   installedAutomation: () => installedAutomation,
-  planAutomationInstall: () => planAutomationInstall
+  planAutomationInstall: () => planAutomationInstall,
+  recordSchema: () => recordSchema
 });
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 async function installationRecord(root) {
   return recordSchema.parse(await readStoreJson(root, AUTOMATION_PATH) ?? { version: 1, hosts: {} });
 }
 async function installAutomation(dir, host, command) {
   const ws = await workspace(dir);
-  return withLock(ws.root, ".mason/reports/automation-install", () => installLocked(ws.root, host, command));
+  return withLock(ws.root, ".mason/reports/setup-lock", () => installLocked(ws.root, host, command));
 }
 async function planAutomationInstall(root, host, command) {
   const file = configPath(host);
-  const existing = automationConfigSchema.parse(await readStoreJson(root, file) ?? {});
+  const before = await readText(root, file);
+  const existing = automationConfigSchema.parse(JSON.parse(before ?? "{}"));
   const record = await installationRecord(root);
   const desired = hookConfig(host, command);
   const newCommand = desired.hooks.SessionStart[0].hooks[0].command;
   const previous = record.hosts[host]?.command;
-  const owned = /* @__PURE__ */ new Set([previous, newCommand]);
+  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 hooks = existing.hooks ?? {};
   for (const event of HOOK_EVENTS) {
     hooks[event] = (hooks[event] ?? []).map((group) => ({
@@ -3529,15 +3612,20 @@ async function planAutomationInstall(root, host, command) {
     hooks[event].push(...desired.hooks[event]);
   }
   record.hosts[host] = { command: newCommand };
-  return { file, config: { ...existing, hooks }, record, newCommand };
+  return { file, before, config: { ...existing, hooks }, record, newCommand };
 }
 async function installLocked(root, host, command) {
-  const { file, config, record, newCommand } = await planAutomationInstall(root, host, command);
+  const { file, before, config, record, newCommand } = await planAutomationInstall(root, host, command);
   const { ancillaryEdits: ancillaryEdits2 } = await Promise.resolve().then(() => (init_config(), config_exports));
   const { applyEdit: applyEdit2 } = await Promise.resolve().then(() => (init_files2(), files_exports));
-  for (const edit of await ancillaryEdits2(root)) await applyEdit2(root, edit);
-  await writeStoreJson(root, file, config);
+  const { ownershipEdit: ownershipEdit2, completedHookOwnership: completedHookOwnership2 } = await Promise.resolve().then(() => (init_ownership(), ownership_exports));
+  const edit = { path: file, before, after: JSON.stringify(config, null, 2) + "\n" };
+  const ancillary = await ancillaryEdits2(root);
+  await applyEdit2(root, await ownershipEdit2(root, [edit], { [file]: newCommand }));
+  for (const edit2 of ancillary) await applyEdit2(root, edit2);
+  await applyEdit2(root, edit);
   await writeStoreJson(root, AUTOMATION_PATH, record);
+  await applyEdit2(root, await completedHookOwnership2(root, file, newCommand));
   return {
     version: 1,
     host,
@@ -3575,9 +3663,11 @@ var init_install = __esm({
     init_evidence();
     init_adapters();
     init_store();
-    groupSchema = z10.object({ hooks: z10.array(z10.object({ type: z10.string(), command: z10.string().optional() }).passthrough()) }).passthrough();
-    automationConfigSchema = z10.object({ hooks: z10.record(z10.array(groupSchema)).optional() }).passthrough();
-    recordSchema = z10.object({ version: z10.literal(1), hosts: z10.record(z10.object({ command: z10.string() })) });
+    init_files2();
+    init_ownership();
+    groupSchema = z11.object({ hooks: z11.array(z11.object({ type: z11.string(), command: z11.string().optional() }).passthrough()) }).passthrough();
+    automationConfigSchema = z11.object({ hooks: z11.record(z11.array(groupSchema)).optional() }).passthrough();
+    recordSchema = z11.object({ version: z11.literal(1), hosts: z11.record(z11.object({ command: z11.string() })) });
     AUTOMATION_PATH = ".mason/local/automation.json";
     configPath = (host) => host === "claude" ? ".claude/settings.json" : ".codex/hooks.json";
   }
@@ -3592,7 +3682,7 @@ __export(model_exports, {
   setupHostSchema: () => setupHostSchema,
   setupSchema: () => setupSchema
 });
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 async function loadSetup(root) {
   const raw = await readStoreJson(root, SETUP_PATH);
   if (raw === null) return null;
@@ -3610,27 +3700,27 @@ var init_model = __esm({
   "src/setup/model.ts"() {
     "use strict";
     init_storage();
-    setupHostSchema = z11.object({
-      configuredVersion: z11.string(),
-      revision: z11.string().uuid(),
-      fingerprint: z11.string(),
-      mcpFingerprint: z11.string(),
-      instructions: z11.array(z11.string())
+    setupHostSchema = z12.object({
+      configuredVersion: z12.string(),
+      revision: z12.string().uuid(),
+      fingerprint: z12.string(),
+      mcpFingerprint: z12.string(),
+      instructions: z12.array(z12.string())
     });
-    setupSchema = z11.object({ version: z11.literal(2), hosts: z11.object({
+    setupSchema = z12.object({ version: z12.literal(2), hosts: z12.object({
       codex: setupHostSchema.optional(),
       claude: setupHostSchema.optional()
     }) });
     SETUP_PATH = ".mason/local/setup.json";
-    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()
+    receiptSchema = z12.object({
+      version: z12.literal(1),
+      host: z12.enum(["codex", "claude"]),
+      status: z12.enum(["installing", "configured"]),
+      initialReportPath: z12.string(),
+      initialBaselinePaths: z12.array(z12.string()),
+      root: z12.string(),
+      revision: z12.string().uuid(),
+      configuredAt: z12.string().optional()
     });
   }
 });
@@ -3662,7 +3752,7 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.15.0" : "development";
+    executingVersion = () => true ? "0.16.1" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host} auto`;
   }
@@ -3679,8 +3769,8 @@ __export(config_exports, {
   mcpPath: () => mcpPath
 });
 import { isDeepStrictEqual } from "util";
-import { parse, stringify } from "smol-toml";
-import { z as z12 } from "zod";
+import { parse as parse2, stringify } from "smol-toml";
+import { z as z13 } 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);
@@ -3721,7 +3811,7 @@ async function mcpEdit(root, host) {
     const servers2 = object.parse(config2.mcpServers ?? {});
     return { path: file, before, after: JSON.stringify({ ...config2, mcpServers: { ...servers2, mason: managedMcp(servers2.mason, host) } }, null, 2) + "\n" };
   }
-  const config = parse(before ?? "");
+  const config = parse2(before ?? "");
   const managed = (before ?? "").includes(TOML_START);
   const servers = config.mcp_servers;
   const desired = managedMcp(servers?.mason, host);
@@ -3733,7 +3823,7 @@ async function mcpEdit(root, host) {
     for (const span of spans.reverse()) base = base.slice(0, span.start) + base.slice(span.end);
   }
   const after = managedBlock(base, TOML_START, TOML_END, stringify({ mcp_servers: { mason: desired } }).trimEnd());
-  const parsed = parse(after);
+  const parsed = parse2(after);
   const expected = { ...config, mcp_servers: { ...servers ?? {}, mason: desired } };
   if (!isDeepStrictEqual(parsed, expected)) throw new Error("Could not safely configure the Mason MCP entry without changing other settings.");
   return { path: file, before, after };
@@ -3771,7 +3861,7 @@ async function ancillaryEdits(root) {
 }
 async function inspectHostConfig(root, host, plannedMcp) {
   const text2 = plannedMcp ?? await readText(root, mcpPath(host));
-  const config = host === "codex" ? parse(text2 ?? "") : object.parse(JSON.parse(text2 ?? "{}"));
+  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 expected = hookConfig(host, hookCommand(host));
@@ -3796,7 +3886,7 @@ var init_config = __esm({
     init_install();
     init_files2();
     init_launcher();
-    object = z12.record(z12.unknown());
+    object = z13.record(z13.unknown());
     mcpPath = (host) => host === "codex" ? ".codex/config.toml" : ".mcp.json";
     TOML_START = "# mason:mcp:start";
     TOML_END = "# mason:mcp:end";
@@ -3806,7 +3896,7 @@ var init_config = __esm({
 });
 
 // src/mcp/init.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 async function loadProjectMarker(rootDir) {
   const raw = await readStoreJson(rootDir, ".mason/local/project.json");
   if (raw === null) return null;
@@ -3814,8 +3904,8 @@ async function loadProjectMarker(rootDir) {
   return { ...marker, features: await loadProjectFeatures(rootDir) };
 }
 async function loadProjectFeatures(rootDir) {
-  const config = z13.record(z13.unknown()).parse(await readStoreJson(rootDir, ".mason/config.json") ?? {});
-  return z13.object({ confluence: z13.boolean().optional() }).passthrough().parse(config.features ?? {});
+  const config = z14.record(z14.unknown()).parse(await readStoreJson(rootDir, ".mason/config.json") ?? {});
+  return z14.object({ confluence: z14.boolean().optional() }).passthrough().parse(config.features ?? {});
 }
 async function saveProjectMarker(rootDir, marker) {
   const { ancillaryEdits: ancillaryEdits2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -3827,8 +3917,8 @@ async function projectMarkerEdits(rootDir, marker) {
   const edits = [{ path: file, before: await readText(rootDir, file), after: JSON.stringify(local, null, 2) + "\n" }];
   if (features && Object.keys(features).length) {
     const configPath2 = ".mason/config.json", before = await readText(rootDir, configPath2);
-    const config = z13.record(z13.unknown()).parse(JSON.parse(before ?? "{}"));
-    config.features = { ...z13.record(z13.unknown()).parse(config.features ?? {}), ...features };
+    const config = z14.record(z14.unknown()).parse(JSON.parse(before ?? "{}"));
+    config.features = { ...z14.record(z14.unknown()).parse(config.features ?? {}), ...features };
     edits.push({ path: configPath2, before, after: JSON.stringify(config, null, 2) + "\n" });
   }
   return edits;
@@ -3842,19 +3932,19 @@ var init_init = __esm({
     "use strict";
     init_storage();
     init_files2();
-    markerSchema = z13.object({
-      version: z13.literal(1),
-      initializedAt: z13.string(),
-      features: z13.object({ confluence: z13.boolean().optional() }).passthrough().optional()
+    markerSchema = z14.object({
+      version: z14.literal(1),
+      initializedAt: z14.string(),
+      features: z14.object({ confluence: z14.boolean().optional() }).passthrough().optional()
     }).passthrough();
     CLAUDE_MD_SECTION = `<!-- mason:start -->
 ## Mason project knowledge
 
 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.
@@ -4039,7 +4129,7 @@ var init_types2 = __esm({
 });
 
 // src/review/evidence/vitest.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function parseVitest(raw, sourceRoot) {
   const report = schema.parse(raw);
   const findings = [], diagnostics = [];
@@ -4088,24 +4178,24 @@ var init_vitest = __esm({
     "use strict";
     init_paths2();
     init_types2();
-    count2 = z14.number().int().nonnegative();
-    schema = z14.object({
-      success: z14.boolean(),
+    count2 = z15.number().int().nonnegative();
+    schema = z15.object({
+      success: z15.boolean(),
       numTotalTests: count2,
       numPassedTests: count2,
       numFailedTests: count2,
       numPendingTests: count2,
       numTodoTests: count2,
       numFailedTestSuites: count2,
-      testResults: z14.array(z14.object({
-        name: z14.string().min(1),
-        status: z14.enum(["passed", "failed"]),
-        message: z14.string().optional(),
-        assertionResults: z14.array(z14.object({
-          fullName: z14.string(),
-          status: z14.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
-          failureMessages: z14.array(z14.string()).nullable().optional(),
-          location: z14.object({ line: count2, column: count2 }).nullable().optional()
+      testResults: z15.array(z15.object({
+        name: z15.string().min(1),
+        status: z15.enum(["passed", "failed"]),
+        message: z15.string().optional(),
+        assertionResults: z15.array(z15.object({
+          fullName: z15.string(),
+          status: z15.enum(["passed", "failed", "pending", "skipped", "todo", "disabled"]),
+          failureMessages: z15.array(z15.string()).nullable().optional(),
+          location: z15.object({ line: count2, column: count2 }).nullable().optional()
         }))
       }))
     });
@@ -4113,7 +4203,7 @@ var init_vitest = __esm({
 });
 
 // src/review/evidence/sarif.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function parseSarif(raw, sourceRoot) {
   const report = schema2.parse(raw), findings = [], diagnostics = [];
   let active = 0, suppressed = 0, absent = 0, unresolved = 0;
@@ -4204,29 +4294,29 @@ var init_sarif = __esm({
     "use strict";
     init_paths2();
     init_types2();
-    index = z15.number().int().nonnegative();
-    artifact = z15.object({ uri: z15.string().optional(), uriBaseId: z15.string().optional(), index: index.optional() });
-    message = z15.object({ text: z15.string().optional(), markdown: z15.string().optional(), id: z15.string().optional(), arguments: z15.array(z15.string()).optional() });
-    level = z15.enum(["error", "warning", "note", "none"]);
-    location = z15.object({ physicalLocation: z15.object({ artifactLocation: artifact.optional(), region: z15.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
-    schema2 = z15.object({
-      version: z15.literal("2.1.0"),
-      runs: z15.array(z15.object({
-        tool: z15.object({ driver: z15.object({ name: z15.string().min(1), rules: z15.array(z15.object({ id: z15.string(), defaultConfiguration: z15.object({ level: level.optional() }).optional(), messageStrings: z15.record(message).optional() })).optional(), globalMessageStrings: z15.record(message).optional() }) }),
-        invocations: z15.array(z15.object({ executionSuccessful: z15.boolean(), commandLine: z15.string().optional(), toolExecutionNotifications: z15.array(z15.object({ level: level.optional(), message })).optional() })).optional(),
-        versionControlProvenance: z15.array(z15.object({ revisionId: z15.string().optional() })).optional(),
-        originalUriBaseIds: z15.record(artifact).optional(),
-        artifacts: z15.array(z15.object({ location: artifact.optional() })).optional(),
-        results: z15.array(z15.object({
-          ruleId: z15.string().optional(),
+    index = z16.number().int().nonnegative();
+    artifact = z16.object({ uri: z16.string().optional(), uriBaseId: z16.string().optional(), index: index.optional() });
+    message = z16.object({ text: z16.string().optional(), markdown: z16.string().optional(), id: z16.string().optional(), arguments: z16.array(z16.string()).optional() });
+    level = z16.enum(["error", "warning", "note", "none"]);
+    location = z16.object({ physicalLocation: z16.object({ artifactLocation: artifact.optional(), region: z16.object({ startLine: index.optional(), startColumn: index.optional() }).optional() }).optional() });
+    schema2 = z16.object({
+      version: z16.literal("2.1.0"),
+      runs: z16.array(z16.object({
+        tool: z16.object({ driver: z16.object({ name: z16.string().min(1), rules: z16.array(z16.object({ id: z16.string(), defaultConfiguration: z16.object({ level: level.optional() }).optional(), messageStrings: z16.record(message).optional() })).optional(), globalMessageStrings: z16.record(message).optional() }) }),
+        invocations: z16.array(z16.object({ executionSuccessful: z16.boolean(), commandLine: z16.string().optional(), toolExecutionNotifications: z16.array(z16.object({ level: level.optional(), message })).optional() })).optional(),
+        versionControlProvenance: z16.array(z16.object({ revisionId: z16.string().optional() })).optional(),
+        originalUriBaseIds: z16.record(artifact).optional(),
+        artifacts: z16.array(z16.object({ location: artifact.optional() })).optional(),
+        results: z16.array(z16.object({
+          ruleId: z16.string().optional(),
           ruleIndex: index.optional(),
           message,
           level: level.optional(),
-          kind: z15.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
-          baselineState: z15.enum(["new", "unchanged", "updated", "absent"]).optional(),
-          suppressions: z15.array(z15.object({ kind: z15.enum(["inSource", "external"]), status: z15.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
-          locations: z15.array(location).optional(),
-          relatedLocations: z15.array(location).optional()
+          kind: z16.enum(["fail", "pass", "open", "informational", "notApplicable", "review"]).optional(),
+          baselineState: z16.enum(["new", "unchanged", "updated", "absent"]).optional(),
+          suppressions: z16.array(z16.object({ kind: z16.enum(["inSource", "external"]), status: z16.enum(["accepted", "underReview", "rejected"]).optional() })).nullable().optional(),
+          locations: z16.array(location).optional(),
+          relatedLocations: z16.array(location).optional()
         })).optional()
       }))
     });
@@ -4235,7 +4325,7 @@ var init_sarif = __esm({
 
 // src/review/evidence.ts
 import path21 from "path";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 function relativeArtifact(root, file) {
   const relative = path21.isAbsolute(file) ? path21.relative(root, file) : file;
   const normalized = normalizeRepoPath(relative);
@@ -4276,7 +4366,7 @@ async function collectReviewEvidence(root, manifests, changedFiles, decisions, d
     let manifest, raw;
     try {
       manifest = relativeArtifact(root, supplied);
-      raw = z16.object({ version: z16.literal(1), checks: z16.array(z16.unknown()) }).parse(await readStoreJson(root, manifest));
+      raw = z17.object({ version: z17.literal(1), checks: z17.array(z17.unknown()) }).parse(await readStoreJson(root, manifest));
     } catch (error) {
       output.diagnostics.push(`${supplied}: ${String(error)}`);
       continue;
@@ -4429,19 +4519,19 @@ var init_evidence2 = __esm({
     init_vitest();
     init_sarif();
     init_types2();
-    checkSchema2 = z16.object({
-      id: z16.string().min(1).max(100),
-      kind: z16.enum(["tests", "static-analysis", "security", "complexity", "duplication"]),
-      tool: z16.string().min(1).max(200),
-      command: z16.string().min(1).max(2e3),
-      commit: z16.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
-      workingTreeClean: z16.boolean().optional(),
-      source: z16.string().max(2e3).optional(),
-      sourceRoot: z16.string().min(1).max(4e3).optional(),
-      status: z16.enum(["completed", "skipped", "unavailable"]).default("completed"),
-      reason: z16.string().min(1).max(2e3).optional(),
-      exitCode: z16.number().int().nullable().optional(),
-      report: z16.object({ format: z16.enum(["vitest-json", "sarif"]), path: z16.string().min(1).max(4e3) }).optional()
+    checkSchema2 = z17.object({
+      id: z17.string().min(1).max(100),
+      kind: z17.enum(["tests", "static-analysis", "security", "complexity", "duplication"]),
+      tool: z17.string().min(1).max(200),
+      command: z17.string().min(1).max(2e3),
+      commit: z17.string().regex(/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/).nullable().optional(),
+      workingTreeClean: z17.boolean().optional(),
+      source: z17.string().max(2e3).optional(),
+      sourceRoot: z17.string().min(1).max(4e3).optional(),
+      status: z17.enum(["completed", "skipped", "unavailable"]).default("completed"),
+      reason: z17.string().min(1).max(2e3).optional(),
+      exitCode: z17.number().int().nullable().optional(),
+      report: z17.object({ format: z17.enum(["vitest-json", "sarif"]), path: z17.string().min(1).max(4e3) }).optional()
     });
   }
 });
@@ -4661,16 +4751,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),
@@ -4747,52 +5025,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 = [
@@ -4812,9 +5062,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({
@@ -4826,15 +5076,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);
   }
 });
@@ -4844,13 +5092,13 @@ var assemble_exports = {};
 __export(assemble_exports, {
   assembleContext: () => assembleContext
 });
-import path24 from "path";
+import path25 from "path";
 import fs17 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 fs17.stat(path25.join(root, candidate)).catch(() => null);
     if (stat?.isDirectory()) {
       sourceFiles ??= await (await createFileAccess(root)).list();
       for (const file of sourceFiles) {
@@ -4864,13 +5112,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);
@@ -5072,7 +5326,7 @@ __export(observations_exports, {
   readObservation: () => readObservation
 });
 import fs18 from "fs/promises";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 function observationPath(directory, host, revision, version = executingVersion()) {
   return `${directory}/activation/${host}-${revision}-${hash(version).slice(0, 12)}.json`;
 }
@@ -5137,19 +5391,19 @@ var init_observations = __esm({
     init_storage();
     init_model();
     init_launcher();
-    observationSchema = z17.object({
-      version: z17.literal(1),
-      masonVersion: z17.string(),
-      root: z17.string(),
-      revision: z17.string(),
-      host: z17.enum(["codex", "claude"]),
-      contextCalls: z17.number().int().nonnegative(),
-      lastContextAt: z17.string().optional(),
-      sessions: z17.record(z17.object({
-        events: z17.array(z17.enum(events)),
-        at: z17.string(),
-        verificationStatus: z17.string().optional(),
-        reportPath: z17.string().optional()
+    observationSchema = z18.object({
+      version: z18.literal(1),
+      masonVersion: z18.string(),
+      root: z18.string(),
+      revision: z18.string(),
+      host: z18.enum(["codex", "claude"]),
+      contextCalls: z18.number().int().nonnegative(),
+      lastContextAt: z18.string().optional(),
+      sessions: z18.record(z18.object({
+        events: z18.array(z18.enum(events)),
+        at: z18.string(),
+        verificationStatus: z18.string().optional(),
+        reportPath: z18.string().optional()
       }))
     });
   }
@@ -5289,6 +5543,8 @@ async function setupProject(dir, options = {}) {
     const setupBefore = await readText(ws.root, SETUP_PATH);
     const mcpFingerprint = hash((await inspectHostConfig(ws.root, host, mcp.after)).mcp);
     const desiredHooks = hookConfig(host, hookCommand(host)).hooks;
+    const configuredHook = desiredHooks.SessionStart[0].hooks[0].command;
+    const ownership = await ownershipEdit(ws.root, [...instructions, mcp, hooks[0]], { [hooks[0].path]: configuredHook });
     const fingerprint = hash({
       command: "mason",
       mcp: mcpFingerprint,
@@ -5315,8 +5571,10 @@ async function setupProject(dir, options = {}) {
       revision
     });
     const changedFiles = [];
+    if (await applyEdit(ws.root, ownership)) changedFiles.push(ownership.path);
     for (const edit of edits) if (await applyEdit(ws.root, edit)) changedFiles.push(edit.path);
     if (await applyEdit(ws.root, { path: SETUP_PATH, before: setupBefore, after: JSON.stringify(setup, null, 2) + "\n" })) changedFiles.push(SETUP_PATH);
+    if (await applyEdit(ws.root, await completedHookOwnership(ws.root, hooks[0].path, configuredHook)) && !changedFiles.includes(ownership.path)) changedFiles.push(ownership.path);
     const checked = await automate(ws.root, { event: "turn_start" });
     const configured = await inspectHostConfig(ws.root, host, void 0);
     await writeStoreJson(ws.root, receiptPath, {
@@ -5375,6 +5633,7 @@ var init_setup = __esm({
     init_adapters();
     init_model();
     init_status();
+    init_ownership();
   }
 });
 
@@ -5386,8 +5645,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,
@@ -5399,7 +5658,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;
@@ -5501,15 +5760,15 @@ __export(config_exports2, {
   validateProvider: () => validateProvider
 });
 import fs19 from "fs/promises";
-import path25 from "path";
+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 {
@@ -5589,21 +5848,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.`
   );
@@ -5619,7 +5878,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.`
@@ -5630,33 +5889,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) {
@@ -5682,16 +5941,16 @@ var init_renderer = __esm({
 
 // src/confluence/diff.ts
 import fs20 from "fs/promises";
-import path26 from "path";
+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 {
@@ -6255,12 +6514,12 @@ var init_sync = __esm({
 init_provenance();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/mcp/tools.ts
 init_repair();
 import fs21 from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import { execFile as execFile19 } from "child_process";
 import { promisify as promisify19 } from "util";
 
@@ -7155,7 +7414,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);
@@ -7210,7 +7469,7 @@ async function detectProjectSnapshot(rootDir) {
   const present = [];
   for (const file of buildFiles) {
     try {
-      await fs21.access(path27.join(rootDir, file));
+      await fs21.access(path28.join(rootDir, file));
       present.push(file);
     } catch {
     }
@@ -7252,7 +7511,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 {
@@ -7263,7 +7522,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.",
@@ -7306,7 +7565,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) {
@@ -7318,7 +7577,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);
       }
@@ -7363,7 +7622,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);
@@ -7464,7 +7723,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({
@@ -7495,7 +7754,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);
@@ -7542,7 +7801,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);
@@ -7571,7 +7830,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(
@@ -7633,7 +7892,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),
@@ -7662,7 +7921,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)) {
@@ -7746,7 +8005,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);
@@ -7755,7 +8014,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({
@@ -7820,7 +8079,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." });
@@ -7858,16 +8117,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);
@@ -7909,7 +8168,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);
@@ -7929,7 +8188,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 = {
@@ -8038,7 +8297,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();
@@ -8076,7 +8335,7 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.15.0"
+      version: "0.16.1"
     },
     {
       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.'
@@ -8086,11 +8345,11 @@ function createMcpServer() {
     "mason_init",
     "Inspect this project now: returns documentation audit findings, committed-diff review findings, decision/map status, and a quickstart playbook. Quickstart and map modes are read-only and deterministic. Explicit mode: setup configures MCP, instructions and lifecycle hooks to use mason on PATH while retaining original audit evidence; use it only when the user requests setup. Optional host selects codex or claude. Optional base selects the review comparison; evidence imports CI manifests with check outcomes, commit freshness, and links to changed files and accepted decisions. mode: map returns the full Map-Reduce build workflow. Repeat calls refresh findings even after setup.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      mode: z18.enum(["quickstart", "map", "setup"]).optional().default("quickstart").describe("Quickstart inspects without edits; map requests an architecture build; setup installs the shared onboarding flow."),
-      host: z18.enum(["codex", "claude"]).optional().describe("Assistant to configure in setup mode; inferred only when unambiguous."),
-      base: z18.string().optional().describe("Git ref for committed-diff review. Defaults to the first available main branch ref."),
-      evidence: z18.array(z18.string()).max(10).optional().describe("Repository-local CI evidence manifests to include in the review. Imports Vitest JSON and SARIF without executing check commands.")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      mode: z19.enum(["quickstart", "map", "setup"]).optional().default("quickstart").describe("Quickstart inspects without edits; map requests an architecture build; setup installs the shared onboarding flow."),
+      host: z19.enum(["codex", "claude"]).optional().describe("Assistant to configure in setup mode; inferred only when unambiguous."),
+      base: z19.string().optional().describe("Git ref for committed-diff review. Defaults to the first available main branch ref."),
+      evidence: z19.array(z19.string()).max(10).optional().describe("Repository-local CI evidence manifests to include in the review. Imports Vitest JSON and SARIF without executing check commands.")
     },
     async ({ dir, mode, host, base, evidence }) => {
       const result = await masonInit(dir, { mode, host, base, evidence });
@@ -8101,8 +8360,8 @@ function createMcpServer() {
     "mason_automation",
     "Inspect installed automation and observed host events, or resume/check retained documentation repair evidence across sessions. status is read-only; check saves local baselines and verification reports without editing source or approving advisories. Returns concise results with a full report path. Works without a map.",
     {
-      dir: z18.string().describe("Absolute path to the project directory"),
-      action: z18.enum(["status", "check"]).describe("Inspect configuration and receipts, or capture/resume and verify original audit evidence.")
+      dir: z19.string().describe("Absolute path to the project directory"),
+      action: z19.enum(["status", "check"]).describe("Inspect configuration and receipts, or capture/resume and verify original audit evidence.")
     },
     async ({ dir, action }) => ({ content: [{ type: "text", text: await masonAutomation(dir, action) }] })
   );
@@ -8110,10 +8369,10 @@ function createMcpServer() {
     "mason_repair",
     "Track documentation repairs against original audit evidence. prepare saves a local baseline and returns a scoped work order; verify reads that baseline and reports resolved, unresolved, review-required, unverified, and new findings. Suppressed advisories remain unresolved. Does not edit documentation or approve decisions. No map required.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      action: z18.enum(["prepare", "verify"]),
-      baselinePath: z18.string().optional().describe("Original baseline path returned by prepare; required for verify."),
-      checks: z18.array(z18.enum(["deleted-reference", "new-module", "stale-count", "dead-command", "deps-changed", "decision-anchor-drift"])).min(1).optional().describe("Optional audit check subset for prepare. Verification always uses the original checks.")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      action: z19.enum(["prepare", "verify"]),
+      baselinePath: z19.string().optional().describe("Original baseline path returned by prepare; required for verify."),
+      checks: z19.array(z19.enum(["deleted-reference", "new-module", "stale-count", "dead-command", "deps-changed", "decision-anchor-drift"])).min(1).optional().describe("Optional audit check subset for prepare. Verification always uses the original checks.")
     },
     async ({ dir, action, baselinePath, checks }) => {
       const result = await masonRepair(dir, { action, baselinePath, checks });
@@ -8124,8 +8383,8 @@ function createMcpServer() {
     "mason_complete_init",
     "Record assistant instruction setup locally in ignored .mason/local/project.json, with feature settings in shared .mason/config.json. Other tools work without this marker. Repeated calls preserve the original setup time and existing settings; pass confluenceConfigured only to change that setting.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      confluenceConfigured: z18.boolean().optional().describe("Set the Confluence setup status; omit to preserve the existing value")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      confluenceConfigured: z19.boolean().optional().describe("Set the Confluence setup status; omit to preserve the existing value")
     },
     async ({ dir, confluenceConfigured }) => {
       const result = await masonCompleteInit(dir, { confluenceConfigured });
@@ -8136,11 +8395,11 @@ function createMcpServer() {
     "mason_set_confluence",
     "Configure Confluence credentials. Two-step flow: (1) call without `spaceKey` to validate the credentials and receive a list of available spaces \u2014 relay them to the user. (2) call again with the same `baseUrl`/`email`/`apiToken` plus the chosen `spaceKey` to persist. Credentials are stored in `~/.mason/config.json`. Warn the user that the API token will be visible in chat history before they paste it.",
     {
-      baseUrl: z18.string().describe("Confluence base URL. Accepts `acme`, `acme.atlassian.net`, or `https://acme.atlassian.net` (normalized automatically)."),
-      email: z18.string().describe("User's Atlassian account email"),
-      apiToken: z18.string().describe("API token from id.atlassian.com/manage-profile/security/api-tokens"),
-      spaceKey: z18.string().optional().describe("Confluence space key. Omit on the first call to list available spaces."),
-      parentPageId: z18.string().optional().describe("Optional parent page ID under which Mason's index page is created")
+      baseUrl: z19.string().describe("Confluence base URL. Accepts `acme`, `acme.atlassian.net`, or `https://acme.atlassian.net` (normalized automatically)."),
+      email: z19.string().describe("User's Atlassian account email"),
+      apiToken: z19.string().describe("API token from id.atlassian.com/manage-profile/security/api-tokens"),
+      spaceKey: z19.string().optional().describe("Confluence space key. Omit on the first call to list available spaces."),
+      parentPageId: z19.string().optional().describe("Optional parent page ID under which Mason's index page is created")
     },
     async ({ baseUrl, email, apiToken, spaceKey, parentPageId }) => {
       const result = await masonSetConfluence({
@@ -8157,7 +8416,7 @@ function createMcpServer() {
     "full_analysis",
     "One-shot orientation for a project WITHOUT a concept map (get_snapshot returned exists:false). Returns git history stats, project structure with file counts, curated code sample previews (~60 lines each), and test-to-source mapping. On a mapped project, prefer get_snapshot \u2014 it is cheaper and answers feature/architecture questions directly.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory")
+      dir: z19.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await fullAnalysis(dir);
@@ -8170,7 +8429,7 @@ function createMcpServer() {
     "analyze_project",
     "Run git history analysis on a codebase. Returns commit convention patterns, stale directories, and frequently changed files. These are aggregate stats across hundreds of commits that would be expensive to compute manually.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory")
+      dir: z19.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await analyzeProject(dir);
@@ -8183,8 +8442,8 @@ function createMcpServer() {
     "get_code_samples",
     "Get previews (first ~60 lines) of representative source files from the codebase. Includes entry points, config files, hot files (frequently changed), test examples, and one file per directory for breadth. Read files natively for full content.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      count: z18.number().optional().default(15).describe("Maximum number of files to sample (default: 15)")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      count: z19.number().optional().default(15).describe("Maximum number of files to sample (default: 15)")
     },
     async ({ dir, count: count3 }) => {
       const result = await getCodeSamples(dir, count3);
@@ -8197,7 +8456,7 @@ function createMcpServer() {
     "get_snapshot",
     "Return the optional feature-to-file architecture map with drift and trust evidence. If no map exists, returns exists:false plus project structure, Git signals, and test pairs. Decision capture, get_context, and get_impact still work. No initialization required.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory")
+      dir: z19.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await getSnapshot(dir);
@@ -8210,9 +8469,9 @@ function createMcpServer() {
     "get_context",
     "Assemble task context: matching decisions with rationale, approval, owner, sources, last review, and freshness, plus related tests, file impact, and any available map entries. Proposals are suggestions; legacy records are unreviewed; accepted decisions are constraints subject to freshness. No initialization or map required. Pass task and optional files. map.status and diagnostics preserve missing or invalid knowledge. Impact covers up to three unique files, expanding directory anchors.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      task: z18.string().describe("The task, bug, or change request in natural language \u2014 e.g. 'add rate limiting to the API client' or a ticket description"),
-      files: z18.array(z18.string()).optional().describe("Optional file paths already known to be involved (e.g. from a diff or stack trace). Entries containing them are boosted above pure text matches.")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      task: z19.string().describe("The task, bug, or change request in natural language \u2014 e.g. 'add rate limiting to the API client' or a ticket description"),
+      files: z19.array(z19.string()).optional().describe("Optional file paths already known to be involved (e.g. from a diff or stack trace). Entries containing them are boosted above pure text matches.")
     },
     async ({ dir, task, files }) => {
       const result = await getContext(dir, task, files);
@@ -8228,10 +8487,10 @@ function createMcpServer() {
     "generate_snapshot_batch",
     "Map step of the concept-map build. Returns one batch of source files (skeletons of every file in the batch plus a few deeper-read bodies for grounding), along with a system prompt instructing you to derive features and flows for ONLY this batch. Call repeatedly with the returned `nextOffset` until it is null, calling `save_partial_snapshot` between each call. Use product-natural feature names so partials merge cleanly in the reduce step.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      offset: z18.number().int().optional().describe("0-indexed file offset to start the batch at. Omit on the first call; pass the `nextOffset` from the previous response for subsequent calls."),
-      batchSize: z18.number().int().optional().describe("Files per batch. Defaults to 50."),
-      files: z18.array(z18.string()).optional().describe("Scope the batch walk to this explicit file list \u2014 e.g. the drift set from mason_check_drift (changedFiles + unmappedFiles). Pass the SAME list on every batch call of one refresh run. Triggers refresh mode: reduce_snapshot will merge the partials into the existing map instead of rebuilding it.")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      offset: z19.number().int().optional().describe("0-indexed file offset to start the batch at. Omit on the first call; pass the `nextOffset` from the previous response for subsequent calls."),
+      batchSize: z19.number().int().optional().describe("Files per batch. Defaults to 50."),
+      files: z19.array(z19.string()).optional().describe("Scope the batch walk to this explicit file list \u2014 e.g. the drift set from mason_check_drift (changedFiles + unmappedFiles). Pass the SAME list on every batch call of one refresh run. Triggers refresh mode: reduce_snapshot will merge the partials into the existing map instead of rebuilding it.")
     },
     async ({ dir, offset, batchSize, files }) => {
       const result = await generateSnapshotBatch(dir, offset, batchSize, files);
@@ -8244,23 +8503,23 @@ function createMcpServer() {
     "save_partial_snapshot",
     "Persist the partial concept map you derived for one batch. Call this once per batch, with the `batchId` from the `generate_snapshot_batch` response. Partials accumulate in `.mason/partial-snapshots/` and are merged in the reduce step.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      batchId: z18.string().describe("The `batchId` returned by `generate_snapshot_batch`."),
-      offset: z18.number().int().describe("The `offset` returned by `generate_snapshot_batch`. Used to order partials in the reduce step."),
-      features: z18.record(
-        z18.object({
-          description: z18.string(),
-          files: z18.array(z18.string()),
-          tests: z18.array(z18.string()).optional(),
-          type: z18.enum(["capability", "infrastructure"]).optional().describe(
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      batchId: z19.string().describe("The `batchId` returned by `generate_snapshot_batch`."),
+      offset: z19.number().int().describe("The `offset` returned by `generate_snapshot_batch`. Used to order partials in the reduce step."),
+      features: z19.record(
+        z19.object({
+          description: z19.string(),
+          files: z19.array(z19.string()),
+          tests: z19.array(z19.string()).optional(),
+          type: z19.enum(["capability", "infrastructure"]).optional().describe(
             '"capability" (user-facing functionality) or "infrastructure" (internal plumbing with no end user \u2014 DI/service wiring, config, logging, adapters). Defaults to "capability".'
           )
         })
       ).describe("Partial features for this batch only \u2014 files outside the batch will be added by other partials."),
-      flows: z18.record(
-        z18.object({
-          description: z18.string(),
-          chain: z18.array(z18.string())
+      flows: z19.record(
+        z19.object({
+          description: z19.string(),
+          chain: z19.array(z19.string())
         })
       ).describe("Partial flows whose entire chain is in this batch. Cross-batch flows are reconstructed in reduce.")
     },
@@ -8275,7 +8534,7 @@ function createMcpServer() {
     "reduce_snapshot",
     "Reduce step of the concept-map build. Returns every partial snapshot plus a system prompt asking you to merge them into one coherent project-wide map. Resolve platform variants into single product features, dedupe near-duplicates, and ensure no file is dropped. After producing the unified map, call `save_snapshot` to persist it (this also clears the partials).",
     {
-      dir: z18.string().describe("Absolute path to the project root directory")
+      dir: z19.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await reduceSnapshot(dir);
@@ -8288,25 +8547,25 @@ function createMcpServer() {
     "save_snapshot",
     "Save a concept-to-files map as a persistent project snapshot. Maps feature names and data flows to the files that implement them. Persists across conversations \u2014 future sessions can call get_snapshot to instantly find relevant files. No API key needed \u2014 you are the LLM generating the map.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      features: z18.record(
-        z18.object({
-          description: z18.string().describe("One-line description of the feature"),
-          files: z18.array(z18.string()).describe("File paths that implement this feature"),
-          tests: z18.array(z18.string()).optional().describe("Test file paths for this feature"),
-          type: z18.enum(["capability", "infrastructure"]).optional().describe(
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      features: z19.record(
+        z19.object({
+          description: z19.string().describe("One-line description of the feature"),
+          files: z19.array(z19.string()).describe("File paths that implement this feature"),
+          tests: z19.array(z19.string()).optional().describe("Test file paths for this feature"),
+          type: z19.enum(["capability", "infrastructure"]).optional().describe(
             'Classification: "capability" for user-facing functionality, "infrastructure" for internal plumbing with no end user (DI/service wiring, config, logging, adapters). Capabilities are published to Confluence; infrastructure stays in the AI concept map only. Defaults to "capability".'
           )
         })
       ).describe("Map of feature names to their implementing files"),
-      flows: z18.record(
-        z18.object({
-          description: z18.string().describe("One-line description of the flow"),
-          chain: z18.array(z18.string()).describe("Ordered list of file paths showing data/call flow")
+      flows: z19.record(
+        z19.object({
+          description: z19.string().describe("One-line description of the flow"),
+          chain: z19.array(z19.string()).describe("Ordered list of file paths showing data/call flow")
         })
       ).describe("Map of flow names to ordered file chains"),
-      removeFeatures: z18.array(z18.string()).optional().describe("Feature names to delete from the existing map \u2014 for features that were renamed or no longer exist. Applied before merging; only meaningful on incremental saves."),
-      removeFlows: z18.array(z18.string()).optional().describe("Flow names to delete from the existing map. Applied before merging; only meaningful on incremental saves.")
+      removeFeatures: z19.array(z19.string()).optional().describe("Feature names to delete from the existing map \u2014 for features that were renamed or no longer exist. Applied before merging; only meaningful on incremental saves."),
+      removeFlows: z19.array(z19.string()).optional().describe("Flow names to delete from the existing map. Applied before merging; only meaningful on incremental saves.")
     },
     async ({ dir, features, flows, removeFeatures, removeFlows }) => {
       const result = await saveSnapshotData(
@@ -8325,17 +8584,17 @@ function createMcpServer() {
     "save_decision",
     "Capture or revise a decision proposal with rationale, anchors, optional owner, sources, and a known actor. No setup or map required. Writes a local record and preserves content history. Changes create a pending proposal while the last accepted revision remains operative; unchanged content does not re-verify or refresh it. Use review_decision for authorized acceptance or reaffirmation. A proposal cannot supersede a record with an operative accepted revision; review its replacement and retire the original separately.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      title: z18.string().max(80).describe("Short, specific headline \u2014 becomes the stable record id"),
-      body: z18.string().max(1500).describe("The knowledge itself: what was tried/decided, why, and what to avoid. Must contain information NOT derivable by reading the code."),
-      category: z18.enum(["decision", "gotcha", "deprecation", "convention"]),
-      files: z18.array(z18.string()).optional().describe("Repo-relative files or directory prefixes this applies to. Matching is shared by retrieval, hooks, review, and drift checking; changes flag the decision for re-verification."),
-      id: z18.string().optional().describe("Existing id to revise. Changed content becomes a proposal; unchanged content leaves the review and freshness untouched."),
-      supersedes: z18.string().optional().describe("Id of an unreviewed record or proposal with no accepted revision to replace. Operative accepted decisions require separate review and retirement."),
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      title: z19.string().max(80).describe("Short, specific headline \u2014 becomes the stable record id"),
+      body: z19.string().max(1500).describe("The knowledge itself: what was tried/decided, why, and what to avoid. Must contain information NOT derivable by reading the code."),
+      category: z19.enum(["decision", "gotcha", "deprecation", "convention"]),
+      files: z19.array(z19.string()).optional().describe("Repo-relative files or directory prefixes this applies to. Matching is shared by retrieval, hooks, review, and drift checking; changes flag the decision for re-verification."),
+      id: z19.string().optional().describe("Existing id to revise. Changed content becomes a proposal; unchanged content leaves the review and freshness untouched."),
+      supersedes: z19.string().optional().describe("Id of an unreviewed record or proposal with no accepted revision to replace. Operative accepted decisions require separate review and retirement."),
       owner: attributionSchema.shape.owner.describe("Responsible person or team, when known. Null clears it. Required for acceptance."),
       sources: attributionSchema.shape.sources.describe("Known PR, issue, incident, discussion, or document references. Omit to preserve; [] clears. At least one is required for acceptance."),
       actor: attributionSchema.shape.actor.describe("Known person or agent recording this revision. Omit if unknown; do not infer from Git identity."),
-      force: z18.boolean().optional().describe("Save even when a near-duplicate was detected")
+      force: z19.boolean().optional().describe("Save even when a near-duplicate was detected")
     },
     async ({ dir, title, body, category, files, id, supersedes, force, owner, sources, actor }) => {
       const result = await saveDecision(dir, {
@@ -8357,12 +8616,12 @@ function createMcpServer() {
     "review_decision",
     "Prepare a decision review: returns the full record and history, any operative accepted revision, provenance, changes and previews for both sets of anchors, and a reviewToken. Then record accept, reaffirm, or retire with that token, the authorized reviewer, and a reason. Acceptance replaces the operative revision; retirement withdraws the entire record including its proposal. Acceptance requires owner, source, readable Git HEAD, and committed anchor changes. Changed records or code invalidate the token. Identities and approvals are recorded assertions for normal PR review, not authenticated proof.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      id: z18.string().regex(/^[a-zA-Z0-9_-]+$/).describe("Decision id from get_context or save_decision"),
-      action: z18.enum(["prepare", "accept", "reaffirm", "retire"]).optional().default("prepare").describe("Prepare is read-only. Other actions record an explicitly authorized review."),
-      reviewer: z18.string().trim().min(1).max(200).optional().describe("Identity of the actual reviewer; required for a verdict. Never invent one."),
-      note: z18.string().trim().min(1).max(1500).optional().describe("Review rationale; required for a verdict. Cite evidence for the decision."),
-      reviewToken: z18.string().regex(/^[a-f0-9]{64}$/).optional().describe("Token from the prepared review; rejects stale record or code revisions")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      id: z19.string().regex(/^[a-zA-Z0-9_-]+$/).describe("Decision id from get_context or save_decision"),
+      action: z19.enum(["prepare", "accept", "reaffirm", "retire"]).optional().default("prepare").describe("Prepare is read-only. Other actions record an explicitly authorized review."),
+      reviewer: z19.string().trim().min(1).max(200).optional().describe("Identity of the actual reviewer; required for a verdict. Never invent one."),
+      note: z19.string().trim().min(1).max(1500).optional().describe("Review rationale; required for a verdict. Cite evidence for the decision."),
+      reviewToken: z19.string().regex(/^[a-f0-9]{64}$/).optional().describe("Token from the prepared review; rejects stale record or code revisions")
     },
     async ({ dir, ...input }) => {
       const result = await reviewDecision2(dir, input);
@@ -8373,7 +8632,7 @@ function createMcpServer() {
     "mason_check_drift",
     "Check how far the concept map has drifted from HEAD. Deterministic (git + filesystem, no LLM). Returns which features/flows are stale and the changed files behind them, new source files not yet mapped, ghost files (mapped but deleted), renames, and a `recommendation`: `up-to-date` (nothing to do), `incremental` (update just the stale entries via save_snapshot), or `full-rebuild` (re-run the Map-Reduce build). Call this before trusting the map in a long session, or periodically to keep the map and any synced wikis fresh.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory")
+      dir: z19.string().describe("Absolute path to the project root directory")
     },
     async ({ dir }) => {
       const result = await checkDrift(dir);
@@ -8386,8 +8645,8 @@ function createMcpServer() {
     "verify_snapshot",
     "Spot-check the concept map's CORRECTNESS (drift checks freshness; this checks entries were right to begin with). Returns a sample of entries \u2014 always the never-verified and least-recently-verified first \u2014 with skeletons of their claimed files, for you to judge whether the files actually implement what the entry claims. Report verdicts back via save_verification. Run periodically, or after an automated refresh wrote entries no human reviewed.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      sample: z18.number().int().optional().describe("Entries to sample (default 5)")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      sample: z19.number().int().optional().describe("Entries to sample (default 5)")
     },
     async ({ dir, sample }) => {
       const result = await verifySnapshot(dir, sample);
@@ -8398,11 +8657,11 @@ function createMcpServer() {
     "save_verification",
     "Record verify_snapshot verdicts. Entries judged ok are stamped verifiedAt; failures are flagged verificationFailed with your note and surface in get_context, get_snapshot, and mason_check_drift until corrected. Verdict notes are required for failures.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      verdicts: z18.record(
-        z18.object({
-          ok: z18.boolean(),
-          note: z18.string().optional().describe("One line on what's wrong \u2014 required when ok is false")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      verdicts: z19.record(
+        z19.object({
+          ok: z19.boolean(),
+          note: z19.string().optional().describe("One line on what's wrong \u2014 required when ok is false")
         })
       ).describe("Entry name \u2192 verdict, exactly as returned by verify_snapshot")
     },
@@ -8413,10 +8672,10 @@ 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: z18.string().describe("Absolute path to the project root directory"),
-      files: z18.array(z18.string()).describe("File paths or names to analyze (e.g., ['WeatherRepository.kt'] or ['src/services/auth.ts'])")
+      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'])")
     },
     async ({ dir, files }) => {
       const result = await getImpact(dir, files);
@@ -8429,12 +8688,12 @@ function createMcpServer() {
     "export_to_confluence",
     "Sync the project's concept map to Confluence as product-readable wiki pages: an index page, one page per feature (PM-language descriptions, no file paths), and a changelog page. Mason replaces managed page bodies; manual edits to those bodies are overwritten. Requires `mason_set_confluence` to have been called first.",
     {
-      dir: z18.string().describe("Absolute path to the project root directory"),
-      spaceKey: z18.string().optional().describe("Override the configured space key"),
-      parentPageId: z18.string().optional().describe("Override the configured parent page ID"),
-      indexPageTitle: z18.string().optional().describe("Title of the index page (default: 'Mason \u2014 System Map')"),
-      changelogPageTitle: z18.string().optional().describe("Title of the changelog page (default: 'Mason \u2014 Changelog')"),
-      featurePagePrefix: z18.string().optional().describe("Prefix for each feature page title (default: 'Feature: ')")
+      dir: z19.string().describe("Absolute path to the project root directory"),
+      spaceKey: z19.string().optional().describe("Override the configured space key"),
+      parentPageId: z19.string().optional().describe("Override the configured parent page ID"),
+      indexPageTitle: z19.string().optional().describe("Title of the index page (default: 'Mason \u2014 System Map')"),
+      changelogPageTitle: z19.string().optional().describe("Title of the changelog page (default: 'Mason \u2014 Changelog')"),
+      featurePagePrefix: z19.string().optional().describe("Prefix for each feature page title (default: 'Feature: ')")
     },
     async ({ dir, spaceKey, parentPageId, indexPageTitle, changelogPageTitle, featurePagePrefix }) => {
       const result = await exportToConfluenceTool(dir, {