mason-context 0.7.0 → 0.8.0

package/README.md

@@ -223,7 +223,19 @@ jobs:
     secrets: inherit
 ```
 
-Omit `agent-command` for detect-only mode: no agent, no credentials — the job fails when the context files have drifted, which is a reasonable default for repos that want the signal before the automation. Note: PRs created with the default `GITHUB_TOKEN` don't trigger the repo's own CI; run your agent with PAT-backed auth if you need that.
+Omit `agent-command` for detect-only mode: no agent, no credentials — the job fails when the context files have drifted, which is a reasonable default for repos that want the signal before the automation. Two GitHub notes: the repo setting **"Allow GitHub Actions to create and approve pull requests"** (Settings → Actions → General) must be enabled for the PR step, and PRs created with the default `GITHUB_TOKEN` don't trigger the repo's own CI — run your agent with PAT-backed auth if you need that.
+
+## Decision injection (mason-hook)
+
+Recorded knowledge only helps if it shows up. Retrieval tools depend on the model deciding to call them — and it often doesn't. `mason-hook` removes the gamble: it's a Claude Code `PostToolUse` hook that fires when a session reads or edits a file, looks up the decision records anchored to that file (exact path or directory prefix), and injects them into the model's context. Deterministic lookup, no LLM call, ~100ms, silent when nothing matches. Each decision is injected at most once per session, and records whose anchors drifted since verification carry a verify-before-relying marker.
+
+```bash
+npx -p mason-context mason-hook --print-config   # the settings block to add
+```
+
+Add the printed block to `.claude/settings.json` — the *committed* project settings, so every teammate's sessions get the same rail. The loop this closes: someone records a constraint once with `save_decision` ("this screen has a v1 and v2 — new work goes in v2 behind flag X"), and from then on any session that touches those files gets told, whether or not it thought to ask.
+
+For faster fires than `npx` resolution allows, install the package (`npm i -D mason-context`) and point the command at `node_modules/.bin/mason-hook`.
 
 ## Confluence sync
 

package/dist/mason-hook.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+
+// src/hook/hook.ts
+import fs5 from "fs/promises";
+import path8 from "path";
+import os from "os";
+
+// src/decisions/decisions.ts
+import fs3 from "fs/promises";
+import path5 from "path";
+import { createHash } from "crypto";
+
+// src/snapshot/snapshot.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import fg3 from "fast-glob";
+
+// src/mcp/sampler.ts
+import fs from "fs/promises";
+import path from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import fg from "fast-glob";
+var exec = promisify(execFile);
+
+// src/test-map.ts
+import path2 from "path";
+import fg2 from "fast-glob";
+
+// src/snapshot/snapshot.ts
+var exec2 = promisify2(execFile2);
+async function getCurrentGitHash(rootDir) {
+  try {
+    const { stdout } = await exec2("git", ["rev-parse", "HEAD"], {
+      cwd: rootDir
+    });
+    return stdout.trim();
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/context/lexical.ts
+import path4 from "path";
+
+// src/decisions/decisions.ts
+function decisionsDir(rootDir) {
+  return path5.join(rootDir, ".mason", "decisions");
+}
+async function loadDecisions(rootDir) {
+  let entries;
+  try {
+    entries = await fs3.readdir(decisionsDir(rootDir));
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const raw = await fs3.readFile(
+        path5.join(decisionsDir(rootDir), entry),
+        "utf-8"
+      );
+      const parsed = JSON.parse(raw);
+      if (parsed.version !== 1 || !parsed.id || !parsed.title || !parsed.body) {
+        continue;
+      }
+      records.push(parsed);
+    } catch {
+      continue;
+    }
+  }
+  return records.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+// src/decisions/drift.ts
+import path7 from "path";
+
+// src/drift/drift.ts
+import fs4 from "fs/promises";
+import path6 from "path";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var exec3 = promisify3(execFile3);
+async function getChangesWithStatus(resolvedRoot, fromHash) {
+  if (!fromHash || fromHash === "unknown") return null;
+  try {
+    const { stdout } = await exec3(
+      "git",
+      ["diff", "--name-status", "-M", fromHash, "HEAD"],
+      { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }
+    );
+    const changes = [];
+    for (const line of stdout.split("\n")) {
+      if (!line.trim()) continue;
+      const parts = line.split("	");
+      if (parts.some((p) => p.startsWith(".mason/"))) continue;
+      const code = parts[0];
+      if (code.startsWith("R") && parts.length >= 3) {
+        changes.push({
+          status: "renamed",
+          path: parts[2],
+          previousPath: parts[1]
+        });
+      } else if (code.startsWith("C") && parts.length >= 3) {
+        changes.push({ status: "added", path: parts[2] });
+      } else if (code === "A" && parts.length >= 2) {
+        changes.push({ status: "added", path: parts[1] });
+      } else if (code === "D" && parts.length >= 2) {
+        changes.push({ status: "deleted", path: parts[1] });
+      } else if (parts.length >= 2) {
+        changes.push({ status: "modified", path: parts[1] });
+      }
+    }
+    return changes;
+  } catch {
+    return null;
+  }
+}
+
+// src/decisions/drift.ts
+async function computeDecisionDrift(rootDir, decisions) {
+  const resolvedRoot = path7.resolve(rootDir);
+  const records = decisions ?? await loadDecisions(resolvedRoot);
+  const report = {
+    historyAvailable: true,
+    totalDecisions: records.length,
+    staleDecisions: {}
+  };
+  const head = await getCurrentGitHash(resolvedRoot);
+  const changesByHash = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (record.status !== "active" || record.files.length === 0) continue;
+    if (record.refreshedHash === head) continue;
+    let touched = changesByHash.get(record.refreshedHash);
+    if (touched === void 0) {
+      const changes = await getChangesWithStatus(
+        resolvedRoot,
+        record.refreshedHash
+      );
+      if (changes === null) {
+        touched = null;
+      } else {
+        touched = /* @__PURE__ */ new Set();
+        for (const change of changes) {
+          touched.add(change.path);
+          if (change.previousPath) touched.add(change.previousPath);
+        }
+      }
+      changesByHash.set(record.refreshedHash, touched);
+    }
+    if (touched === null) {
+      report.historyAvailable = false;
+      continue;
+    }
+    const hits = record.files.filter((f) => touched.has(f));
+    if (hits.length > 0) {
+      report.staleDecisions[record.id] = hits;
+    }
+  }
+  return report;
+}
+
+// src/hook/hook.ts
+var MAX_INJECTED_DECISIONS = 3;
+var MAX_WALK_UP = 30;
+var SUPPORTED_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write"]);
+async function exists(p) {
+  try {
+    await fs5.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findMasonRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < MAX_WALK_UP; i++) {
+    if (await exists(path8.join(dir, ".mason", "decisions"))) return dir;
+    if (await exists(path8.join(dir, ".git"))) return null;
+    const parent = path8.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+function anchorsCover(record, relPath) {
+  return record.files.some((anchor) => {
+    const a = anchor.replace(/\/+$/, "");
+    return a === relPath || relPath.startsWith(`${a}/`);
+  });
+}
+function exactAnchor(record, relPath) {
+  return record.files.some((a) => a.replace(/\/+$/, "") === relPath);
+}
+function stateKey(input) {
+  const raw = `${input.session_id ?? "nosession"}${input.agent_id ? `-${input.agent_id}` : ""}`;
+  return raw.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 120) || "nosession";
+}
+async function loadInjected(stateFile) {
+  try {
+    const parsed = JSON.parse(await fs5.readFile(stateFile, "utf-8"));
+    return new Set(Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string") : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function formatContext(relPath, records, staleIds) {
+  const lines = [];
+  lines.push(
+    `Mason: recorded team knowledge anchored to ${relPath} \u2014 treat as constraints. Do not modify decision records in .mason/decisions/.`
+  );
+  for (const record of records) {
+    const stale = staleIds.has(record.id) ? " [recorded against an older commit \u2013 verify against current code before relying on it]" : "";
+    lines.push(
+      `- [${record.category}] ${record.title}: ${record.body} (anchors: ${record.files.join(", ")})${stale}`
+    );
+  }
+  return lines.join("\n");
+}
+async function runHook(stdinText, env = {}) {
+  let input;
+  try {
+    input = JSON.parse(stdinText);
+  } catch {
+    return null;
+  }
+  if (input.tool_name && !SUPPORTED_TOOLS.has(input.tool_name)) return null;
+  const filePath = input.tool_input?.file_path;
+  if (!filePath || typeof filePath !== "string") return null;
+  const absPath = path8.isAbsolute(filePath) ? filePath : path8.resolve(input.cwd ?? process.cwd(), filePath);
+  const root = await findMasonRoot(path8.dirname(absPath));
+  if (!root) return null;
+  const relPath = path8.relative(root, absPath).split(path8.sep).join("/");
+  if (relPath.startsWith("..")) return null;
+  const records = await loadDecisions(root);
+  const matched = records.filter(
+    (r) => r.status === "active" && anchorsCover(r, relPath)
+  );
+  if (matched.length === 0) return null;
+  const stateDir = env.stateDir ?? os.tmpdir();
+  const stateFile = path8.join(stateDir, `mason-hook-${stateKey(input)}.json`);
+  const injected = await loadInjected(stateFile);
+  const fresh = matched.filter((r) => !injected.has(r.id));
+  if (fresh.length === 0) return null;
+  fresh.sort((a, b) => {
+    const exactDiff = Number(exactAnchor(b, relPath)) - Number(exactAnchor(a, relPath));
+    if (exactDiff !== 0) return exactDiff;
+    return b.updatedAt.localeCompare(a.updatedAt);
+  });
+  const selected = fresh.slice(0, MAX_INJECTED_DECISIONS);
+  const drift = await computeDecisionDrift(root, selected);
+  const staleIds = new Set(Object.keys(drift.staleDecisions));
+  for (const record of selected) injected.add(record.id);
+  try {
+    await fs5.writeFile(stateFile, JSON.stringify([...injected]), "utf-8");
+  } catch {
+  }
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PostToolUse",
+      additionalContext: formatContext(relPath, selected, staleIds)
+    }
+  });
+}
+
+// src/hook/cli.ts
+var USAGE = `Usage: mason-hook [--print-config | --help]
+
+Claude Code PostToolUse hook: when the session reads or edits a file that a
+Mason decision record anchors, the record is injected into the model's
+context. Deterministic lookup, no LLM call; silent when nothing matches.
+
+Reads the hook JSON on stdin and prints the hook output JSON on stdout.
+Register it via .claude/settings.json (committed to the repo, so the whole
+team gets the same rail):
+
+  mason-hook --print-config   Print the settings.json hooks block
+
+Repeat injections are deduped per session; state lives in the OS temp dir.`;
+var SETTINGS_CONFIG = {
+  hooks: {
+    PostToolUse: [
+      {
+        matcher: "Read|Edit|Write",
+        hooks: [
+          {
+            type: "command",
+            command: "npx -y -p mason-context mason-hook",
+            timeout: 10
+          }
+        ]
+      }
+    ]
+  }
+};
+async function runHookCli(argv, stdinText, io = {
+  out: (line) => process.stdout.write(`${line}
+`),
+  err: (line) => process.stderr.write(`${line}
+`)
+}, env = {}) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    io.out(USAGE);
+    return 0;
+  }
+  if (argv.includes("--print-config")) {
+    io.out(JSON.stringify(SETTINGS_CONFIG, null, 2));
+    return 0;
+  }
+  try {
+    const output = await runHook(stdinText, env);
+    if (output !== null) io.out(output);
+  } catch {
+  }
+  return 0;
+}
+
+// bin/mason-hook.ts
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+readStdin().then((stdinText) => runHookCli(process.argv.slice(2), stdinText)).then((code) => process.exit(code)).catch(() => process.exit(0));
+//# sourceMappingURL=mason-hook.js.map

package/dist/mason-hook.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hook/hook.ts","../src/decisions/decisions.ts","../src/snapshot/snapshot.ts","../src/mcp/sampler.ts","../src/test-map.ts","../src/context/lexical.ts","../src/decisions/drift.ts","../src/drift/drift.ts","../src/hook/cli.ts","../bin/mason-hook.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport os from \"node:os\";\nimport { loadDecisions } from \"../decisions/decisions.js\";\nimport type { DecisionRecord } from \"../decisions/decisions.js\";\nimport { computeDecisionDrift } from \"../decisions/drift.js\";\n\n/** More than a few constraints per fire is noise, not context. */\nconst MAX_INJECTED_DECISIONS = 3;\n/** Walk-up bound when locating the Mason root from an edited file. */\nconst MAX_WALK_UP = 30;\n\nconst SUPPORTED_TOOLS = new Set([\"Read\", \"Edit\", \"Write\"]);\n\nexport interface HookStdin {\n  session_id?: string;\n  agent_id?: string;\n  cwd?: string;\n  hook_event_name?: string;\n  tool_name?: string;\n  tool_input?: { file_path?: string };\n}\n\nexport interface HookEnv {\n  /** Override for tests; defaults to os.tmpdir(). */\n  stateDir?: string;\n}\n\nasync function exists(p: string): Promise<boolean> {\n  try {\n    await fs.access(p);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Locate the nearest ancestor holding a .mason/decisions store. Stops at the\n * first .git boundary — a repo without Mason must stay silent, not borrow a\n * parent directory's decisions.\n */\nasync function findMasonRoot(startDir: string): Promise<string | null> {\n  let dir = startDir;\n  for (let i = 0; i < MAX_WALK_UP; i++) {\n    if (await exists(path.join(dir, \".mason\", \"decisions\"))) return dir;\n    if (await exists(path.join(dir, \".git\"))) return null;\n    const parent = path.dirname(dir);\n    if (parent === dir) return null;\n    dir = parent;\n  }\n  return null;\n}\n\nfunction anchorsCover(record: DecisionRecord, relPath: string): boolean {\n  return record.files.some((anchor) => {\n    const a = anchor.replace(/\\/+$/, \"\");\n    return a === relPath || relPath.startsWith(`${a}/`);\n  });\n}\n\nfunction exactAnchor(record: DecisionRecord, relPath: string): boolean {\n  return record.files.some((a) => a.replace(/\\/+$/, \"\") === relPath);\n}\n\nfunction stateKey(input: HookStdin): string {\n  const raw = `${input.session_id ?? \"nosession\"}${input.agent_id ? `-${input.agent_id}` : \"\"}`;\n  return raw.replace(/[^A-Za-z0-9_-]/g, \"\").slice(0, 120) || \"nosession\";\n}\n\nasync function loadInjected(stateFile: string): Promise<Set<string>> {\n  try {\n    const parsed = JSON.parse(await fs.readFile(stateFile, \"utf-8\"));\n    return new Set(Array.isArray(parsed) ? parsed.filter((x) => typeof x === \"string\") : []);\n  } catch {\n    return new Set();\n  }\n}\n\nfunction formatContext(\n  relPath: string,\n  records: DecisionRecord[],\n  staleIds: Set<string>\n): string {\n  const lines: string[] = [];\n  lines.push(\n    `Mason: recorded team knowledge anchored to ${relPath} — treat as constraints. Do not modify decision records in .mason/decisions/.`\n  );\n  for (const record of records) {\n    const stale = staleIds.has(record.id)\n      ? \" [recorded against an older commit – verify against current code before relying on it]\"\n      : \"\";\n    lines.push(\n      `- [${record.category}] ${record.title}: ${record.body} (anchors: ${record.files.join(\", \")})${stale}`\n    );\n  }\n  return lines.join(\"\\n\");\n}\n\n/**\n * The push half of Mason's memory: when an agent touches a file that a\n * decision record anchors, the record is injected into the session via the\n * PostToolUse hook contract — deterministically, without relying on the\n * model deciding to ask. Returns the hook's stdout JSON, or null for\n * \"stay silent\" (no store, no match, already injected, malformed input —\n * a hook must never disrupt the session).\n */\nexport async function runHook(\n  stdinText: string,\n  env: HookEnv = {}\n): Promise<string | null> {\n  let input: HookStdin;\n  try {\n    input = JSON.parse(stdinText);\n  } catch {\n    return null;\n  }\n\n  if (input.tool_name && !SUPPORTED_TOOLS.has(input.tool_name)) return null;\n  const filePath = input.tool_input?.file_path;\n  if (!filePath || typeof filePath !== \"string\") return null;\n\n  const absPath = path.isAbsolute(filePath)\n    ? filePath\n    : path.resolve(input.cwd ?? process.cwd(), filePath);\n  const root = await findMasonRoot(path.dirname(absPath));\n  if (!root) return null;\n  const relPath = path.relative(root, absPath).split(path.sep).join(\"/\");\n  if (relPath.startsWith(\"..\")) return null;\n\n  const records = await loadDecisions(root);\n  const matched = records.filter(\n    (r) => r.status === \"active\" && anchorsCover(r, relPath)\n  );\n  if (matched.length === 0) return null;\n\n  const stateDir = env.stateDir ?? os.tmpdir();\n  const stateFile = path.join(stateDir, `mason-hook-${stateKey(input)}.json`);\n  const injected = await loadInjected(stateFile);\n  const fresh = matched.filter((r) => !injected.has(r.id));\n  if (fresh.length === 0) return null;\n\n  // Exact-file anchors outrank directory-prefix ones; newest knowledge wins ties.\n  fresh.sort((a, b) => {\n    const exactDiff =\n      Number(exactAnchor(b, relPath)) - Number(exactAnchor(a, relPath));\n    if (exactDiff !== 0) return exactDiff;\n    return b.updatedAt.localeCompare(a.updatedAt);\n  });\n  const selected = fresh.slice(0, MAX_INJECTED_DECISIONS);\n\n  const drift = await computeDecisionDrift(root, selected);\n  const staleIds = new Set(Object.keys(drift.staleDecisions));\n\n  for (const record of selected) injected.add(record.id);\n  try {\n    await fs.writeFile(stateFile, JSON.stringify([...injected]), \"utf-8\");\n  } catch {\n    // Dedupe state is a convenience; losing it must not block injection.\n  }\n\n  return JSON.stringify({\n    hookSpecificOutput: {\n      hookEventName: \"PostToolUse\",\n      additionalContext: formatContext(relPath, selected, staleIds),\n    },\n  });\n}\n","import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash } from \"node:crypto\";\nimport { getCurrentGitHash } from \"../snapshot/snapshot.js\";\nimport { jaccard, tokenSet } from \"../context/lexical.js\";\n\nexport type DecisionCategory =\n  | \"decision\"\n  | \"gotcha\"\n  | \"deprecation\"\n  | \"convention\";\nexport type DecisionStatus = \"active\" | \"superseded\";\n\n/**\n * One unit of team knowledge the code alone can't express: a failed\n * approach, a deprecation, a workaround's reason, a review-settled\n * convention. Stored one file per record under .mason/decisions/ so\n * concurrent additions on different branches merge without conflict,\n * while concurrent edits to the SAME record conflict — contested\n * knowledge should reach a human.\n */\nexport interface DecisionRecord {\n  version: 1;\n  id: string;\n  title: string;\n  body: string;\n  category: DecisionCategory;\n  /** Repo-relative anchor files. Empty means pure prose — never goes stale. */\n  files: string[];\n  createdAt: string;\n  updatedAt: string;\n  /** Commit this record was last verified against. */\n  refreshedHash: string;\n  status: DecisionStatus;\n  supersededBy?: string;\n}\n\nexport const TITLE_MAX_CHARS = 80;\nexport const BODY_MAX_CHARS = 1500;\nexport const MAX_ACTIVE_DECISIONS = 150;\n\nconst DUPLICATE_JACCARD = 0.5;\nconst DUPLICATE_JACCARD_WITH_SHARED_FILE = 0.35;\n\nfunction decisionsDir(rootDir: string): string {\n  return path.join(rootDir, \".mason\", \"decisions\");\n}\n\nexport async function loadDecisions(\n  rootDir: string\n): Promise<DecisionRecord[]> {\n  let entries: string[];\n  try {\n    entries = await fs.readdir(decisionsDir(rootDir));\n  } catch {\n    return [];\n  }\n  const records: DecisionRecord[] = [];\n  for (const entry of entries) {\n    if (!entry.endsWith(\".json\")) continue;\n    try {\n      const raw = await fs.readFile(\n        path.join(decisionsDir(rootDir), entry),\n        \"utf-8\"\n      );\n      const parsed = JSON.parse(raw);\n      // Skip unknown versions and malformed records individually — one bad\n      // merge artifact must not take down the store.\n      if (parsed.version !== 1 || !parsed.id || !parsed.title || !parsed.body) {\n        continue;\n      }\n      records.push(parsed);\n    } catch {\n      continue;\n    }\n  }\n  return records.sort((a, b) => a.id.localeCompare(b.id));\n}\n\nexport async function saveDecisionRecord(\n  rootDir: string,\n  record: DecisionRecord\n): Promise<void> {\n  await fs.mkdir(decisionsDir(rootDir), { recursive: true });\n  await fs.writeFile(\n    path.join(decisionsDir(rootDir), `${record.id}.json`),\n    JSON.stringify(record, null, 2) + \"\\n\",\n    \"utf-8\"\n  );\n}\n\n/**\n * Deterministic, human-readable id: kebab slug of the title, ≤60 chars.\n * A slug collision with a DIFFERENT record appends a 6-hex content suffix.\n */\nexport function decisionIdFor(\n  title: string,\n  body: string,\n  existingIds: Set<string>\n): string {\n  const slug = title\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-+|-+$/g, \"\")\n    .slice(0, 60)\n    .replace(/-+$/, \"\");\n  if (!existingIds.has(slug)) return slug || \"decision\";\n  const suffix = createHash(\"sha1\")\n    .update(title + body)\n    .digest(\"hex\")\n    .slice(0, 6);\n  return `${slug}-${suffix}`;\n}\n\nexport function findNearDuplicate(\n  candidate: { title: string; body: string; files: string[] },\n  existing: DecisionRecord[]\n): { record: DecisionRecord; similarity: number } | null {\n  const candidateTokens = tokenSet(`${candidate.title} ${candidate.body}`);\n  const candidateFiles = new Set(candidate.files);\n  let best: { record: DecisionRecord; similarity: number } | null = null;\n\n  for (const record of existing) {\n    if (record.status !== \"active\") continue;\n    const similarity = jaccard(\n      candidateTokens,\n      tokenSet(`${record.title} ${record.body}`)\n    );\n    const sharesFile = record.files.some((f) => candidateFiles.has(f));\n    const threshold = sharesFile\n      ? DUPLICATE_JACCARD_WITH_SHARED_FILE\n      : DUPLICATE_JACCARD;\n    if (similarity >= threshold && (!best || similarity > best.similarity)) {\n      best = { record, similarity };\n    }\n  }\n  return best;\n}\n\nfunction sanitizeAnchorFiles(rootDir: string, files: string[]): string[] {\n  const resolvedRoot = path.resolve(rootDir);\n  return files.filter((f) => {\n    const resolved = path.resolve(resolvedRoot, f);\n    return (\n      resolved.startsWith(resolvedRoot) &&\n      !f.startsWith(\"/\") &&\n      !f.includes(\"..\")\n    );\n  });\n}\n\nexport interface UpsertDecisionInput {\n  title: string;\n  body: string;\n  category: DecisionCategory;\n  files?: string[];\n  /** Existing id to update. Same id + unchanged content = re-verify (re-pin to HEAD). */\n  id?: string;\n  /** Id of a decision this one replaces; the old record is kept, marked superseded. */\n  supersedes?: string;\n  /** Save even when a near-duplicate was detected. */\n  force?: boolean;\n}\n\nexport type UpsertDecisionResult =\n  | {\n      status: \"created\" | \"updated\" | \"reverified\" | \"superseded_and_created\";\n      id: string;\n      totalActive: number;\n      warnings: string[];\n      pruneCandidates?: string[];\n    }\n  | { status: \"duplicate_suspected\"; existing: DecisionRecord; hint: string }\n  | { status: \"error\"; error: string };\n\nexport async function upsertDecision(\n  rootDir: string,\n  input: UpsertDecisionInput\n): Promise<UpsertDecisionResult> {\n  const title = input.title.trim();\n  const body = input.body.trim();\n  if (title.length === 0 || body.length === 0) {\n    return { status: \"error\", error: \"title and body must be non-empty\" };\n  }\n  if (title.length > TITLE_MAX_CHARS) {\n    return {\n      status: \"error\",\n      error: `title exceeds ${TITLE_MAX_CHARS} chars — tighten it to a specific headline`,\n    };\n  }\n  if (body.length > BODY_MAX_CHARS) {\n    return {\n      status: \"error\",\n      error: `body exceeds ${BODY_MAX_CHARS} chars — record the decision, not the transcript`,\n    };\n  }\n\n  const existing = await loadDecisions(rootDir);\n  const byId = new Map(existing.map((r) => [r.id, r]));\n  const now = new Date().toISOString();\n  const head = await getCurrentGitHash(rootDir);\n  const warnings: string[] = [];\n\n  const files = sanitizeAnchorFiles(rootDir, input.files ?? []);\n  if (input.files && files.length < input.files.length) {\n    warnings.push(\"some anchor paths were outside the repo and were dropped\");\n  }\n  // Nonexistent anchors warn but save — a deprecation note may outlive its file.\n  for (const f of files) {\n    try {\n      await fs.access(path.join(rootDir, f));\n    } catch {\n      warnings.push(`anchor file does not exist on disk: ${f}`);\n    }\n  }\n\n  // Update / re-verify path\n  if (input.id) {\n    const record = byId.get(input.id);\n    if (!record) {\n      return { status: \"error\", error: `no decision with id \"${input.id}\"` };\n    }\n    const unchanged =\n      record.title === title &&\n      record.body === body &&\n      record.category === input.category &&\n      JSON.stringify(record.files) === JSON.stringify(files.length > 0 ? files : record.files);\n    const updated: DecisionRecord = {\n      ...record,\n      title,\n      body,\n      category: input.category,\n      files: input.files !== undefined ? files : record.files,\n      updatedAt: now,\n      refreshedHash: head,\n    };\n    await saveDecisionRecord(rootDir, updated);\n    return {\n      status: unchanged ? \"reverified\" : \"updated\",\n      id: record.id,\n      totalActive: existing.filter((r) => r.status === \"active\").length,\n      warnings,\n    };\n  }\n\n  // Create path — dedupe first\n  if (!input.force) {\n    const duplicate = findNearDuplicate({ title, body, files }, existing);\n    if (duplicate) {\n      return {\n        status: \"duplicate_suspected\",\n        existing: duplicate.record,\n        hint: `A similar decision exists (\"${duplicate.record.title}\"). Call save_decision with id=\"${duplicate.record.id}\" to update/merge into it, or force:true if genuinely distinct.`,\n      };\n    }\n  }\n\n  // Supersede\n  if (input.supersedes) {\n    const old = byId.get(input.supersedes);\n    if (!old) {\n      return {\n        status: \"error\",\n        error: `no decision with id \"${input.supersedes}\" to supersede`,\n      };\n    }\n    const id = decisionIdFor(title, body, new Set(byId.keys()));\n    await saveDecisionRecord(rootDir, {\n      ...old,\n      status: \"superseded\",\n      supersededBy: id,\n      updatedAt: now,\n    });\n    const record: DecisionRecord = {\n      version: 1,\n      id,\n      title,\n      body,\n      category: input.category,\n      files,\n      createdAt: now,\n      updatedAt: now,\n      refreshedHash: head,\n      status: \"active\",\n    };\n    await saveDecisionRecord(rootDir, record);\n    return {\n      status: \"superseded_and_created\",\n      id,\n      totalActive: existing.filter((r) => r.status === \"active\").length,\n      warnings,\n    };\n  }\n\n  const id = decisionIdFor(title, body, new Set(byId.keys()));\n  const record: DecisionRecord = {\n    version: 1,\n    id,\n    title,\n    body,\n    category: input.category,\n    files,\n    createdAt: now,\n    updatedAt: now,\n    refreshedHash: head,\n    status: \"active\",\n  };\n  await saveDecisionRecord(rootDir, record);\n\n  const totalActive =\n    existing.filter((r) => r.status === \"active\").length + 1;\n  const result: UpsertDecisionResult = {\n    status: \"created\",\n    id,\n    totalActive,\n    warnings,\n  };\n  if (totalActive > MAX_ACTIVE_DECISIONS) {\n    // Never auto-evict git-committed team knowledge — surface candidates\n    // for a human cleanup PR instead.\n    result.pruneCandidates = existing\n      .filter((r) => r.status === \"superseded\")\n      .map((r) => r.id)\n      .slice(0, 10);\n    warnings.push(\n      `${totalActive} active decisions exceeds the soft cap of ${MAX_ACTIVE_DECISIONS} — consider a cleanup PR (superseded records first)`\n    );\n  }\n  return result;\n}\n","import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { execFile } from \"node:child_process\";\nimport { promisify } from \"node:util\";\nimport fg from \"fast-glob\";\nimport { readFullFile } from \"../mcp/sampler.js\";\nimport { buildTestMap } from \"../test-map.js\";\n\nconst exec = promisify(execFile);\n\nexport interface FeatureEntry {\n  description: string;\n  files: string[];\n  tests?: string[];\n  /**\n   * Commit this entry was last verified against. Entries updated by an\n   * incremental save carry HEAD here; untouched entries keep the hash the\n   * map had before the save, so drift stays visible per entry. Absent means\n   * \"as of the snapshot's top-level gitHash\".\n   */\n  refreshedHash?: string;\n  /**\n   * Whether this is a user-facing capability or internal infrastructure\n   * (DI wiring, config loading, logging, provider/transport plumbing).\n   * Capabilities are published to product-facing docs (Confluence);\n   * infrastructure stays in the AI concept map only. Defaults to \"capability\"\n   * when absent (older snapshots) or unrecognized — see normalizeFeatureType.\n   */\n  type?: \"capability\" | \"infrastructure\";\n  /**\n   * When an assistant last confirmed this entry's files actually implement\n   * the claimed feature (verify_snapshot flow). Absent on older snapshots\n   * and never-verified entries. Drift checks freshness against git; this\n   * checks the map was CORRECT in the first place.\n   */\n  verifiedAt?: string;\n  /** Set when verification judged the entry wrong — re-map it. */\n  verificationFailed?: boolean;\n  verificationNote?: string;\n}\n\nexport type FeatureType = \"capability\" | \"infrastructure\";\n\n/**\n * Coerce an arbitrary type value to a known classification. Anything that\n * isn't explicitly \"infrastructure\" defaults to \"capability\" — so older\n * snapshots and unclassified entries are treated as user-facing (published),\n * never silently hidden.\n */\nexport function normalizeFeatureType(value: unknown): FeatureType {\n  return value === \"infrastructure\" ? \"infrastructure\" : \"capability\";\n}\n\nexport interface FlowEntry {\n  description: string;\n  chain: string[];\n  /** See FeatureEntry.refreshedHash. */\n  refreshedHash?: string;\n  /** See FeatureEntry.verifiedAt / verificationFailed. */\n  verifiedAt?: string;\n  verificationFailed?: boolean;\n  verificationNote?: string;\n}\n\nexport interface Snapshot {\n  version: 2;\n  createdAt: string;\n  updatedAt: string;\n  gitHash: string;\n  features: Record<string, FeatureEntry>;\n  flows: Record<string, FlowEntry>;\n}\n\nfunction snapshotDir(rootDir: string): string {\n  return path.join(rootDir, \".mason\");\n}\n\nfunction snapshotPath(rootDir: string): string {\n  return path.join(snapshotDir(rootDir), \"snapshot.json\");\n}\n\nexport async function loadSnapshot(rootDir: string): Promise<Snapshot | null> {\n  try {\n    const raw = await fs.readFile(snapshotPath(rootDir), \"utf-8\");\n    const parsed = JSON.parse(raw);\n    // Skip v1 snapshots — they're the old per-file format\n    if (parsed.version !== 2) return null;\n    return parsed;\n  } catch {\n    return null;\n  }\n}\n\nexport async function saveSnapshot(\n  rootDir: string,\n  snapshot: Snapshot\n): Promise<void> {\n  await fs.mkdir(snapshotDir(rootDir), { recursive: true });\n  await fs.writeFile(\n    snapshotPath(rootDir),\n    JSON.stringify(snapshot, null, 2),\n    \"utf-8\"\n  );\n}\n\nexport async function getCurrentGitHash(rootDir: string): Promise<string> {\n  try {\n    const { stdout } = await exec(\"git\", [\"rev-parse\", \"HEAD\"], {\n      cwd: rootDir,\n    });\n    return stdout.trim();\n  } catch {\n    return \"unknown\";\n  }\n}\n\nexport const SOURCE_GLOB =\n  \"**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,dart}\";\nexport const SOURCE_IGNORE = [\n  \"**/node_modules/**\", \"**/dist/**\", \"**/build/**\", \"**/.gradle/**\",\n  \"**/target/**\", \"**/.git/**\", \"**/vendor/**\", \"**/__pycache__/**\",\n  \"**/venv/**\", \"**/.venv/**\", \"**/*.min.*\", \"**/*.map\",\n  \"**/generated/**\", \"**/R.java\", \"**/BuildConfig.java\",\n];\n\nexport const DEFAULT_BATCH_SIZE = 50;\nconst SKELETON_CHARS = 500;\nconst DEEP_SAMPLE_CHARS = 1500;\nconst DEEP_SAMPLES_PER_BATCH = 3;\n\nexport interface SnapshotBatch {\n  offset: number;\n  batchSize: number;\n  nextOffset: number | null;\n  totalFiles: number;\n  skeletons: Array<{ path: string; content: string }>;\n  samples: Array<{ path: string; content: string }>;\n  testPairs: Array<{ test: string; source: string; confidence: string }>;\n}\n\nexport async function listSourceFiles(resolvedRoot: string): Promise<string[]> {\n  const all = await fg(SOURCE_GLOB, {\n    cwd: resolvedRoot,\n    ignore: SOURCE_IGNORE,\n  });\n  // Deterministic order so the same offset always returns the same batch.\n  return [...all].sort();\n}\n\nexport async function prepareSnapshotBatch(\n  rootDir: string,\n  offset: number,\n  batchSize: number = DEFAULT_BATCH_SIZE,\n  scopeFiles?: string[]\n): Promise<SnapshotBatch> {\n  const resolvedRoot = path.resolve(rootDir);\n  let allFiles = await listSourceFiles(resolvedRoot);\n  if (scopeFiles) {\n    // Intersect with the real source list: keeps ignore rules and path safety,\n    // and silently drops scope entries that no longer exist on disk. An empty\n    // scope stays empty — it must not fall back to walking the whole project.\n    const scopeSet = new Set(scopeFiles);\n    allFiles = allFiles.filter((f) => scopeSet.has(f));\n  }\n  const totalFiles = allFiles.length;\n  const safeOffset = Math.max(0, Math.min(offset, totalFiles));\n  const batchPaths = allFiles.slice(safeOffset, safeOffset + batchSize);\n\n  const skeletons: Array<{ path: string; content: string }> = [];\n  for (const filePath of batchPaths) {\n    const full = await readFullFile(resolvedRoot, filePath);\n    if (full) {\n      skeletons.push({\n        path: full.path,\n        content: full.content.slice(0, SKELETON_CHARS),\n      });\n    }\n  }\n\n  // Pick a few files from this batch to read deeply for grounding. Spread\n  // evenly across the batch so the deep samples represent the batch's range.\n  const samples: Array<{ path: string; content: string }> = [];\n  if (skeletons.length > 0) {\n    const step = Math.max(1, Math.floor(skeletons.length / DEEP_SAMPLES_PER_BATCH));\n    for (let i = 0; i < skeletons.length && samples.length < DEEP_SAMPLES_PER_BATCH; i += step) {\n      const full = await readFullFile(resolvedRoot, skeletons[i].path);\n      if (full) {\n        samples.push({\n          path: full.path,\n          content: full.content.slice(0, DEEP_SAMPLE_CHARS),\n        });\n      }\n    }\n  }\n\n  // Only include test pairs that involve files in this batch — keeps the\n  // appendix relevant and small.\n  const batchPathSet = new Set(batchPaths);\n  const allTestPairs = (await buildTestMap(resolvedRoot)).paired;\n  const testPairs = allTestPairs.filter(\n    (p) => batchPathSet.has(p.test) || batchPathSet.has(p.source)\n  );\n\n  const nextOffset =\n    safeOffset + batchSize >= totalFiles ? null : safeOffset + batchSize;\n\n  return {\n    offset: safeOffset,\n    batchSize,\n    nextOffset,\n    totalFiles,\n    skeletons,\n    samples,\n    testPairs,\n  };\n}\n","import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { execFile } from \"node:child_process\";\nimport { promisify } from \"node:util\";\nimport fg from \"fast-glob\";\n\nconst exec = promisify(execFile);\n\nconst SOURCE_EXTENSIONS = [\n  \"ts\", \"tsx\", \"js\", \"jsx\", \"mts\", \"mjs\",\n  \"kt\", \"kts\", \"java\",\n  \"py\",\n  \"go\",\n  \"rs\",\n  \"swift\",\n  \"rb\",\n  \"cs\", \"cpp\", \"c\", \"h\",\n  \"dart\",\n];\n\nconst CONFIG_FILES = [\n  // Build & project config\n  \"package.json\",\n  \"tsconfig.json\",\n  \"build.gradle.kts\",\n  \"build.gradle\",\n  \"settings.gradle.kts\",\n  \"settings.gradle\",\n  \"Cargo.toml\",\n  \"go.mod\",\n  \"pyproject.toml\",\n  \"Gemfile\",\n  \"*.csproj\",\n  // Version catalogs & dependency locks\n  \"gradle/libs.versions.toml\",\n  // Code quality & formatting\n  \".editorconfig\",\n  \".eslintrc.*\",\n  \"eslint.config.*\",\n  \".prettierrc\",\n  \"rustfmt.toml\",\n  \".swiftlint.yml\",\n  // CI/CD\n  \".github/workflows/*.yml\",\n  \".gitlab-ci.yml\",\n  \"Jenkinsfile\",\n  // Containerization\n  \"Dockerfile\",\n  \"docker-compose.yml\",\n  \"docker-compose.yaml\",\n];\n\nconst ENTRY_POINT_PATTERNS = [\n  \"src/main.*\",\n  \"src/index.*\",\n  \"src/app.*\",\n  \"main.*\",\n  \"index.*\",\n  \"app.*\",\n  \"App.*\",\n  \"**/Main.kt\",\n  \"**/Application.kt\",\n  \"**/main.py\",\n  \"**/main.go\",\n  \"**/main.rs\",\n  \"**/lib.rs\",\n  \"**/Program.cs\",\n];\n\n// Filename patterns that reveal architectural patterns and conventions.\n// These are language-agnostic — the suffixes appear across ecosystems.\n// Ordered by architectural importance — most distinctive patterns first.\nconst ARCHITECTURAL_PATTERNS = [\n  // State/data flow\n  { glob: \"**/*ViewModel.*\", category: \"state\", reason: \"viewmodel (state management)\" },\n  { glob: \"**/*Store.*\", category: \"state\", reason: \"store (state management)\" },\n  { glob: \"**/*Reducer.*\", category: \"state\", reason: \"reducer (state management)\" },\n  // Data layer — interface\n  { glob: \"**/*Repository.*\", category: \"data-interface\", reason: \"repository interface (data layer contract)\" },\n  { glob: \"**/*Dao.*\", category: \"data-interface\", reason: \"DAO (data access)\" },\n  { glob: \"**/*DataSource.*\", category: \"data-interface\", reason: \"data source\" },\n  // Data layer — implementation (where actual patterns live: mappers, retry, IO dispatchers)\n  { glob: \"**/*RepositoryImpl.*\", category: \"data-impl\", reason: \"repository implementation (data layer patterns)\" },\n  { glob: \"**/*ServiceImpl.*\", category: \"data-impl\", reason: \"service implementation\" },\n  { glob: \"**/*Impl.*\", category: \"data-impl\", reason: \"implementation (concrete patterns)\" },\n  // Data transformation\n  { glob: \"**/*Mapper.*\", category: \"transform\", reason: \"mapper (data transformation)\" },\n  { glob: \"**/*Converter.*\", category: \"transform\", reason: \"converter (data transformation)\" },\n  { glob: \"**/*Adapter.*\", category: \"transform\", reason: \"adapter (interface adaptation)\" },\n  // Dependency injection / wiring\n  { glob: \"**/*Module.*\", category: \"di\", reason: \"module (DI/wiring)\" },\n  { glob: \"**/*Provider.*\", category: \"di\", reason: \"provider (DI/wiring)\" },\n  { glob: \"**/*Container.*\", category: \"di\", reason: \"container (DI/wiring)\" },\n  { glob: \"**/*Factory.*\", category: \"di\", reason: \"factory (object creation)\" },\n  // API / network\n  { glob: \"**/*Service.*\", category: \"api\", reason: \"service (business/API layer)\" },\n  { glob: \"**/*Client.*\", category: \"api\", reason: \"client (API/network layer)\" },\n  { glob: \"**/*Api.*\", category: \"api\", reason: \"API interface definition\" },\n  // Interface contracts / protocols\n  { glob: \"**/*Interface.*\", category: \"contract\", reason: \"interface definition\" },\n  { glob: \"**/*Protocol.*\", category: \"contract\", reason: \"protocol definition\" },\n  { glob: \"**/*Trait.*\", category: \"contract\", reason: \"trait definition\" },\n  // Routing / navigation\n  { glob: \"**/*Router.*\", category: \"routing\", reason: \"router (navigation/routing)\" },\n  { glob: \"**/*Route.*\", category: \"routing\", reason: \"route definition\" },\n  { glob: \"**/*NavHost.*\", category: \"routing\", reason: \"navigation host\" },\n  { glob: \"**/*Controller.*\", category: \"routing\", reason: \"controller (request handling)\" },\n  { glob: \"**/*Handler.*\", category: \"routing\", reason: \"handler (request handling)\" },\n  // Middleware / interceptors\n  { glob: \"**/*Middleware.*\", category: \"middleware\", reason: \"middleware (request pipeline)\" },\n  { glob: \"**/*Interceptor.*\", category: \"middleware\", reason: \"interceptor (cross-cutting)\" },\n  { glob: \"**/*Plugin.*\", category: \"middleware\", reason: \"plugin (extensibility)\" },\n  // Models / types\n  { glob: \"**/*Model.*\", category: \"model\", reason: \"model (domain types)\" },\n  { glob: \"**/*Entity.*\", category: \"model\", reason: \"entity (persistence types)\" },\n  { glob: \"**/*Dto.*\", category: \"model\", reason: \"DTO (data transfer types)\" },\n  { glob: \"**/*Schema.*\", category: \"model\", reason: \"schema (data validation)\" },\n  // Use cases / commands\n  { glob: \"**/*UseCase.*\", category: \"usecase\", reason: \"use case (business logic)\" },\n  { glob: \"**/*Interactor.*\", category: \"usecase\", reason: \"interactor (business logic)\" },\n  { glob: \"**/*Command.*\", category: \"usecase\", reason: \"command (CQRS pattern)\" },\n];\n\nconst IGNORE_PATTERNS = [\n  \"**/node_modules/**\",\n  \"**/dist/**\",\n  \"**/build/**\",\n  \"**/.gradle/**\",\n  \"**/target/**\",\n  \"**/.git/**\",\n  \"**/vendor/**\",\n  \"**/__pycache__/**\",\n  \"**/venv/**\",\n  \"**/.venv/**\",\n  \"**/*.min.*\",\n  \"**/*.map\",\n  \"**/package-lock.json\",\n  \"**/yarn.lock\",\n  \"**/pnpm-lock.yaml\",\n  \"**/*.lock\",\n  \"**/*.generated.*\",\n  \"**/generated/**\",\n  \"**/R.java\",\n  \"**/BuildConfig.java\",\n];\n\nconst PREVIEW_LINES = 60;\n\nexport interface ProjectConfig {\n  patterns?: string[];\n  alwaysInclude?: string[];\n  ignore?: string[];\n}\n\nexport interface SampledFile {\n  path: string;\n  preview: string;\n  totalLines: number;\n  sizeBytes: number;\n  reason: string;\n}\n\nasync function loadProjectConfig(\n  rootDir: string\n): Promise<ProjectConfig> {\n  try {\n    const raw = await fs.readFile(\n      path.join(rootDir, \".mason\", \"config.json\"),\n      \"utf-8\"\n    );\n    return JSON.parse(raw);\n  } catch {\n    return {};\n  }\n}\n\nasync function getTrackedFiles(rootDir: string): Promise<Set<string> | null> {\n  try {\n    const { stdout } = await exec(\"git\", [\"ls-files\", \"--cached\", \"--others\", \"--exclude-standard\"], {\n      cwd: rootDir,\n      maxBuffer: 10_000_000,\n    });\n    return new Set(stdout.trim().split(\"\\n\").filter(Boolean));\n  } catch {\n    return null; // Not a git repo — skip filtering\n  }\n}\n\nexport async function sampleFiles(\n  rootDir: string,\n  maxFiles: number = 25\n): Promise<SampledFile[]> {\n  const selected = new Map<string, string>(); // path -> reason\n  const projectConfig = await loadProjectConfig(rootDir);\n  const ignorePatterns = [...IGNORE_PATTERNS, ...(projectConfig.ignore ?? [])];\n  const trackedFiles = await getTrackedFiles(rootDir);\n\n  // 0. Always-include files from project config (highest priority)\n  for (const filePath of projectConfig.alwaysInclude ?? []) {\n    if (selected.size >= maxFiles) break;\n    // Validate path stays within project root\n    const resolvedPath = path.resolve(rootDir, filePath);\n    if (!resolvedPath.startsWith(path.resolve(rootDir))) continue;\n    selected.set(filePath, \"always-include (project config)\");\n  }\n\n  // 1. Config files (cap at 5)\n  let configCount = 0;\n  for (const pattern of CONFIG_FILES) {\n    if (configCount >= 5) break;\n    const matches = await fg(pattern, {\n      cwd: rootDir,\n      ignore: ignorePatterns,\n      deep: 3,\n    });\n    for (const match of matches) {\n      if (configCount >= 5 || selected.size >= maxFiles) break;\n      selected.set(match, \"config file\");\n      configCount++;\n    }\n  }\n\n  // 2. Module build/config files — build files from subdirectories reveal dependency graph\n  const moduleBuildPatterns = [\n    // Gradle\n    \"**/build.gradle.kts\",\n    \"**/build.gradle\",\n    // Cargo workspace members\n    \"**/Cargo.toml\",\n    // Node workspaces\n    \"**/package.json\",\n    // Go sub-modules\n    \"**/go.mod\",\n  ];\n  let moduleBuildCount = 0;\n  for (const pattern of moduleBuildPatterns) {\n    const matches = await fg(pattern, {\n      cwd: rootDir,\n      ignore: ignorePatterns,\n      deep: 4,\n    });\n    // Skip root-level files (already captured as config)\n    const subMatches = matches.filter((m) => m.includes(\"/\"));\n    for (const match of subMatches) {\n      if (moduleBuildCount >= 4 || selected.size >= maxFiles) break;\n      if (!selected.has(match)) {\n        selected.set(match, \"module build file (reveals dependency graph)\");\n        moduleBuildCount++;\n      }\n    }\n    if (moduleBuildCount >= 4) break;\n  }\n\n  // 3. Entry points (cap at 2)\n  let entryCount = 0;\n  for (const pattern of ENTRY_POINT_PATTERNS) {\n    if (entryCount >= 2) break;\n    const matches = await fg(pattern, {\n      cwd: rootDir,\n      ignore: ignorePatterns,\n      deep: 5,\n    });\n    for (const match of matches) {\n      if (entryCount >= 2 || selected.size >= maxFiles) break;\n      if (!selected.has(match)) {\n        selected.set(match, \"entry point\");\n        entryCount++;\n      }\n    }\n  }\n\n  // 4. Hot files from git (up to 5)\n  try {\n    const { stdout } = await exec(\n      \"git\",\n      [\"log\", \"--since=3 months ago\", \"--format=\", \"--name-only\"],\n      { cwd: rootDir, maxBuffer: 5_000_000 }\n    );\n\n    const fileCounts = new Map<string, number>();\n    for (const line of stdout.split(\"\\n\")) {\n      if (!line) continue;\n      if (\n        line.includes(\"node_modules\") ||\n        line.includes(\"/build/\") ||\n        line.includes(\".gradle\") ||\n        line.includes(\"/generated/\")\n      )\n        continue;\n      const ext = path.extname(line).slice(1);\n      if (!SOURCE_EXTENSIONS.includes(ext)) continue;\n      fileCounts.set(line, (fileCounts.get(line) ?? 0) + 1);\n    }\n\n    const hotFiles = [...fileCounts.entries()]\n      .sort((a, b) => b[1] - a[1])\n      .slice(0, 5);\n\n    for (const [file, count] of hotFiles) {\n      if (selected.size >= maxFiles) break;\n      if (!selected.has(file)) {\n        selected.set(file, `frequently changed (${count} commits in 3 months)`);\n      }\n    }\n  } catch {\n    // No git\n  }\n\n  // 5. Architectural pattern files — one per category (cap at 8)\n  const seenCategories = new Set<string>();\n  let patternCount = 0;\n  for (const pattern of ARCHITECTURAL_PATTERNS) {\n    if (patternCount >= 8 || selected.size >= maxFiles) break;\n    if (seenCategories.has(pattern.category)) continue;\n\n    const matches = await fg(pattern.glob, {\n      cwd: rootDir,\n      ignore: ignorePatterns,\n    });\n\n    if (matches.length > 0) {\n      for (const match of matches) {\n        if (!selected.has(match)) {\n          selected.set(match, pattern.reason);\n          seenCategories.add(pattern.category);\n          patternCount++;\n          break;\n        }\n      }\n    }\n  }\n\n  // 5b. Custom patterns from project config\n  for (const customGlob of projectConfig.patterns ?? []) {\n    if (selected.size >= maxFiles) break;\n    const matches = await fg(customGlob, {\n      cwd: rootDir,\n      ignore: ignorePatterns,\n    });\n    for (const match of matches) {\n      if (selected.size >= maxFiles) break;\n      if (!selected.has(match)) {\n        selected.set(match, \"custom pattern (project config)\");\n        break; // one per pattern\n      }\n    }\n  }\n\n  // 6. Test examples — diverse across file types (cap at 3)\n  const testPatternGroups = [\n    // JS/TS tests\n    { patterns: [\"**/*.test.*\", \"**/*.spec.*\"], label: \"JS/TS test\" },\n    // JVM tests\n    { patterns: [\"**/*Test.kt\", \"**/*Test.java\"], label: \"JVM test\" },\n    // Python tests\n    { patterns: [\"**/test_*.py\", \"**/*_test.py\"], label: \"Python test\" },\n    // Go tests\n    { patterns: [\"**/*_test.go\"], label: \"Go test\" },\n    // Swift tests\n    { patterns: [\"**/*Tests.swift\", \"**/*Test.swift\"], label: \"Swift test\" },\n    // Rust tests\n    { patterns: [\"**/*_test.rs\"], label: \"Rust test\" },\n  ];\n  let testCount = 0;\n  for (const group of testPatternGroups) {\n    if (testCount >= 3 || selected.size >= maxFiles) break;\n    const testFiles = await fg(group.patterns, {\n      cwd: rootDir,\n      ignore: ignorePatterns,\n    });\n    if (testFiles.length > 0) {\n      for (const file of testFiles) {\n        if (!selected.has(file)) {\n          selected.set(file, `test example (${group.label})`);\n          testCount++;\n          break;\n        }\n      }\n    }\n  }\n\n  // 7. Directory breadth — fill remaining slots with one file per top-level dir\n  const sourceGlobs = SOURCE_EXTENSIONS.map((ext) => `**/*.${ext}`);\n  const allSourceFiles = await fg(sourceGlobs, {\n    cwd: rootDir,\n    ignore: ignorePatterns,\n  });\n\n  const dirRepresentatives = new Map<string, string>();\n  const boringFiles = /\\.(gradle|gradle\\.kts|json|toml|yaml|yml|xml|properties)$/;\n  for (const file of allSourceFiles) {\n    const topDir = file.split(\"/\")[0];\n    if (!dirRepresentatives.has(topDir) && !boringFiles.test(file)) {\n      dirRepresentatives.set(topDir, file);\n    }\n  }\n\n  for (const [, file] of dirRepresentatives) {\n    if (selected.size >= maxFiles) break;\n    if (!selected.has(file)) {\n      selected.set(file, \"directory representative\");\n    }\n  }\n\n  // Read file previews\n  const results: SampledFile[] = [];\n  for (const [filePath, reason] of selected) {\n    try {\n      const fullPath = path.resolve(rootDir, filePath);\n      if (!fullPath.startsWith(path.resolve(rootDir))) continue;\n      if (isSensitiveFile(filePath)) continue;\n      if (trackedFiles && !trackedFiles.has(filePath)) continue; // respect .gitignore\n      const stat = await fs.stat(fullPath);\n      if (stat.size > 100_000) continue;\n\n      const content = await fs.readFile(fullPath, \"utf-8\");\n      const lines = content.split(\"\\n\");\n      const preview = lines.slice(0, PREVIEW_LINES).join(\"\\n\");\n\n      results.push({\n        path: filePath,\n        preview,\n        totalLines: lines.length,\n        sizeBytes: stat.size,\n        reason,\n      });\n    } catch {\n      // Skip\n    }\n  }\n\n  return results;\n}\n\nconst SENSITIVE_PATTERNS = [\n  /^\\.env$/,\n  /^\\.env\\./,\n  /\\.pem$/,\n  /\\.key$/,\n  /\\.p12$/,\n  /\\.pfx$/,\n  /\\.jks$/,\n  /id_rsa/,\n  /id_ed25519/,\n  /credentials\\./,\n  /secret/i,\n  /\\.keystore$/,\n  /local\\.properties$/,\n];\n\nfunction isSensitiveFile(filePath: string): boolean {\n  const basename = path.basename(filePath);\n  return SENSITIVE_PATTERNS.some((p) => p.test(basename));\n}\n\nexport async function readFullFile(\n  rootDir: string,\n  filePath: string\n): Promise<{ path: string; content: string; totalLines: number } | null> {\n  try {\n    const fullPath = path.join(path.resolve(rootDir), filePath);\n    if (!fullPath.startsWith(path.resolve(rootDir))) return null;\n    if (isSensitiveFile(filePath)) return null;\n\n    const content = await fs.readFile(fullPath, \"utf-8\");\n    return {\n      path: filePath,\n      content,\n      totalLines: content.split(\"\\n\").length,\n    };\n  } catch {\n    return null;\n  }\n}\n","import path from \"node:path\";\nimport fg from \"fast-glob\";\n\nconst IGNORE = [\n  \"**/node_modules/**\",\n  \"**/dist/**\",\n  \"**/build/**\",\n  \"**/.gradle/**\",\n  \"**/target/**\",\n  \"**/.git/**\",\n  \"**/vendor/**\",\n  \"**/__pycache__/**\",\n  \"**/venv/**\",\n  \"**/.venv/**\",\n  \"**/*.min.*\",\n  \"**/*.map\",\n];\n\nexport interface TestPair {\n  test: string;\n  source: string;\n  confidence: string;\n}\n\nexport interface TestMapResult {\n  totalTestFiles: number;\n  paired: TestPair[];\n  unmatched: string[];\n}\n\nexport async function buildTestMap(dir: string): Promise<TestMapResult> {\n  const rootDir = path.resolve(dir);\n\n  // Find all test files\n  const testPatterns = [\n    \"**/*.test.*\", \"**/*.spec.*\",\n    \"**/*Test.kt\", \"**/*Test.java\", \"**/*Tests.kt\", \"**/*Tests.java\",\n    \"**/test_*.py\", \"**/*_test.py\",\n    \"**/*_test.go\",\n    \"**/*Tests.swift\", \"**/*Test.swift\",\n    \"**/*_test.rs\",\n  ];\n  const testFiles = await fg(testPatterns, { cwd: rootDir, ignore: IGNORE });\n\n  // Find all source files\n  const sourceFiles = await fg(\n    \"**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,dart}\",\n    { cwd: rootDir, ignore: IGNORE }\n  );\n\n  // Build source file index by base name (without extension)\n  const sourceByBaseName = new Map<string, string[]>();\n  for (const file of sourceFiles) {\n    if (testFiles.includes(file)) continue; // Skip test files\n    const baseName = path.basename(file).replace(/\\.[^.]+$/, \"\");\n    const existing = sourceByBaseName.get(baseName) ?? [];\n    existing.push(file);\n    sourceByBaseName.set(baseName, existing);\n  }\n\n  // Match test files to source files by name\n  const paired: TestPair[] = [];\n  const unmatched: string[] = [];\n\n  for (const testFile of testFiles) {\n    const testBaseName = path.basename(testFile).replace(/\\.[^.]+$/, \"\");\n\n    // Strip test suffixes/prefixes to get the source name\n    const sourceName = testBaseName\n      .replace(/Test$|Tests$|Spec$|\\.test$|\\.spec$/, \"\")\n      .replace(/^test_|_test$/, \"\");\n\n    if (!sourceName) {\n      unmatched.push(testFile);\n      continue;\n    }\n\n    const candidates = sourceByBaseName.get(sourceName);\n    if (candidates && candidates.length > 0) {\n      // If multiple candidates, prefer one in a similar directory path\n      const testDir = path.dirname(testFile);\n      const bestMatch = candidates.reduce((best, candidate) => {\n        const candidateDir = path.dirname(candidate);\n        const bestDir = path.dirname(best);\n        const candidateOverlap = commonSegments(testDir, candidateDir);\n        const bestOverlap = commonSegments(testDir, bestDir);\n        return candidateOverlap > bestOverlap ? candidate : best;\n      });\n\n      paired.push({\n        test: testFile,\n        source: bestMatch,\n        confidence: candidates.length === 1 ? \"exact\" : \"best-guess\",\n      });\n    } else {\n      unmatched.push(testFile);\n    }\n  }\n\n  return { totalTestFiles: testFiles.length, paired, unmatched };\n}\n\nfunction commonSegments(pathA: string, pathB: string): number {\n  const segsA = pathA.split(\"/\");\n  const segsB = pathB.split(\"/\");\n  let count = 0;\n  for (let i = 0; i < Math.min(segsA.length, segsB.length); i++) {\n    if (segsA[i] === segsB[i]) count++;\n    else break;\n  }\n  return count;\n}\n","import path from \"node:path\";\n\n// Question/filler words that carry no signal about which entry a task\n// touches. Domain words (\"auth\", \"drift\") are never in this list.\nconst STOPWORDS = new Set([\n  \"the\", \"a\", \"an\", \"and\", \"or\", \"of\", \"to\", \"in\", \"on\", \"for\", \"with\",\n  \"how\", \"does\", \"do\", \"is\", \"are\", \"was\", \"what\", \"where\", \"which\", \"why\",\n  \"when\", \"who\", \"i\", \"we\", \"my\", \"our\", \"you\", \"your\", \"it\", \"its\", \"this\",\n  \"that\", \"these\", \"those\", \"can\", \"could\", \"should\", \"would\", \"will\",\n  \"want\", \"need\", \"please\", \"about\", \"into\", \"from\", \"when\", \"there\", \"any\",\n  \"all\", \"some\", \"not\", \"but\", \"also\", \"just\", \"like\", \"get\", \"make\", \"use\",\n  \"new\", \"work\", \"works\", \"working\", \"implement\", \"implemented\", \"change\",\n  \"changed\", \"file\", \"files\", \"code\",\n]);\n\n/** Split camelCase/PascalCase/kebab/snake/path into lowercase word tokens. */\nexport function tokenize(text: string): string[] {\n  return text\n    .replace(/([a-z0-9])([A-Z])/g, \"$1 $2\")\n    .toLowerCase()\n    .split(/[^a-z0-9]+/)\n    .filter((t) => t.length > 2 && !STOPWORDS.has(t));\n}\n\n/** Crude singular/plural folding so \"flows\" matches \"flow\" etc. */\nexport function stem(token: string): string {\n  return token.length > 3 && token.endsWith(\"s\") ? token.slice(0, -1) : token;\n}\n\nexport function tokenSet(text: string): Set<string> {\n  return new Set(tokenize(text).map(stem));\n}\n\nexport interface Scorable {\n  name: string;\n  description: string;\n  files: string[];\n}\n\n/**\n * Lexical relevance of one entry to the task. Name hits are the strongest\n * signal, then description, then file-path words. Each distinct task token\n * counts once at its best weight, so a token appearing everywhere doesn't\n * triple-count.\n */\nexport function scoreEntry(taskTokens: Set<string>, entry: Scorable): number {\n  const nameTokens = tokenSet(entry.name);\n  const descTokens = tokenSet(entry.description);\n  const fileTokens = tokenSet(entry.files.map((f) => path.basename(f)).join(\" \"));\n\n  let score = 0;\n  for (const token of taskTokens) {\n    if (nameTokens.has(token)) score += 3;\n    else if (descTokens.has(token)) score += 1;\n    else if (fileTokens.has(token)) score += 1;\n  }\n  return score;\n}\n\n/** Jaccard similarity of two token sets: |∩| / |∪|, 0 when both empty. */\nexport function jaccard(a: Set<string>, b: Set<string>): number {\n  if (a.size === 0 && b.size === 0) return 0;\n  let intersection = 0;\n  for (const token of a) if (b.has(token)) intersection++;\n  return intersection / (a.size + b.size - intersection);\n}\n","import path from \"node:path\";\nimport { getChangesWithStatus } from \"../drift/drift.js\";\nimport { getCurrentGitHash } from \"../snapshot/snapshot.js\";\nimport { loadDecisions } from \"./decisions.js\";\nimport type { DecisionRecord } from \"./decisions.js\";\n\n/**\n * Deliberately separate from DriftReport: mason-drift's exit codes and\n * --json shape are a CI contract, and `stale` there means MAP staleness.\n * Decision staleness is additive on top.\n */\nexport interface DecisionDriftReport {\n  historyAvailable: boolean;\n  totalDecisions: number;\n  /** Decision id → anchor files changed since the record's refreshedHash. */\n  staleDecisions: Record<string, string[]>;\n}\n\n/**\n * Flag active decisions whose anchor files changed since the record was\n * last verified. Anchorless decisions are pure prose and never go stale.\n * Deterministic — git only, no LLM.\n */\nexport async function computeDecisionDrift(\n  rootDir: string,\n  decisions?: DecisionRecord[]\n): Promise<DecisionDriftReport> {\n  const resolvedRoot = path.resolve(rootDir);\n  const records = decisions ?? (await loadDecisions(resolvedRoot));\n  const report: DecisionDriftReport = {\n    historyAvailable: true,\n    totalDecisions: records.length,\n    staleDecisions: {},\n  };\n\n  const head = await getCurrentGitHash(resolvedRoot);\n  const changesByHash = new Map<string, Set<string> | null>();\n\n  for (const record of records) {\n    if (record.status !== \"active\" || record.files.length === 0) continue;\n    if (record.refreshedHash === head) continue;\n\n    let touched = changesByHash.get(record.refreshedHash);\n    if (touched === undefined) {\n      const changes = await getChangesWithStatus(\n        resolvedRoot,\n        record.refreshedHash\n      );\n      if (changes === null) {\n        touched = null;\n      } else {\n        touched = new Set<string>();\n        for (const change of changes) {\n          touched.add(change.path);\n          if (change.previousPath) touched.add(change.previousPath);\n        }\n      }\n      changesByHash.set(record.refreshedHash, touched);\n    }\n\n    if (touched === null) {\n      // Unreachable base commit — we know nothing per-file; surface that\n      // rather than silently reporting the record fresh.\n      report.historyAvailable = false;\n      continue;\n    }\n\n    const hits = record.files.filter((f) => touched.has(f));\n    if (hits.length > 0) {\n      report.staleDecisions[record.id] = hits;\n    }\n  }\n\n  return report;\n}\n","import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { execFile } from \"node:child_process\";\nimport { promisify } from \"node:util\";\nimport {\n  loadSnapshot,\n  getCurrentGitHash,\n  listSourceFiles,\n} from \"../snapshot/snapshot.js\";\nimport type { Snapshot } from \"../snapshot/snapshot.js\";\n\nconst exec = promisify(execFile);\n\n// Incremental refresh stops paying off once a large share of the map is\n// touched — but small absolute counts are always cheap to refresh in place,\n// so both thresholds must be exceeded before recommending a full rebuild.\nconst FULL_REBUILD_FRACTION = 0.4;\nconst FULL_REBUILD_MIN_CHANGED_MAPPED_FILES = 10;\n\nexport type ChangeStatus = \"added\" | \"modified\" | \"deleted\" | \"renamed\";\n\nexport interface FileChange {\n  status: ChangeStatus;\n  /** Current path (the new path for renames). */\n  path: string;\n  /** Pre-rename path, only present for renames. */\n  previousPath?: string;\n}\n\nexport type DriftRecommendation = \"up-to-date\" | \"incremental\" | \"full-rebuild\";\n\nexport interface DriftReport {\n  stale: boolean;\n  snapshotHash: string;\n  headHash: string;\n  /** Commits between the snapshot and HEAD; null when history is unavailable. */\n  commitsBehind: number | null;\n  /**\n   * False when the snapshot commit is unreachable (shallow clone, rewritten\n   * history) — staleFeatures/unmappedFiles/renames cannot be computed then.\n   */\n  historyAvailable: boolean;\n  /** Current paths of every file changed since the snapshot. */\n  changedFiles: string[];\n  /** Stale feature name → the mapped files that changed under it. */\n  staleFeatures: Record<string, string[]>;\n  /** Stale flow name → the chain files that changed under it. */\n  staleFlows: Record<string, string[]>;\n  totalFeatures: number;\n  totalFlows: number;\n  /** New source files not referenced by any feature or flow. */\n  unmappedFiles: string[];\n  /** Files referenced by the map that no longer exist on disk. */\n  ghostFiles: string[];\n  renames: Array<{ from: string; to: string }>;\n  recommendation: DriftRecommendation;\n}\n\nexport async function getChangesWithStatus(\n  resolvedRoot: string,\n  fromHash: string\n): Promise<FileChange[] | null> {\n  if (!fromHash || fromHash === \"unknown\") return null;\n  try {\n    const { stdout } = await exec(\n      \"git\",\n      [\"diff\", \"--name-status\", \"-M\", fromHash, \"HEAD\"],\n      { cwd: resolvedRoot, maxBuffer: 10 * 1024 * 1024 }\n    );\n\n    const changes: FileChange[] = [];\n    for (const line of stdout.split(\"\\n\")) {\n      if (!line.trim()) continue;\n      const parts = line.split(\"\\t\");\n      // Mason's own metadata changes on every save — never count it as drift.\n      if (parts.some((p) => p.startsWith(\".mason/\"))) continue;\n      const code = parts[0];\n      if (code.startsWith(\"R\") && parts.length >= 3) {\n        changes.push({\n          status: \"renamed\",\n          path: parts[2],\n          previousPath: parts[1],\n        });\n      } else if (code.startsWith(\"C\") && parts.length >= 3) {\n        // A copy leaves the original in place — only the new path is a change.\n        changes.push({ status: \"added\", path: parts[2] });\n      } else if (code === \"A\" && parts.length >= 2) {\n        changes.push({ status: \"added\", path: parts[1] });\n      } else if (code === \"D\" && parts.length >= 2) {\n        changes.push({ status: \"deleted\", path: parts[1] });\n      } else if (parts.length >= 2) {\n        // M, T (typechange), and anything unrecognized count as modified.\n        changes.push({ status: \"modified\", path: parts[1] });\n      }\n    }\n    return changes;\n  } catch {\n    return null;\n  }\n}\n\nasync function countCommitsBehind(\n  resolvedRoot: string,\n  fromHash: string\n): Promise<number | null> {\n  try {\n    const { stdout } = await exec(\n      \"git\",\n      [\"rev-list\", \"--count\", `${fromHash}..HEAD`],\n      { cwd: resolvedRoot }\n    );\n    const count = Number.parseInt(stdout.trim(), 10);\n    return Number.isNaN(count) ? null : count;\n  } catch {\n    return null;\n  }\n}\n\nfunction collectMappedFiles(snapshot: Snapshot): Set<string> {\n  const mappedFiles = new Set<string>();\n  for (const feature of Object.values(snapshot.features)) {\n    for (const f of feature.files) mappedFiles.add(f);\n    for (const t of feature.tests ?? []) mappedFiles.add(t);\n  }\n  for (const flow of Object.values(snapshot.flows)) {\n    for (const f of flow.chain) mappedFiles.add(f);\n  }\n  return mappedFiles;\n}\n\nasync function findGhostFiles(\n  resolvedRoot: string,\n  mappedFiles: Set<string>\n): Promise<string[]> {\n  const ghosts: string[] = [];\n  for (const file of mappedFiles) {\n    try {\n      await fs.access(path.join(resolvedRoot, file));\n    } catch {\n      ghosts.push(file);\n    }\n  }\n  return ghosts.sort();\n}\n\n/**\n * Compare the concept map against HEAD and report feature-level drift.\n * Fully deterministic — git + filesystem only, no LLM involved.\n * Returns null when no snapshot exists.\n */\nexport async function computeDrift(\n  rootDir: string\n): Promise<DriftReport | null> {\n  const resolvedRoot = path.resolve(rootDir);\n  const snapshot = await loadSnapshot(resolvedRoot);\n  if (!snapshot) return null;\n\n  const headHash = await getCurrentGitHash(resolvedRoot);\n  const totalFeatures = Object.keys(snapshot.features).length;\n  const totalFlows = Object.keys(snapshot.flows).length;\n\n  // Each entry is only verified as of its refreshedHash (falling back to the\n  // top-level gitHash), so drift is evaluated per distinct hash — a partially\n  // refreshed map can be fresh at the top level and still hold stale entries.\n  const hashFor = (entry: { refreshedHash?: string }): string =>\n    entry.refreshedHash ?? snapshot.gitHash;\n\n  const distinctHashes = new Set<string>([snapshot.gitHash]);\n  for (const feature of Object.values(snapshot.features)) {\n    distinctHashes.add(hashFor(feature));\n  }\n  for (const flow of Object.values(snapshot.flows)) {\n    distinctHashes.add(hashFor(flow));\n  }\n  distinctHashes.delete(\"unknown\");\n\n  const staleHashes =\n    headHash === \"unknown\"\n      ? []\n      : [...distinctHashes].filter((h) => h !== headHash);\n  const stale = staleHashes.length > 0;\n\n  const report: DriftReport = {\n    stale,\n    snapshotHash: snapshot.gitHash,\n    headHash,\n    commitsBehind: stale ? null : 0,\n    historyAvailable: true,\n    changedFiles: [],\n    staleFeatures: {},\n    staleFlows: {},\n    totalFeatures,\n    totalFlows,\n    unmappedFiles: [],\n    ghostFiles: [],\n    renames: [],\n    recommendation: \"up-to-date\",\n  };\n\n  if (!stale) return report;\n\n  const mappedFiles = collectMappedFiles(snapshot);\n  report.ghostFiles = await findGhostFiles(resolvedRoot, mappedFiles);\n\n  const changesByHash = new Map<string, FileChange[]>();\n  const touchedByHash = new Map<string, Set<string>>();\n  for (const hash of staleHashes) {\n    const changes = await getChangesWithStatus(resolvedRoot, hash);\n    if (changes === null) {\n      // One unreachable base commit is enough to make per-entry drift\n      // uncomputable — we know the map is stale but not how.\n      report.historyAvailable = false;\n      report.recommendation = \"full-rebuild\";\n      return report;\n    }\n    changesByHash.set(hash, changes);\n    // Every path a change touches, old and new — an entry referencing either\n    // side of a rename is stale.\n    const touched = new Set<string>();\n    for (const change of changes) {\n      touched.add(change.path);\n      if (change.previousPath) touched.add(change.previousPath);\n    }\n    touchedByHash.set(hash, touched);\n  }\n\n  // The oldest verification state in the map is the honest answer to \"how\n  // far behind is this snapshot\".\n  const commitCounts = await Promise.all(\n    staleHashes.map((hash) => countCommitsBehind(resolvedRoot, hash))\n  );\n  const validCounts = commitCounts.filter((c): c is number => c !== null);\n  report.commitsBehind =\n    validCounts.length > 0 ? Math.max(...validCounts) : null;\n\n  const emptySet = new Set<string>();\n  const touchedFor = (entry: { refreshedHash?: string }): Set<string> =>\n    touchedByHash.get(hashFor(entry)) ?? emptySet;\n\n  for (const [name, feature] of Object.entries(snapshot.features)) {\n    const touched = touchedFor(feature);\n    const hits = [...feature.files, ...(feature.tests ?? [])].filter((f) =>\n      touched.has(f)\n    );\n    if (hits.length > 0) report.staleFeatures[name] = [...new Set(hits)];\n  }\n  for (const [name, flow] of Object.entries(snapshot.flows)) {\n    const touched = touchedFor(flow);\n    const hits = flow.chain.filter((f) => touched.has(f));\n    if (hits.length > 0) report.staleFlows[name] = [...new Set(hits)];\n  }\n\n  const allChanges = [...changesByHash.values()].flat();\n  report.changedFiles = [...new Set(allChanges.map((c) => c.path))].sort();\n\n  // New source files (added, or the new side of a rename) missing from the map.\n  const sourceFileSet = new Set(await listSourceFiles(resolvedRoot));\n  const newPaths = allChanges\n    .filter((c) => c.status === \"added\" || c.status === \"renamed\")\n    .map((c) => c.path);\n  report.unmappedFiles = [...new Set(newPaths)]\n    .filter((p) => sourceFileSet.has(p) && !mappedFiles.has(p))\n    .sort();\n\n  const renameKeys = new Set<string>();\n  for (const change of allChanges) {\n    if (change.status !== \"renamed\" || !change.previousPath) continue;\n    const key = `${change.previousPath}\u0000${change.path}`;\n    if (renameKeys.has(key)) continue;\n    renameKeys.add(key);\n    report.renames.push({ from: change.previousPath, to: change.path });\n  }\n\n  const changedMapped = new Set<string>([\n    ...Object.values(report.staleFeatures).flat(),\n    ...Object.values(report.staleFlows).flat(),\n  ]);\n  const changedFraction =\n    mappedFiles.size > 0 ? changedMapped.size / mappedFiles.size : 0;\n  report.recommendation =\n    changedMapped.size >= FULL_REBUILD_MIN_CHANGED_MAPPED_FILES &&\n    changedFraction > FULL_REBUILD_FRACTION\n      ? \"full-rebuild\"\n      : \"incremental\";\n\n  return report;\n}\n","import { runHook } from \"./hook.js\";\nimport type { HookEnv } from \"./hook.js\";\n\nexport const USAGE = `Usage: mason-hook [--print-config | --help]\n\nClaude Code PostToolUse hook: when the session reads or edits a file that a\nMason decision record anchors, the record is injected into the model's\ncontext. Deterministic lookup, no LLM call; silent when nothing matches.\n\nReads the hook JSON on stdin and prints the hook output JSON on stdout.\nRegister it via .claude/settings.json (committed to the repo, so the whole\nteam gets the same rail):\n\n  mason-hook --print-config   Print the settings.json hooks block\n\nRepeat injections are deduped per session; state lives in the OS temp dir.`;\n\nexport const SETTINGS_CONFIG = {\n  hooks: {\n    PostToolUse: [\n      {\n        matcher: \"Read|Edit|Write\",\n        hooks: [\n          {\n            type: \"command\",\n            command: \"npx -y -p mason-context mason-hook\",\n            timeout: 10,\n          },\n        ],\n      },\n    ],\n  },\n};\n\nexport interface HookCliIo {\n  out: (line: string) => void;\n  err: (line: string) => void;\n}\n\nexport async function runHookCli(\n  argv: string[],\n  stdinText: string,\n  io: HookCliIo = {\n    out: (line) => process.stdout.write(`${line}\\n`),\n    err: (line) => process.stderr.write(`${line}\\n`),\n  },\n  env: HookEnv = {}\n): Promise<number> {\n  if (argv.includes(\"--help\") || argv.includes(\"-h\")) {\n    io.out(USAGE);\n    return 0;\n  }\n  if (argv.includes(\"--print-config\")) {\n    io.out(JSON.stringify(SETTINGS_CONFIG, null, 2));\n    return 0;\n  }\n\n  // A hook must never disrupt the session: any failure path is a silent\n  // success with no output.\n  try {\n    const output = await runHook(stdinText, env);\n    if (output !== null) io.out(output);\n  } catch {\n    // Silent by design.\n  }\n  return 0;\n}\n","import { runHookCli } from \"../src/hook/cli.js\";\n\nasync function readStdin(): Promise<string> {\n  if (process.stdin.isTTY) return \"\";\n  const chunks: Buffer[] = [];\n  for await (const chunk of process.stdin) {\n    chunks.push(Buffer.from(chunk));\n  }\n  return Buffer.concat(chunks).toString(\"utf-8\");\n}\n\nreadStdin()\n  .then((stdinText) => runHookCli(process.argv.slice(2), stdinText))\n  .then((code) => process.exit(code))\n  .catch(() => process.exit(0));\n"],"mappings":"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","names":["fs","path","fs","path","fs","path","execFile","promisify","fg","path","fg","exec","promisify","execFile","exec","path","path","fs","path","fs","path","execFile","promisify","exec","promisify","execFile","exec","path","fs","path"]}

