@massu/core 1.2.0 → 1.3.0

package/dist/cli.js

@@ -118,13 +118,16 @@ Hint: run \`massu config refresh\` to regenerate a valid config or fix the liste
       name: parsed.project.name,
       root: projectRoot
     },
+    // Spread `fw` first so zod-`.passthrough()` extras (e.g., `framework.swift`,
+    // `framework.python`) survive into the consumer-visible Config. Then override
+    // the v2-backcompat-mirrored router/orm/ui values. Without the spread, the
+    // variant-resolution `pickVariant` (install-commands.ts) cannot see the
+    // top-level passthrough language blocks.
     framework: {
-      type: fw.type,
+      ...fw,
       router,
       orm,
-      ui,
-      primary: fw.primary,
-      languages: fw.languages
+      ui
     },
     paths: parsed.paths,
     toolPrefix: parsed.toolPrefix,
@@ -414,6 +417,7 @@ var init_config = __esm({
     PathsConfigSchema = z.object({
       source: z.string().default("src"),
       aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+      monorepo_roots: z.array(z.string()).optional(),
       routers: z.string().optional(),
       routerRoot: z.string().optional(),
       pages: z.string().optional(),
@@ -1680,15 +1684,30 @@ var init_memory_file_ingest = __esm({
 // src/commands/install-commands.ts
 var install_commands_exports = {};
 __export(install_commands_exports, {
+  hashContent: () => hashContent,
   installAll: () => installAll,
   installCommands: () => installCommands,
+  loadManifest: () => loadManifest,
+  pickVariant: () => pickVariant,
   resolveAssetDir: () => resolveAssetDir,
   resolveCommandsDir: () => resolveCommandsDir,
-  runInstallCommands: () => runInstallCommands
+  runInstallCommands: () => runInstallCommands,
+  runWithManifest: () => runWithManifest,
+  saveManifest: () => saveManifest,
+  syncDirectory: () => syncDirectory
 });
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2, readdirSync as readdirSync2, statSync } from "fs";
-import { resolve as resolve3, dirname as dirname3 } from "path";
+import {
+  existsSync as existsSync4,
+  readFileSync as readFileSync3,
+  writeFileSync,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  statSync,
+  renameSync
+} from "fs";
+import { resolve as resolve3, dirname as dirname3, join as join2 } from "path";
 import { fileURLToPath } from "url";
+import { createHash } from "crypto";
 function resolveAssetDir(assetName) {
   const cwd = process.cwd();
   const nodeModulesPath = resolve3(cwd, "node_modules/@massu/core", assetName);
@@ -1708,42 +1727,189 @@ function resolveAssetDir(assetName) {
 function resolveCommandsDir() {
   return resolveAssetDir("commands");
 }
-function syncDirectory(sourceDir, targetDir) {
-  const stats = { installed: 0, updated: 0, skipped: 0 };
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function loadManifest(claudeDir) {
+  const path = resolve3(claudeDir, MANIFEST_RELPATH);
+  if (!existsSync4(path)) {
+    return emptyManifest();
+  }
+  try {
+    const raw = readFileSync3(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || !parsed.entries) {
+      return emptyManifest();
+    }
+    return parsed;
+  } catch {
+    return emptyManifest();
+  }
+}
+function saveManifest(claudeDir, manifest) {
+  const dir = resolve3(claudeDir, ".massu");
+  if (!existsSync4(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const finalPath = resolve3(dir, "install-manifest.json");
+  const tempPath = finalPath + ".tmp";
+  manifest.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync(tempPath, JSON.stringify(manifest, null, 2), "utf-8");
+  renameSync(tempPath, finalPath);
+}
+function emptyManifest() {
+  return {
+    version: MANIFEST_VERSION,
+    generatedBy: "@massu/core",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entries: {}
+  };
+}
+function runWithManifest(claudeDir, fn) {
+  const manifest = loadManifest(claudeDir);
+  const result = fn(manifest);
+  saveManifest(claudeDir, manifest);
+  return result;
+}
+function pickVariant(baseName, sourceDir, framework) {
+  const candidates = [];
+  const primary = framework.primary ?? framework.type;
+  if (primary && primary !== "multi") {
+    candidates.push(primary);
+  }
+  if (framework.languages) {
+    for (const lang of Object.keys(framework.languages)) {
+      const entry = framework.languages[lang];
+      if (entry && typeof entry.framework === "string" && entry.framework.length > 0) {
+        if (!candidates.includes(lang)) {
+          candidates.push(lang);
+        }
+      }
+    }
+  }
+  const passthrough = framework;
+  for (const lang of PASSTHROUGH_LANG_KEYS) {
+    if (candidates.includes(lang)) continue;
+    const block = passthrough[lang];
+    if (block && typeof block === "object") {
+      const fw = block.framework;
+      if (typeof fw === "string" && fw.length > 0) {
+        candidates.push(lang);
+      }
+    }
+  }
+  for (const cand of candidates) {
+    const path = resolve3(sourceDir, `${baseName}.${cand}.md`);
+    if (existsSync4(path)) {
+      return { kind: "hit", suffix: `.${cand}` };
+    }
+  }
+  const defaultPath = resolve3(sourceDir, `${baseName}.md`);
+  if (existsSync4(defaultPath)) {
+    return { kind: "hit", suffix: "" };
+  }
+  if (framework.type === "multi" && !framework.primary) {
+    process.stderr.write(
+      "massu: warning - framework.type=multi but framework.primary is undefined; falling back to default templates\n"
+    );
+    return { kind: "fallback", reason: "multi-without-primary" };
+  }
+  return { kind: "miss" };
+}
+function isVariantFilename(entry) {
+  return /^[^.]+\.[^.]+\.md$/.test(entry);
+}
+function syncDirectory(sourceDir, targetDir, framework, manifest, manifestKeyPrefix, topLevel = true) {
+  const stats = { installed: 0, updated: 0, skipped: 0, kept: 0 };
   if (!existsSync4(targetDir)) {
     mkdirSync2(targetDir, { recursive: true });
   }
   const entries = readdirSync2(sourceDir);
   for (const entry of entries) {
     const sourcePath = resolve3(sourceDir, entry);
-    const targetPath = resolve3(targetDir, entry);
     const entryStat = statSync(sourcePath);
     if (entryStat.isDirectory()) {
-      const subStats = syncDirectory(sourcePath, targetPath);
+      const subTargetDir = resolve3(targetDir, entry);
+      const subPrefix = manifestKeyPrefix === "" ? entry : `${manifestKeyPrefix}/${entry}`;
+      const subStats = syncDirectory(
+        sourcePath,
+        subTargetDir,
+        framework,
+        manifest,
+        subPrefix,
+        false
+      );
       stats.installed += subStats.installed;
       stats.updated += subStats.updated;
       stats.skipped += subStats.skipped;
-    } else if (entry.endsWith(".md")) {
-      const sourceContent = readFileSync3(sourcePath, "utf-8");
-      if (existsSync4(targetPath)) {
-        const existingContent = readFileSync3(targetPath, "utf-8");
-        if (existingContent === sourceContent) {
-          stats.skipped++;
-          continue;
-        }
-        writeFileSync(targetPath, sourceContent, "utf-8");
-        stats.updated++;
-      } else {
-        writeFileSync(targetPath, sourceContent, "utf-8");
-        stats.installed++;
+      stats.kept += subStats.kept;
+      continue;
+    }
+    if (!entry.endsWith(".md")) continue;
+    let sourceFilename = entry;
+    let baseName = entry.slice(0, -".md".length);
+    if (topLevel) {
+      if (isVariantFilename(entry)) continue;
+      const choice = pickVariant(baseName, sourceDir, framework);
+      if (choice.kind === "miss") {
+        continue;
       }
+      const suffix = choice.kind === "hit" ? choice.suffix : "";
+      sourceFilename = suffix === "" ? `${baseName}.md` : `${baseName}${suffix}.md`;
+    }
+    const resolvedSourcePath = resolve3(sourceDir, sourceFilename);
+    if (!existsSync4(resolvedSourcePath)) {
+      continue;
+    }
+    const targetFilename = topLevel ? `${baseName}.md` : entry;
+    const targetPath = resolve3(targetDir, targetFilename);
+    const sourceContent = readFileSync3(resolvedSourcePath, "utf-8");
+    const sourceHash = hashContent(sourceContent);
+    const manifestKey = manifestKeyPrefix === "" ? targetFilename : `${manifestKeyPrefix}/${targetFilename}`;
+    const lastInstalledHash = manifest.entries[manifestKey];
+    if (existsSync4(targetPath)) {
+      const existingContent = readFileSync3(targetPath, "utf-8");
+      const existingHash = hashContent(existingContent);
+      if (existingHash === sourceHash) {
+        manifest.entries[manifestKey] = sourceHash;
+        stats.skipped++;
+        continue;
+      }
+      if (lastInstalledHash === void 0) {
+        manifest.entries[manifestKey] = existingHash;
+        process.stderr.write(
+          `First-install heuristic: keeping existing ${targetPath} (differs from upstream).
+  To accept upstream: rm ${targetPath} && npx massu install-commands
+`
+        );
+        stats.kept++;
+        continue;
+      }
+      if (existingHash !== lastInstalledHash) {
+        process.stderr.write(
+          `${targetFilename} has local edits - kept your version.
+  To accept upstream: rm ${targetPath} && npx massu install-commands
+  To diff:            diff ${targetPath} <(npx massu show-template ${baseName})
+`
+        );
+        stats.kept++;
+        continue;
+      }
+      writeFileSync(targetPath, sourceContent, "utf-8");
+      manifest.entries[manifestKey] = sourceHash;
+      stats.updated++;
+    } else {
+      writeFileSync(targetPath, sourceContent, "utf-8");
+      manifest.entries[manifestKey] = sourceHash;
+      stats.installed++;
     }
   }
   return stats;
 }
 function installCommands(projectRoot) {
   const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
-  const targetDir = resolve3(projectRoot, claudeDirName, "commands");
+  const claudeDir = resolve3(projectRoot, claudeDirName);
+  const targetDir = resolve3(claudeDir, "commands");
   if (!existsSync4(targetDir)) {
     mkdirSync2(targetDir, { recursive: true });
   }
@@ -1751,9 +1917,13 @@ function installCommands(projectRoot) {
   if (!sourceDir) {
     console.error("  ERROR: Could not find massu commands directory.");
     console.error("  Try reinstalling: npm install @massu/core");
-    return { installed: 0, updated: 0, skipped: 0, commandsDir: targetDir };
+    return { installed: 0, updated: 0, skipped: 0, kept: 0, commandsDir: targetDir };
   }
-  const stats = syncDirectory(sourceDir, targetDir);
+  const framework = getConfig().framework;
+  const stats = runWithManifest(
+    claudeDir,
+    (manifest) => syncDirectory(sourceDir, targetDir, framework, manifest, "commands", true)
+  );
   return { ...stats, commandsDir: targetDir };
 }
 function installAll(projectRoot) {
@@ -1763,19 +1933,36 @@ function installAll(projectRoot) {
   let totalInstalled = 0;
   let totalUpdated = 0;
   let totalSkipped = 0;
-  for (const assetType of ASSET_TYPES) {
-    const sourceDir = resolveAssetDir(assetType.name);
-    if (!sourceDir) {
-      continue;
+  let totalKept = 0;
+  const framework = getConfig().framework;
+  runWithManifest(claudeDir, (manifest) => {
+    for (const assetType of ASSET_TYPES) {
+      const sourceDir = resolveAssetDir(assetType.name);
+      if (!sourceDir) continue;
+      const targetDir = resolve3(claudeDir, assetType.targetSubdir);
+      const stats = syncDirectory(
+        sourceDir,
+        targetDir,
+        framework,
+        manifest,
+        assetType.targetSubdir,
+        true
+      );
+      assets[assetType.name] = stats;
+      totalInstalled += stats.installed;
+      totalUpdated += stats.updated;
+      totalSkipped += stats.skipped;
+      totalKept += stats.kept;
     }
-    const targetDir = resolve3(claudeDir, assetType.targetSubdir);
-    const stats = syncDirectory(sourceDir, targetDir);
-    assets[assetType.name] = stats;
-    totalInstalled += stats.installed;
-    totalUpdated += stats.updated;
-    totalSkipped += stats.skipped;
-  }
-  return { assets, totalInstalled, totalUpdated, totalSkipped, claudeDir };
+  });
+  return {
+    assets,
+    totalInstalled,
+    totalUpdated,
+    totalSkipped,
+    totalKept,
+    claudeDir
+  };
 }
 async function runInstallCommands() {
   const projectRoot = process.cwd();
@@ -1789,23 +1976,29 @@ async function runInstallCommands() {
     if (!stats) {
       continue;
     }
-    const total = stats.installed + stats.updated + stats.skipped;
+    const total = stats.installed + stats.updated + stats.skipped + stats.kept;
     if (total === 0) continue;
     const parts = [];
     if (stats.installed > 0) parts.push(`${stats.installed} new`);
     if (stats.updated > 0) parts.push(`${stats.updated} updated`);
     if (stats.skipped > 0) parts.push(`${stats.skipped} current`);
+    if (stats.kept > 0) parts.push(`${stats.kept} kept (local edits)`);
     const description = assetType.description;
     console.log(`  ${description}: ${parts.join(", ")} (${total} total)`);
   }
-  const grandTotal = result.totalInstalled + result.totalUpdated + result.totalSkipped;
+  const grandTotal = result.totalInstalled + result.totalUpdated + result.totalSkipped + result.totalKept;
   console.log("");
   console.log(`  ${grandTotal} total files synced to ${result.claudeDir}`);
+  if (result.totalKept > 0) {
+    console.log(
+      `  ${result.totalKept} file(s) had local edits and were preserved (see stderr above).`
+    );
+  }
   console.log("");
   console.log("  Restart your Claude Code session to use them.");
   console.log("");
 }
-var __filename, __dirname, ASSET_TYPES;
+var __filename, __dirname, ASSET_TYPES, MANIFEST_VERSION, MANIFEST_RELPATH, PASSTHROUGH_LANG_KEYS;
 var init_install_commands = __esm({
   "src/commands/install-commands.ts"() {
     "use strict";
@@ -1819,6 +2012,16 @@ var init_install_commands = __esm({
       { name: "protocols", targetSubdir: "protocols", description: "protocol files" },
       { name: "reference", targetSubdir: "reference", description: "reference files" }
     ];
+    MANIFEST_VERSION = 1;
+    MANIFEST_RELPATH = join2(".massu", "install-manifest.json");
+    PASSTHROUGH_LANG_KEYS = [
+      "typescript",
+      "javascript",
+      "python",
+      "swift",
+      "rust",
+      "go"
+    ];
   }
 });
 
@@ -7797,41 +8000,41 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p19 = new Promise(function(resolve25, reject) {
+        var p19 = new Promise(function(resolve26, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve25(result);
+            resolve26(result);
           });
         });
         p19.catch(noop);
         return p19;
       }
       function unshift(value) {
-        var p19 = new Promise(function(resolve25, reject) {
+        var p19 = new Promise(function(resolve26, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve25(result);
+            resolve26(result);
           });
         });
         p19.catch(noop);
         return p19;
       }
       function drained() {
-        var p19 = new Promise(function(resolve25) {
+        var p19 = new Promise(function(resolve26) {
           process.nextTick(function() {
             if (queue.idle()) {
-              resolve25();
+              resolve26();
             } else {
               var previousDrain = queue.drain;
               queue.drain = function() {
                 if (typeof previousDrain === "function") previousDrain();
-                resolve25();
+                resolve26();
                 queue.drain = previousDrain;
               };
             }
@@ -8317,9 +8520,9 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve25, reject) => {
+        return new Promise((resolve26, reject) => {
           this._stat(filepath, this._fsStatSettings, (error, stats) => {
-            return error === null ? resolve25(stats) : reject(error);
+            return error === null ? resolve26(stats) : reject(error);
           });
         });
       }
@@ -8343,10 +8546,10 @@ var require_async5 = __commonJS({
         this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root, options) {
-        return new Promise((resolve25, reject) => {
+        return new Promise((resolve26, reject) => {
           this._walkAsync(root, options, (error, entries) => {
             if (error === null) {
-              resolve25(entries);
+              resolve26(entries);
             } else {
               reject(error);
             }
@@ -8356,10 +8559,10 @@ var require_async5 = __commonJS({
       async static(patterns, options) {
         const entries = [];
         const stream = this._readerStream.static(patterns, options);
-        return new Promise((resolve25, reject) => {
+        return new Promise((resolve26, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
-          stream.once("end", () => resolve25(entries));
+          stream.once("end", () => resolve26(entries));
         });
       }
     };
@@ -9022,6 +9225,13 @@ import { resolve as resolve4 } from "path";
 function extsFor(language) {
   return EXTENSIONS[language] ?? [];
 }
+function extsWithFallback(language, fallbackTsForJs) {
+  const base = extsFor(language);
+  if (language === "javascript" && fallbackTsForJs) {
+    return [...base, "ts", "tsx"];
+  }
+  return base;
+}
 function isTestPath(language, path) {
   const segments = path.split("/");
   for (const seg of segments) {
@@ -9043,10 +9253,11 @@ function isInsideRoot(root, candidate) {
     return false;
   }
 }
-function detectSourceDirs(projectRoot, languages) {
+function detectSourceDirs(projectRoot, languages, opts) {
+  const fallbackTsForJs = opts?.fallbackTsForJs ?? false;
   const out = {};
   for (const lang of languages) {
-    const exts = extsFor(lang);
+    const exts = extsWithFallback(lang, fallbackTsForJs);
     if (exts.length === 0) continue;
     const patterns = exts.map((e2) => `**/*.${e2}`);
     let files;
@@ -9644,8 +9855,9 @@ async function runDetection(projectRoot, overrides) {
   const languages = Array.from(
     new Set(pkg.manifests.map((m3) => m3.language))
   );
+  const fallbackTsForJs = languages.includes("javascript") && !languages.includes("typescript");
   const [sourceDirs, monorepo] = await Promise.all([
-    Promise.resolve(detectSourceDirs(projectRoot, languages)),
+    Promise.resolve(detectSourceDirs(projectRoot, languages, { fallbackTsForJs })),
     Promise.resolve(detectMonorepo(projectRoot))
   ]);
   const domains = inferDomains(projectRoot, monorepo, sourceDirs);
@@ -9687,7 +9899,7 @@ var init_detect = __esm({
 });
 
 // src/detect/drift.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function summarizeDetection(det) {
   const languages = Array.from(new Set(det.manifests.map((m3) => m3.language))).sort();
   const frameworks = {};
@@ -9718,7 +9930,7 @@ function summarizeDetection(det) {
 function computeFingerprint(det) {
   const data = summarizeDetection(det);
   const stable = JSON.stringify(data, Object.keys(data).sort());
-  return createHash("sha256").update(stable).digest("hex");
+  return createHash2("sha256").update(stable).digest("hex");
 }
 function stringOf(v3) {
   if (typeof v3 === "string") return v3;
@@ -10876,7 +11088,7 @@ __export(init_exports, {
   validateWrittenConfig: () => validateWrittenConfig,
   writeConfigAtomic: () => writeConfigAtomic
 });
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync6, renameSync, rmSync, statSync as statSync4, chmodSync } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync6, renameSync as renameSync2, rmSync, statSync as statSync4, chmodSync } from "fs";
 import { resolve as resolve5, basename as basename2, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { homedir as homedir2 } from "os";
@@ -10978,6 +11190,9 @@ function detectPython(projectRoot) {
   return result;
 }
 function generateConfig(projectRoot, framework) {
+  console.warn(
+    "[@massu/core] generateConfig() is deprecated since 1.2.1 \u2014 use buildConfigFromDetection instead. It cannot produce valid configs for monorepos."
+  );
   const configPath = resolve5(projectRoot, "massu.config.yaml");
   if (existsSync8(configPath)) {
     return false;
@@ -11028,6 +11243,20 @@ ${yamlStringify(config)}`;
   writeFileSync2(configPath, yamlContent, "utf-8");
   return true;
 }
+function monorepoCommonRoot(packages) {
+  const roots = monorepoDistinctRoots(packages);
+  return roots.length === 1 ? roots[0] : ".";
+}
+function monorepoDistinctRoots(packages) {
+  const set = /* @__PURE__ */ new Set();
+  for (const p19 of packages) {
+    const parts = p19.path.split("/");
+    if (parts.length > 1 && parts[0] !== "" && parts[0] !== ".") {
+      set.add(parts[0]);
+    }
+  }
+  return [...set].sort();
+}
 function buildConfigFromDetection(opts) {
   const { projectRoot, detection } = opts;
   if (!detection) {
@@ -11072,6 +11301,16 @@ function buildConfigFromDetection(opts) {
     const primaryDirs = detection.sourceDirs[primary]?.source_dirs ?? [];
     if (primaryDirs.length > 0) {
       pathsSource = primaryDirs[0];
+    } else if (detection.monorepo.type !== "single" && detection.monorepo.packages.length > 0) {
+      pathsSource = monorepoCommonRoot(detection.monorepo.packages);
+    }
+  }
+  let monorepoRoots;
+  if (detection.monorepo.type !== "single") {
+    if (detection.monorepo.packages.length > 0) {
+      monorepoRoots = monorepoDistinctRoots(detection.monorepo.packages);
+    } else if (pathsSource !== "src" && pathsSource !== ".") {
+      monorepoRoots = [pathsSource];
     }
   }
   const verification = {};
@@ -11108,6 +11347,13 @@ function buildConfigFromDetection(opts) {
   if (Object.keys(languageEntries).length > 0) {
     frameworkBlock.languages = languageEntries;
   }
+  const pathsBlock = {
+    source: pathsSource,
+    aliases: { "@": pathsSource }
+  };
+  if (monorepoRoots && monorepoRoots.length > 0) {
+    pathsBlock.monorepo_roots = monorepoRoots;
+  }
   const config = {
     schema_version: 2,
     project: {
@@ -11115,10 +11361,7 @@ function buildConfigFromDetection(opts) {
       root: "auto"
     },
     framework: frameworkBlock,
-    paths: {
-      source: pathsSource,
-      aliases: { "@": pathsSource }
-    },
+    paths: pathsBlock,
     toolPrefix: "massu",
     domains,
     rules: []
@@ -11167,7 +11410,7 @@ function writeConfigAtomic(configPath, content) {
     if (parsed === null || typeof parsed !== "object") {
       throw new Error("Generated config is not a valid YAML object");
     }
-    renameSync(tmpPath, configPath);
+    renameSync2(tmpPath, configPath);
     if (existingMode !== void 0) {
       try {
         chmodSync(configPath, existingMode);
@@ -11225,6 +11468,15 @@ function validateWrittenConfig(configPath, projectRoot, checkPaths = true) {
             }
           }
         }
+        const mRoots = cfg.paths.monorepo_roots;
+        if (Array.isArray(mRoots)) {
+          for (const r2 of mRoots) {
+            if (typeof r2 !== "string" || r2 === ".") continue;
+            if (!existsSync8(resolve5(projectRoot, r2))) {
+              return `paths.monorepo_roots '${r2}' does not exist on disk`;
+            }
+          }
+        }
       }
     } catch (err) {
       return err instanceof Error ? err.message : String(err);
@@ -11736,7 +11988,7 @@ var init_init = __esm({
 });
 
 // src/license.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function tierLevel(tier) {
   return TIER_LEVELS[tier] ?? 0;
 }
@@ -11761,7 +12013,7 @@ function annotateToolDefinitions(defs) {
   });
 }
 async function validateLicense(apiKey) {
-  const keyHash = createHash2("sha256").update(apiKey).digest("hex");
+  const keyHash = createHash3("sha256").update(apiKey).digest("hex");
   const memDb = getMemoryDb();
   try {
     const cached = memDb.prepare(
@@ -11822,7 +12074,7 @@ async function validateLicense(apiKey) {
   }
 }
 function updateLicenseCache(apiKey, tier, validUntil, features = []) {
-  const keyHash = createHash2("sha256").update(apiKey).digest("hex");
+  const keyHash = createHash3("sha256").update(apiKey).digest("hex");
   const memDb = getMemoryDb();
   try {
     memDb.prepare(`
@@ -12438,13 +12690,64 @@ var init_install_hooks = __esm({
   }
 });
 
+// src/commands/show-template.ts
+var show_template_exports = {};
+__export(show_template_exports, {
+  runShowTemplate: () => runShowTemplate
+});
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve7 } from "path";
+function normalizeBaseName(input) {
+  return input.endsWith(".md") ? input.slice(0, -".md".length) : input;
+}
+async function runShowTemplate(args2) {
+  const rawName = args2[0];
+  if (!rawName) {
+    process.stderr.write("massu: show-template requires a template name\n");
+    process.stderr.write("  usage: massu show-template <name>\n");
+    process.exit(1);
+    return;
+  }
+  const baseName = normalizeBaseName(rawName);
+  const sourceDir = resolveAssetDir("commands");
+  if (!sourceDir) {
+    process.stderr.write("massu: could not locate the bundled commands directory\n");
+    process.exit(1);
+    return;
+  }
+  const framework = getConfig().framework;
+  const choice = pickVariant(baseName, sourceDir, framework);
+  if (choice.kind === "miss") {
+    process.stderr.write(`massu: no template named "${baseName}" found
+`);
+    process.exit(1);
+    return;
+  }
+  const suffix = choice.kind === "hit" ? choice.suffix : "";
+  const file = suffix === "" ? resolve7(sourceDir, `${baseName}.md`) : resolve7(sourceDir, `${baseName}${suffix}.md`);
+  if (!existsSync10(file)) {
+    process.stderr.write(`massu: resolved template "${file}" no longer exists
+`);
+    process.exit(1);
+    return;
+  }
+  process.stdout.write(readFileSync8(file, "utf-8"));
+}
+var init_show_template = __esm({
+  "src/commands/show-template.ts"() {
+    "use strict";
+    init_config();
+    init_install_commands();
+  }
+});
+
 // src/db.ts
 import Database2 from "better-sqlite3";
 import { dirname as dirname6, join as join6 } from "path";
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
 function getCodeGraphDb() {
   const dbPath = getResolvedPaths().codegraphDbPath;
-  if (!existsSync10(dbPath)) {
+  if (!existsSync11(dbPath)) {
     throw new Error(`CodeGraph database not found at ${dbPath}. Run 'npx @colbymchenry/codegraph sync' first.`);
   }
   const db = new Database2(dbPath, { readonly: true });
@@ -12454,7 +12757,7 @@ function getCodeGraphDb() {
 function getDataDb() {
   const dbPath = getResolvedPaths().dataDbPath;
   const dir = dirname6(dbPath);
-  if (!existsSync10(dir)) {
+  if (!existsSync11(dir)) {
     mkdirSync4(dir, { recursive: true });
   }
   const db = new Database2(dbPath);
@@ -12752,10 +13055,10 @@ var init_db = __esm({
 });
 
 // src/security-utils.ts
-import { resolve as resolve7, normalize } from "path";
+import { resolve as resolve8, normalize } from "path";
 function ensureWithinRoot(filePath, projectRoot) {
-  const resolvedRoot = resolve7(projectRoot);
-  const resolvedPath = resolve7(resolvedRoot, filePath);
+  const resolvedRoot = resolve8(projectRoot);
+  const resolvedPath = resolve8(resolvedRoot, filePath);
   const normalizedPath = normalize(resolvedPath);
   const normalizedRoot = normalize(resolvedRoot);
   if (!normalizedPath.startsWith(normalizedRoot + "/") && normalizedPath !== normalizedRoot) {
@@ -12828,8 +13131,8 @@ var init_rules = __esm({
 });
 
 // src/import-resolver.ts
-import { readFileSync as readFileSync8, existsSync as existsSync11, statSync as statSync6 } from "fs";
-import { resolve as resolve8, dirname as dirname7, join as join7 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync12, statSync as statSync6 } from "fs";
+import { resolve as resolve9, dirname as dirname7, join as join7 } from "path";
 function parseImports(source) {
   const imports = [];
   const lines = source.split("\n");
@@ -12885,23 +13188,23 @@ function resolveImportPath(specifier, fromFile) {
   let basePath;
   if (specifier.startsWith("@/")) {
     const paths = getResolvedPaths();
-    basePath = resolve8(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
+    basePath = resolve9(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
   } else {
-    basePath = resolve8(dirname7(fromFile), specifier);
+    basePath = resolve9(dirname7(fromFile), specifier);
   }
-  if (existsSync11(basePath) && !isDirectory(basePath)) {
+  if (existsSync12(basePath) && !isDirectory(basePath)) {
     return toRelative(basePath);
   }
   const resolvedPaths = getResolvedPaths();
   for (const ext of resolvedPaths.extensions) {
     const withExt = basePath + ext;
-    if (existsSync11(withExt)) {
+    if (existsSync12(withExt)) {
       return toRelative(withExt);
     }
   }
   for (const indexFile of resolvedPaths.indexFiles) {
     const indexPath = join7(basePath, indexFile);
-    if (existsSync11(indexPath)) {
+    if (existsSync12(indexPath)) {
       return toRelative(indexPath);
     }
   }
@@ -12937,11 +13240,11 @@ function buildImportIndex(dataDb2, codegraphDb2) {
   const batchSize = 500;
   let batch = [];
   for (const file of files) {
-    const absPath = ensureWithinRoot(resolve8(projectRoot, file.path), projectRoot);
-    if (!existsSync11(absPath)) continue;
+    const absPath = ensureWithinRoot(resolve9(projectRoot, file.path), projectRoot);
+    if (!existsSync12(absPath)) continue;
     let source;
     try {
-      source = readFileSync8(absPath, "utf-8");
+      source = readFileSync9(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -12977,15 +13280,15 @@ var init_import_resolver = __esm({
 });
 
 // src/trpc-index.ts
-import { readFileSync as readFileSync9, existsSync as existsSync12, readdirSync as readdirSync9 } from "fs";
-import { resolve as resolve9, join as join8 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync13, readdirSync as readdirSync9 } from "fs";
+import { resolve as resolve10, join as join8 } from "path";
 function parseRootRouter() {
   const paths = getResolvedPaths();
   const rootPath = paths.rootRouterPath;
-  if (!existsSync12(rootPath)) {
+  if (!existsSync13(rootPath)) {
     throw new Error(`Root router not found at ${rootPath}`);
   }
-  const source = readFileSync9(rootPath, "utf-8");
+  const source = readFileSync10(rootPath, "utf-8");
   const mappings = [];
   const importMap = /* @__PURE__ */ new Map();
   const importRegex = /import\s+\{[^}]*?(\w+Router)[^}]*\}\s+from\s+['"]\.\/routers\/([^'"]+)['"]/g;
@@ -12993,16 +13296,16 @@ function parseRootRouter() {
   while ((match = importRegex.exec(source)) !== null) {
     const variable = match[1];
     let filePath = match[2];
-    const fullPath = resolve9(paths.routersDir, filePath);
+    const fullPath = resolve10(paths.routersDir, filePath);
     for (const ext of [".ts", ".tsx", ""]) {
       const candidate = fullPath + ext;
       const routersRelPath = getConfig().paths.routers ?? "src/server/api/routers";
-      if (existsSync12(candidate)) {
+      if (existsSync13(candidate)) {
         filePath = routersRelPath + "/" + filePath + ext;
         break;
       }
       const indexCandidate = join8(fullPath, "index.ts");
-      if (existsSync12(indexCandidate)) {
+      if (existsSync13(indexCandidate)) {
         filePath = routersRelPath + "/" + filePath + "/index.ts";
         break;
       }
@@ -13021,9 +13324,9 @@ function parseRootRouter() {
   return mappings;
 }
 function extractProcedures(routerFilePath) {
-  const absPath = resolve9(getProjectRoot(), routerFilePath);
-  if (!existsSync12(absPath)) return [];
-  const source = readFileSync9(absPath, "utf-8");
+  const absPath = resolve10(getProjectRoot(), routerFilePath);
+  if (!existsSync13(absPath)) return [];
+  const source = readFileSync10(absPath, "utf-8");
   const procedures = [];
   const seen = /* @__PURE__ */ new Set();
   const procRegex = /(\w+)\s*:\s*(protected|public)Procedure/g;
@@ -13046,13 +13349,13 @@ function findUICallSites(routerKey, procedureName) {
   const root = getProjectRoot();
   const src = config.paths.source;
   const searchDirs = [
-    resolve9(root, config.paths.pages ?? src + "/app"),
-    resolve9(root, config.paths.components ?? src + "/components"),
-    resolve9(root, config.paths.hooks ?? src + "/hooks")
+    resolve10(root, config.paths.pages ?? src + "/app"),
+    resolve10(root, config.paths.components ?? src + "/components"),
+    resolve10(root, config.paths.hooks ?? src + "/hooks")
   ];
   const searchPattern = `api.${routerKey}.${procedureName}`;
   for (const dir of searchDirs) {
-    if (!existsSync12(dir)) continue;
+    if (!existsSync13(dir)) continue;
     searchDirectory(dir, searchPattern, callSites);
   }
   return callSites;
@@ -13066,7 +13369,7 @@ function searchDirectory(dir, pattern, results) {
       searchDirectory(fullPath, pattern, results);
     } else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
       try {
-        const source = readFileSync9(fullPath, "utf-8");
+        const source = readFileSync10(fullPath, "utf-8");
         const lines = source.split("\n");
         for (let i = 0; i < lines.length; i++) {
           if (lines[i].includes(pattern)) {
@@ -13129,8 +13432,8 @@ var init_trpc_index = __esm({
 });
 
 // src/page-deps.ts
-import { readFileSync as readFileSync10, existsSync as existsSync13 } from "fs";
-import { resolve as resolve10 } from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync14 } from "fs";
+import { resolve as resolve11 } from "path";
 function deriveRoute(pageFile) {
   let route = pageFile.replace(/^src\/app/, "").replace(/\/page\.tsx?$/, "").replace(/\/page\.jsx?$/, "");
   return route || "/";
@@ -13168,10 +13471,10 @@ function findRouterCalls(files) {
   const routers = /* @__PURE__ */ new Set();
   const projectRoot = getProjectRoot();
   for (const file of files) {
-    const absPath = ensureWithinRoot(resolve10(projectRoot, file), projectRoot);
-    if (!existsSync13(absPath)) continue;
+    const absPath = ensureWithinRoot(resolve11(projectRoot, file), projectRoot);
+    if (!existsSync14(absPath)) continue;
     try {
-      const source = readFileSync10(absPath, "utf-8");
+      const source = readFileSync11(absPath, "utf-8");
       const apiCallRegex = /api\.(\w+)\.\w+/g;
       let match;
       while ((match = apiCallRegex.exec(source)) !== null) {
@@ -13189,10 +13492,10 @@ function findTablesFromRouters(routerNames, dataDb2) {
       "SELECT DISTINCT router_file FROM massu_trpc_procedures WHERE router_name = ?"
     ).all(routerName);
     for (const proc of procs) {
-      const absPath = ensureWithinRoot(resolve10(getProjectRoot(), proc.router_file), getProjectRoot());
-      if (!existsSync13(absPath)) continue;
+      const absPath = ensureWithinRoot(resolve11(getProjectRoot(), proc.router_file), getProjectRoot());
+      if (!existsSync14(absPath)) continue;
       try {
-        const source = readFileSync10(absPath, "utf-8");
+        const source = readFileSync11(absPath, "utf-8");
         const dbPattern = getConfig().dbAccessPattern ?? "ctx.db.{table}";
         const regexStr = dbPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\{table\\}", "(\\w+)");
         const tableRegex = new RegExp(regexStr + "\\.", "g");
@@ -13461,14 +13764,14 @@ var init_domains = __esm({
 });
 
 // src/schema-mapper.ts
-import { readFileSync as readFileSync11, existsSync as existsSync14, readdirSync as readdirSync10 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync15, readdirSync as readdirSync10 } from "fs";
 import { join as join9 } from "path";
 function parsePrismaSchema() {
   const schemaPath = getResolvedPaths().prismaSchemaPath;
-  if (!existsSync14(schemaPath)) {
+  if (!existsSync15(schemaPath)) {
     throw new Error(`Prisma schema not found at ${schemaPath}`);
   }
-  const source = readFileSync11(schemaPath, "utf-8");
+  const source = readFileSync12(schemaPath, "utf-8");
   const models = [];
   const sourceLines = source.split("\n");
   let i = 0;
@@ -13526,7 +13829,7 @@ function toSnakeCase(str) {
 function findColumnUsageInRouters(tableName) {
   const usage = /* @__PURE__ */ new Map();
   const routersDir = getResolvedPaths().routersDir;
-  if (!existsSync14(routersDir)) return usage;
+  if (!existsSync15(routersDir)) return usage;
   scanDirectory(routersDir, tableName, usage);
   return usage;
 }
@@ -13543,7 +13846,7 @@ function scanDirectory(dir, tableName, usage) {
 }
 function scanFile(absPath, tableName, usage) {
   try {
-    const source = readFileSync11(absPath, "utf-8");
+    const source = readFileSync12(absPath, "utf-8");
     if (!source.includes(tableName)) return;
     const relPath = absPath.slice(getProjectRoot().length + 1);
     const lines = source.split("\n");
@@ -13588,7 +13891,7 @@ function detectMismatches(models) {
 }
 function findFilesUsingColumn(dir, column, tableName) {
   const result = [];
-  if (!existsSync14(dir)) return result;
+  if (!existsSync15(dir)) return result;
   const entries = readdirSync10(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join9(dir, entry.name);
@@ -13596,7 +13899,7 @@ function findFilesUsingColumn(dir, column, tableName) {
       result.push(...findFilesUsingColumn(fullPath, column, tableName));
     } else if (entry.name.endsWith(".ts")) {
       try {
-        const source = readFileSync11(fullPath, "utf-8");
+        const source = readFileSync12(fullPath, "utf-8");
         if (source.includes(tableName) && source.includes(column)) {
           result.push(fullPath.slice(getProjectRoot().length + 1));
         }
@@ -13741,12 +14044,12 @@ var init_import_parser = __esm({
 });
 
 // src/python/import-resolver.ts
-import { readFileSync as readFileSync12, existsSync as existsSync15, readdirSync as readdirSync11 } from "fs";
-import { resolve as resolve12, join as join10, relative as relative4, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync16, readdirSync as readdirSync11 } from "fs";
+import { resolve as resolve13, join as join10, relative as relative4, dirname as dirname8 } from "path";
 function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
   const projectRoot = getProjectRoot();
   if (level > 0) {
-    let baseDir = dirname8(resolve12(projectRoot, fromFile));
+    let baseDir = dirname8(resolve13(projectRoot, fromFile));
     for (let i = 1; i < level; i++) {
       baseDir = dirname8(baseDir);
     }
@@ -13758,17 +14061,17 @@ function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
     return tryResolvePythonPath(baseDir, projectRoot);
   }
   const parts = module.split(".");
-  const candidate = join10(resolve12(projectRoot, pythonRoot), ...parts);
+  const candidate = join10(resolve13(projectRoot, pythonRoot), ...parts);
   return tryResolvePythonPath(candidate, projectRoot);
 }
 function tryResolvePythonPath(basePath, projectRoot) {
-  if (existsSync15(basePath + ".py")) {
+  if (existsSync16(basePath + ".py")) {
     return relative4(projectRoot, basePath + ".py");
   }
-  if (existsSync15(join10(basePath, "__init__.py"))) {
+  if (existsSync16(join10(basePath, "__init__.py"))) {
     return relative4(projectRoot, join10(basePath, "__init__.py"));
   }
-  if (basePath.endsWith(".py") && existsSync15(basePath)) {
+  if (basePath.endsWith(".py") && existsSync16(basePath)) {
     return relative4(projectRoot, basePath);
   }
   return null;
@@ -13791,7 +14094,7 @@ function walkPythonFiles(dir, excludeDirs) {
 }
 function buildPythonImportIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]) {
   const projectRoot = getProjectRoot();
-  const absRoot = resolve12(projectRoot, pythonRoot);
+  const absRoot = resolve13(projectRoot, pythonRoot);
   dataDb2.exec("DELETE FROM massu_py_imports");
   const insertStmt = dataDb2.prepare(
     "INSERT INTO massu_py_imports (source_file, target_file, import_type, imported_names, line) VALUES (?, ?, ?, ?, ?)"
@@ -13808,7 +14111,7 @@ function buildPythonImportIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__
     const relFile = relative4(projectRoot, absFile);
     let source;
     try {
-      source = readFileSync12(absFile, "utf-8");
+      source = readFileSync13(absFile, "utf-8");
     } catch {
       continue;
     }
@@ -14074,7 +14377,7 @@ var init_route_parser = __esm({
 });
 
 // src/python/route-indexer.ts
-import { readFileSync as readFileSync13, readdirSync as readdirSync12 } from "fs";
+import { readFileSync as readFileSync14, readdirSync as readdirSync12 } from "fs";
 import { join as join11, relative as relative5 } from "path";
 function walkPyFiles(dir, excludeDirs) {
   const files = [];
@@ -14107,7 +14410,7 @@ function buildPythonRouteIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__"
       const relFile = relative5(projectRoot, absFile);
       let source;
       try {
-        source = readFileSync13(absFile, "utf-8");
+        source = readFileSync14(absFile, "utf-8");
       } catch {
         continue;
       }
@@ -14318,7 +14621,7 @@ var init_model_parser = __esm({
 });
 
 // src/python/model-indexer.ts
-import { readFileSync as readFileSync14, readdirSync as readdirSync13 } from "fs";
+import { readFileSync as readFileSync15, readdirSync as readdirSync13 } from "fs";
 import { join as join12, relative as relative6 } from "path";
 function walkPyFiles2(dir, excludeDirs) {
   const files = [];
@@ -14354,7 +14657,7 @@ function buildPythonModelIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__"
       const relFile = relative6(projectRoot, absFile);
       let source;
       try {
-        source = readFileSync14(absFile, "utf-8");
+        source = readFileSync15(absFile, "utf-8");
       } catch {
         continue;
       }
@@ -14614,7 +14917,7 @@ var init_migration_parser = __esm({
 });
 
 // src/python/migration-indexer.ts
-import { readFileSync as readFileSync15, readdirSync as readdirSync14 } from "fs";
+import { readFileSync as readFileSync16, readdirSync as readdirSync14 } from "fs";
 import { join as join13, relative as relative7 } from "path";
 function buildPythonMigrationIndex(dataDb2, alembicDir) {
   const projectRoot = getProjectRoot();
@@ -14640,7 +14943,7 @@ function buildPythonMigrationIndex(dataDb2, alembicDir) {
   for (const absFile of files) {
     let source;
     try {
-      source = readFileSync15(absFile, "utf-8");
+      source = readFileSync16(absFile, "utf-8");
     } catch {
       continue;
     }
@@ -14674,7 +14977,7 @@ var init_migration_indexer = __esm({
 });
 
 // src/python/coupling-detector.ts
-import { readFileSync as readFileSync16, readdirSync as readdirSync15 } from "fs";
+import { readFileSync as readFileSync17, readdirSync as readdirSync15 } from "fs";
 import { join as join14, relative as relative8 } from "path";
 function buildPythonCouplingIndex(dataDb2) {
   const projectRoot = getProjectRoot();
@@ -14711,7 +15014,7 @@ function buildPythonCouplingIndex(dataDb2) {
       const relFile = relative8(projectRoot, absFile);
       let source;
       try {
-        source = readFileSync16(absFile, "utf-8");
+        source = readFileSync17(absFile, "utf-8");
       } catch {
         continue;
       }
@@ -15116,8 +15419,8 @@ var init_memory_tools = __esm({
 });
 
 // src/docs-tools.ts
-import { readFileSync as readFileSync17, existsSync as existsSync16 } from "fs";
-import { resolve as resolve13, basename as basename3 } from "path";
+import { readFileSync as readFileSync18, existsSync as existsSync17 } from "fs";
+import { resolve as resolve14, basename as basename3 } from "path";
 function p3(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -15172,10 +15475,10 @@ function handleDocsToolCall(name, args2) {
 }
 function loadDocsMap() {
   const mapPath = getResolvedPaths().docsMapPath;
-  if (!existsSync16(mapPath)) {
+  if (!existsSync17(mapPath)) {
     throw new Error(`docs-map.json not found at ${mapPath}`);
   }
-  return JSON.parse(readFileSync17(mapPath, "utf-8"));
+  return JSON.parse(readFileSync18(mapPath, "utf-8"));
 }
 function matchesPattern(filePath, pattern) {
   const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
@@ -15245,13 +15548,13 @@ function extractFrontmatter(content) {
 }
 function extractProcedureNames(routerPath) {
   const root = getProjectRoot();
-  const absPath = ensureWithinRoot(resolve13(getResolvedPaths().srcDir, "..", routerPath), root);
-  if (!existsSync16(absPath)) {
-    const altPath = ensureWithinRoot(resolve13(getResolvedPaths().srcDir, "../server/api/routers", basename3(routerPath)), root);
-    if (!existsSync16(altPath)) return [];
-    return extractProcedureNamesFromContent(readFileSync17(altPath, "utf-8"));
+  const absPath = ensureWithinRoot(resolve14(getResolvedPaths().srcDir, "..", routerPath), root);
+  if (!existsSync17(absPath)) {
+    const altPath = ensureWithinRoot(resolve14(getResolvedPaths().srcDir, "../server/api/routers", basename3(routerPath)), root);
+    if (!existsSync17(altPath)) return [];
+    return extractProcedureNamesFromContent(readFileSync18(altPath, "utf-8"));
   }
-  return extractProcedureNamesFromContent(readFileSync17(absPath, "utf-8"));
+  return extractProcedureNamesFromContent(readFileSync18(absPath, "utf-8"));
 }
 function extractProcedureNamesFromContent(content) {
   const procRegex = /\.(?:query|mutation)\s*\(/g;
@@ -15291,8 +15594,8 @@ function handleDocsAudit(args2) {
   for (const [mappingId, triggeringFiles] of affectedMappings) {
     const mapping = docsMap.mappings.find((m3) => m3.id === mappingId);
     if (!mapping) continue;
-    const helpPagePath = ensureWithinRoot(resolve13(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
-    if (!existsSync16(helpPagePath)) {
+    const helpPagePath = ensureWithinRoot(resolve14(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
+    if (!existsSync17(helpPagePath)) {
       results.push({
         helpPage: mapping.helpPage,
         mappingId,
@@ -15304,7 +15607,7 @@ function handleDocsAudit(args2) {
       });
       continue;
     }
-    const content = readFileSync17(helpPagePath, "utf-8");
+    const content = readFileSync18(helpPagePath, "utf-8");
     const sections = extractSections(content);
     const frontmatter = extractFrontmatter(content);
     const staleReasons = [];
@@ -15344,9 +15647,9 @@ function handleDocsAudit(args2) {
     });
     for (const [guideName, parentId] of Object.entries(docsMap.userGuideInheritance.examples)) {
       if (parentId === mappingId) {
-        const guidePath = ensureWithinRoot(resolve13(getResolvedPaths().helpSitePath, `pages/user-guides/${guideName}/index.mdx`), getProjectRoot());
-        if (existsSync16(guidePath)) {
-          const guideContent = readFileSync17(guidePath, "utf-8");
+        const guidePath = ensureWithinRoot(resolve14(getResolvedPaths().helpSitePath, `pages/user-guides/${guideName}/index.mdx`), getProjectRoot());
+        if (existsSync17(guidePath)) {
+          const guideContent = readFileSync18(guidePath, "utf-8");
           const guideFrontmatter = extractFrontmatter(guideContent);
           if (!guideFrontmatter?.lastVerified || status === "STALE") {
             results.push({
@@ -15379,14 +15682,14 @@ function handleDocsCoverage(args2) {
   const gaps = [];
   const mappings = filterDomain ? docsMap.mappings.filter((m3) => m3.id === filterDomain) : docsMap.mappings;
   for (const mapping of mappings) {
-    const helpPagePath = ensureWithinRoot(resolve13(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
-    const exists = existsSync16(helpPagePath);
+    const helpPagePath = ensureWithinRoot(resolve14(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
+    const exists = existsSync17(helpPagePath);
     let hasContent = false;
     let lineCount = 0;
     let lastVerified = null;
     let status = null;
     if (exists) {
-      const content = readFileSync17(helpPagePath, "utf-8");
+      const content = readFileSync18(helpPagePath, "utf-8");
       lineCount = content.split("\n").length;
       hasContent = lineCount > 10;
       const frontmatter = extractFrontmatter(content);
@@ -15727,8 +16030,8 @@ var init_observability_tools = __esm({
 });
 
 // src/sentinel-db.ts
-import { existsSync as existsSync17 } from "fs";
-import { resolve as resolve14 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { resolve as resolve15 } from "path";
 function parsePortalScope(raw) {
   if (!raw) return [];
   try {
@@ -15964,23 +16267,23 @@ function validateFeatures(db, domainFilter) {
     const missingProcedures = [];
     const missingPages = [];
     for (const comp of components) {
-      const absPath = resolve14(PROJECT_ROOT, comp.component_file);
-      if (!existsSync17(absPath)) {
+      const absPath = resolve15(PROJECT_ROOT, comp.component_file);
+      if (!existsSync18(absPath)) {
         missingComponents.push(comp.component_file);
       }
     }
     for (const proc of procedures) {
-      const routerPath = resolve14(PROJECT_ROOT, `src/server/api/routers/${proc.router_name}.ts`);
-      if (!existsSync17(routerPath)) {
+      const routerPath = resolve15(PROJECT_ROOT, `src/server/api/routers/${proc.router_name}.ts`);
+      if (!existsSync18(routerPath)) {
         missingProcedures.push({ router: proc.router_name, procedure: proc.procedure_name });
       }
     }
     for (const page of pages) {
       const routeToPath = page.page_route.replace(/^\/(portal-[^/]+\/)?/, "src/app/").replace(/\/$/, "") + "/page.tsx";
-      const absPath = resolve14(PROJECT_ROOT, routeToPath);
-      if (page.page_route.startsWith("/") && !existsSync17(absPath)) {
-        const altPath = resolve14(PROJECT_ROOT, `src/app${page.page_route}/page.tsx`);
-        if (!existsSync17(altPath)) {
+      const absPath = resolve15(PROJECT_ROOT, routeToPath);
+      if (page.page_route.startsWith("/") && !existsSync18(absPath)) {
+        const altPath = resolve15(PROJECT_ROOT, `src/app${page.page_route}/page.tsx`);
+        if (!existsSync18(altPath)) {
           missingPages.push(page.page_route);
         }
       }
@@ -16504,8 +16807,8 @@ var init_sentinel_tools = __esm({
 });
 
 // src/sentinel-scanner.ts
-import { readFileSync as readFileSync18, existsSync as existsSync18, readdirSync as readdirSync16, statSync as statSync7 } from "fs";
-import { resolve as resolve15, join as join15, basename as basename4, dirname as dirname9, relative as relative9 } from "path";
+import { readFileSync as readFileSync19, existsSync as existsSync19, readdirSync as readdirSync16, statSync as statSync7 } from "fs";
+import { resolve as resolve16, join as join15, basename as basename4, dirname as dirname9, relative as relative9 } from "path";
 function inferDomain(filePath) {
   const domains = getConfig().domains;
   const path = filePath.toLowerCase();
@@ -16634,8 +16937,8 @@ function scanComponentExports(dataDb2) {
   const projectRoot = getProjectRoot();
   const componentsBase = config.paths.components ?? config.paths.source + "/components";
   const componentDirs = [];
-  const basePath = resolve15(projectRoot, componentsBase);
-  if (existsSync18(basePath)) {
+  const basePath = resolve16(projectRoot, componentsBase);
+  if (existsSync19(basePath)) {
     try {
       const entries = readdirSync16(basePath, { withFileTypes: true });
       for (const entry of entries) {
@@ -16647,12 +16950,12 @@ function scanComponentExports(dataDb2) {
     }
   }
   for (const dir of componentDirs) {
-    const absDir = resolve15(projectRoot, dir);
-    if (!existsSync18(absDir)) continue;
+    const absDir = resolve16(projectRoot, dir);
+    if (!existsSync19(absDir)) continue;
     const files = walkDir(absDir).filter((f2) => f2.endsWith(".tsx") || f2.endsWith(".ts"));
     for (const file of files) {
       const relPath = relative9(projectRoot, file);
-      const source = readFileSync18(file, "utf-8");
+      const source = readFileSync19(file, "utf-8");
       const annotations = parseFeatureAnnotations(source);
       if (annotations.length > 0) {
         for (const ann of annotations) {
@@ -17691,7 +17994,7 @@ var init_audit_trail = __esm({
 });
 
 // src/validation-engine.ts
-import { existsSync as existsSync19, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync20 } from "fs";
 function p10(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -17722,7 +18025,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  if (!existsSync19(absPath)) {
+  if (!existsSync20(absPath)) {
     checks.push({
       name: "file_exists",
       severity: "error",
@@ -17731,7 +18034,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  const source = readFileSync19(absPath, "utf-8");
+  const source = readFileSync20(absPath, "utf-8");
   const lines = source.split("\n");
   if (activeChecks.rule_compliance !== false) {
     for (const ruleSet of config.rules) {
@@ -18176,7 +18479,7 @@ var init_adr_generator = __esm({
 });
 
 // src/security-scorer.ts
-import { existsSync as existsSync20, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync21 } from "fs";
 function p12(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -18200,12 +18503,12 @@ function scoreFileSecurity(filePath, projectRoot) {
       }]
     };
   }
-  if (!existsSync20(absPath)) {
+  if (!existsSync21(absPath)) {
     return { riskScore: 0, findings: [] };
   }
   let source;
   try {
-    source = readFileSync20(absPath, "utf-8");
+    source = readFileSync21(absPath, "utf-8");
   } catch {
     return { riskScore: 0, findings: [] };
   }
@@ -18494,8 +18797,8 @@ var init_security_scorer = __esm({
 });
 
 // src/dependency-scorer.ts
-import { existsSync as existsSync21, readFileSync as readFileSync21 } from "fs";
-import { resolve as resolve16 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync22 } from "fs";
+import { resolve as resolve17 } from "path";
 function p13(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -18527,10 +18830,10 @@ function calculateDepRisk(factors) {
   return Math.min(100, risk);
 }
 function getInstalledPackages(projectRoot) {
-  const pkgPath = resolve16(projectRoot, "package.json");
-  if (!existsSync21(pkgPath)) return /* @__PURE__ */ new Map();
+  const pkgPath = resolve17(projectRoot, "package.json");
+  if (!existsSync22(pkgPath)) return /* @__PURE__ */ new Map();
   try {
-    const pkg = JSON.parse(readFileSync21(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync22(pkgPath, "utf-8"));
     const packages = /* @__PURE__ */ new Map();
     for (const [name, version] of Object.entries(pkg.dependencies ?? {})) {
       packages.set(name, version);
@@ -19132,9 +19435,9 @@ var init_regression_detector = __esm({
 });
 
 // src/knowledge-indexer.ts
-import { createHash as createHash3 } from "crypto";
-import { readFileSync as readFileSync22, readdirSync as readdirSync17, statSync as statSync8, existsSync as existsSync22 } from "fs";
-import { resolve as resolve17, relative as relative10, basename as basename5, extname } from "path";
+import { createHash as createHash4 } from "crypto";
+import { readFileSync as readFileSync23, readdirSync as readdirSync17, statSync as statSync8, existsSync as existsSync23 } from "fs";
+import { resolve as resolve18, relative as relative10, basename as basename5, extname } from "path";
 function getKnowledgePaths() {
   const resolved = getResolvedPaths();
   const config = getConfig();
@@ -19162,7 +19465,7 @@ function discoverMarkdownFiles(baseDir) {
     try {
       const entries = readdirSync17(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = resolve17(dir, entry.name);
+        const fullPath = resolve18(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "archive" && dir.includes("session-state")) continue;
           if (entry.name === "archive" && dir.includes("status")) continue;
@@ -19219,8 +19522,8 @@ function categorizeFile(filePath) {
   if (knownCategories.includes(firstDir)) return firstDir;
   return "root";
 }
-function hashContent(content) {
-  return createHash3("sha256").update(content).digest("hex");
+function hashContent2(content) {
+  return createHash4("sha256").update(content).digest("hex");
 }
 function parseCRTable(content) {
   const rules = [];
@@ -19440,11 +19743,11 @@ function indexAllKnowledge(db) {
     files.push(...memFiles);
   } catch {
   }
-  if (existsSync22(paths.plansDir)) {
+  if (existsSync23(paths.plansDir)) {
     const planFiles = discoverMarkdownFiles(paths.plansDir);
     files.push(...planFiles);
   }
-  if (existsSync22(paths.docsDir)) {
+  if (existsSync23(paths.docsDir)) {
     const excludePatterns = getConfig().conventions?.excludePatterns ?? ["/ARCHIVE/", "/SESSION-HISTORY/"];
     const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f2) => !f2.includes("/plans/") && !excludePatterns.some((p19) => f2.includes(p19)));
     files.push(...docsFiles);
@@ -19487,9 +19790,9 @@ function indexAllKnowledge(db) {
     } catch {
     }
     for (const filePath of files) {
-      if (!existsSync22(filePath)) continue;
-      const content = readFileSync22(filePath, "utf-8");
-      const hash = hashContent(content);
+      if (!existsSync23(filePath)) continue;
+      const content = readFileSync23(filePath, "utf-8");
+      const hash = hashContent2(content);
       const relPath = filePath.startsWith(paths.claudeDir) ? relative10(paths.claudeDir, filePath) : filePath.startsWith(paths.plansDir) ? "plans/" + relative10(paths.plansDir, filePath) : filePath.startsWith(paths.docsDir) ? "docs/" + relative10(paths.docsDir, filePath) : filePath.startsWith(paths.memoryDir) ? `memory/${relative10(paths.memoryDir, filePath)}` : basename5(filePath);
       const category = categorizeFile(filePath);
       const title = extractTitle(content, filePath);
@@ -19608,10 +19911,10 @@ function isKnowledgeStale(db) {
     files.push(...discoverMarkdownFiles(paths.memoryDir));
   } catch {
   }
-  if (existsSync22(paths.plansDir)) {
+  if (existsSync23(paths.plansDir)) {
     files.push(...discoverMarkdownFiles(paths.plansDir));
   }
-  if (existsSync22(paths.docsDir)) {
+  if (existsSync23(paths.docsDir)) {
     const excludePatterns = getConfig().conventions?.excludePatterns ?? ["/ARCHIVE/", "/SESSION-HISTORY/"];
     const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f2) => !f2.includes("/plans/") && !excludePatterns.some((p19) => f2.includes(p19)));
     files.push(...docsFiles);
@@ -19640,8 +19943,8 @@ var init_knowledge_indexer = __esm({
 });
 
 // src/knowledge-tools.ts
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync3, appendFileSync, readdirSync as readdirSync18 } from "fs";
-import { resolve as resolve18, basename as basename6 } from "path";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync3, appendFileSync, readdirSync as readdirSync18 } from "fs";
+import { resolve as resolve19, basename as basename6 } from "path";
 function p16(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -20378,7 +20681,7 @@ function handleCorrect(db, args2) {
   if (!wrong || !correction || !rule) {
     return text15("Error: wrong, correction, and rule are all required.");
   }
-  const correctionsPath = resolve18(getResolvedPaths().memoryDir, "corrections.md");
+  const correctionsPath = resolve19(getResolvedPaths().memoryDir, "corrections.md");
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const title = rule.slice(0, 60);
   const entry = `
@@ -20391,7 +20694,7 @@ ${crRule ? `- **CR**: ${crRule}
 `;
   let existing = "";
   try {
-    existing = readFileSync23(correctionsPath, "utf-8");
+    existing = readFileSync24(correctionsPath, "utf-8");
   } catch {
   }
   const archiveIdx = existing.indexOf("## Archived");
@@ -20730,11 +21033,11 @@ var init_knowledge_tools = __esm({
 // src/knowledge-db.ts
 import Database3 from "better-sqlite3";
 import { dirname as dirname10 } from "path";
-import { existsSync as existsSync24, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync5 } from "fs";
 function getKnowledgeDb() {
   const dbPath = getResolvedPaths().knowledgeDbPath;
   const dir = dirname10(dbPath);
-  if (!existsSync24(dir)) {
+  if (!existsSync25(dir)) {
     mkdirSync5(dir, { recursive: true });
   }
   const db = new Database3(dbPath);
@@ -21468,8 +21771,8 @@ var init_python_tools = __esm({
 });
 
 // src/tools.ts
-import { readFileSync as readFileSync24, existsSync as existsSync25 } from "fs";
-import { resolve as resolve19, basename as basename7 } from "path";
+import { readFileSync as readFileSync25, existsSync as existsSync26 } from "fs";
+import { resolve as resolve20, basename as basename7 } from "path";
 function prefix2() {
   return getConfig().toolPrefix;
 }
@@ -21504,7 +21807,7 @@ function ensureIndexes(dataDb2, codegraphDb2, force = false) {
   if (config.python?.root) {
     const pythonRoot = config.python.root;
     const excludeDirs = config.python.exclude_dirs || ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"];
-    if (force || isPythonDataStale(dataDb2, resolve19(getProjectRoot(), pythonRoot))) {
+    if (force || isPythonDataStale(dataDb2, resolve20(getProjectRoot(), pythonRoot))) {
       const pyImports = buildPythonImportIndex(dataDb2, pythonRoot, excludeDirs);
       results.push(`Python imports: ${pyImports}`);
       const pyRoutes = buildPythonRouteIndex(dataDb2, pythonRoot, excludeDirs);
@@ -21903,9 +22206,9 @@ function handleContext(file, dataDb2, codegraphDb2) {
         try {
           const resolvedPaths = getResolvedPaths();
           const root = getProjectRoot();
-          const absFilePath = ensureWithinRoot(resolve19(resolvedPaths.srcDir, "..", file), root);
-          if (existsSync25(absFilePath)) {
-            const fileContent = readFileSync24(absFilePath, "utf-8").slice(0, 3e3);
+          const absFilePath = ensureWithinRoot(resolve20(resolvedPaths.srcDir, "..", file), root);
+          if (existsSync26(absFilePath)) {
+            const fileContent = readFileSync25(absFilePath, "utf-8").slice(0, 3e3);
             const keywords = [];
             if (fileContent.includes("ctx.db")) keywords.push("database", "schema");
             if (fileContent.includes("BigInt") || fileContent.includes("Decimal")) keywords.push("BigInt", "serialization");
@@ -22329,11 +22632,11 @@ function handleSchema(args2) {
     lines.push("Checking all column references against Prisma schema...");
     lines.push("");
     const projectRoot = getProjectRoot();
-    const absPath = ensureWithinRoot(resolve19(projectRoot, file), projectRoot);
-    if (!existsSync25(absPath)) {
+    const absPath = ensureWithinRoot(resolve20(projectRoot, file), projectRoot);
+    if (!existsSync26(absPath)) {
       return text17(`File not found: ${file}`);
     }
-    const source = readFileSync24(absPath, "utf-8");
+    const source = readFileSync25(absPath, "utf-8");
     const config = getConfig();
     const dbPattern = config.dbAccessPattern ?? "ctx.db.{table}";
     const regexStr = dbPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\{table\\}", "(\\w+)");
@@ -22411,8 +22714,8 @@ var init_tools = __esm({
 
 // src/server.ts
 var server_exports = {};
-import { readFileSync as readFileSync25 } from "fs";
-import { resolve as resolve20, dirname as dirname11 } from "path";
+import { readFileSync as readFileSync26 } from "fs";
+import { resolve as resolve21, dirname as dirname11 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function getDb() {
   if (!codegraphDb) codegraphDb = getCodeGraphDb();
@@ -22507,7 +22810,7 @@ var init_server = __esm({
     __dirname4 = dirname11(fileURLToPath4(import.meta.url));
     PKG_VERSION = (() => {
       try {
-        const pkg = JSON.parse(readFileSync25(resolve20(__dirname4, "..", "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync26(resolve21(__dirname4, "..", "package.json"), "utf-8"));
         return pkg.version ?? "0.0.0";
       } catch {
         return "0.0.0";
@@ -22619,8 +22922,8 @@ __export(config_refresh_exports, {
   mergeRefresh: () => mergeRefresh,
   runConfigRefresh: () => runConfigRefresh
 });
-import { existsSync as existsSync26, readFileSync as readFileSync26 } from "fs";
-import { resolve as resolve21 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync27 } from "fs";
+import { resolve as resolve22 } from "path";
 import { parse as parseYaml5 } from "yaml";
 function flatten(obj, prefix3 = "") {
   const out = {};
@@ -22748,17 +23051,17 @@ function renderDiff(diff) {
 }
 async function runConfigRefresh(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = resolve21(cwd, "massu.config.yaml");
+  const configPath = resolve22(cwd, "massu.config.yaml");
   const log = opts.silent ? () => {
   } : (s) => process.stdout.write(s);
-  if (!existsSync26(configPath)) {
+  if (!existsSync27(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     if (!opts.silent) process.stderr.write(message + "\n");
     return { exitCode: 1, applied: false, dryRun: !!opts.dryRun, diff: [], message };
   }
   let existing;
   try {
-    const content = readFileSync26(configPath, "utf-8");
+    const content = readFileSync27(configPath, "utf-8");
     const parsed = parseYaml5(content);
     if (!parsed || typeof parsed !== "object") {
       throw new Error("config is not a YAML object");
@@ -22958,13 +23261,21 @@ function migrateV1ToV2(v1Config, detection) {
   let pathsSource = typeof v1Paths.source === "string" ? v1Paths.source : "src";
   if (pathsSource === "src" && primary) {
     const primaryDirs = detection.sourceDirs[primary]?.source_dirs ?? [];
-    if (primaryDirs.length > 0) pathsSource = primaryDirs[0];
+    if (primaryDirs.length > 0) {
+      pathsSource = primaryDirs[0];
+    } else if (detection.monorepo?.type !== void 0 && detection.monorepo.type !== "single" && detection.monorepo.packages.length > 0) {
+      pathsSource = monorepoCommonRootMigrate(detection.monorepo.packages);
+    }
   }
   const aliases = v1Paths.aliases && typeof v1Paths.aliases === "object" ? v1Paths.aliases : { "@": pathsSource };
   const paths = {
     source: pathsSource,
     aliases
   };
+  if (detection.monorepo?.type !== void 0 && detection.monorepo.type !== "single" && detection.monorepo.packages.length > 0 && !("monorepo_roots" in v1Paths)) {
+    const roots = monorepoDistinctRootsMigrate(detection.monorepo.packages);
+    if (roots.length > 0) paths.monorepo_roots = roots;
+  }
   for (const k3 of ["routers", "routerRoot", "pages", "middleware", "schema", "components", "hooks"]) {
     if (typeof v1Paths[k3] === "string") paths[k3] = v1Paths[k3];
   }
@@ -23035,6 +23346,20 @@ function migrateV1ToV2(v1Config, detection) {
   }
   return v22;
 }
+function monorepoCommonRootMigrate(packages) {
+  const roots = monorepoDistinctRootsMigrate(packages);
+  return roots.length === 1 ? roots[0] : ".";
+}
+function monorepoDistinctRootsMigrate(packages) {
+  const set = /* @__PURE__ */ new Set();
+  for (const p19 of packages) {
+    const parts = p19.path.split("/");
+    if (parts.length > 1 && parts[0] !== "" && parts[0] !== ".") {
+      set.add(parts[0]);
+    }
+  }
+  return [...set].sort();
+}
 var PRESERVED_FIELDS2;
 var init_migrate = __esm({
   "src/detect/migrate.ts"() {
@@ -23066,19 +23391,19 @@ var config_upgrade_exports = {};
 __export(config_upgrade_exports, {
   runConfigUpgrade: () => runConfigUpgrade
 });
-import { existsSync as existsSync27, readFileSync as readFileSync27, writeFileSync as writeFileSync4, copyFileSync, unlinkSync } from "fs";
-import { resolve as resolve22 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync28, writeFileSync as writeFileSync4, copyFileSync, unlinkSync } from "fs";
+import { resolve as resolve23 } from "path";
 import { parse as parseYaml6 } from "yaml";
 async function runConfigUpgrade(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = resolve22(cwd, "massu.config.yaml");
+  const configPath = resolve23(cwd, "massu.config.yaml");
   const bakPath = `${configPath}.bak`;
   const log = opts.silent ? () => {
   } : (s) => process.stdout.write(s);
   const err = opts.silent ? () => {
   } : (s) => process.stderr.write(s);
   if (opts.rollback) {
-    if (!existsSync27(bakPath)) {
+    if (!existsSync28(bakPath)) {
       const message = `No backup found at ${bakPath}`;
       err(message + "\n");
       return { exitCode: 1, action: "none", message };
@@ -23094,14 +23419,14 @@ async function runConfigUpgrade(opts = {}) {
       return { exitCode: 2, action: "none", message };
     }
   }
-  if (!existsSync27(configPath)) {
+  if (!existsSync28(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     err(message + "\n");
     return { exitCode: 1, action: "none", message };
   }
   let existing;
   try {
-    const content = readFileSync27(configPath, "utf-8");
+    const content = readFileSync28(configPath, "utf-8");
     const parsed = parseYaml6(content);
     if (!parsed || typeof parsed !== "object") {
       throw new Error("config is not a YAML object");
@@ -23124,7 +23449,7 @@ async function runConfigUpgrade(opts = {}) {
     fingerprint: computeFingerprint(detection)
   };
   try {
-    const original = readFileSync27(configPath, "utf-8");
+    const original = readFileSync28(configPath, "utf-8");
     writeFileSync4(bakPath, original, "utf-8");
   } catch (e2) {
     const message = `Failed to write backup: ${e2 instanceof Error ? e2.message : String(e2)}`;
@@ -23158,8 +23483,8 @@ var config_check_drift_exports = {};
 __export(config_check_drift_exports, {
   runConfigCheckDrift: () => runConfigCheckDrift
 });
-import { existsSync as existsSync28, readFileSync as readFileSync28 } from "fs";
-import { resolve as resolve23 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync29 } from "fs";
+import { resolve as resolve24 } from "path";
 import { parse as parseYaml7 } from "yaml";
 function renderChanges(changes) {
   if (changes.length === 0) return "(none)\n";
@@ -23167,12 +23492,12 @@ function renderChanges(changes) {
 }
 async function runConfigCheckDrift(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = resolve23(cwd, "massu.config.yaml");
+  const configPath = resolve24(cwd, "massu.config.yaml");
   const log = opts.silent ? () => {
   } : (s) => process.stdout.write(s);
   const err = opts.silent ? () => {
   } : (s) => process.stderr.write(s);
-  if (!existsSync28(configPath)) {
+  if (!existsSync29(configPath)) {
     const message = "massu.config.yaml not found. Run: npx massu init";
     err(message + "\n");
     return {
@@ -23186,7 +23511,7 @@ async function runConfigCheckDrift(opts = {}) {
   }
   let config;
   try {
-    const content = readFileSync28(configPath, "utf-8");
+    const content = readFileSync29(configPath, "utf-8");
     const parsed = parseYaml7(content);
     if (!parsed || typeof parsed !== "object") {
       throw new Error("config is not a YAML object");
@@ -23253,8 +23578,8 @@ var init_config_check_drift = __esm({
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync29 } from "fs";
-import { resolve as resolve24, dirname as dirname12 } from "path";
+import { readFileSync as readFileSync30 } from "fs";
+import { resolve as resolve25, dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename4 = fileURLToPath5(import.meta.url);
 var __dirname5 = dirname12(__filename4);
@@ -23282,6 +23607,11 @@ async function main() {
       await runInstallCommands2();
       break;
     }
+    case "show-template": {
+      const { runShowTemplate: runShowTemplate2 } = await Promise.resolve().then(() => (init_show_template(), show_template_exports));
+      await runShowTemplate2(args.slice(1));
+      break;
+    }
     case "validate-config": {
       const { runValidateConfig: runValidateConfig2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
       await runValidateConfig2();
@@ -23368,6 +23698,7 @@ Commands:
   doctor            Check installation health
   install-hooks     Install/update Claude Code hooks
   install-commands  Install/update slash commands
+  show-template     Print the resolved variant of a bundled template (e.g. for diffs)
   validate-config   Validate massu.config.yaml (alias: config validate)
   config <sub>      Config lifecycle: refresh | validate | upgrade | doctor | check-drift
 
@@ -23406,7 +23737,7 @@ Examples:
 }
 function printVersion() {
   try {
-    const pkg = JSON.parse(readFileSync29(resolve24(__dirname5, "../package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync30(resolve25(__dirname5, "../package.json"), "utf-8"));
     console.log(`massu v${pkg.version}`);
   } catch {
     console.log("massu v0.1.0");