mason-context 0.3.7 → 0.7.0

package/dist/mason-mcp.js

@@ -0,0 +1,4283 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/mcp/sampler.ts
+import fs2 from "fs/promises";
+import path from "path";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import fg2 from "fast-glob";
+async function loadProjectConfig(rootDir) {
+  try {
+    const raw = await fs2.readFile(
+      path.join(rootDir, ".mason", "config.json"),
+      "utf-8"
+    );
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function getTrackedFiles(rootDir) {
+  try {
+    const { stdout } = await exec3("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+      cwd: rootDir,
+      maxBuffer: 1e7
+    });
+    return new Set(stdout.trim().split("\n").filter(Boolean));
+  } catch {
+    return null;
+  }
+}
+async function sampleFiles(rootDir, maxFiles = 25) {
+  const selected = /* @__PURE__ */ new Map();
+  const projectConfig = await loadProjectConfig(rootDir);
+  const ignorePatterns = [...IGNORE_PATTERNS, ...projectConfig.ignore ?? []];
+  const trackedFiles = await getTrackedFiles(rootDir);
+  for (const filePath of projectConfig.alwaysInclude ?? []) {
+    if (selected.size >= maxFiles) break;
+    const resolvedPath = path.resolve(rootDir, filePath);
+    if (!resolvedPath.startsWith(path.resolve(rootDir))) continue;
+    selected.set(filePath, "always-include (project config)");
+  }
+  let configCount = 0;
+  for (const pattern of CONFIG_FILES) {
+    if (configCount >= 5) break;
+    const matches = await fg2(pattern, {
+      cwd: rootDir,
+      ignore: ignorePatterns,
+      deep: 3
+    });
+    for (const match of matches) {
+      if (configCount >= 5 || selected.size >= maxFiles) break;
+      selected.set(match, "config file");
+      configCount++;
+    }
+  }
+  const moduleBuildPatterns = [
+    // Gradle
+    "**/build.gradle.kts",
+    "**/build.gradle",
+    // Cargo workspace members
+    "**/Cargo.toml",
+    // Node workspaces
+    "**/package.json",
+    // Go sub-modules
+    "**/go.mod"
+  ];
+  let moduleBuildCount = 0;
+  for (const pattern of moduleBuildPatterns) {
+    const matches = await fg2(pattern, {
+      cwd: rootDir,
+      ignore: ignorePatterns,
+      deep: 4
+    });
+    const subMatches = matches.filter((m) => m.includes("/"));
+    for (const match of subMatches) {
+      if (moduleBuildCount >= 4 || selected.size >= maxFiles) break;
+      if (!selected.has(match)) {
+        selected.set(match, "module build file (reveals dependency graph)");
+        moduleBuildCount++;
+      }
+    }
+    if (moduleBuildCount >= 4) break;
+  }
+  let entryCount = 0;
+  for (const pattern of ENTRY_POINT_PATTERNS) {
+    if (entryCount >= 2) break;
+    const matches = await fg2(pattern, {
+      cwd: rootDir,
+      ignore: ignorePatterns,
+      deep: 5
+    });
+    for (const match of matches) {
+      if (entryCount >= 2 || selected.size >= maxFiles) break;
+      if (!selected.has(match)) {
+        selected.set(match, "entry point");
+        entryCount++;
+      }
+    }
+  }
+  try {
+    const { stdout } = await exec3(
+      "git",
+      ["log", "--since=3 months ago", "--format=", "--name-only"],
+      { cwd: rootDir, maxBuffer: 5e6 }
+    );
+    const fileCounts = /* @__PURE__ */ new Map();
+    for (const line of stdout.split("\n")) {
+      if (!line) continue;
+      if (line.includes("node_modules") || line.includes("/build/") || line.includes(".gradle") || line.includes("/generated/"))
+        continue;
+      const ext = path.extname(line).slice(1);
+      if (!SOURCE_EXTENSIONS.includes(ext)) continue;
+      fileCounts.set(line, (fileCounts.get(line) ?? 0) + 1);
+    }
+    const hotFiles = [...fileCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+    for (const [file, count] of hotFiles) {
+      if (selected.size >= maxFiles) break;
+      if (!selected.has(file)) {
+        selected.set(file, `frequently changed (${count} commits in 3 months)`);
+      }
+    }
+  } catch {
+  }
+  const seenCategories = /* @__PURE__ */ new Set();
+  let patternCount = 0;
+  for (const pattern of ARCHITECTURAL_PATTERNS) {
+    if (patternCount >= 8 || selected.size >= maxFiles) break;
+    if (seenCategories.has(pattern.category)) continue;
+    const matches = await fg2(pattern.glob, {
+      cwd: rootDir,
+      ignore: ignorePatterns
+    });
+    if (matches.length > 0) {
+      for (const match of matches) {
+        if (!selected.has(match)) {
+          selected.set(match, pattern.reason);
+          seenCategories.add(pattern.category);
+          patternCount++;
+          break;
+        }
+      }
+    }
+  }
+  for (const customGlob of projectConfig.patterns ?? []) {
+    if (selected.size >= maxFiles) break;
+    const matches = await fg2(customGlob, {
+      cwd: rootDir,
+      ignore: ignorePatterns
+    });
+    for (const match of matches) {
+      if (selected.size >= maxFiles) break;
+      if (!selected.has(match)) {
+        selected.set(match, "custom pattern (project config)");
+        break;
+      }
+    }
+  }
+  const testPatternGroups = [
+    // JS/TS tests
+    { patterns: ["**/*.test.*", "**/*.spec.*"], label: "JS/TS test" },
+    // JVM tests
+    { patterns: ["**/*Test.kt", "**/*Test.java"], label: "JVM test" },
+    // Python tests
+    { patterns: ["**/test_*.py", "**/*_test.py"], label: "Python test" },
+    // Go tests
+    { patterns: ["**/*_test.go"], label: "Go test" },
+    // Swift tests
+    { patterns: ["**/*Tests.swift", "**/*Test.swift"], label: "Swift test" },
+    // Rust tests
+    { patterns: ["**/*_test.rs"], label: "Rust test" }
+  ];
+  let testCount = 0;
+  for (const group of testPatternGroups) {
+    if (testCount >= 3 || selected.size >= maxFiles) break;
+    const testFiles = await fg2(group.patterns, {
+      cwd: rootDir,
+      ignore: ignorePatterns
+    });
+    if (testFiles.length > 0) {
+      for (const file of testFiles) {
+        if (!selected.has(file)) {
+          selected.set(file, `test example (${group.label})`);
+          testCount++;
+          break;
+        }
+      }
+    }
+  }
+  const sourceGlobs = SOURCE_EXTENSIONS.map((ext) => `**/*.${ext}`);
+  const allSourceFiles = await fg2(sourceGlobs, {
+    cwd: rootDir,
+    ignore: ignorePatterns
+  });
+  const dirRepresentatives = /* @__PURE__ */ new Map();
+  const boringFiles = /\.(gradle|gradle\.kts|json|toml|yaml|yml|xml|properties)$/;
+  for (const file of allSourceFiles) {
+    const topDir = file.split("/")[0];
+    if (!dirRepresentatives.has(topDir) && !boringFiles.test(file)) {
+      dirRepresentatives.set(topDir, file);
+    }
+  }
+  for (const [, file] of dirRepresentatives) {
+    if (selected.size >= maxFiles) break;
+    if (!selected.has(file)) {
+      selected.set(file, "directory representative");
+    }
+  }
+  const results = [];
+  for (const [filePath, reason] of selected) {
+    try {
+      const fullPath = path.resolve(rootDir, filePath);
+      if (!fullPath.startsWith(path.resolve(rootDir))) continue;
+      if (isSensitiveFile(filePath)) continue;
+      if (trackedFiles && !trackedFiles.has(filePath)) continue;
+      const stat = await fs2.stat(fullPath);
+      if (stat.size > 1e5) continue;
+      const content = await fs2.readFile(fullPath, "utf-8");
+      const lines = content.split("\n");
+      const preview = lines.slice(0, PREVIEW_LINES).join("\n");
+      results.push({
+        path: filePath,
+        preview,
+        totalLines: lines.length,
+        sizeBytes: stat.size,
+        reason
+      });
+    } catch {
+    }
+  }
+  return results;
+}
+function isSensitiveFile(filePath) {
+  const basename = path.basename(filePath);
+  return SENSITIVE_PATTERNS.some((p) => p.test(basename));
+}
+async function readFullFile(rootDir, filePath) {
+  try {
+    const fullPath = path.join(path.resolve(rootDir), filePath);
+    if (!fullPath.startsWith(path.resolve(rootDir))) return null;
+    if (isSensitiveFile(filePath)) return null;
+    const content = await fs2.readFile(fullPath, "utf-8");
+    return {
+      path: filePath,
+      content,
+      totalLines: content.split("\n").length
+    };
+  } catch {
+    return null;
+  }
+}
+var exec3, SOURCE_EXTENSIONS, CONFIG_FILES, ENTRY_POINT_PATTERNS, ARCHITECTURAL_PATTERNS, IGNORE_PATTERNS, PREVIEW_LINES, SENSITIVE_PATTERNS;
+var init_sampler = __esm({
+  "src/mcp/sampler.ts"() {
+    "use strict";
+    exec3 = promisify3(execFile3);
+    SOURCE_EXTENSIONS = [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "mts",
+      "mjs",
+      "kt",
+      "kts",
+      "java",
+      "py",
+      "go",
+      "rs",
+      "swift",
+      "rb",
+      "cs",
+      "cpp",
+      "c",
+      "h",
+      "dart"
+    ];
+    CONFIG_FILES = [
+      // Build & project config
+      "package.json",
+      "tsconfig.json",
+      "build.gradle.kts",
+      "build.gradle",
+      "settings.gradle.kts",
+      "settings.gradle",
+      "Cargo.toml",
+      "go.mod",
+      "pyproject.toml",
+      "Gemfile",
+      "*.csproj",
+      // Version catalogs & dependency locks
+      "gradle/libs.versions.toml",
+      // Code quality & formatting
+      ".editorconfig",
+      ".eslintrc.*",
+      "eslint.config.*",
+      ".prettierrc",
+      "rustfmt.toml",
+      ".swiftlint.yml",
+      // CI/CD
+      ".github/workflows/*.yml",
+      ".gitlab-ci.yml",
+      "Jenkinsfile",
+      // Containerization
+      "Dockerfile",
+      "docker-compose.yml",
+      "docker-compose.yaml"
+    ];
+    ENTRY_POINT_PATTERNS = [
+      "src/main.*",
+      "src/index.*",
+      "src/app.*",
+      "main.*",
+      "index.*",
+      "app.*",
+      "App.*",
+      "**/Main.kt",
+      "**/Application.kt",
+      "**/main.py",
+      "**/main.go",
+      "**/main.rs",
+      "**/lib.rs",
+      "**/Program.cs"
+    ];
+    ARCHITECTURAL_PATTERNS = [
+      // State/data flow
+      { glob: "**/*ViewModel.*", category: "state", reason: "viewmodel (state management)" },
+      { glob: "**/*Store.*", category: "state", reason: "store (state management)" },
+      { glob: "**/*Reducer.*", category: "state", reason: "reducer (state management)" },
+      // Data layer — interface
+      { glob: "**/*Repository.*", category: "data-interface", reason: "repository interface (data layer contract)" },
+      { glob: "**/*Dao.*", category: "data-interface", reason: "DAO (data access)" },
+      { glob: "**/*DataSource.*", category: "data-interface", reason: "data source" },
+      // Data layer — implementation (where actual patterns live: mappers, retry, IO dispatchers)
+      { glob: "**/*RepositoryImpl.*", category: "data-impl", reason: "repository implementation (data layer patterns)" },
+      { glob: "**/*ServiceImpl.*", category: "data-impl", reason: "service implementation" },
+      { glob: "**/*Impl.*", category: "data-impl", reason: "implementation (concrete patterns)" },
+      // Data transformation
+      { glob: "**/*Mapper.*", category: "transform", reason: "mapper (data transformation)" },
+      { glob: "**/*Converter.*", category: "transform", reason: "converter (data transformation)" },
+      { glob: "**/*Adapter.*", category: "transform", reason: "adapter (interface adaptation)" },
+      // Dependency injection / wiring
+      { glob: "**/*Module.*", category: "di", reason: "module (DI/wiring)" },
+      { glob: "**/*Provider.*", category: "di", reason: "provider (DI/wiring)" },
+      { glob: "**/*Container.*", category: "di", reason: "container (DI/wiring)" },
+      { glob: "**/*Factory.*", category: "di", reason: "factory (object creation)" },
+      // API / network
+      { glob: "**/*Service.*", category: "api", reason: "service (business/API layer)" },
+      { glob: "**/*Client.*", category: "api", reason: "client (API/network layer)" },
+      { glob: "**/*Api.*", category: "api", reason: "API interface definition" },
+      // Interface contracts / protocols
+      { glob: "**/*Interface.*", category: "contract", reason: "interface definition" },
+      { glob: "**/*Protocol.*", category: "contract", reason: "protocol definition" },
+      { glob: "**/*Trait.*", category: "contract", reason: "trait definition" },
+      // Routing / navigation
+      { glob: "**/*Router.*", category: "routing", reason: "router (navigation/routing)" },
+      { glob: "**/*Route.*", category: "routing", reason: "route definition" },
+      { glob: "**/*NavHost.*", category: "routing", reason: "navigation host" },
+      { glob: "**/*Controller.*", category: "routing", reason: "controller (request handling)" },
+      { glob: "**/*Handler.*", category: "routing", reason: "handler (request handling)" },
+      // Middleware / interceptors
+      { glob: "**/*Middleware.*", category: "middleware", reason: "middleware (request pipeline)" },
+      { glob: "**/*Interceptor.*", category: "middleware", reason: "interceptor (cross-cutting)" },
+      { glob: "**/*Plugin.*", category: "middleware", reason: "plugin (extensibility)" },
+      // Models / types
+      { glob: "**/*Model.*", category: "model", reason: "model (domain types)" },
+      { glob: "**/*Entity.*", category: "model", reason: "entity (persistence types)" },
+      { glob: "**/*Dto.*", category: "model", reason: "DTO (data transfer types)" },
+      { glob: "**/*Schema.*", category: "model", reason: "schema (data validation)" },
+      // Use cases / commands
+      { glob: "**/*UseCase.*", category: "usecase", reason: "use case (business logic)" },
+      { glob: "**/*Interactor.*", category: "usecase", reason: "interactor (business logic)" },
+      { glob: "**/*Command.*", category: "usecase", reason: "command (CQRS pattern)" }
+    ];
+    IGNORE_PATTERNS = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.gradle/**",
+      "**/target/**",
+      "**/.git/**",
+      "**/vendor/**",
+      "**/__pycache__/**",
+      "**/venv/**",
+      "**/.venv/**",
+      "**/*.min.*",
+      "**/*.map",
+      "**/package-lock.json",
+      "**/yarn.lock",
+      "**/pnpm-lock.yaml",
+      "**/*.lock",
+      "**/*.generated.*",
+      "**/generated/**",
+      "**/R.java",
+      "**/BuildConfig.java"
+    ];
+    PREVIEW_LINES = 60;
+    SENSITIVE_PATTERNS = [
+      /^\.env$/,
+      /^\.env\./,
+      /\.pem$/,
+      /\.key$/,
+      /\.p12$/,
+      /\.pfx$/,
+      /\.jks$/,
+      /id_rsa/,
+      /id_ed25519/,
+      /credentials\./,
+      /secret/i,
+      /\.keystore$/,
+      /local\.properties$/
+    ];
+  }
+});
+
+// src/test-map.ts
+var test_map_exports = {};
+__export(test_map_exports, {
+  buildTestMap: () => buildTestMap
+});
+import path2 from "path";
+import fg3 from "fast-glob";
+async function buildTestMap(dir) {
+  const rootDir = path2.resolve(dir);
+  const testPatterns = [
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/*Test.kt",
+    "**/*Test.java",
+    "**/*Tests.kt",
+    "**/*Tests.java",
+    "**/test_*.py",
+    "**/*_test.py",
+    "**/*_test.go",
+    "**/*Tests.swift",
+    "**/*Test.swift",
+    "**/*_test.rs"
+  ];
+  const testFiles = await fg3(testPatterns, { cwd: rootDir, ignore: IGNORE });
+  const sourceFiles = await fg3(
+    "**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,dart}",
+    { cwd: rootDir, ignore: IGNORE }
+  );
+  const sourceByBaseName = /* @__PURE__ */ new Map();
+  for (const file of sourceFiles) {
+    if (testFiles.includes(file)) continue;
+    const baseName = path2.basename(file).replace(/\.[^.]+$/, "");
+    const existing = sourceByBaseName.get(baseName) ?? [];
+    existing.push(file);
+    sourceByBaseName.set(baseName, existing);
+  }
+  const paired = [];
+  const unmatched = [];
+  for (const testFile of testFiles) {
+    const testBaseName = path2.basename(testFile).replace(/\.[^.]+$/, "");
+    const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
+    if (!sourceName) {
+      unmatched.push(testFile);
+      continue;
+    }
+    const candidates = sourceByBaseName.get(sourceName);
+    if (candidates && candidates.length > 0) {
+      const testDir = path2.dirname(testFile);
+      const bestMatch = candidates.reduce((best, candidate) => {
+        const candidateDir = path2.dirname(candidate);
+        const bestDir = path2.dirname(best);
+        const candidateOverlap = commonSegments(testDir, candidateDir);
+        const bestOverlap = commonSegments(testDir, bestDir);
+        return candidateOverlap > bestOverlap ? candidate : best;
+      });
+      paired.push({
+        test: testFile,
+        source: bestMatch,
+        confidence: candidates.length === 1 ? "exact" : "best-guess"
+      });
+    } else {
+      unmatched.push(testFile);
+    }
+  }
+  return { totalTestFiles: testFiles.length, paired, unmatched };
+}
+function commonSegments(pathA, pathB) {
+  const segsA = pathA.split("/");
+  const segsB = pathB.split("/");
+  let count = 0;
+  for (let i = 0; i < Math.min(segsA.length, segsB.length); i++) {
+    if (segsA[i] === segsB[i]) count++;
+    else break;
+  }
+  return count;
+}
+var IGNORE;
+var init_test_map = __esm({
+  "src/test-map.ts"() {
+    "use strict";
+    IGNORE = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.gradle/**",
+      "**/target/**",
+      "**/.git/**",
+      "**/vendor/**",
+      "**/__pycache__/**",
+      "**/venv/**",
+      "**/.venv/**",
+      "**/*.min.*",
+      "**/*.map"
+    ];
+  }
+});
+
+// src/snapshot/snapshot.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+import fg4 from "fast-glob";
+function normalizeFeatureType(value) {
+  return value === "infrastructure" ? "infrastructure" : "capability";
+}
+function snapshotDir(rootDir) {
+  return path3.join(rootDir, ".mason");
+}
+function snapshotPath(rootDir) {
+  return path3.join(snapshotDir(rootDir), "snapshot.json");
+}
+async function loadSnapshot(rootDir) {
+  try {
+    const raw = await fs3.readFile(snapshotPath(rootDir), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 2) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveSnapshot(rootDir, snapshot) {
+  await fs3.mkdir(snapshotDir(rootDir), { recursive: true });
+  await fs3.writeFile(
+    snapshotPath(rootDir),
+    JSON.stringify(snapshot, null, 2),
+    "utf-8"
+  );
+}
+async function getCurrentGitHash(rootDir) {
+  try {
+    const { stdout } = await exec4("git", ["rev-parse", "HEAD"], {
+      cwd: rootDir
+    });
+    return stdout.trim();
+  } catch {
+    return "unknown";
+  }
+}
+async function listSourceFiles(resolvedRoot) {
+  const all = await fg4(SOURCE_GLOB, {
+    cwd: resolvedRoot,
+    ignore: SOURCE_IGNORE
+  });
+  return [...all].sort();
+}
+async function prepareSnapshotBatch(rootDir, offset, batchSize = DEFAULT_BATCH_SIZE, scopeFiles) {
+  const resolvedRoot = path3.resolve(rootDir);
+  let allFiles = await listSourceFiles(resolvedRoot);
+  if (scopeFiles) {
+    const scopeSet = new Set(scopeFiles);
+    allFiles = allFiles.filter((f) => scopeSet.has(f));
+  }
+  const totalFiles = allFiles.length;
+  const safeOffset = Math.max(0, Math.min(offset, totalFiles));
+  const batchPaths = allFiles.slice(safeOffset, safeOffset + batchSize);
+  const skeletons = [];
+  for (const filePath of batchPaths) {
+    const full = await readFullFile(resolvedRoot, filePath);
+    if (full) {
+      skeletons.push({
+        path: full.path,
+        content: full.content.slice(0, SKELETON_CHARS)
+      });
+    }
+  }
+  const samples = [];
+  if (skeletons.length > 0) {
+    const step = Math.max(1, Math.floor(skeletons.length / DEEP_SAMPLES_PER_BATCH));
+    for (let i = 0; i < skeletons.length && samples.length < DEEP_SAMPLES_PER_BATCH; i += step) {
+      const full = await readFullFile(resolvedRoot, skeletons[i].path);
+      if (full) {
+        samples.push({
+          path: full.path,
+          content: full.content.slice(0, DEEP_SAMPLE_CHARS)
+        });
+      }
+    }
+  }
+  const batchPathSet = new Set(batchPaths);
+  const allTestPairs = (await buildTestMap(resolvedRoot)).paired;
+  const testPairs = allTestPairs.filter(
+    (p) => batchPathSet.has(p.test) || batchPathSet.has(p.source)
+  );
+  const nextOffset = safeOffset + batchSize >= totalFiles ? null : safeOffset + batchSize;
+  return {
+    offset: safeOffset,
+    batchSize,
+    nextOffset,
+    totalFiles,
+    skeletons,
+    samples,
+    testPairs
+  };
+}
+var exec4, SOURCE_GLOB, SOURCE_IGNORE, DEFAULT_BATCH_SIZE, SKELETON_CHARS, DEEP_SAMPLE_CHARS, DEEP_SAMPLES_PER_BATCH;
+var init_snapshot = __esm({
+  "src/snapshot/snapshot.ts"() {
+    "use strict";
+    init_sampler();
+    init_test_map();
+    exec4 = promisify4(execFile4);
+    SOURCE_GLOB = "**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,dart}";
+    SOURCE_IGNORE = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.gradle/**",
+      "**/target/**",
+      "**/.git/**",
+      "**/vendor/**",
+      "**/__pycache__/**",
+      "**/venv/**",
+      "**/.venv/**",
+      "**/*.min.*",
+      "**/*.map",
+      "**/generated/**",
+      "**/R.java",
+      "**/BuildConfig.java"
+    ];
+    DEFAULT_BATCH_SIZE = 50;
+    SKELETON_CHARS = 500;
+    DEEP_SAMPLE_CHARS = 1500;
+    DEEP_SAMPLES_PER_BATCH = 3;
+  }
+});
+
+// src/drift/drift.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
+async function getChangesWithStatus(resolvedRoot, fromHash) {
+  if (!fromHash || fromHash === "unknown") return null;
+  try {
+    const { stdout } = await exec5(
+      "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;
+  }
+}
+async function countCommitsBehind(resolvedRoot, fromHash) {
+  try {
+    const { stdout } = await exec5(
+      "git",
+      ["rev-list", "--count", `${fromHash}..HEAD`],
+      { cwd: resolvedRoot }
+    );
+    const count = Number.parseInt(stdout.trim(), 10);
+    return Number.isNaN(count) ? null : count;
+  } catch {
+    return null;
+  }
+}
+function collectMappedFiles(snapshot) {
+  const mappedFiles = /* @__PURE__ */ new Set();
+  for (const feature of Object.values(snapshot.features)) {
+    for (const f of feature.files) mappedFiles.add(f);
+    for (const t of feature.tests ?? []) mappedFiles.add(t);
+  }
+  for (const flow of Object.values(snapshot.flows)) {
+    for (const f of flow.chain) mappedFiles.add(f);
+  }
+  return mappedFiles;
+}
+async function findGhostFiles(resolvedRoot, mappedFiles) {
+  const ghosts = [];
+  for (const file of mappedFiles) {
+    try {
+      await fs4.access(path4.join(resolvedRoot, file));
+    } catch {
+      ghosts.push(file);
+    }
+  }
+  return ghosts.sort();
+}
+async function computeDrift(rootDir) {
+  const resolvedRoot = path4.resolve(rootDir);
+  const snapshot = await loadSnapshot(resolvedRoot);
+  if (!snapshot) return null;
+  const headHash = await getCurrentGitHash(resolvedRoot);
+  const totalFeatures = Object.keys(snapshot.features).length;
+  const totalFlows = Object.keys(snapshot.flows).length;
+  const hashFor = (entry) => entry.refreshedHash ?? snapshot.gitHash;
+  const distinctHashes = /* @__PURE__ */ new Set([snapshot.gitHash]);
+  for (const feature of Object.values(snapshot.features)) {
+    distinctHashes.add(hashFor(feature));
+  }
+  for (const flow of Object.values(snapshot.flows)) {
+    distinctHashes.add(hashFor(flow));
+  }
+  distinctHashes.delete("unknown");
+  const staleHashes = headHash === "unknown" ? [] : [...distinctHashes].filter((h) => h !== headHash);
+  const stale = staleHashes.length > 0;
+  const report = {
+    stale,
+    snapshotHash: snapshot.gitHash,
+    headHash,
+    commitsBehind: stale ? null : 0,
+    historyAvailable: true,
+    changedFiles: [],
+    staleFeatures: {},
+    staleFlows: {},
+    totalFeatures,
+    totalFlows,
+    unmappedFiles: [],
+    ghostFiles: [],
+    renames: [],
+    recommendation: "up-to-date"
+  };
+  if (!stale) return report;
+  const mappedFiles = collectMappedFiles(snapshot);
+  report.ghostFiles = await findGhostFiles(resolvedRoot, mappedFiles);
+  const changesByHash = /* @__PURE__ */ new Map();
+  const touchedByHash = /* @__PURE__ */ new Map();
+  for (const hash of staleHashes) {
+    const changes = await getChangesWithStatus(resolvedRoot, hash);
+    if (changes === null) {
+      report.historyAvailable = false;
+      report.recommendation = "full-rebuild";
+      return report;
+    }
+    changesByHash.set(hash, changes);
+    const touched = /* @__PURE__ */ new Set();
+    for (const change of changes) {
+      touched.add(change.path);
+      if (change.previousPath) touched.add(change.previousPath);
+    }
+    touchedByHash.set(hash, touched);
+  }
+  const commitCounts = await Promise.all(
+    staleHashes.map((hash) => countCommitsBehind(resolvedRoot, hash))
+  );
+  const validCounts = commitCounts.filter((c) => c !== null);
+  report.commitsBehind = validCounts.length > 0 ? Math.max(...validCounts) : null;
+  const emptySet = /* @__PURE__ */ new Set();
+  const touchedFor = (entry) => touchedByHash.get(hashFor(entry)) ?? emptySet;
+  for (const [name, feature] of Object.entries(snapshot.features)) {
+    const touched = touchedFor(feature);
+    const hits = [...feature.files, ...feature.tests ?? []].filter(
+      (f) => touched.has(f)
+    );
+    if (hits.length > 0) report.staleFeatures[name] = [...new Set(hits)];
+  }
+  for (const [name, flow] of Object.entries(snapshot.flows)) {
+    const touched = touchedFor(flow);
+    const hits = flow.chain.filter((f) => touched.has(f));
+    if (hits.length > 0) report.staleFlows[name] = [...new Set(hits)];
+  }
+  const allChanges = [...changesByHash.values()].flat();
+  report.changedFiles = [...new Set(allChanges.map((c) => c.path))].sort();
+  const sourceFileSet = new Set(await listSourceFiles(resolvedRoot));
+  const newPaths = allChanges.filter((c) => c.status === "added" || c.status === "renamed").map((c) => c.path);
+  report.unmappedFiles = [...new Set(newPaths)].filter((p) => sourceFileSet.has(p) && !mappedFiles.has(p)).sort();
+  const renameKeys = /* @__PURE__ */ new Set();
+  for (const change of allChanges) {
+    if (change.status !== "renamed" || !change.previousPath) continue;
+    const key = `${change.previousPath}\0${change.path}`;
+    if (renameKeys.has(key)) continue;
+    renameKeys.add(key);
+    report.renames.push({ from: change.previousPath, to: change.path });
+  }
+  const changedMapped = /* @__PURE__ */ new Set([
+    ...Object.values(report.staleFeatures).flat(),
+    ...Object.values(report.staleFlows).flat()
+  ]);
+  const changedFraction = mappedFiles.size > 0 ? changedMapped.size / mappedFiles.size : 0;
+  report.recommendation = changedMapped.size >= FULL_REBUILD_MIN_CHANGED_MAPPED_FILES && changedFraction > FULL_REBUILD_FRACTION ? "full-rebuild" : "incremental";
+  return report;
+}
+var exec5, FULL_REBUILD_FRACTION, FULL_REBUILD_MIN_CHANGED_MAPPED_FILES;
+var init_drift = __esm({
+  "src/drift/drift.ts"() {
+    "use strict";
+    init_snapshot();
+    exec5 = promisify5(execFile5);
+    FULL_REBUILD_FRACTION = 0.4;
+    FULL_REBUILD_MIN_CHANGED_MAPPED_FILES = 10;
+  }
+});
+
+// src/context/lexical.ts
+import path7 from "path";
+function tokenize(text) {
+  return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2 && !STOPWORDS.has(t));
+}
+function stem(token) {
+  return token.length > 3 && token.endsWith("s") ? token.slice(0, -1) : token;
+}
+function tokenSet(text) {
+  return new Set(tokenize(text).map(stem));
+}
+function scoreEntry(taskTokens, entry) {
+  const nameTokens = tokenSet(entry.name);
+  const descTokens = tokenSet(entry.description);
+  const fileTokens = tokenSet(entry.files.map((f) => path7.basename(f)).join(" "));
+  let score = 0;
+  for (const token of taskTokens) {
+    if (nameTokens.has(token)) score += 3;
+    else if (descTokens.has(token)) score += 1;
+    else if (fileTokens.has(token)) score += 1;
+  }
+  return score;
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersection = 0;
+  for (const token of a) if (b.has(token)) intersection++;
+  return intersection / (a.size + b.size - intersection);
+}
+var STOPWORDS;
+var init_lexical = __esm({
+  "src/context/lexical.ts"() {
+    "use strict";
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "and",
+      "or",
+      "of",
+      "to",
+      "in",
+      "on",
+      "for",
+      "with",
+      "how",
+      "does",
+      "do",
+      "is",
+      "are",
+      "was",
+      "what",
+      "where",
+      "which",
+      "why",
+      "when",
+      "who",
+      "i",
+      "we",
+      "my",
+      "our",
+      "you",
+      "your",
+      "it",
+      "its",
+      "this",
+      "that",
+      "these",
+      "those",
+      "can",
+      "could",
+      "should",
+      "would",
+      "will",
+      "want",
+      "need",
+      "please",
+      "about",
+      "into",
+      "from",
+      "when",
+      "there",
+      "any",
+      "all",
+      "some",
+      "not",
+      "but",
+      "also",
+      "just",
+      "like",
+      "get",
+      "make",
+      "use",
+      "new",
+      "work",
+      "works",
+      "working",
+      "implement",
+      "implemented",
+      "change",
+      "changed",
+      "file",
+      "files",
+      "code"
+    ]);
+  }
+});
+
+// src/decisions/decisions.ts
+var decisions_exports = {};
+__export(decisions_exports, {
+  BODY_MAX_CHARS: () => BODY_MAX_CHARS,
+  MAX_ACTIVE_DECISIONS: () => MAX_ACTIVE_DECISIONS,
+  TITLE_MAX_CHARS: () => TITLE_MAX_CHARS,
+  decisionIdFor: () => decisionIdFor,
+  findNearDuplicate: () => findNearDuplicate,
+  loadDecisions: () => loadDecisions,
+  saveDecisionRecord: () => saveDecisionRecord,
+  upsertDecision: () => upsertDecision
+});
+import fs7 from "fs/promises";
+import path8 from "path";
+import { createHash } from "crypto";
+function decisionsDir(rootDir) {
+  return path8.join(rootDir, ".mason", "decisions");
+}
+async function loadDecisions(rootDir) {
+  let entries;
+  try {
+    entries = await fs7.readdir(decisionsDir(rootDir));
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const raw = await fs7.readFile(
+        path8.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));
+}
+async function saveDecisionRecord(rootDir, record) {
+  await fs7.mkdir(decisionsDir(rootDir), { recursive: true });
+  await fs7.writeFile(
+    path8.join(decisionsDir(rootDir), `${record.id}.json`),
+    JSON.stringify(record, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function decisionIdFor(title, body, existingIds) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/, "");
+  if (!existingIds.has(slug)) return slug || "decision";
+  const suffix = createHash("sha1").update(title + body).digest("hex").slice(0, 6);
+  return `${slug}-${suffix}`;
+}
+function findNearDuplicate(candidate, existing) {
+  const candidateTokens = tokenSet(`${candidate.title} ${candidate.body}`);
+  const candidateFiles = new Set(candidate.files);
+  let best = null;
+  for (const record of existing) {
+    if (record.status !== "active") continue;
+    const similarity = jaccard(
+      candidateTokens,
+      tokenSet(`${record.title} ${record.body}`)
+    );
+    const sharesFile = record.files.some((f) => candidateFiles.has(f));
+    const threshold = sharesFile ? DUPLICATE_JACCARD_WITH_SHARED_FILE : DUPLICATE_JACCARD;
+    if (similarity >= threshold && (!best || similarity > best.similarity)) {
+      best = { record, similarity };
+    }
+  }
+  return best;
+}
+function sanitizeAnchorFiles(rootDir, files) {
+  const resolvedRoot = path8.resolve(rootDir);
+  return files.filter((f) => {
+    const resolved = path8.resolve(resolvedRoot, f);
+    return resolved.startsWith(resolvedRoot) && !f.startsWith("/") && !f.includes("..");
+  });
+}
+async function upsertDecision(rootDir, input) {
+  const title = input.title.trim();
+  const body = input.body.trim();
+  if (title.length === 0 || body.length === 0) {
+    return { status: "error", error: "title and body must be non-empty" };
+  }
+  if (title.length > TITLE_MAX_CHARS) {
+    return {
+      status: "error",
+      error: `title exceeds ${TITLE_MAX_CHARS} chars \u2014 tighten it to a specific headline`
+    };
+  }
+  if (body.length > BODY_MAX_CHARS) {
+    return {
+      status: "error",
+      error: `body exceeds ${BODY_MAX_CHARS} chars \u2014 record the decision, not the transcript`
+    };
+  }
+  const existing = await loadDecisions(rootDir);
+  const byId = new Map(existing.map((r) => [r.id, r]));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const head = await getCurrentGitHash(rootDir);
+  const warnings = [];
+  const files = sanitizeAnchorFiles(rootDir, input.files ?? []);
+  if (input.files && files.length < input.files.length) {
+    warnings.push("some anchor paths were outside the repo and were dropped");
+  }
+  for (const f of files) {
+    try {
+      await fs7.access(path8.join(rootDir, f));
+    } catch {
+      warnings.push(`anchor file does not exist on disk: ${f}`);
+    }
+  }
+  if (input.id) {
+    const record2 = byId.get(input.id);
+    if (!record2) {
+      return { status: "error", error: `no decision with id "${input.id}"` };
+    }
+    const unchanged = record2.title === title && record2.body === body && record2.category === input.category && JSON.stringify(record2.files) === JSON.stringify(files.length > 0 ? files : record2.files);
+    const updated = {
+      ...record2,
+      title,
+      body,
+      category: input.category,
+      files: input.files !== void 0 ? files : record2.files,
+      updatedAt: now,
+      refreshedHash: head
+    };
+    await saveDecisionRecord(rootDir, updated);
+    return {
+      status: unchanged ? "reverified" : "updated",
+      id: record2.id,
+      totalActive: existing.filter((r) => r.status === "active").length,
+      warnings
+    };
+  }
+  if (!input.force) {
+    const duplicate = findNearDuplicate({ title, body, files }, existing);
+    if (duplicate) {
+      return {
+        status: "duplicate_suspected",
+        existing: duplicate.record,
+        hint: `A similar decision exists ("${duplicate.record.title}"). Call save_decision with id="${duplicate.record.id}" to update/merge into it, or force:true if genuinely distinct.`
+      };
+    }
+  }
+  if (input.supersedes) {
+    const old = byId.get(input.supersedes);
+    if (!old) {
+      return {
+        status: "error",
+        error: `no decision with id "${input.supersedes}" to supersede`
+      };
+    }
+    const id2 = decisionIdFor(title, body, new Set(byId.keys()));
+    await saveDecisionRecord(rootDir, {
+      ...old,
+      status: "superseded",
+      supersededBy: id2,
+      updatedAt: now
+    });
+    const record2 = {
+      version: 1,
+      id: id2,
+      title,
+      body,
+      category: input.category,
+      files,
+      createdAt: now,
+      updatedAt: now,
+      refreshedHash: head,
+      status: "active"
+    };
+    await saveDecisionRecord(rootDir, record2);
+    return {
+      status: "superseded_and_created",
+      id: id2,
+      totalActive: existing.filter((r) => r.status === "active").length,
+      warnings
+    };
+  }
+  const id = decisionIdFor(title, body, new Set(byId.keys()));
+  const record = {
+    version: 1,
+    id,
+    title,
+    body,
+    category: input.category,
+    files,
+    createdAt: now,
+    updatedAt: now,
+    refreshedHash: head,
+    status: "active"
+  };
+  await saveDecisionRecord(rootDir, record);
+  const totalActive = existing.filter((r) => r.status === "active").length + 1;
+  const result = {
+    status: "created",
+    id,
+    totalActive,
+    warnings
+  };
+  if (totalActive > MAX_ACTIVE_DECISIONS) {
+    result.pruneCandidates = existing.filter((r) => r.status === "superseded").map((r) => r.id).slice(0, 10);
+    warnings.push(
+      `${totalActive} active decisions exceeds the soft cap of ${MAX_ACTIVE_DECISIONS} \u2014 consider a cleanup PR (superseded records first)`
+    );
+  }
+  return result;
+}
+var TITLE_MAX_CHARS, BODY_MAX_CHARS, MAX_ACTIVE_DECISIONS, DUPLICATE_JACCARD, DUPLICATE_JACCARD_WITH_SHARED_FILE;
+var init_decisions = __esm({
+  "src/decisions/decisions.ts"() {
+    "use strict";
+    init_snapshot();
+    init_lexical();
+    TITLE_MAX_CHARS = 80;
+    BODY_MAX_CHARS = 1500;
+    MAX_ACTIVE_DECISIONS = 150;
+    DUPLICATE_JACCARD = 0.5;
+    DUPLICATE_JACCARD_WITH_SHARED_FILE = 0.35;
+  }
+});
+
+// src/impact/impact.ts
+var impact_exports = {};
+__export(impact_exports, {
+  analyzeImpact: () => analyzeImpact
+});
+import fs8 from "fs/promises";
+import path9 from "path";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
+import fg5 from "fast-glob";
+async function analyzeImpact(rootDir, targetFiles) {
+  const resolvedRoot = path9.resolve(rootDir);
+  const resolvedTargets = await resolveTargetFiles(resolvedRoot, targetFiles);
+  const [cochange, references, tests] = await Promise.all([
+    getCochangeFiles(resolvedRoot, resolvedTargets),
+    getReferences(resolvedRoot, resolvedTargets),
+    getRelatedTests(resolvedRoot, resolvedTargets)
+  ]);
+  return {
+    targetFiles: resolvedTargets,
+    cochange,
+    references,
+    tests
+  };
+}
+async function resolveTargetFiles(rootDir, targets) {
+  const resolved = [];
+  for (const target of targets) {
+    if (target.includes("/")) {
+      resolved.push(target);
+      continue;
+    }
+    const matches = await fg5(`**/${target}`, {
+      cwd: rootDir,
+      ignore: IGNORE2
+    });
+    if (matches.length > 0) {
+      resolved.push(matches[0]);
+    } else {
+      const noExt = target.replace(/\.[^.]+$/, "");
+      const extMatches = await fg5(`**/${noExt}.*`, {
+        cwd: rootDir,
+        ignore: IGNORE2
+      });
+      if (extMatches.length > 0) {
+        resolved.push(extMatches[0]);
+      } else {
+        resolved.push(target);
+      }
+    }
+  }
+  return resolved;
+}
+async function getCochangeFiles(rootDir, targetFiles) {
+  const cochangeCounts = /* @__PURE__ */ new Map();
+  let totalTargetCommits = 0;
+  for (const targetFile of targetFiles) {
+    try {
+      const { stdout: commitLog } = await exec6(
+        "git",
+        ["log", "--format=%H", "-n", "500", "--", targetFile],
+        { cwd: rootDir, maxBuffer: 5e6 }
+      );
+      const commits = commitLog.trim().split("\n").filter(Boolean);
+      totalTargetCommits += commits.length;
+      if (commits.length === 0) continue;
+      for (const commit of commits) {
+        try {
+          const { stdout: filesInCommit } = await exec6(
+            "git",
+            ["diff-tree", "--no-commit-id", "--name-only", "-r", commit],
+            { cwd: rootDir }
+          );
+          const files = filesInCommit.trim().split("\n").filter(Boolean);
+          for (const file of files) {
+            if (targetFiles.includes(file)) continue;
+            cochangeCounts.set(file, (cochangeCounts.get(file) ?? 0) + 1);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  if (totalTargetCommits === 0) return [];
+  return [...cochangeCounts.entries()].map(([file, count]) => ({
+    file,
+    cochangeRate: Math.round(count / totalTargetCommits * 100) / 100,
+    sharedCommits: count
+  })).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 = path9.basename(target).replace(/\.[^.]+$/, "");
+    searchNames.add(basename);
+  }
+  const allSourceFiles = await fg5(`**/${SOURCE_EXTENSIONS2}`, {
+    cwd: rootDir,
+    ignore: IGNORE2
+  });
+  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 content = await fs8.readFile(
+            path9.join(rootDir, file),
+            "utf-8"
+          );
+          const lines = content.split("\n");
+          for (const name of searchNames) {
+            const regex = new RegExp(`\\b${escapeRegex(name)}\\b`);
+            if (!regex.test(content)) 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 {
+        }
+      })
+    );
+  }
+  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;
+  });
+}
+async function getRelatedTests(rootDir, targetFiles) {
+  const testPatterns = [
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/*Test.kt",
+    "**/*Test.java",
+    "**/*Tests.kt",
+    "**/*Tests.java",
+    "**/test_*.py",
+    "**/*_test.py",
+    "**/*_test.go",
+    "**/*Tests.swift",
+    "**/*Test.swift",
+    "**/*_test.rs"
+  ];
+  const testFiles = await fg5(testPatterns, { cwd: rootDir, ignore: IGNORE2 });
+  const results = [];
+  for (const target of targetFiles) {
+    const targetBaseName = path9.basename(target).replace(/\.[^.]+$/, "");
+    for (const testFile of testFiles) {
+      const testBaseName = path9.basename(testFile).replace(/\.[^.]+$/, "");
+      const sourceName = testBaseName.replace(/Test$|Tests$|Spec$|\.test$|\.spec$/, "").replace(/^test_|_test$/, "");
+      if (sourceName === targetBaseName) {
+        results.push({
+          file: testFile,
+          confidence: "exact"
+        });
+      }
+    }
+  }
+  return results;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var exec6, IGNORE2, SOURCE_EXTENSIONS2;
+var init_impact = __esm({
+  "src/impact/impact.ts"() {
+    "use strict";
+    exec6 = promisify6(execFile6);
+    IGNORE2 = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.gradle/**",
+      "**/target/**",
+      "**/.git/**",
+      "**/vendor/**",
+      "**/__pycache__/**",
+      "**/venv/**",
+      "**/.venv/**",
+      "**/generated/**"
+    ];
+    SOURCE_EXTENSIONS2 = "*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,h,dart,gradle.kts,gradle}";
+  }
+});
+
+// src/decisions/drift.ts
+import path10 from "path";
+async function computeDecisionDrift(rootDir, decisions) {
+  const resolvedRoot = path10.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;
+}
+var init_drift2 = __esm({
+  "src/decisions/drift.ts"() {
+    "use strict";
+    init_drift();
+    init_snapshot();
+    init_decisions();
+  }
+});
+
+// src/context/assemble.ts
+var assemble_exports = {};
+__export(assemble_exports, {
+  assembleContext: () => assembleContext
+});
+import path11 from "path";
+async function assembleContext(rootDir, task, files) {
+  const resolvedRoot = path11.resolve(rootDir);
+  const snapshot = await loadSnapshot(resolvedRoot);
+  if (!snapshot) return null;
+  const drift = await computeDrift(resolvedRoot);
+  const allDecisions = await loadDecisions(resolvedRoot);
+  const decisionDrift = await computeDecisionDrift(resolvedRoot, allDecisions);
+  const taskTokens = tokenSet(task);
+  const anchorFiles = new Set(files ?? []);
+  const anchorBoost = (entryFiles) => {
+    let boost = 0;
+    for (const f of entryFiles) if (anchorFiles.has(f)) boost += 5;
+    return boost;
+  };
+  const featureScores = Object.entries(snapshot.features).map(([name, feat]) => ({
+    name,
+    feat,
+    score: scoreEntry(taskTokens, { name, description: feat.description, files: feat.files }) + anchorBoost([...feat.files, ...feat.tests ?? []])
+  })).filter((e) => e.score > 0).sort((a, b) => b.score - a.score).slice(0, MAX_FEATURES);
+  const flowScores = Object.entries(snapshot.flows).map(([name, flow]) => ({
+    name,
+    flow,
+    score: scoreEntry(taskTokens, { name, description: flow.description, files: flow.chain }) + anchorBoost(flow.chain)
+  })).filter((e) => e.score > 0).sort((a, b) => b.score - a.score).slice(0, MAX_FLOWS);
+  const matchedEntryFiles = /* @__PURE__ */ new Set([
+    ...featureScores.flatMap((e) => e.feat.files),
+    ...flowScores.flatMap((e) => e.flow.chain)
+  ]);
+  const decisions = matchDecisions(
+    allDecisions,
+    taskTokens,
+    anchorBoost,
+    matchedEntryFiles,
+    decisionDrift.staleDecisions
+  );
+  if (featureScores.length === 0 && flowScores.length === 0) {
+    return noMatchBundle(snapshot, task, decisions);
+  }
+  const features = {};
+  const staleMatches = [];
+  for (const { name, feat, score } of featureScores) {
+    const stale2 = drift?.staleFeatures[name] !== void 0;
+    if (stale2) staleMatches.push(name);
+    features[name] = {
+      description: feat.description,
+      files: feat.files,
+      ...feat.tests && feat.tests.length > 0 ? { tests: feat.tests } : {},
+      type: normalizeFeatureType(feat.type),
+      score,
+      stale: stale2
+    };
+  }
+  const flows = {};
+  for (const { name, flow, score } of flowScores) {
+    const stale2 = drift?.staleFlows[name] !== void 0;
+    if (stale2) staleMatches.push(name);
+    flows[name] = {
+      description: flow.description,
+      chain: flow.chain,
+      score,
+      stale: stale2
+    };
+  }
+  const impactTargets = [
+    ...anchorFiles,
+    ...featureScores.flatMap((e) => e.feat.files)
+  ].slice(0, MAX_IMPACT_TARGETS);
+  let impact = null;
+  let impactTests = [];
+  if (impactTargets.length > 0) {
+    const result = await analyzeImpact(resolvedRoot, impactTargets);
+    impact = {
+      targets: result.targetFiles,
+      cochange: result.cochange,
+      references: result.references.slice(0, 10)
+    };
+    impactTests = result.tests.map((t) => t.file);
+  }
+  const relatedTests = [
+    .../* @__PURE__ */ new Set([
+      ...featureScores.flatMap((e) => e.feat.tests ?? []),
+      ...impactTests
+    ])
+  ];
+  const stale = drift?.stale ?? false;
+  const staleDecisionIds = Object.keys(decisions).filter(
+    (id) => decisions[id].stale
+  );
+  return {
+    exists: true,
+    task,
+    features,
+    flows,
+    decisions,
+    relatedTests,
+    impact,
+    freshness: {
+      stale,
+      recommendation: drift?.recommendation ?? "up-to-date",
+      staleMatches
+    },
+    hint: bundleHint(stale, staleMatches, staleDecisionIds)
+  };
+}
+function matchDecisions(allDecisions, taskTokens, anchorBoost, matchedEntryFiles, staleDecisions) {
+  const scored = allDecisions.filter((d) => d.status === "active").map((d) => {
+    let score = scoreEntry(taskTokens, {
+      name: d.title,
+      description: d.body,
+      files: d.files
+    }) + anchorBoost(d.files);
+    if (d.files.some((f) => matchedEntryFiles.has(f))) {
+      score += DECISION_FEATURE_OVERLAP_BOOST;
+    }
+    return { d, score };
+  }).filter((e) => e.score > 0).sort((a, b) => b.score - a.score).slice(0, MAX_DECISIONS);
+  const result = {};
+  for (const { d, score } of scored) {
+    result[d.id] = {
+      title: d.title,
+      body: d.body,
+      category: d.category,
+      files: d.files,
+      score,
+      stale: staleDecisions[d.id] !== void 0
+    };
+  }
+  return result;
+}
+function bundleHint(stale, staleMatches, staleDecisionIds = []) {
+  const parts = [];
+  if (staleMatches.length > 0) {
+    parts.push(
+      `Entries [${staleMatches.join(", ")}] changed since they were last verified \u2014 read their files rather than trusting the descriptions, and consider mason_check_drift for a refresh plan.`
+    );
+  } else if (stale) {
+    parts.push(
+      "The matched entries are current, but other parts of the map have drifted \u2014 mason_check_drift shows what needs refreshing."
+    );
+  } else {
+    parts.push(
+      "Map is current. Start from the listed files; cochange/references show what else an edit would touch."
+    );
+  }
+  if (staleDecisionIds.length > 0) {
+    parts.push(
+      `Decisions [${staleDecisionIds.join(", ")}] have anchor files that changed since they were recorded \u2014 verify each still holds; if it does, re-save it with its id to re-pin, otherwise update or supersede it via save_decision.`
+    );
+  }
+  return parts.join(" ");
+}
+function noMatchBundle(snapshot, task, decisions) {
+  const availableFeatures = {};
+  for (const [name, feat] of Object.entries(snapshot.features)) {
+    availableFeatures[name] = feat.description;
+  }
+  const availableFlows = {};
+  for (const [name, flow] of Object.entries(snapshot.flows)) {
+    availableFlows[name] = flow.description;
+  }
+  return {
+    exists: true,
+    task,
+    features: {},
+    flows: {},
+    decisions,
+    availableFeatures,
+    availableFlows,
+    hint: "No map entry matched the task wording. The full catalog is listed \u2014 pick the relevant entries and call get_context again with their names in the task, or read their files directly via get_snapshot."
+  };
+}
+var MAX_FEATURES, MAX_FLOWS, MAX_IMPACT_TARGETS, MAX_DECISIONS, DECISION_FEATURE_OVERLAP_BOOST;
+var init_assemble = __esm({
+  "src/context/assemble.ts"() {
+    "use strict";
+    init_snapshot();
+    init_drift();
+    init_impact();
+    init_lexical();
+    init_decisions();
+    init_drift2();
+    MAX_FEATURES = 5;
+    MAX_FLOWS = 3;
+    MAX_IMPACT_TARGETS = 3;
+    MAX_DECISIONS = 5;
+    DECISION_FEATURE_OVERLAP_BOOST = 2;
+  }
+});
+
+// src/confluence/client.ts
+var client_exports = {};
+__export(client_exports, {
+  createConfluenceClient: () => createConfluenceClient
+});
+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, path15, body) {
+    const res = await fetchFn(`${baseUrl}${path15}`, {
+      method,
+      headers: {
+        Authorization: auth,
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(
+        `Confluence ${method} ${path15} failed: ${res.status} ${res.statusText} \u2014 ${text}`
+      );
+    }
+    if (res.status === 204) return null;
+    return res.json();
+  }
+  function toPage(raw) {
+    return {
+      id: raw.id,
+      title: raw.title,
+      version: raw.version?.number ?? 1,
+      body: raw.body?.storage?.value ?? "",
+      parentId: raw.parentId
+    };
+  }
+  return {
+    async resolveSpaceId(spaceKey) {
+      const res = await call(
+        "GET",
+        `/wiki/api/v2/spaces?keys=${encodeURIComponent(spaceKey)}`
+      );
+      const space = res.results?.find((s) => s.key === spaceKey);
+      if (!space) {
+        throw new Error(`Confluence space not found: ${spaceKey}`);
+      }
+      return space.id;
+    },
+    async listSpaces() {
+      const all = [];
+      let cursor = "/wiki/api/v2/spaces?limit=100";
+      while (cursor) {
+        const res = await call("GET", cursor);
+        for (const s of res.results ?? []) {
+          all.push({ id: s.id, key: s.key, name: s.name ?? s.key });
+        }
+        const next = res._links?.next;
+        if (!next) break;
+        cursor = next.startsWith("/") ? next : `/${next}`;
+      }
+      return all;
+    },
+    async listRootPages(spaceId) {
+      const url = `/wiki/api/v2/spaces/${encodeURIComponent(spaceId)}/pages?depth=root&limit=50`;
+      const res = await call("GET", url);
+      return (res.results ?? []).map((p) => ({ id: p.id, title: p.title }));
+    },
+    async findPageByTitle(spaceId, title) {
+      const url = `/wiki/api/v2/spaces/${encodeURIComponent(spaceId)}/pages?title=${encodeURIComponent(title)}&body-format=storage&limit=1`;
+      const res = await call("GET", url);
+      const match = res.results?.find((p) => p.title === title);
+      return match ? toPage(match) : null;
+    },
+    async createPage(input) {
+      const res = await call("POST", "/wiki/api/v2/pages", {
+        spaceId: input.spaceId,
+        status: "current",
+        title: input.title,
+        parentId: input.parentId,
+        body: {
+          representation: "storage",
+          value: input.body
+        }
+      });
+      return toPage(res);
+    },
+    async updatePage(input) {
+      const res = await call("PUT", `/wiki/api/v2/pages/${input.id}`, {
+        id: input.id,
+        status: "current",
+        title: input.title,
+        parentId: input.parentId,
+        body: {
+          representation: "storage",
+          value: input.body
+        },
+        version: {
+          number: input.version + 1
+        }
+      });
+      return toPage(res);
+    }
+  };
+}
+var init_client = __esm({
+  "src/confluence/client.ts"() {
+    "use strict";
+  }
+});
+
+// src/llm/config.ts
+var config_exports = {};
+__export(config_exports, {
+  detectCLI: () => detectCLI,
+  getDefaultModel: () => getDefaultModel,
+  loadConfig: () => loadConfig,
+  loadConfluenceConfig: () => loadConfluenceConfig,
+  needsApiKey: () => needsApiKey,
+  saveConfig: () => saveConfig,
+  saveConfluenceConfig: () => saveConfluenceConfig,
+  validateProvider: () => validateProvider
+});
+import fs9 from "fs/promises";
+import path12 from "path";
+import os from "os";
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
+function configDir() {
+  return path12.join(os.homedir(), ".mason");
+}
+function configFile() {
+  return path12.join(configDir(), "config.json");
+}
+async function loadConfig() {
+  try {
+    const raw = await fs9.readFile(configFile(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(config) {
+  await fs9.mkdir(configDir(), { recursive: true });
+  await fs9.writeFile(configFile(), JSON.stringify(config, null, 2), "utf-8");
+}
+function getDefaultModel(provider) {
+  return DEFAULT_MODELS[provider];
+}
+function validateProvider(value) {
+  const valid = ["claude", "gemini", "openai", "ollama"];
+  if (!valid.includes(value)) {
+    throw new Error(
+      `Invalid provider "${value}". Must be one of: ${valid.join(", ")}`
+    );
+  }
+  return value;
+}
+async function detectCLI(provider) {
+  const cliName = provider === "claude" ? "claude" : provider === "gemini" ? "gemini" : provider === "ollama" ? "ollama" : null;
+  if (!cliName) return { available: false };
+  try {
+    const { stdout } = await exec7(cliName, ["--version"]);
+    return { available: true, version: stdout.trim() };
+  } catch {
+    return { available: false };
+  }
+}
+function needsApiKey(provider) {
+  return provider === "openai";
+}
+async function saveConfluenceConfig(confluence) {
+  const existing = await loadConfig() ?? { provider: "claude" };
+  await saveConfig({ ...existing, confluence });
+}
+async function loadConfluenceConfig() {
+  const config = await loadConfig();
+  return config?.confluence ?? null;
+}
+var exec7, DEFAULT_MODELS;
+var init_config = __esm({
+  "src/llm/config.ts"() {
+    "use strict";
+    exec7 = promisify7(execFile7);
+    DEFAULT_MODELS = {
+      claude: "claude-sonnet-4-20250514",
+      gemini: "gemini-2.5-flash",
+      openai: "gpt-4o",
+      ollama: "llama3"
+    };
+  }
+});
+
+// src/confluence/url.ts
+var url_exports = {};
+__export(url_exports, {
+  normalizeAtlassianBaseUrl: () => normalizeAtlassianBaseUrl
+});
+function normalizeAtlassianBaseUrl(input) {
+  const trimmed = input.trim().replace(/\/+$/, "");
+  if (!trimmed) throw new Error("Confluence baseUrl is required.");
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  if (trimmed.includes(".")) return `https://${trimmed}`;
+  return `https://${trimmed}.atlassian.net`;
+}
+var init_url = __esm({
+  "src/confluence/url.ts"() {
+    "use strict";
+  }
+});
+
+// src/confluence/renderer.ts
+function escape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function infoPanel(text) {
+  return `<ac:structured-macro ac:name="info"><ac:rich-text-body><p>${escape(text)}</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 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>`
+  ).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 footer = infoPanel(
+    `Generated from code by Mason. This page is overwritten on each sync \u2014 edit the code, not the page.`
+  );
+  const body = overviewBody + flowsBody + navBody + footer;
+  return {
+    title: options.name,
+    body
+  };
+}
+function renderIndexPage(options) {
+  if (options.featureTitles.length === 0) {
+    return infoPanel("No features in the snapshot yet.");
+  }
+  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>`;
+  }).join("") + `</ul>`;
+  const banner = infoPanel(
+    `Generated from code by Mason. Maintained automatically \u2014 edit the code, not this page.`
+  );
+  return banner + list;
+}
+function renderChangelogSection(section) {
+  const segments = [];
+  if (section.addedFeatures.length) {
+    segments.push(
+      `<p><strong>Added features:</strong> ${section.addedFeatures.map(escape).join(", ")}</p>`
+    );
+  }
+  if (section.removedFeatures.length) {
+    segments.push(
+      `<p><strong>Removed features:</strong> ${section.removedFeatures.map(escape).join(", ")}</p>`
+    );
+  }
+  if (section.changedFeatures.length) {
+    segments.push(
+      `<p><strong>Updated features:</strong> ${section.changedFeatures.map(escape).join(", ")}</p>`
+    );
+  }
+  if (section.addedFlows.length) {
+    segments.push(
+      `<p><strong>Added flows:</strong> ${section.addedFlows.map(escape).join(", ")}</p>`
+    );
+  }
+  if (section.removedFlows.length) {
+    segments.push(
+      `<p><strong>Removed flows:</strong> ${section.removedFlows.map(escape).join(", ")}</p>`
+    );
+  }
+  if (segments.length === 0) {
+    segments.push(`<p><em>No meaningful changes detected.</em></p>`);
+  }
+  return `<h3>${escape(section.syncedAt)}</h3>` + segments.join("");
+}
+function renderChangelogPage(sections) {
+  if (sections.length === 0) {
+    return `<p><em>No sync has run yet.</em></p>`;
+  }
+  return sections.join("\n<hr/>\n");
+}
+function flowsForFeature(featureFiles, flows) {
+  const fileSet = new Set(featureFiles);
+  const result = [];
+  for (const [name, flow] of Object.entries(flows)) {
+    if (flow.chain.some((file) => fileSet.has(file))) {
+      result.push({ name, description: flow.description });
+    }
+  }
+  return result;
+}
+var init_renderer = __esm({
+  "src/confluence/renderer.ts"() {
+    "use strict";
+  }
+});
+
+// src/confluence/diff.ts
+import fs10 from "fs/promises";
+import path13 from "path";
+import { createHash as createHash2 } from "crypto";
+function hashDescription(description) {
+  return createHash2("sha256").update(description, "utf8").digest("hex");
+}
+function syncStateDir(rootDir) {
+  return path13.join(rootDir, ".mason");
+}
+function syncStatePath(rootDir) {
+  return path13.join(syncStateDir(rootDir), "confluence-sync.json");
+}
+async function loadSyncState(rootDir) {
+  try {
+    const raw = await fs10.readFile(syncStatePath(rootDir), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 2) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveSyncState(rootDir, state) {
+  await fs10.mkdir(syncStateDir(rootDir), { recursive: true });
+  await fs10.writeFile(
+    syncStatePath(rootDir),
+    JSON.stringify(state, null, 2),
+    "utf-8"
+  );
+}
+function computeDiff(previous, current, syncedAt) {
+  const prevFeatures = previous?.lastSnapshot.features ?? {};
+  const prevFlows = previous?.lastSnapshot.flows ?? {};
+  const currentFeatureNames = Object.keys(current.features);
+  const prevFeatureNames = Object.keys(prevFeatures);
+  const addedFeatures = currentFeatureNames.filter(
+    (n) => !(n in prevFeatures)
+  );
+  const removedFeatures = prevFeatureNames.filter(
+    (n) => !(n in current.features)
+  );
+  const changedFeatures = currentFeatureNames.filter(
+    (n) => n in prevFeatures && prevFeatures[n].description !== current.features[n].description
+  );
+  const currentFlowNames = Object.keys(current.flows);
+  const prevFlowNames = Object.keys(prevFlows);
+  const addedFlows = currentFlowNames.filter((n) => !(n in prevFlows));
+  const removedFlows = prevFlowNames.filter((n) => !(n in current.flows));
+  return {
+    syncedAt,
+    addedFeatures,
+    removedFeatures,
+    changedFeatures,
+    addedFlows,
+    removedFlows
+  };
+}
+function isMeaningfulDiff(diff) {
+  return diff.addedFeatures.length > 0 || diff.removedFeatures.length > 0 || diff.changedFeatures.length > 0 || diff.addedFlows.length > 0 || diff.removedFlows.length > 0;
+}
+function snapshotMinimal(snapshot) {
+  const features = {};
+  for (const [k, v] of Object.entries(snapshot.features)) {
+    features[k] = { description: v.description };
+  }
+  const flows = {};
+  for (const [k, v] of Object.entries(snapshot.flows)) {
+    flows[k] = { description: v.description };
+  }
+  return { features, flows };
+}
+var init_diff = __esm({
+  "src/confluence/diff.ts"() {
+    "use strict";
+  }
+});
+
+// src/llm/providers.ts
+import { execFile as execFile8, spawn } from "child_process";
+import { promisify as promisify8 } from "util";
+async function callLLM(config, userMessage, systemPrompt) {
+  const model = config.model ?? getDefaultModel(config.provider);
+  const system = systemPrompt ?? CLAUDE_MD_SYSTEM_PROMPT;
+  switch (config.provider) {
+    case "claude":
+      if (config.apiKey) {
+        return {
+          type: "response",
+          text: await callClaudeAPI(config.apiKey, model, system, userMessage)
+        };
+      }
+      return {
+        type: "response",
+        text: await callClaudeCLI(system, userMessage)
+      };
+    case "ollama":
+      return {
+        type: "response",
+        text: await callOllamaCLI(
+          config.ollamaHost ?? "http://localhost:11434",
+          model,
+          system,
+          userMessage
+        )
+      };
+    case "gemini":
+      if (config.apiKey) {
+        return {
+          type: "response",
+          text: await callGeminiAPI(config.apiKey, model, system, userMessage)
+        };
+      }
+      return {
+        type: "response",
+        text: await callGeminiCLI(system, userMessage)
+      };
+    case "openai":
+      if (config.apiKey) {
+        return {
+          type: "response",
+          text: await callOpenAIAPI(config.apiKey, model, system, userMessage)
+        };
+      }
+      return {
+        type: "prompt",
+        text: formatPromptForCopy(system, userMessage)
+      };
+  }
+}
+function formatPromptForCopy(system, userMessage) {
+  return `${system}
+
+---
+
+${userMessage}`;
+}
+function spawnWithStdin(command, args, input) {
+  return new Promise((resolve2, reject) => {
+    const proc = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e5
+    });
+    const onSigint = () => proc.kill("SIGINT");
+    process.on("SIGINT", onSigint);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      process.off("SIGINT", onSigint);
+      if (code === 0) {
+        resolve2(stdout.trim());
+      } else {
+        reject(new Error(`${command} exited with code ${code}: ${stderr}`));
+      }
+    });
+    proc.on("error", (err) => {
+      process.off("SIGINT", onSigint);
+      reject(err);
+    });
+    proc.stdin.write(input);
+    proc.stdin.end();
+  });
+}
+async function callClaudeCLI(system, userMessage) {
+  return spawnWithStdin("claude", ["-p", "--system-prompt", system], userMessage);
+}
+async function callGeminiCLI(system, userMessage) {
+  const prompt = `<system>
+${system}
+</system>
+
+${userMessage}`;
+  return spawnWithStdin("gemini", ["-p", ""], prompt);
+}
+async function callOllamaCLI(host, model, system, userMessage) {
+  const response = await fetch(`${host}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      stream: false,
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content: userMessage }
+      ]
+    })
+  });
+  const result = await response.json();
+  return result.message?.content ?? "";
+}
+async function callClaudeAPI(apiKey, model, system, userMessage) {
+  const { default: Anthropic } = await import("@anthropic-ai/sdk");
+  const client = new Anthropic({ apiKey });
+  const response = await client.messages.create({
+    model,
+    max_tokens: 8192,
+    system,
+    messages: [{ role: "user", content: userMessage }]
+  });
+  const textBlock = response.content.find((b) => b.type === "text");
+  return textBlock?.text ?? "";
+}
+async function callGeminiAPI(apiKey, model, system, userMessage) {
+  const { default: OpenAI } = await import("openai");
+  const client = new OpenAI({
+    apiKey,
+    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
+  });
+  const response = await client.chat.completions.create({
+    model,
+    max_tokens: 8192,
+    messages: [
+      { role: "system", content: system },
+      { role: "user", content: userMessage }
+    ]
+  });
+  return response.choices[0]?.message?.content ?? "";
+}
+async function callOpenAIAPI(apiKey, model, system, userMessage) {
+  const { default: OpenAI } = await import("openai");
+  const client = new OpenAI({ apiKey });
+  const response = await client.chat.completions.create({
+    model,
+    max_tokens: 8192,
+    messages: [
+      { role: "system", content: system },
+      { role: "user", content: userMessage }
+    ]
+  });
+  return response.choices[0]?.message?.content ?? "";
+}
+var exec8, CLAUDE_MD_SYSTEM_PROMPT;
+var init_providers = __esm({
+  "src/llm/providers.ts"() {
+    "use strict";
+    init_config();
+    exec8 = promisify8(execFile8);
+    CLAUDE_MD_SYSTEM_PROMPT = `You are Mason, a context engineering tool. You've been given a comprehensive analysis of a codebase including:
+- Git history stats (commit patterns, frequently changed files, stale directories)
+- Project structure (directory layout, file counts by type)
+- Curated code samples (key architectural files with previews)
+- Test-to-source file mapping
+
+Your job: write a COMPLETE CLAUDE.md file from scratch based ONLY on the analysis data provided below. Do NOT read any existing files in the project. Do NOT reference or preserve any existing CLAUDE.md. Generate the entire document fresh.
+
+CRITICAL: Output ONLY the raw markdown content. No preamble, no summary, no "Here's the CLAUDE.md:", no explanation, no questions, no commentary. Start directly with "# CLAUDE.md" and end with the last line of content. Your entire response will be written directly to a file.
+
+The CLAUDE.md should include:
+- Project overview (what it is, tech stack, architecture)
+- Module/package structure and boundaries
+- Code conventions and patterns you observe in the samples
+- Testing conventions and coverage
+- Build and development commands
+- Important files and hot spots
+- Any warnings or gotchas
+
+Be specific and actionable. Reference actual file paths. Don't be generic \u2014 every rule should be grounded in what you see in the data.`;
+  }
+});
+
+// src/confluence/rewrite.ts
+function buildPrompt(input) {
+  return `Rewrite the descriptions below for a product audience. Return ONLY a JSON object of the form {"features": {"name": "rewritten description", ...}, "flows": {...}}.
+
+${JSON.stringify(input, null, 2)}`;
+}
+function parseRewriteResponse(raw) {
+  let cleaned = raw.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  }
+  try {
+    const parsed = JSON.parse(cleaned);
+    return {
+      features: parsed.features ?? {},
+      flows: parsed.flows ?? {}
+    };
+  } catch {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (match) {
+      try {
+        const parsed = JSON.parse(match[0]);
+        return {
+          features: parsed.features ?? {},
+          flows: parsed.flows ?? {}
+        };
+      } catch {
+        return { features: {}, flows: {} };
+      }
+    }
+    return { features: {}, flows: {} };
+  }
+}
+function pick(source, keys) {
+  const out = {};
+  for (const k of keys) out[k] = source[k];
+  return out;
+}
+async function rewriteForProduct(snapshot, config, ctx = {}) {
+  const featureHashes = hashEntries(snapshot.features);
+  const flowHashes = hashEntries(snapshot.flows);
+  const missFeatures = missingNames(
+    snapshot.features,
+    featureHashes,
+    ctx.previousCache?.features
+  );
+  const missFlows = missingNames(
+    snapshot.flows,
+    flowHashes,
+    ctx.previousCache?.flows
+  );
+  let parsed = { features: {}, flows: {} };
+  if (missFeatures.length > 0 || missFlows.length > 0) {
+    const input = {
+      features: pick(snapshot.features, missFeatures),
+      flows: pick(snapshot.flows, missFlows)
+    };
+    const prompt = buildPrompt(input);
+    const llm = ctx.llm ?? callLLM;
+    const result = await llm(config, prompt, PM_REWRITE_SYSTEM_PROMPT);
+    const text = typeof result === "string" ? result : result.type === "response" ? result.text : "";
+    if (text) parsed = parseRewriteResponse(text);
+  }
+  const features = resolve(
+    snapshot.features,
+    featureHashes,
+    parsed.features,
+    ctx.previousCache?.features
+  );
+  const flows = resolve(
+    snapshot.flows,
+    flowHashes,
+    parsed.flows,
+    ctx.previousCache?.flows
+  );
+  return {
+    features: features.descriptions,
+    flows: flows.descriptions,
+    cache: { features: features.cache, flows: flows.cache }
+  };
+}
+function hashEntries(entries) {
+  const out = {};
+  for (const [name, entry] of Object.entries(entries)) {
+    out[name] = hashDescription(entry.description);
+  }
+  return out;
+}
+function isHit(prev, hash) {
+  return !!prev && prev.sourceHash === hash && !prev.fallback;
+}
+function missingNames(entries, hashes, prevCache) {
+  return Object.keys(entries).filter(
+    (name) => !isHit(prevCache?.[name], hashes[name])
+  );
+}
+function resolve(entries, hashes, rewritten, prevCache) {
+  const descriptions = {};
+  const cache = {};
+  for (const [name, entry] of Object.entries(entries)) {
+    const hash = hashes[name];
+    const prev = prevCache?.[name];
+    if (isHit(prev, hash)) {
+      descriptions[name] = prev.product;
+      cache[name] = { sourceHash: hash, product: prev.product };
+      continue;
+    }
+    const fresh = rewritten[name];
+    if (typeof fresh === "string" && fresh.trim().length > 0) {
+      descriptions[name] = fresh;
+      cache[name] = { sourceHash: hash, product: fresh };
+    } else {
+      descriptions[name] = entry.description;
+      cache[name] = { sourceHash: hash, product: entry.description, fallback: true };
+    }
+  }
+  return { descriptions, cache };
+}
+var PM_REWRITE_SYSTEM_PROMPT;
+var init_rewrite = __esm({
+  "src/confluence/rewrite.ts"() {
+    "use strict";
+    init_providers();
+    init_diff();
+    PM_REWRITE_SYSTEM_PROMPT = `You are Mason, rewriting an engineering-flavoured concept map into product-readable language for a company wiki.
+
+You will receive a JSON object with two maps:
+- "features": each entry has a description and a list of source file paths.
+- "flows": each entry has a description and an ordered chain of file paths.
+
+Your job: rewrite EACH description so a Product Manager, designer, or non-engineering stakeholder can understand what the system does \u2014 without seeing any code. Treat the file paths as hints, not content. Do NOT include them in your output.
+
+Hard rules:
+- NEVER mention file names, directory names, file extensions, class names, function names, repository names, framework names, or libraries.
+- NEVER use words like "module", "service", "handler", "controller", "ViewModel", "repository", "endpoint", "API", "schema", "interface", "class".
+- Use plain English. Focus on what users or the business can do, what data moves, what decisions get made, and why it matters.
+- 1\u20133 sentences per description. Concrete. No filler.
+- Preserve the original keys exactly; only the description values change.
+
+Output ONLY raw JSON with the same shape as the input \u2014 same keys, rewritten descriptions. No markdown, no code fences, no preamble.`;
+  }
+});
+
+// src/confluence/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  exportToConfluence: () => exportToConfluence
+});
+async function exportToConfluence(rootDir, config, options = {}, deps) {
+  const confluence = config.confluence;
+  if (!confluence) {
+    throw new Error(
+      "No Confluence credentials configured. Ask your assistant to call mason_set_confluence first."
+    );
+  }
+  const snapshot = await loadSnapshot(rootDir);
+  if (!snapshot) {
+    throw new Error(
+      "No snapshot found. Build the concept map first (ask your assistant to run mason_init and follow the playbook)."
+    );
+  }
+  const client = deps?.client ?? createConfluenceClient(confluence);
+  const rewrite = deps?.rewrite ?? rewriteForProduct;
+  const publishedFeatures = {};
+  for (const [name, entry] of Object.entries(snapshot.features)) {
+    if (entry.type !== "infrastructure") publishedFeatures[name] = entry;
+  }
+  const publishSnapshot = { ...snapshot, features: publishedFeatures };
+  const indexTitle = options.indexPageTitle ?? DEFAULT_INDEX_TITLE;
+  const changelogTitle = options.changelogPageTitle ?? DEFAULT_CHANGELOG_TITLE;
+  const featurePrefix = options.featurePagePrefix ?? DEFAULT_FEATURE_PREFIX;
+  const spaceId = await client.resolveSpaceId(confluence.spaceKey);
+  const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const previousState = await loadSyncState(rootDir);
+  const previousHashes = previousState?.pageHashes ?? {};
+  const nextHashes = {};
+  const productLanguage = await rewrite(publishSnapshot, config, {
+    previousCache: previousState?.rewriteCache
+  });
+  const indexBody = renderIndexPage({
+    featureTitles: Object.keys(publishSnapshot.features),
+    featurePrefix
+  });
+  const indexPage = await upsertPage({
+    client,
+    spaceId,
+    title: indexTitle,
+    parentId: confluence.parentPageId,
+    renderedBody: indexBody,
+    previousHash: previousHashes[indexTitle]
+  });
+  nextHashes[indexTitle] = indexPage.hash;
+  const created = [];
+  const updated = [];
+  const unchanged = [];
+  const featurePageIds = {};
+  for (const [name, entry] of Object.entries(publishSnapshot.features)) {
+    const title = featurePageTitle(featurePrefix, name);
+    const productDescription = productLanguage.features[name] ?? entry.description;
+    const relatedFlows = flowsForFeature(entry.files, publishSnapshot.flows).map(
+      (f) => ({
+        name: f.name,
+        description: productLanguage.flows[f.name] ?? f.description
+      })
+    );
+    const rendered = renderFeaturePage({
+      name,
+      productDescription,
+      flowDescriptions: relatedFlows,
+      indexPageTitle: indexTitle
+    });
+    const result = await upsertPage({
+      client,
+      spaceId,
+      title,
+      parentId: indexPage.id,
+      renderedBody: rendered.body,
+      previousHash: previousHashes[title]
+    });
+    nextHashes[title] = result.hash;
+    featurePageIds[name] = result.id;
+    if (result.outcome === "created") created.push(title);
+    else if (result.outcome === "updated") updated.push(title);
+    else unchanged.push(title);
+  }
+  const diff = computeDiff(previousState, publishSnapshot, syncedAt);
+  const hadChanges = previousState === null || isMeaningfulDiff(diff);
+  const previousSections = previousState?.changelogSections ?? [];
+  let newSections = previousSections;
+  if (hadChanges) {
+    const section = renderChangelogSection(diff);
+    newSections = [section, ...previousSections].slice(0, 50);
+  }
+  const changelogBody = renderChangelogPage(newSections);
+  const changelogPage = await upsertPage({
+    client,
+    spaceId,
+    title: changelogTitle,
+    parentId: indexPage.id,
+    renderedBody: changelogBody,
+    previousHash: previousHashes[changelogTitle]
+  });
+  nextHashes[changelogTitle] = changelogPage.hash;
+  const nextState = {
+    version: 2,
+    syncedAt,
+    pageIds: {
+      index: indexPage.id,
+      changelog: changelogPage.id,
+      features: featurePageIds
+    },
+    lastSnapshot: snapshotMinimal(publishSnapshot),
+    changelogSections: newSections,
+    rewriteCache: productLanguage.cache,
+    pageHashes: nextHashes
+  };
+  await saveSyncState(rootDir, nextState);
+  return {
+    created,
+    updated,
+    unchanged,
+    indexPageId: indexPage.id,
+    changelogPageId: changelogPage.id,
+    hadChanges
+  };
+}
+async function upsertPage(args) {
+  const hash = hashDescription(args.renderedBody);
+  const existing = await args.client.findPageByTitle(args.spaceId, args.title);
+  if (!existing) {
+    const page = await args.client.createPage({
+      spaceId: args.spaceId,
+      title: args.title,
+      parentId: args.parentId,
+      body: args.renderedBody
+    });
+    return { id: page.id, outcome: "created", hash };
+  }
+  if (args.previousHash === hash) {
+    return { id: existing.id, outcome: "unchanged", hash };
+  }
+  const updated = await args.client.updatePage({
+    id: existing.id,
+    title: args.title,
+    parentId: args.parentId,
+    body: args.renderedBody,
+    version: existing.version
+  });
+  return { id: updated.id, outcome: "updated", hash };
+}
+var DEFAULT_INDEX_TITLE, DEFAULT_CHANGELOG_TITLE, DEFAULT_FEATURE_PREFIX;
+var init_sync = __esm({
+  "src/confluence/sync.ts"() {
+    "use strict";
+    init_snapshot();
+    init_client();
+    init_renderer();
+    init_diff();
+    init_rewrite();
+    DEFAULT_INDEX_TITLE = "Mason \u2014 System Map";
+    DEFAULT_CHANGELOG_TITLE = "Mason \u2014 Changelog";
+    DEFAULT_FEATURE_PREFIX = "Feature: ";
+  }
+});
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/mcp/tools.ts
+import fs11 from "fs/promises";
+import path14 from "path";
+import { execFile as execFile9 } from "child_process";
+import { promisify as promisify9 } from "util";
+import fg6 from "fast-glob";
+
+// src/analyzers/git-history.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/analyzers/base.ts
+import fs from "fs/promises";
+import fg from "fast-glob";
+var BaseAnalyzer = class {
+  async findFiles(patterns, root) {
+    return fg(patterns, {
+      cwd: root,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
+      absolute: true
+    });
+  }
+  async readFile(filePath) {
+    return fs.readFile(filePath, "utf-8");
+  }
+  createFinding(partial) {
+    return {
+      analyzer: this.name,
+      category: partial.category,
+      confidence: partial.confidence,
+      summary: partial.summary,
+      evidence: partial.evidence ?? [],
+      ruleCandidate: partial.ruleCandidate ?? null
+    };
+  }
+  createResult(findings, gaps, startTime) {
+    return {
+      analyzer: this.name,
+      findings,
+      gaps,
+      durationMs: Date.now() - startTime
+    };
+  }
+};
+
+// src/analyzers/git-history.ts
+var exec = promisify(execFile);
+var GitHistoryAnalyzer = class extends BaseAnalyzer {
+  name = "git-history";
+  async analyze(context) {
+    const startTime = Date.now();
+    const findings = [];
+    const gaps = [];
+    if (!context.gitAvailable) {
+      return this.createResult([], [], startTime);
+    }
+    const [staleFindings, staleGaps] = await this.findStaleDirectories(context);
+    findings.push(...staleFindings);
+    gaps.push(...staleGaps);
+    const hotFindings = await this.findHotFiles(context);
+    findings.push(...hotFindings);
+    const commitFindings = await this.analyzeCommitPatterns(context);
+    findings.push(...commitFindings);
+    return this.createResult(findings, gaps, startTime);
+  }
+  async git(args, cwd) {
+    try {
+      const { stdout } = await exec("git", args, { cwd, maxBuffer: 1e7 });
+      return stdout.trim();
+    } catch {
+      return "";
+    }
+  }
+  async findStaleDirectories(context) {
+    const findings = [];
+    const gaps = [];
+    const output = await this.git(
+      ["log", "--all", "--format=%ci", "--name-only", "--diff-filter=AMCR", "-n", "500"],
+      context.rootDir
+    );
+    if (!output) return [findings, gaps];
+    const dirLastTouch = /* @__PURE__ */ new Map();
+    let currentDate = null;
+    for (const line of output.split("\n")) {
+      if (!line) continue;
+      if (/^\d{4}-\d{2}-\d{2}/.test(line)) {
+        currentDate = new Date(line);
+      } else if (currentDate) {
+        const topDir = line.split("/")[0];
+        if (topDir && !topDir.startsWith(".") && !topDir.includes("node_modules")) {
+          const existing = dirLastTouch.get(topDir);
+          if (!existing || currentDate > existing) {
+            dirLastTouch.set(topDir, currentDate);
+          }
+        }
+      }
+    }
+    const sixMonthsAgo = /* @__PURE__ */ new Date();
+    sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
+    for (const [dir, lastTouch] of dirLastTouch) {
+      if (lastTouch < sixMonthsAgo) {
+        const monthsStale = Math.floor(
+          (Date.now() - lastTouch.getTime()) / (1e3 * 60 * 60 * 24 * 30)
+        );
+        findings.push(
+          this.createFinding({
+            category: "risk",
+            confidence: 0.7,
+            summary: `Directory "${dir}" hasn't been modified in ${monthsStale} months`,
+            evidence: [
+              { filePath: dir, detail: `Last commit: ${lastTouch.toISOString().split("T")[0]}` }
+            ],
+            ruleCandidate: `Do not refactor or modify files in "${dir}/" unless explicitly asked \u2014 this area has been stable for ${monthsStale} months and may be legacy code.`
+          })
+        );
+        gaps.push({
+          analyzer: this.name,
+          question: `Directory "${dir}" hasn't been touched in ${monthsStale} months. Is it deprecated, stable, or legacy?`,
+          context: `Last modified: ${lastTouch.toISOString().split("T")[0]}`,
+          answerKey: `stale-dir-${dir}`
+        });
+      }
+    }
+    return [findings, gaps];
+  }
+  async findHotFiles(context) {
+    const findings = [];
+    const output = await this.git(
+      ["log", "--since=3 months ago", "--format=", "--name-only"],
+      context.rootDir
+    );
+    if (!output) return findings;
+    const fileCounts = /* @__PURE__ */ new Map();
+    for (const line of output.split("\n")) {
+      if (!line || line.startsWith(".") || line.includes("node_modules")) continue;
+      fileCounts.set(line, (fileCounts.get(line) ?? 0) + 1);
+    }
+    const sorted = [...fileCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+    if (sorted.length > 0 && sorted[0][1] >= 5) {
+      const hotFiles = sorted.filter(([, count]) => count >= 5);
+      if (hotFiles.length > 0) {
+        findings.push(
+          this.createFinding({
+            category: "risk",
+            confidence: 0.8,
+            summary: `${hotFiles.length} files changed frequently in the last 3 months`,
+            evidence: hotFiles.map(([file, count]) => ({
+              filePath: file,
+              detail: `${count} commits`
+            })),
+            ruleCandidate: `These files change frequently and are high-risk for conflicts: ${hotFiles.map(([f]) => f).join(", ")}. Take extra care when modifying them.`
+          })
+        );
+      }
+    }
+    return findings;
+  }
+  async analyzeCommitPatterns(context) {
+    const findings = [];
+    const output = await this.git(
+      ["log", "--format=%s", "-n", "100"],
+      context.rootDir
+    );
+    if (!output) return findings;
+    const messages = output.split("\n").filter(Boolean);
+    const conventionalPattern = /^(feat|fix|chore|docs|style|refactor|test|perf|ci|build|revert)(\(.+\))?:/;
+    const conventionalCount = messages.filter(
+      (m) => conventionalPattern.test(m)
+    ).length;
+    const conventionalRatio = conventionalCount / messages.length;
+    if (conventionalRatio > 0.5) {
+      findings.push(
+        this.createFinding({
+          category: "convention",
+          confidence: Math.min(conventionalRatio + 0.1, 1),
+          summary: `${Math.round(conventionalRatio * 100)}% of recent commits use conventional commit format`,
+          evidence: [
+            {
+              filePath: ".git",
+              detail: `${conventionalCount} of ${messages.length} commits match`
+            }
+          ],
+          ruleCandidate: "Use conventional commit format: type(scope): description (e.g., feat(auth): add login endpoint)"
+        })
+      );
+    }
+    const ticketPattern = /[A-Z]+-\d+|#\d+/;
+    const ticketCount = messages.filter((m) => ticketPattern.test(m)).length;
+    const ticketRatio = ticketCount / messages.length;
+    if (ticketRatio > 0.3) {
+      findings.push(
+        this.createFinding({
+          category: "convention",
+          confidence: ticketRatio,
+          summary: `${Math.round(ticketRatio * 100)}% of commits reference issue/ticket IDs`,
+          evidence: [
+            {
+              filePath: ".git",
+              detail: `${ticketCount} of ${messages.length} commits have ticket refs`
+            }
+          ],
+          ruleCandidate: "Include issue/ticket references in commit messages when applicable."
+        })
+      );
+    }
+    return findings;
+  }
+};
+
+// src/analyzers/index.ts
+var analyzers = [new GitHistoryAnalyzer()];
+async function runAll(context) {
+  return Promise.all(analyzers.map((a) => a.analyze(context)));
+}
+
+// src/utils/git.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var exec2 = promisify2(execFile2);
+async function isGitRepo(dir) {
+  try {
+    await exec2("git", ["rev-parse", "--git-dir"], { cwd: dir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/mcp/tools.ts
+init_sampler();
+init_snapshot();
+init_drift();
+
+// src/snapshot/prompt.ts
+var BATCH_SYSTEM_PROMPT = `You are Mason, building one piece of a larger concept-to-files map via a Map-Reduce pattern.
+
+You are seeing ONE batch of files from this project \u2014 not the whole codebase. Other batches will be processed separately and merged with yours in a final reduce step.
+
+Your job for this batch: identify the features and flows that involve the files in this batch, and return a partial concept map.
+
+Respond with ONLY a JSON object. No markdown, no explanation, no code fences. Just the raw JSON. Same shape as the full map (\`{"features": {...}, "flows": {...}}\`).
+
+CRITICAL: name features in PRODUCT-NATURAL language (e.g., "home screen", "authentication", "checkout"). Do NOT add platform or layer suffixes \u2014 call both the Android and iOS home-screen files part of a feature named "home screen". This is what lets the reduce step merge platform variants from other batches into a single product feature.
+
+Other rules:
+- Only include files that you see in this batch. Don't predict files in other batches.
+- Use the FULL relative file paths exactly as given.
+- Classify each feature with a "type": "capability" (user-facing functionality) or "infrastructure" (internal plumbing with no end user \u2014 DI/service wiring, configuration, logging, adapters, build tooling). When unsure, use "capability".
+- Each feature should have 1\u20138 files from this batch \u2014 partials can be narrow.
+- Flows in a partial only make sense if all their chain steps are in this batch. Skip flows that span batches; the reduce step will assemble them.
+- Include test files in "tests" when present in this batch.
+- Two views of the batch: FILE HEADERS (every file in the batch, skeleton-level) and REPRESENTATIVE BODIES (deeper read of a few for grounding). Use the bodies to learn the codebase's domain vocabulary; use the headers to know which files exist.`;
+var REDUCE_SYSTEM_PROMPT = `You are Mason, merging partial concept maps from a Map-Reduce pass into a single unified map.
+
+You will receive an array of \`partials\`, each produced from one batch of files. Your job: merge them into one coherent concept-to-files map for the whole project.
+
+Respond with ONLY a JSON object: \`{"features": {...}, "flows": {...}}\`. No markdown, no preamble.
+
+Merge rules:
+- If two partials use the same feature name (e.g., both have "home screen"), MERGE them \u2014 combine their \`files\` and \`tests\` arrays (dedupe), and reconcile descriptions by picking the more product-natural wording or merging the two.
+- If two partials use *near-duplicate* feature names that clearly refer to the same product concept ("home screen" vs "home view", "auth" vs "authentication"), merge them under the more product-natural name.
+- If a partial split what should be one feature by platform ("home Android" + "home iOS"), merge into a single platform-agnostic feature ("home screen").
+- Preserve each feature's "type" ("capability" or "infrastructure"). When merged partials disagree on a feature's type, prefer "capability". If a partial omitted the type, infer it: user-facing functionality is "capability"; internal plumbing with no end user (DI/service wiring, config, logging, adapters) is "infrastructure".
+- For flows that were skipped by partials because they span batches, reconstruct them when you can see the full chain across multiple partials.
+- Every file that appears in any partial MUST end up in some feature in the unified map. Don't silently drop files.
+- Feature descriptions in the final map should be 1\u20132 sentences, written for a product/PM audience \u2014 concrete and specific, but free of code-level detail.
+- Each feature should have 2\u20138 files. If merging produces a feature with 20+ files, consider whether it should be split into sub-features.`;
+function buildBatchPrompt(batch) {
+  const skeletonBlocks = batch.skeletons.map(
+    (f) => `--- ${f.path} ---
+${f.content}${f.content.length >= 500 ? "\n... (truncated)" : ""}`
+  ).join("\n\n");
+  const sampleBlocks = batch.samples.map(
+    (f) => `=== ${f.path} (deeper read) ===
+${f.content}${f.content.length >= 1500 ? "\n... (truncated)" : ""}`
+  ).join("\n\n");
+  const batchInfo = `Batch ${Math.floor(batch.offset / batch.batchSize) + 1}: files ${batch.offset + 1}\u2013${batch.offset + batch.skeletons.length} of ${batch.totalFiles}.`;
+  let prompt = `${batchInfo}
+
+=== FILE HEADERS (every file in this batch) ===
+
+${skeletonBlocks}
+
+=== REPRESENTATIVE BODIES (for grounding) ===
+
+${sampleBlocks}`;
+  if (batch.testPairs && batch.testPairs.length > 0) {
+    const testBlock = batch.testPairs.map((p) => `${p.test} \u2192 ${p.source}`).join("\n");
+    prompt += `
+
+=== TEST \u2192 SOURCE MAPPINGS (for this batch) ===
+
+${testBlock}`;
+  }
+  return prompt;
+}
+function buildReducePrompt(partials) {
+  return `Merge the following ${partials.length} partial concept maps into a single unified map.
+
+${JSON.stringify({ partials }, null, 2)}`;
+}
+var REFRESH_REDUCE_SYSTEM_PROMPT = `You are Mason, merging a scoped refresh into an existing concept-to-files map.
+
+Only a subset of the project's files was re-analyzed (they changed since the map was built). You receive the existing full map, the list of re-analyzed file paths, and partial concept maps derived from ONLY those files.
+
+Respond with ONLY a JSON object: \`{"features": {...}, "flows": {...}}\` \u2014 the COMPLETE updated map. No markdown, no preamble.
+
+Merge rules:
+- Entries in the existing map that reference none of the re-analyzed files: copy them through UNCHANGED.
+- Entries that reference re-analyzed files: update them using the partials \u2014 adjust descriptions, add new files, drop files that moved elsewhere.
+- Merge partial features into existing features when they're the same product concept, even if named slightly differently ("auth" vs "authentication") \u2014 keep the existing name unless the new one is clearly more product-natural.
+- Features whose files were all deleted or renamed away: remove them by omitting them from your output.
+- Every file that appears in any partial MUST end up in some feature. Don't silently drop files.
+- Do not invent or alter entries for files you haven't seen.`;
+function buildRefreshReducePrompt(existingMap, refreshedFiles, partials) {
+  return `Merge this scoped refresh into the existing concept map.
+
+=== EXISTING MAP ===
+${JSON.stringify(existingMap, null, 2)}
+
+=== RE-ANALYZED FILES ===
+${refreshedFiles.join("\n")}
+
+=== PARTIALS (derived from the re-analyzed files only) ===
+${JSON.stringify({ partials }, null, 2)}`;
+}
+
+// src/snapshot/partials.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+function partialsDir(rootDir) {
+  return path5.join(rootDir, ".mason", "partial-snapshots");
+}
+function partialPath(rootDir, batchId) {
+  return path5.join(partialsDir(rootDir), `${batchId}.json`);
+}
+function isSafeBatchId(batchId) {
+  return /^[a-zA-Z0-9_-]+$/.test(batchId);
+}
+async function savePartial(rootDir, partial) {
+  if (!isSafeBatchId(partial.batchId)) {
+    throw new Error(`Invalid batchId: ${partial.batchId}`);
+  }
+  await fs5.mkdir(partialsDir(rootDir), { recursive: true });
+  await fs5.writeFile(
+    partialPath(rootDir, partial.batchId),
+    JSON.stringify(partial, null, 2),
+    "utf-8"
+  );
+}
+async function loadAllPartials(rootDir) {
+  let entries;
+  try {
+    entries = await fs5.readdir(partialsDir(rootDir));
+  } catch {
+    return [];
+  }
+  const partials = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const raw = await fs5.readFile(
+        path5.join(partialsDir(rootDir), entry),
+        "utf-8"
+      );
+      const parsed = JSON.parse(raw);
+      if (parsed && parsed.batchId && parsed.features && parsed.flows) {
+        partials.push(parsed);
+      }
+    } catch {
+    }
+  }
+  partials.sort((a, b) => a.offset - b.offset);
+  return partials;
+}
+function scopePath(rootDir) {
+  return path5.join(partialsDir(rootDir), "scope.json");
+}
+async function saveScope(rootDir, files) {
+  await fs5.mkdir(partialsDir(rootDir), { recursive: true });
+  await fs5.writeFile(
+    scopePath(rootDir),
+    JSON.stringify({ files, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    "utf-8"
+  );
+}
+async function loadScope(rootDir) {
+  try {
+    const raw = await fs5.readFile(scopePath(rootDir), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed?.files)) return parsed.files;
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function clearScope(rootDir) {
+  await fs5.rm(scopePath(rootDir), { force: true });
+}
+async function clearAllPartials(rootDir) {
+  try {
+    await fs5.rm(partialsDir(rootDir), { recursive: true, force: true });
+  } catch {
+  }
+}
+function batchIdFor(offset) {
+  return `batch-${String(offset).padStart(6, "0")}`;
+}
+
+// src/mcp/init.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+function masonDir(rootDir) {
+  return path6.join(rootDir, ".mason");
+}
+function markerPath(rootDir) {
+  return path6.join(masonDir(rootDir), "project.json");
+}
+async function loadProjectMarker(rootDir) {
+  try {
+    const raw = await fs6.readFile(markerPath(rootDir), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveProjectMarker(rootDir, marker) {
+  await fs6.mkdir(masonDir(rootDir), { recursive: true });
+  await fs6.writeFile(
+    markerPath(rootDir),
+    JSON.stringify(marker, null, 2),
+    "utf-8"
+  );
+}
+async function isInitialized(rootDir) {
+  const marker = await loadProjectMarker(rootDir);
+  return marker !== null;
+}
+function uninitializedResponse(action) {
+  return JSON.stringify(
+    {
+      initialized: false,
+      hint: `This project hasn't been set up for Mason yet. Call \`mason_init\` first; it will walk the user through ${action}.`
+    },
+    null,
+    2
+  );
+}
+var CLAUDE_MD_SECTION = `<!-- mason:start -->
+## Mason concept map
+
+This project has a Mason concept map (\`.mason/snapshot.json\`) and decision store (\`.mason/decisions/\`) served over MCP. Use them BEFORE grep, glob, or file reads:
+
+- Task, bug, or change request \u2192 \`get_context\` with the task text: relevant features, files, tests, blast radius, freshness, and decisions in one call.
+- "How does X work / where is Y" \u2192 \`get_snapshot\` first.
+- Before editing any file \u2192 \`get_impact\`.
+- Learned something the code can't tell you (a failed approach, a deprecation, a workaround's reason, a review-settled convention) \u2192 record it with \`save_decision\`. Never record code-derivable facts, session trivia, or secrets.
+- Decisions returned by \`get_context\` are constraints \u2014 follow them; verify any marked stale before relying on it.
+
+Fall back to manual exploration only for what the map doesn't answer.
+<!-- mason:end -->`;
+var SETUP_PLAYBOOK = `You are walking the user through one-time Mason setup for this project. Mason persists a concept map of this codebase so future questions don't re-explore from scratch. The map is built via a Map-Reduce pattern so it covers the WHOLE codebase, not just a sample. Surface each question to the user in plain language and wait for their answer before proceeding.
+
+CONSENT
+Tell the user: "Mason will read your codebase in batches and build a concept map at .mason/snapshot.json. This can take a while \u2014 Mason makes several tool calls in sequence. Proceed?"
+On no: stop. Mason setup is opt-in.
+On yes: continue with the phases below.
+
+PHASE 1 \u2014 Map (loop until done)
+Goal: process every file in the codebase, batch by batch, producing a partial concept map per batch.
+
+  1. Call \`generate_snapshot_batch(dir)\` (omit offset on the first call).
+     The response includes:
+     - \`batchId\`: identifier for this batch
+     - \`offset\`, \`nextOffset\`, \`totalFiles\`: progress markers
+     - \`instructions\`: the system prompt for the batch step
+     - \`prompt\`: the files in this batch (skeletons + a few deeper bodies)
+  2. Following the \`instructions\`, derive features and flows that involve ONLY the files in this batch. Use product-natural feature names ("home screen", not "HomeScreenAndroid") so the reduce step can merge platform variants.
+  3. Call \`save_partial_snapshot(dir, batchId, offset, features, flows)\` to persist the partial.
+  4. If \`nextOffset\` is null, the Map phase is done. Otherwise call \`generate_snapshot_batch(dir, offset=nextOffset)\` and repeat from step 2.
+
+  Briefly tell the user "Batch N of M done" each iteration so they see progress.
+
+  CRITICAL RULES FOR PHASE 1:
+  - Derive features and file paths ONLY from what appears verbatim in the \`prompt\` field of each batch response. NEVER invent paths from memory, prior projects, or what you assume a project of this kind would contain. If you have not seen a path in a batch \`prompt\`, do not put it in \`features.files\` or \`flows.chain\`.
+  - Process batches SEQUENTIALLY: one \`generate_snapshot_batch\` \u2192 derive \u2192 one \`save_partial_snapshot\` \u2192 next \`generate_snapshot_batch\`. Do not parallelise. Do not call \`save_snapshot\` during this phase \u2014 that is a Phase 2 step.
+  - You must walk every batch until \`nextOffset\` is null. Do not stop early. Do not skip ahead to reduce until every batch has been saved as a partial.
+
+PHASE 2 \u2014 Reduce (once)
+Goal: merge all partial maps into one coherent product-shaped catalog.
+
+  1. Call \`reduce_snapshot(dir)\`. It returns every partial map plus reconciliation instructions.
+  2. Follow the instructions to produce a unified \`features\` and \`flows\` map. Specifically: merge platform variants ("home Android" + "home iOS" \u2192 "home screen"), dedupe near-duplicates, reconcile descriptions, and ensure every file from every partial appears somewhere in the final map.
+  3. Call \`save_snapshot(dir, features, flows)\` ONCE with the unified map. Mason detects that partials exist and replaces the snapshot wholesale (rather than merging with any earlier state) and then clears the partials. Do not call \`save_snapshot\` more than once per Map-Reduce run.
+
+PHASE 3 \u2014 Confluence sync (optional)
+Goal: optionally configure Confluence so the concept map can be exported as a product-readable wiki later.
+
+Tell the user: "Mason can keep a Confluence wiki in sync with the concept map, rewriting it into product-readable language for PMs and designers. Want to set that up now? You can also skip and configure it later by asking your assistant to 'set up Confluence for this project'."
+On no: skip to Phase 4.
+On yes:
+  1. Ask the user for the Atlassian site URL (e.g. \`acme.atlassian.net\` or \`https://acme.atlassian.net\`).
+  2. Ask for the user's Atlassian account email.
+  3. Tell the user: "Generate an API token at https://id.atlassian.com/manage-profile/security/api-tokens (label it 'Mason') and paste it here. WARNING: the token will be visible in this chat history; if that's not acceptable, skip Confluence and configure it elsewhere."
+  4. Call \`mason_set_confluence({ baseUrl, email, apiToken })\` \u2014 no spaceKey on the first call. The tool validates credentials and returns a list of spaces.
+  5. Show the spaces to the user (key + name) and ask which one to use.
+  6. Call \`mason_set_confluence({ baseUrl, email, apiToken, spaceKey })\` with the chosen spaceKey to persist.
+  7. Confirm Confluence is configured. Mention they can run \`export_to_confluence\` whenever they want to sync.
+
+If the credentials are rejected with a 401/403 the tool returns a friendly error \u2014 re-ask the user for a fresh token or correct email.
+
+PHASE 4 \u2014 Assistant instructions (recommended)
+Goal: make sure future assistant sessions actually use the map instead of re-exploring.
+
+Tell the user: "Assistants reliably follow project instruction files but often ignore available tools. Mason works best if I add a short section to this project's instruction file telling assistants to consult the concept map first. Add it?"
+On no: skip to Phase 5.
+On yes, pick the target file by what the project already uses:
+  - \`AGENTS.md\` exists \u2192 put the section there (it's the tool-agnostic standard). If a \`CLAUDE.md\` also exists and doesn't reference AGENTS.md, add a one-line pointer to it.
+  - only \`CLAUDE.md\` (or \`.claude/CLAUDE.md\`) exists \u2192 put the section there.
+  - neither exists \u2192 create \`CLAUDE.md\` with just the section.
+Append the following section verbatim; if the \`<!-- mason:start -->\` marker is already present in the target file, replace the marked block instead of appending:
+
+${CLAUDE_MD_SECTION}
+
+PHASE 5 \u2014 Finalize
+  1. Call \`mason_complete_init(dir, { confluenceConfigured: true | false })\` \u2014 true if Phase 3 ended with status "saved", false otherwise.
+  2. Confirm to the user that setup is complete and they can now ask architectural questions, request impact analysis, or sync to Confluence (if configured).
+
+Notes:
+- Read tools (\`get_snapshot\`, \`get_impact\`) refuse to run until \`mason_complete_init\` has been called. Do not skip Phase 5.
+- If the user aborts mid-flow, the partials persist in \`.mason/partial-snapshots/\`; the next \`mason_init\` run can pick up where it left off.
+- \`mason_init\` is idempotent \u2014 already-initialized projects return \`{ initialized: true, confluenceConfigured: ... }\`.
+- The user can reconfigure Confluence later by asking their assistant to call \`mason_set_confluence\` directly.`;
+function setupPlaybook() {
+  return SETUP_PLAYBOOK;
+}
+
+// src/mcp/tools.ts
+var exec9 = promisify9(execFile9);
+var IGNORE3 = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.gradle/**",
+  "**/target/**",
+  "**/.git/**",
+  "**/vendor/**",
+  "**/__pycache__/**",
+  "**/venv/**",
+  "**/.venv/**",
+  "**/*.min.*",
+  "**/*.map"
+];
+async function buildContext(dir) {
+  return {
+    rootDir: dir,
+    gitAvailable: await isGitRepo(dir)
+  };
+}
+async function analyzeProject(dir) {
+  const rootDir = path14.resolve(dir);
+  const context = await buildContext(rootDir);
+  const results = await runAll(context);
+  const projectSnapshot = await detectProjectSnapshot(rootDir);
+  const output = {
+    project: projectSnapshot,
+    analyzers: results.map((r) => ({
+      name: r.analyzer,
+      durationMs: r.durationMs,
+      findings: r.findings.map((f) => ({
+        category: f.category,
+        confidence: f.confidence,
+        summary: f.summary,
+        evidence: f.evidence,
+        suggestedRule: f.ruleCandidate
+      })),
+      gaps: r.gaps.map((g) => ({
+        question: g.question,
+        context: g.context
+      }))
+    }))
+  };
+  return JSON.stringify(output, null, 2);
+}
+async function detectProjectSnapshot(rootDir) {
+  const buildFiles = [
+    "package.json",
+    "tsconfig.json",
+    "build.gradle.kts",
+    "build.gradle",
+    "settings.gradle.kts",
+    "settings.gradle",
+    "gradle/libs.versions.toml",
+    "Cargo.toml",
+    "go.mod",
+    "go.sum",
+    "pyproject.toml",
+    "setup.py",
+    "requirements.txt",
+    "Pipfile",
+    "Gemfile",
+    "Package.swift",
+    "Makefile",
+    "CMakeLists.txt",
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    ".github/workflows",
+    ".gitlab-ci.yml",
+    "Jenkinsfile"
+  ];
+  const present = [];
+  for (const file of buildFiles) {
+    try {
+      await fs11.access(path14.join(rootDir, file));
+      present.push(file);
+    } catch {
+    }
+  }
+  const testDirs = [
+    "test",
+    "tests",
+    "__tests__",
+    "spec",
+    "src/test",
+    "src/tests",
+    "**/src/test",
+    "**/src/androidTest",
+    "**/src/iosTest"
+  ];
+  const testInfo = {};
+  for (const pattern of testDirs) {
+    const files = await fg6(`${pattern}/**/*`, {
+      cwd: rootDir,
+      ignore: IGNORE3,
+      onlyFiles: true
+    });
+    if (files.length > 0) {
+      testInfo[pattern] = files.length;
+    }
+  }
+  const testFilePatterns = [
+    { pattern: "**/*.test.*", label: "*.test.*" },
+    { pattern: "**/*.spec.*", label: "*.spec.*" },
+    { pattern: "**/*Test.kt", label: "*Test.kt" },
+    { pattern: "**/*Test.java", label: "*Test.java" },
+    { pattern: "**/test_*.py", label: "test_*.py" },
+    { pattern: "**/*_test.go", label: "*_test.go" },
+    { pattern: "**/*Tests.swift", label: "*Tests.swift" },
+    { pattern: "**/*_test.rs", label: "*_test.rs" }
+  ];
+  for (const { pattern, label } of testFilePatterns) {
+    const files = await fg6(pattern, { cwd: rootDir, ignore: IGNORE3 });
+    if (files.length > 0) {
+      testInfo[label] = files.length;
+    }
+  }
+  const sourceFiles = await fg6("**/*.{ts,tsx,js,jsx,kt,kts,java,py,go,rs,swift,rb,cs,cpp,c,dart}", {
+    cwd: rootDir,
+    ignore: IGNORE3
+  });
+  const fileCounts = {};
+  for (const file of sourceFiles) {
+    const ext = path14.extname(file).slice(1);
+    fileCounts[ext] = (fileCounts[ext] ?? 0) + 1;
+  }
+  return {
+    configFilesPresent: present,
+    sourceFileCounts: fileCounts,
+    totalSourceFiles: sourceFiles.length,
+    testInfo: Object.keys(testInfo).length > 0 ? testInfo : void 0
+  };
+}
+async function getCodeSamples(dir, count = 15) {
+  const rootDir = path14.resolve(dir);
+  const samples = await sampleFiles(rootDir, count);
+  const output = {
+    note: "These are previews (first ~60 lines). Read the file directly with your own tools to see it in full.",
+    files: samples.map((s) => ({
+      path: s.path,
+      reason: s.reason,
+      totalLines: s.totalLines,
+      sizeBytes: s.sizeBytes,
+      preview: s.preview
+    }))
+  };
+  return JSON.stringify(output, null, 2);
+}
+var UNINIT_MAX_DIRECTORIES = 40;
+var UNINIT_MAX_TEST_PAIRS = 30;
+async function uninitializedContextResponse(rootDir, action) {
+  const [structureRaw, analyzerResults, testMap] = await Promise.all([
+    getProjectStructure(rootDir),
+    runAll(await buildContext(rootDir)).catch(() => []),
+    Promise.resolve().then(() => (init_test_map(), test_map_exports)).then((m) => m.buildTestMap(rootDir)).catch(() => null)
+  ]);
+  const structure = JSON.parse(structureRaw);
+  structure.directories = (structure.directories ?? []).sort(
+    (a, b) => b.fileCount - a.fileCount
+  ).slice(0, UNINIT_MAX_DIRECTORIES);
+  const gitSignals = analyzerResults.flatMap(
+    (r) => r.findings.map((f) => ({
+      category: f.category,
+      summary: f.summary,
+      evidence: f.evidence.slice(0, 5)
+    }))
+  );
+  return JSON.stringify({
+    initialized: false,
+    hint: `No Mason concept map exists here yet. Use the context below plus your own reads to answer now \u2014 then offer to set Mason up (\`mason_init\` walks the user through ${action}); don't start setup unprompted.`,
+    structure,
+    gitSignals,
+    testPairs: testMap?.paired?.slice(0, UNINIT_MAX_TEST_PAIRS) ?? []
+  });
+}
+async function getProjectStructure(dir) {
+  const rootDir = path14.resolve(dir);
+  const allFiles = await fg6("**/*", {
+    cwd: rootDir,
+    ignore: IGNORE3,
+    onlyFiles: true
+  });
+  const dirInfo = /* @__PURE__ */ new Map();
+  for (const file of allFiles) {
+    const parts = file.split("/");
+    for (let depth = 1; depth <= Math.min(parts.length, 2); depth++) {
+      const dirPath = parts.slice(0, depth).join("/");
+      if (!dirInfo.has(dirPath)) {
+        dirInfo.set(dirPath, { fileCount: 0, extensions: /* @__PURE__ */ new Map() });
+      }
+      const info = dirInfo.get(dirPath);
+      info.fileCount++;
+      const ext = path14.extname(file).slice(1);
+      if (ext) {
+        info.extensions.set(ext, (info.extensions.get(ext) ?? 0) + 1);
+      }
+    }
+  }
+  const directories = [...dirInfo.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([dirPath, info]) => {
+    const extensions = {};
+    for (const [ext, count] of info.extensions) {
+      extensions[ext] = count;
+    }
+    return { path: dirPath, fileCount: info.fileCount, extensions };
+  });
+  const topLevelFiles = allFiles.filter((f) => !f.includes("/"));
+  const output = {
+    totalFiles: allFiles.length,
+    topLevelFiles,
+    directories
+  };
+  return JSON.stringify(output, null, 2);
+}
+async function getTestMap(dir) {
+  const { buildTestMap: buildTestMap2 } = await Promise.resolve().then(() => (init_test_map(), test_map_exports));
+  const result = await buildTestMap2(dir);
+  return JSON.stringify(result, null, 2);
+}
+var STALE_DIFF_PREVIEW_LINES = 60;
+var STALE_DIFF_MAX_FILES = 25;
+async function buildChangedFilePreviews(rootDir, changedFiles) {
+  const capped = changedFiles.slice(0, STALE_DIFF_MAX_FILES);
+  const previews = [];
+  for (const filePath of capped) {
+    const full = await readFullFile(rootDir, filePath);
+    if (!full) continue;
+    const lines = full.content.split("\n");
+    previews.push({
+      path: full.path,
+      totalLines: full.totalLines,
+      preview: lines.slice(0, STALE_DIFF_PREVIEW_LINES).join("\n")
+    });
+  }
+  return previews;
+}
+async function getSnapshot(dir) {
+  const rootDir = path14.resolve(dir);
+  if (!await isInitialized(rootDir)) {
+    return uninitializedContextResponse(rootDir, "building the concept map");
+  }
+  const snapshot = await loadSnapshot(rootDir);
+  if (!snapshot) {
+    return JSON.stringify({
+      exists: false,
+      hint: "Project is initialized but no concept map exists yet. Run mason_init for the setup playbook (generate_snapshot_batch \u2192 save_partial_snapshot per batch, then reduce_snapshot and save_snapshot)."
+    });
+  }
+  const drift = await computeDrift(rootDir);
+  const isStale = drift?.stale ?? false;
+  const seenFiles = /* @__PURE__ */ new Set();
+  const compactFeatures = {};
+  for (const [name, feat] of Object.entries(snapshot.features)) {
+    const unique = feat.files.filter((f) => !seenFiles.has(f));
+    if (unique.length === 0) continue;
+    for (const f of unique) seenFiles.add(f);
+    const entry = {
+      files: unique,
+      type: normalizeFeatureType(feat.type)
+    };
+    if (feat.tests && feat.tests.length > 0) {
+      entry.tests = feat.tests;
+    }
+    compactFeatures[name] = entry;
+  }
+  const compactFlows = {};
+  for (const [name, flow] of Object.entries(snapshot.flows)) {
+    compactFlows[name] = flow.chain;
+  }
+  const output = {
+    exists: true,
+    updatedAt: snapshot.updatedAt,
+    features: compactFeatures,
+    flows: compactFlows,
+    stale: isStale
+  };
+  const { loadDecisions: loadDecisions2 } = await Promise.resolve().then(() => (init_decisions(), decisions_exports));
+  const decisionRecords = await loadDecisions2(rootDir);
+  if (decisionRecords.length > 0) {
+    const compactDecisions = {};
+    for (const d of decisionRecords) {
+      if (d.status !== "active") continue;
+      compactDecisions[d.id] = {
+        title: d.title,
+        category: d.category,
+        files: d.files
+      };
+    }
+    output.decisions = compactDecisions;
+    output.decisionsHint = "Recorded team knowledge \u2014 get_context returns matching full bodies; records live at .mason/decisions/<id>.json.";
+  }
+  if (isStale && drift) {
+    output.hint = driftHint(drift);
+    if (drift.historyAvailable && drift.changedFiles.length > 0) {
+      const samples = await buildChangedFilePreviews(
+        rootDir,
+        drift.changedFiles
+      );
+      output.diff = {
+        changedFiles: drift.changedFiles,
+        samples,
+        truncated: drift.changedFiles.length > STALE_DIFF_MAX_FILES
+      };
+      output.drift = {
+        staleFeatures: drift.staleFeatures,
+        staleFlows: drift.staleFlows,
+        unmappedFiles: drift.unmappedFiles,
+        ghostFiles: drift.ghostFiles,
+        renames: drift.renames,
+        recommendation: drift.recommendation
+      };
+    }
+  }
+  return JSON.stringify(output);
+}
+function driftHint(report) {
+  if (!report.stale) {
+    return "Snapshot matches HEAD. No action needed.";
+  }
+  if (!report.historyAvailable) {
+    return "Snapshot is stale but its commit is unreachable (shallow clone or rewritten history), so per-feature drift cannot be computed. Re-run the Map-Reduce build: generate_snapshot_batch \u2192 save_partial_snapshot \u2192 reduce_snapshot \u2192 save_snapshot.";
+  }
+  if (report.recommendation === "full-rebuild") {
+    return "Drift is too large for an incremental update. Re-run the Map-Reduce build: generate_snapshot_batch \u2192 save_partial_snapshot \u2192 reduce_snapshot \u2192 save_snapshot.";
+  }
+  if (report.changedFiles.length + report.unmappedFiles.length > STALE_DIFF_MAX_FILES) {
+    return "Many files drifted \u2014 use a scoped refresh instead of reading them all inline: call generate_snapshot_batch(dir, files=[...changedFiles, ...unmappedFiles]) repeatedly (same list every call) with save_partial_snapshot per batch, then reduce_snapshot and save_snapshot. Entries untouched by the drift are preserved in the reduce step.";
+  }
+  const nothingToRemap = Object.keys(report.staleFeatures).length === 0 && Object.keys(report.staleFlows).length === 0 && report.unmappedFiles.length === 0 && report.ghostFiles.length === 0;
+  if (nothingToRemap) {
+    return "Changes since the snapshot don't touch any mapped files. Call save_snapshot with empty features/flows to re-pin the snapshot to HEAD.";
+  }
+  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 = path14.resolve(dir);
+  if (!await isInitialized(rootDir)) {
+    return uninitializedResponse("checking concept-map drift");
+  }
+  const report = await computeDrift(rootDir);
+  if (!report) {
+    return JSON.stringify({
+      exists: false,
+      hint: "No concept map exists yet. Build one first: generate_snapshot_batch \u2192 save_partial_snapshot \u2192 reduce_snapshot \u2192 save_snapshot."
+    });
+  }
+  const snapshot = await loadSnapshot(rootDir);
+  let verification;
+  let hint = driftHint(report);
+  if (snapshot) {
+    const all = [
+      ...Object.values(snapshot.features),
+      ...Object.values(snapshot.flows)
+    ];
+    const failedNames = [
+      ...Object.entries(snapshot.features).filter(([, e]) => e.verificationFailed).map(([n]) => n),
+      ...Object.entries(snapshot.flows).filter(([, e]) => e.verificationFailed).map(([n]) => n)
+    ];
+    verification = {
+      neverVerified: all.filter((e) => !e.verifiedAt).length,
+      failed: failedNames
+    };
+    if (failedNames.length > 0) {
+      hint += ` Verification previously FAILED for [${failedNames.join(", ")}] \u2014 re-map those entries before trusting them.`;
+    }
+  }
+  return JSON.stringify({ exists: true, ...report, verification, hint });
+}
+async function generateSnapshotBatch(dir, offset = 0, batchSize = DEFAULT_BATCH_SIZE, files) {
+  const rootDir = path14.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);
+  if (scoped && batch.totalFiles > 0) {
+    await saveScope(rootDir, scopeFiles);
+  } else if (!scoped) {
+    await clearScope(rootDir);
+  }
+  const task = scoped ? "Refresh the concept map for a scoped set of drifted files (batch step)." : "Build a concept-to-files map for this project (batch step).";
+  if (batch.totalFiles === 0) {
+    return JSON.stringify(
+      {
+        task,
+        offset: 0,
+        nextOffset: null,
+        totalFiles: 0,
+        batchId: batchIdFor(0),
+        instructions: BATCH_SYSTEM_PROMPT,
+        prompt: scoped ? "(None of the requested files exist as source files in this project.)" : "(No source files found to map.)",
+        next: scoped ? "None of the requested files matched project source files. Check the paths passed in `files` \u2014 they must be repo-relative." : "No source files were found. Skip the rest of the playbook and call mason_complete_init."
+      },
+      null,
+      2
+    );
+  }
+  const batchId = batchIdFor(batch.offset);
+  const continueCall = scoped ? `generate_snapshot_batch(dir, offset=${batch.nextOffset}, files=<the same list>)` : `generate_snapshot_batch(dir, offset=${batch.nextOffset})`;
+  return JSON.stringify(
+    {
+      task,
+      offset: batch.offset,
+      nextOffset: batch.nextOffset,
+      totalFiles: batch.totalFiles,
+      batchId,
+      batchSize: batch.batchSize,
+      filesInBatch: batch.skeletons.length,
+      scoped,
+      instructions: BATCH_SYSTEM_PROMPT,
+      prompt: buildBatchPrompt(batch),
+      next: batch.nextOffset === null ? `Derive partial features/flows for this batch and call save_partial_snapshot(dir, batchId="${batchId}", features, flows). This is the last batch \u2014 after saving, proceed to reduce_snapshot.` : `Derive partial features/flows for this batch and call save_partial_snapshot(dir, batchId="${batchId}", features, flows). Then call ${continueCall} to continue.`
+    },
+    null,
+    2
+  );
+}
+async function saveSnapshotPartial(dir, batchId, offset, features, flows) {
+  const rootDir = path14.resolve(dir);
+  for (const feat of Object.values(features)) {
+    feat.files = sanitizePaths(rootDir, feat.files);
+    if (feat.tests) feat.tests = sanitizePaths(rootDir, feat.tests);
+    feat.type = normalizeFeatureType(feat.type);
+  }
+  for (const flow of Object.values(flows)) {
+    flow.chain = sanitizePaths(rootDir, flow.chain);
+  }
+  await savePartial(rootDir, {
+    batchId,
+    offset,
+    features,
+    flows,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const all = await loadAllPartials(rootDir);
+  return JSON.stringify(
+    {
+      status: "stored",
+      batchId,
+      partialsStored: all.length,
+      hint: "Partial saved. Continue with the next generate_snapshot_batch call, or proceed to reduce_snapshot when nextOffset is null."
+    },
+    null,
+    2
+  );
+}
+async function reduceSnapshot(dir) {
+  const rootDir = path14.resolve(dir);
+  const partials = await loadAllPartials(rootDir);
+  if (partials.length === 0) {
+    return JSON.stringify(
+      {
+        status: "error",
+        error: "No partial snapshots found. Run generate_snapshot_batch and save_partial_snapshot at least once before calling reduce_snapshot."
+      },
+      null,
+      2
+    );
+  }
+  const scope = await loadScope(rootDir);
+  const existing = scope && scope.length > 0 ? await loadSnapshot(rootDir) : null;
+  if (scope && existing) {
+    const cleanFeatures = Object.fromEntries(
+      Object.entries(existing.features).map(([name, feat]) => [
+        name,
+        {
+          description: feat.description,
+          files: feat.files,
+          ...feat.tests && feat.tests.length > 0 ? { tests: feat.tests } : {}
+        }
+      ])
+    );
+    const cleanFlows = Object.fromEntries(
+      Object.entries(existing.flows).map(([name, flow]) => [
+        name,
+        { description: flow.description, chain: flow.chain }
+      ])
+    );
+    return JSON.stringify(
+      {
+        task: "Merge a scoped refresh into the existing concept map.",
+        partialsCount: partials.length,
+        refreshedFiles: scope.length,
+        instructions: REFRESH_REDUCE_SYSTEM_PROMPT,
+        prompt: buildRefreshReducePrompt(
+          { features: cleanFeatures, flows: cleanFlows },
+          scope,
+          partials
+        ),
+        next: "Follow `instructions` to produce the COMPLETE updated features/flows (entries untouched by the refresh copied through unchanged), then call save_snapshot(dir, features, flows). Partials and the scope marker are cleaned up automatically after save_snapshot succeeds."
+      },
+      null,
+      2
+    );
+  }
+  return JSON.stringify(
+    {
+      task: "Merge partial concept maps into one unified map.",
+      partialsCount: partials.length,
+      instructions: REDUCE_SYSTEM_PROMPT,
+      prompt: buildReducePrompt(partials),
+      next: "Follow `instructions` to produce the unified features/flows, then call save_snapshot(dir, features, flows). Partial files will be cleaned up automatically after save_snapshot succeeds. Finish with mason_complete_init(dir)."
+    },
+    null,
+    2
+  );
+}
+async function fullAnalysis(dir) {
+  const rootDir = path14.resolve(dir);
+  const [analysis, structure, samples, testMap, snapshot] = await Promise.all([
+    analyzeProject(dir),
+    getProjectStructure(dir),
+    getCodeSamples(dir, 25),
+    getTestMap(dir),
+    loadSnapshot(rootDir)
+  ]);
+  const output = {
+    note: "Full project analysis. Code samples are previews (~60 lines). Read files directly with your own tools to see them in full.",
+    analysis: JSON.parse(analysis),
+    structure: JSON.parse(structure),
+    codeSamples: JSON.parse(samples),
+    testMap: JSON.parse(testMap)
+  };
+  if (snapshot) {
+    output.conceptMap = {
+      updatedAt: snapshot.updatedAt,
+      features: snapshot.features,
+      flows: snapshot.flows
+    };
+    output.note = "Full project analysis with concept map. The concept map shows which files implement each feature and how data flows through them. Use it to jump straight to relevant files instead of exploring, then read them directly with your own tools.";
+  }
+  return JSON.stringify(output, null, 2);
+}
+function sanitizePaths(rootDir, files) {
+  return files.filter((f) => {
+    const resolved = path14.resolve(rootDir, f);
+    return resolved.startsWith(rootDir) && !f.startsWith("/") && !f.includes("..");
+  });
+}
+async function saveSnapshotData(dir, features, flows, removeFeatures = [], removeFlows = []) {
+  const rootDir = path14.resolve(dir);
+  const gitHash = await getCurrentGitHash(rootDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const feat of Object.values(features)) {
+    feat.files = sanitizePaths(rootDir, feat.files);
+    if (feat.tests) feat.tests = sanitizePaths(rootDir, feat.tests);
+    feat.type = normalizeFeatureType(feat.type);
+  }
+  for (const flow of Object.values(flows)) {
+    flow.chain = sanitizePaths(rootDir, flow.chain);
+  }
+  const partials = await loadAllPartials(rootDir);
+  const replaceMode = partials.length > 0;
+  const existing = replaceMode ? null : await loadSnapshot(rootDir);
+  if (existing) {
+    if (existing.gitHash !== "unknown") {
+      for (const feat of Object.values(existing.features)) {
+        feat.refreshedHash ??= existing.gitHash;
+      }
+      for (const flow of Object.values(existing.flows)) {
+        flow.refreshedHash ??= existing.gitHash;
+      }
+    }
+    const removedFeatures = removeFeatures.filter(
+      (name) => name in existing.features
+    );
+    const removedFlows = removeFlows.filter((name) => name in existing.flows);
+    for (const name of removedFeatures) delete existing.features[name];
+    for (const name of removedFlows) delete existing.flows[name];
+    if (gitHash !== "unknown") {
+      for (const feat of Object.values(features)) feat.refreshedHash = gitHash;
+      for (const flow of Object.values(flows)) flow.refreshedHash = gitHash;
+    }
+    existing.features = { ...existing.features, ...features };
+    existing.flows = { ...existing.flows, ...flows };
+    existing.updatedAt = now;
+    existing.gitHash = gitHash;
+    await saveSnapshot(rootDir, existing);
+    await clearAllPartials(rootDir);
+    return JSON.stringify({
+      status: "updated",
+      mode: "merged",
+      features: Object.keys(existing.features).length,
+      flows: Object.keys(existing.flows).length,
+      removedFeatures: removedFeatures.length,
+      removedFlows: removedFlows.length
+    });
+  }
+  const snapshot = {
+    version: 2,
+    createdAt: now,
+    updatedAt: now,
+    gitHash,
+    features,
+    flows
+  };
+  await saveSnapshot(rootDir, snapshot);
+  await clearAllPartials(rootDir);
+  return JSON.stringify({
+    status: replaceMode ? "replaced" : "created",
+    mode: replaceMode ? "replaced-from-partials" : "fresh",
+    features: Object.keys(features).length,
+    flows: Object.keys(flows).length
+  });
+}
+async function getImpact(dir, files) {
+  const rootDir = path14.resolve(dir);
+  if (!await isInitialized(rootDir)) {
+    return uninitializedContextResponse(rootDir, "analyzing change impact");
+  }
+  const { analyzeImpact: analyzeImpact2 } = await Promise.resolve().then(() => (init_impact(), impact_exports));
+  const result = await analyzeImpact2(rootDir, files);
+  return JSON.stringify(result, null, 2);
+}
+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 = path14.resolve(dir);
+  if (!await isInitialized(rootDir)) {
+    return uninitializedResponse("verifying the concept map");
+  }
+  const snapshot = await loadSnapshot(rootDir);
+  if (!snapshot) {
+    return JSON.stringify({
+      exists: false,
+      hint: "No concept map exists yet \u2014 nothing to verify."
+    });
+  }
+  const entries = [
+    ...Object.entries(snapshot.features).map(([name, e]) => ({
+      name,
+      kind: "feature",
+      description: e.description,
+      files: e.files,
+      verifiedAt: e.verifiedAt
+    })),
+    ...Object.entries(snapshot.flows).map(([name, e]) => ({
+      name,
+      kind: "flow",
+      description: e.description,
+      files: e.chain,
+      verifiedAt: e.verifiedAt
+    }))
+  ];
+  entries.sort((a, b) => {
+    if (!a.verifiedAt && !b.verifiedAt) return a.name.localeCompare(b.name);
+    if (!a.verifiedAt) return -1;
+    if (!b.verifiedAt) return 1;
+    return a.verifiedAt.localeCompare(b.verifiedAt);
+  });
+  const picked = entries.slice(0, Math.max(1, sample));
+  const toVerify = [];
+  for (const entry of picked) {
+    const skeletons = [];
+    for (const filePath of entry.files.slice(0, VERIFY_MAX_FILES_PER_ENTRY)) {
+      const full = await readFullFile(rootDir, filePath);
+      if (full) {
+        skeletons.push({
+          path: full.path,
+          content: full.content.slice(0, VERIFY_SKELETON_CHARS)
+        });
+      } else {
+        skeletons.push({ path: filePath, missing: true });
+      }
+    }
+    toVerify.push({
+      name: entry.name,
+      kind: entry.kind,
+      description: entry.description,
+      lastVerified: entry.verifiedAt ?? "never",
+      skeletons,
+      truncated: entry.files.length > VERIFY_MAX_FILES_PER_ENTRY
+    });
+  }
+  const neverVerified = entries.filter((e) => !e.verifiedAt).length;
+  return JSON.stringify({
+    exists: true,
+    totalEntries: entries.length,
+    neverVerified,
+    entries: toVerify,
+    instructions: 'For each entry, judge from the skeletons whether the listed files actually implement the claimed feature/flow (missing files count against it). Then call save_verification with verdicts: {"<entry name>": {"ok": true|false, "note": "<one line, required when ok is false>"}}. Be skeptical \u2014 a plausible description is not evidence; the files must show it.'
+  });
+}
+async function saveVerification(dir, verdicts) {
+  const rootDir = path14.resolve(dir);
+  if (!await isInitialized(rootDir)) {
+    return uninitializedResponse("saving verification verdicts");
+  }
+  const snapshot = await loadSnapshot(rootDir);
+  if (!snapshot) {
+    return JSON.stringify({ exists: false, hint: "No concept map exists." });
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const stamped = [];
+  const unknown = [];
+  const failed = [];
+  for (const [name, verdict] of Object.entries(verdicts)) {
+    const entry = snapshot.features[name] ?? snapshot.flows[name];
+    if (!entry) {
+      unknown.push(name);
+      continue;
+    }
+    entry.verifiedAt = now;
+    if (verdict.ok) {
+      delete entry.verificationFailed;
+      delete entry.verificationNote;
+    } else {
+      entry.verificationFailed = true;
+      entry.verificationNote = verdict.note ?? "verification failed";
+      failed.push(name);
+    }
+    stamped.push(name);
+  }
+  snapshot.updatedAt = now;
+  await saveSnapshot(rootDir, snapshot);
+  return JSON.stringify({
+    stamped,
+    unknown,
+    failed,
+    hint: failed.length > 0 ? `Entries [${failed.join(", ")}] are mis-mapped. Re-map them: read their actual files, correct the entries, and call save_snapshot with only those entries (plus removeFeatures/removeFlows if a concept no longer exists).` : "All sampled entries verified. Re-run verify_snapshot periodically \u2014 it always picks the least-recently-verified entries next."
+  });
+}
+async function saveDecision(dir, input) {
+  const rootDir = path14.resolve(dir);
+  if (!await isInitialized(rootDir)) {
+    return uninitializedResponse("recording team decisions");
+  }
+  const { upsertDecision: upsertDecision2 } = await Promise.resolve().then(() => (init_decisions(), decisions_exports));
+  const result = await upsertDecision2(rootDir, input);
+  return JSON.stringify(result);
+}
+async function getContext(dir, task, files) {
+  const rootDir = path14.resolve(dir);
+  if (!await isInitialized(rootDir)) {
+    return uninitializedContextResponse(rootDir, "assembling task context");
+  }
+  const { assembleContext: assembleContext2 } = await Promise.resolve().then(() => (init_assemble(), assemble_exports));
+  const bundle = await assembleContext2(rootDir, task, files);
+  if (!bundle) {
+    return JSON.stringify({
+      exists: false,
+      hint: "No concept map exists yet. Build one first: generate_snapshot_batch \u2192 save_partial_snapshot \u2192 reduce_snapshot \u2192 save_snapshot."
+    });
+  }
+  return JSON.stringify(bundle);
+}
+async function masonInit(dir) {
+  const rootDir = path14.resolve(dir);
+  const marker = await loadProjectMarker(rootDir);
+  if (marker) {
+    return JSON.stringify(
+      {
+        initialized: true,
+        initializedAt: marker.initializedAt,
+        confluenceConfigured: marker.features?.confluence === true,
+        hint: "This project is already set up for Mason. To refresh the concept map, call generate_snapshot_batch. To (re)configure Confluence, call mason_set_confluence directly."
+      },
+      null,
+      2
+    );
+  }
+  return JSON.stringify(
+    {
+      initialized: false,
+      playbook: setupPlaybook()
+    },
+    null,
+    2
+  );
+}
+async function masonCompleteInit(dir, options = {}) {
+  const rootDir = path14.resolve(dir);
+  const marker = {
+    version: 1,
+    initializedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    features: {
+      confluence: options.confluenceConfigured ?? false
+    }
+  };
+  await saveProjectMarker(rootDir, marker);
+  return JSON.stringify(
+    {
+      status: "initialized",
+      marker,
+      hint: "Setup complete. Future calls to other Mason tools will work normally."
+    },
+    null,
+    2
+  );
+}
+async function masonSetConfluence(input) {
+  const { createConfluenceClient: createConfluenceClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  const { saveConfluenceConfig: saveConfluenceConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { normalizeAtlassianBaseUrl: normalizeAtlassianBaseUrl2 } = await Promise.resolve().then(() => (init_url(), url_exports));
+  let baseUrl;
+  try {
+    baseUrl = normalizeAtlassianBaseUrl2(input.baseUrl);
+  } catch (err) {
+    return JSON.stringify({
+      status: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  if (!input.email.includes("@")) {
+    return JSON.stringify({
+      status: "error",
+      error: `Email looks invalid: "${input.email}".`
+    });
+  }
+  if (!input.apiToken.trim()) {
+    return JSON.stringify({
+      status: "error",
+      error: "API token is required."
+    });
+  }
+  const probeConfig = {
+    baseUrl,
+    email: input.email,
+    apiToken: input.apiToken,
+    spaceKey: input.spaceKey ?? "",
+    parentPageId: input.parentPageId
+  };
+  const client = createConfluenceClient2(probeConfig);
+  let spaces;
+  try {
+    spaces = await client.listSpaces();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("401") || msg.includes("403")) {
+      return JSON.stringify({
+        status: "error",
+        error: "Credentials rejected by Confluence. Re-check the email and that the API token hasn't expired or been revoked."
+      });
+    }
+    return JSON.stringify({
+      status: "error",
+      error: `Confluence validation failed: ${msg}`
+    });
+  }
+  if (!input.spaceKey) {
+    return JSON.stringify(
+      {
+        status: "spaces_listed",
+        baseUrl,
+        spaces: spaces.map((s) => ({ key: s.key, name: s.name })),
+        hint: spaces.length === 0 ? "Authenticated, but no spaces are visible to this account. Create one in Confluence first, then re-run mason_set_confluence." : "Ask the user which space to use, then call mason_set_confluence again with the same baseUrl/email/apiToken plus the chosen spaceKey."
+      },
+      null,
+      2
+    );
+  }
+  const match = spaces.find((s) => s.key === input.spaceKey);
+  if (!match) {
+    return JSON.stringify({
+      status: "error",
+      error: `Space key "${input.spaceKey}" was not found among the spaces visible to this account. Available keys: ${spaces.map((s) => s.key).join(", ") || "(none)"}.`
+    });
+  }
+  await saveConfluenceConfig2({
+    baseUrl,
+    email: input.email,
+    apiToken: input.apiToken,
+    spaceKey: input.spaceKey,
+    parentPageId: input.parentPageId
+  });
+  return JSON.stringify(
+    {
+      status: "saved",
+      spaceKey: input.spaceKey,
+      spaceName: match.name,
+      hint: "Confluence is configured. The credentials are stored in ~/.mason/config.json. Call export_to_confluence to sync the concept map."
+    },
+    null,
+    2
+  );
+}
+async function exportToConfluenceTool(dir, overrides) {
+  const rootDir = path14.resolve(dir);
+  if (!await isInitialized(rootDir)) {
+    return uninitializedResponse("syncing to Confluence");
+  }
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { exportToConfluence: exportToConfluence2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+  const config = await loadConfig2();
+  if (!config?.confluence) {
+    return JSON.stringify({
+      status: "error",
+      error: "No Confluence credentials configured. Call mason_set_confluence first (or re-run mason_init and walk through the Confluence section)."
+    });
+  }
+  const merged = {
+    ...config,
+    confluence: {
+      ...config.confluence,
+      spaceKey: overrides?.spaceKey ?? config.confluence.spaceKey,
+      parentPageId: overrides?.parentPageId ?? config.confluence.parentPageId
+    }
+  };
+  try {
+    const summary = await exportToConfluence2(rootDir, merged, {
+      indexPageTitle: overrides?.indexPageTitle,
+      changelogPageTitle: overrides?.changelogPageTitle,
+      featurePagePrefix: overrides?.featurePagePrefix
+    });
+    return JSON.stringify({ status: "ok", ...summary }, null, 2);
+  } catch (err) {
+    return JSON.stringify({
+      status: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+
+// src/mcp/server.ts
+function createMcpServer() {
+  const server = new McpServer(
+    {
+      name: "mason",
+      version: "0.7.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."
+    }
+  );
+  server.tool(
+    "mason_init",
+    "Start here. Checks if Mason is set up for this project. If not, returns a `playbook` of questions the assistant must walk the user through (concept map + optional Confluence sync). Once the walkthrough is done, call `mason_complete_init`. Idempotent: re-running on an already-initialized project just returns the current state.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory")
+    },
+    async ({ dir }) => {
+      const result = await masonInit(dir);
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.tool(
+    "mason_complete_init",
+    "Mark the project as initialized. Call this after walking the user through the playbook returned by `mason_init`. Writes `.mason/project.json` so future tool calls don't re-run the wizard. Pass `confluenceConfigured: true` if Phase 3 of the playbook ended with Confluence credentials saved.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory"),
+      confluenceConfigured: z.boolean().optional().default(false).describe("True if Confluence was successfully configured during init")
+    },
+    async ({ dir, confluenceConfigured }) => {
+      const result = await masonCompleteInit(dir, { confluenceConfigured });
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Confluence base URL. Accepts `acme`, `acme.atlassian.net`, or `https://acme.atlassian.net` (normalized automatically)."),
+      email: z.string().describe("User's Atlassian account email"),
+      apiToken: z.string().describe("API token from id.atlassian.com/manage-profile/security/api-tokens"),
+      spaceKey: z.string().optional().describe("Confluence space key. Omit on the first call to list available spaces."),
+      parentPageId: z.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({
+        baseUrl,
+        email,
+        apiToken,
+        spaceKey,
+        parentPageId
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Absolute path to the project root directory")
+    },
+    async ({ dir }) => {
+      const result = await fullAnalysis(dir);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Absolute path to the project root directory")
+    },
+    async ({ dir }) => {
+      const result = await analyzeProject(dir);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Absolute path to the project root directory"),
+      count: z.number().optional().default(15).describe("Maximum number of files to sample (default: 15)")
+    },
+    async ({ dir, count }) => {
+      const result = await getCodeSamples(dir, count);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "get_snapshot",
+    "CALL THIS FIRST \u2014 before grep, glob, or reading files \u2014 for any question about what this codebase does, its features, architecture, data flows, or where something is implemented ('where is X handled?', 'how does Y work?', 'what implements Z?'). Returns the persistent feature-to-file concept map in one cheap, instant, LLM-free call, replacing 5-10 exploration round-trips. Example: 'home screen' \u2192 [HomeScreen.kt, HomeViewModel.kt, HomeModule.kt]. Then read only the mapped files. If the map has drifted it says so (with a diff) \u2014 trust the freshness signal. If exists:false, the project isn't set up; offer mason_init.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory")
+    },
+    async ({ dir }) => {
+      const result = await getSnapshot(dir);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "get_context",
+    "CALL THIS FIRST when given a task to implement, a bug to fix, a ticket, or a change request ('add X', 'fix Y', 'refactor Z'). One call returns everything needed to start: the matching features/flows with their files, related tests, blast radius for the key files (git co-change + references), and per-entry freshness \u2014 replacing a get_snapshot + get_impact + test-hunting sequence. Cheap, instant, LLM-free. Pass the task in natural language; optionally pass `files` (e.g. from a diff) to anchor the match. For open-ended architecture questions with no task, use get_snapshot instead.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory"),
+      task: z.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: z.array(z.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);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Absolute path to the project root directory"),
+      offset: z.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: z.number().int().optional().describe("Files per batch. Defaults to 50."),
+      files: z.array(z.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);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Absolute path to the project root directory"),
+      batchId: z.string().describe("The `batchId` returned by `generate_snapshot_batch`."),
+      offset: z.number().int().describe("The `offset` returned by `generate_snapshot_batch`. Used to order partials in the reduce step."),
+      features: z.record(
+        z.object({
+          description: z.string(),
+          files: z.array(z.string()),
+          tests: z.array(z.string()).optional(),
+          type: z.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: z.record(
+        z.object({
+          description: z.string(),
+          chain: z.array(z.string())
+        })
+      ).describe("Partial flows whose entire chain is in this batch. Cross-batch flows are reconstructed in reduce.")
+    },
+    async ({ dir, batchId, offset, features, flows }) => {
+      const result = await saveSnapshotPartial(dir, batchId, offset, features, flows);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Absolute path to the project root directory")
+    },
+    async ({ dir }) => {
+      const result = await reduceSnapshot(dir);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Absolute path to the project root directory"),
+      features: z.record(
+        z.object({
+          description: z.string().describe("One-line description of the feature"),
+          files: z.array(z.string()).describe("File paths that implement this feature"),
+          tests: z.array(z.string()).optional().describe("Test file paths for this feature"),
+          type: z.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: z.record(
+        z.object({
+          description: z.string().describe("One-line description of the flow"),
+          chain: z.array(z.string()).describe("Ordered list of file paths showing data/call flow")
+        })
+      ).describe("Map of flow names to ordered file chains"),
+      removeFeatures: z.array(z.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: z.array(z.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(
+        dir,
+        features,
+        flows,
+        removeFeatures ?? [],
+        removeFlows ?? []
+      );
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "save_decision",
+    "CALL THIS when you learn something about this codebase that the code alone can't tell you: a failed approach ('we tried X, it broke Y'), a deprecation ('don't extend Z'), a workaround and its reason, or a convention settled in review. Best moments: the end of a debugging session, right after a design choice. Records are git-committed to .mason/decisions/ and PR-reviewed like code; get_context surfaces them on matching tasks. Do NOT record anything derivable by reading the code, session trivia, or secrets. Also handles updates (pass id), re-verification (same id + content re-pins to HEAD), and supersession (pass supersedes).",
+    {
+      dir: z.string().describe("Absolute path to the project root directory"),
+      title: z.string().max(80).describe("Short, specific headline \u2014 becomes the stable record id"),
+      body: z.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: z.enum(["decision", "gotcha", "deprecation", "convention"]),
+      files: z.array(z.string()).optional().describe("Repo-relative files this applies to. Anchors drift-checking: if these change, the decision is flagged for re-verification."),
+      id: z.string().optional().describe("Existing decision id to update. Passing id with unchanged content re-verifies it (re-pins refreshedHash to HEAD)."),
+      supersedes: z.string().optional().describe("Id of a decision this one replaces \u2014 the old record is kept but marked superseded"),
+      force: z.boolean().optional().describe("Save even when a near-duplicate was detected")
+    },
+    async ({ dir, title, body, category, files, id, supersedes, force }) => {
+      const result = await saveDecision(dir, {
+        title,
+        body,
+        category,
+        files,
+        id,
+        supersedes,
+        force
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Absolute path to the project root directory")
+    },
+    async ({ dir }) => {
+      const result = await checkDrift(dir);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "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: z.string().describe("Absolute path to the project root directory"),
+      sample: z.number().int().optional().describe("Entries to sample (default 5)")
+    },
+    async ({ dir, sample }) => {
+      const result = await verifySnapshot(dir, sample);
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.tool(
+    "save_verification",
+    "Record verify_snapshot verdicts. Entries judged ok are stamped verifiedAt; failures are flagged verificationFailed with your note and surface in mason_check_drift until re-mapped. Verdict notes are required for failures.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory"),
+      verdicts: z.record(
+        z.object({
+          ok: z.boolean(),
+          note: z.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")
+    },
+    async ({ dir, verdicts }) => {
+      const result = await saveVerification(dir, verdicts);
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  server.tool(
+    "get_impact",
+    "CALL THIS BEFORE editing, refactoring, or assessing the blast radius of any file. Returns three signals you cannot get by reading the file itself: git co-change history (files that historically change in the same commits), references (files that mention the target by name), and related tests. One call replaces a manual sweep of grep + git log. Also the right tool for 'what would break if I changed X?' questions.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory"),
+      files: z.array(z.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);
+      return {
+        content: [{ type: "text", text: result }]
+      };
+    }
+  );
+  server.tool(
+    "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. Hand-edits outside `<!-- mason:start/end:* -->` markers are preserved across syncs. Requires `mason_set_confluence` to have been called first.",
+    {
+      dir: z.string().describe("Absolute path to the project root directory"),
+      spaceKey: z.string().optional().describe("Override the configured space key"),
+      parentPageId: z.string().optional().describe("Override the configured parent page ID"),
+      indexPageTitle: z.string().optional().describe("Title of the index page (default: 'Mason \u2014 System Map')"),
+      changelogPageTitle: z.string().optional().describe("Title of the changelog page (default: 'Mason \u2014 Changelog')"),
+      featurePagePrefix: z.string().optional().describe("Prefix for each feature page title (default: 'Feature: ')")
+    },
+    async ({ dir, spaceKey, parentPageId, indexPageTitle, changelogPageTitle, featurePagePrefix }) => {
+      const result = await exportToConfluenceTool(dir, {
+        spaceKey,
+        parentPageId,
+        indexPageTitle,
+        changelogPageTitle,
+        featurePagePrefix
+      });
+      return { content: [{ type: "text", text: result }] };
+    }
+  );
+  return server;
+}
+async function startMcpServer() {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// bin/mason-mcp.ts
+startMcpServer().catch((err) => {
+  process.stderr.write(`Mason MCP server error: ${err}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=mason-mcp.js.map