package/dist/mason-mcp.js

@@ -3947,7 +3947,7 @@ function createMcpServer() {
   const server = new McpServer(
     {
       name: "mason",
-      version: "0.7.0"
+      version: "0.8.0"
     },
     {
       instructions: "Mason maintains a persistent feature-to-file concept map of this codebase so you can skip manual exploration. RULE: when given a task, bug, or change request, call `get_context` with the task text first \u2014 one call returns the relevant features, files, tests, blast radius, and freshness. Before answering ANY question about features, architecture, data flows, or where something lives \u2014 and before any grep/glob/file-read exploration for such a question \u2014 call `get_snapshot` first. One call returns the whole map and replaces 5-10 search round-trips; if it has drifted it says so and self-corrects. Likewise call `get_impact` BEFORE editing or refactoring a file (git co-change history + references + related tests \u2014 signals you cannot get from reading the file itself), and `mason_check_drift` to verify the map is fresh in long sessions. When you learn something the code alone can't tell you \u2014 a failed approach, a deprecation, a workaround's reason, a review-settled convention \u2014 record it with `save_decision` so the whole team's assistants inherit it; `get_context` returns matching decisions as constraints. If `get_snapshot` reports no snapshot exists, offer to set Mason up: `mason_init` returns a setup playbook (a Map-Reduce loop of `generate_snapshot_batch` + `save_partial_snapshot`, then `reduce_snapshot` + `save_snapshot`, optionally `mason_set_confluence`, then `mason_complete_init`). `full_analysis`, `analyze_project`, and `get_code_samples` are read-only diagnostics for unmapped projects and never need init. Mason has no CLI; everything happens through these tools."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mason-context",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "MCP server for codebase context engineering — feature-to-file concept maps, change impact, and Confluence wiki sync for AI coding assistants",
   "type": "module",
   "mcpName": "com.adrianczuczka/mason",
@@ -9,7 +9,8 @@
     "mason-mcp": "dist/mason-mcp.js",
     "mason-context": "dist/mason-mcp.js",
     "mason-drift": "dist/mason-drift.js",
-    "mason-audit": "dist/mason-audit.js"
+    "mason-audit": "dist/mason-audit.js",
+    "mason-hook": "dist/mason-hook.js"
   },
   "scripts": {
     "build": "tsup",