@massu/core 0.8.0 → 0.9.0

package/dist/cli.js

@@ -1485,20 +1485,25 @@ var init_memory_db = __esm({
 // src/memory-file-ingest.ts
 import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync } from "fs";
 import { join } from "path";
-import { parse as parseYaml2 } from "yaml";
 function ingestMemoryFile(db, sessionId, filePath) {
   if (!existsSync3(filePath)) return "skipped";
   const content = readFileSync2(filePath, "utf-8");
-  const basename8 = (filePath.split("/").pop() ?? "").replace(".md", "");
+  const basename9 = (filePath.split("/").pop() ?? "").replace(".md", "");
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  let name = basename8;
+  let name = basename9;
   let description = "";
   let type = "discovery";
   let confidence;
   if (frontmatterMatch) {
     try {
-      const fm = parseYaml2(frontmatterMatch[1]);
-      name = fm.name ?? basename8;
+      const fm = {};
+      for (const line of frontmatterMatch[1].split("\n")) {
+        const sep = line.indexOf(":");
+        if (sep > 0) {
+          fm[line.slice(0, sep).trim()] = line.slice(sep + 1).trim();
+        }
+      }
+      name = fm.name ?? basename9;
       description = fm.description ?? "";
       type = fm.type ?? "discovery";
       confidence = fm.confidence != null ? Number(fm.confidence) : void 0;
@@ -1558,6 +1563,265 @@ var init_memory_file_ingest = __esm({
   }
 });
 
+// src/claude-md-templates.ts
+import { readdirSync as readdirSync2, statSync } from "fs";
+import { resolve as resolve3, basename as basename2 } from "path";
+function scanDirectoryStructure(projectRoot, maxDepth = 2) {
+  const lines = [];
+  const rootName = basename2(projectRoot);
+  lines.push(`${rootName}/`);
+  scanLevel(projectRoot, "", maxDepth, 0, lines);
+  return lines.join("\n");
+}
+function scanLevel(dir, prefix2, maxDepth, currentDepth, lines) {
+  if (currentDepth >= maxDepth) return;
+  let entries;
+  try {
+    entries = readdirSync2(dir).sort();
+  } catch {
+    return;
+  }
+  const dirs = [];
+  const files = [];
+  for (const entry of entries) {
+    if (entry.startsWith(".") && EXCLUDED_DIRS.has(entry)) continue;
+    if (EXCLUDED_DIRS.has(entry)) continue;
+    try {
+      const stat = statSync(resolve3(dir, entry));
+      if (stat.isDirectory()) dirs.push(entry);
+      else files.push(entry);
+    } catch {
+    }
+  }
+  const allEntries = [...dirs, ...files];
+  for (let i = 0; i < allEntries.length; i++) {
+    const entry = allEntries[i];
+    const isLast = i === allEntries.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const childPrefix = isLast ? "    " : "\u2502   ";
+    const isDir = dirs.includes(entry);
+    lines.push(`${prefix2}${connector}${entry}${isDir ? "/" : ""}`);
+    if (isDir) {
+      scanLevel(resolve3(dir, entry), prefix2 + childPrefix, maxDepth, currentDepth + 1, lines);
+    }
+  }
+}
+function buildClaudeMdContent(projectName, projectRoot, framework, python) {
+  const sections = [];
+  sections.push(buildProjectOverview(projectName, framework, python));
+  sections.push(buildTechStack(framework, python));
+  sections.push(buildDirectorySection(projectRoot));
+  sections.push(buildCodingConventions(framework, python));
+  sections.push(buildTestingSection(framework, python));
+  sections.push(buildMassuWorkflow());
+  sections.push(buildMemorySystem());
+  sections.push(buildCriticalRules());
+  return sections.join("\n\n---\n\n") + "\n";
+}
+function buildProjectOverview(projectName, framework, python) {
+  const stack = [];
+  if (framework.type !== "javascript") stack.push(capitalize(framework.type));
+  if (framework.ui !== "none") stack.push(formatUiName(framework.ui));
+  if (framework.router !== "none") stack.push(framework.router.toUpperCase());
+  if (framework.orm !== "none") stack.push(capitalize(framework.orm));
+  if (python.detected) {
+    stack.push("Python");
+    if (python.hasFastapi) stack.push("FastAPI");
+  }
+  const stackStr = stack.length > 0 ? stack.join(", ") : "JavaScript";
+  return `# ${projectName}
+
+## Project Overview
+
+${projectName} is a ${stackStr} project.
+
+<!-- Add a brief description of what this project does -->`;
+}
+function buildTechStack(framework, python) {
+  const rows = [];
+  rows.push("| Technology | Details |");
+  rows.push("|-----------|---------|");
+  rows.push(`| Language | ${capitalize(framework.type)} |`);
+  if (framework.ui !== "none") rows.push(`| UI Framework | ${formatUiName(framework.ui)} |`);
+  if (framework.router !== "none") rows.push(`| Router/API | ${framework.router.toUpperCase()} |`);
+  if (framework.orm !== "none") rows.push(`| ORM | ${capitalize(framework.orm)} |`);
+  if (python.detected) {
+    rows.push("| Python | Yes |");
+    if (python.hasFastapi) rows.push("| Python Framework | FastAPI |");
+    if (python.hasSqlalchemy) rows.push("| Python ORM | SQLAlchemy |");
+    if (python.hasAlembic) rows.push("| Migrations | Alembic |");
+  }
+  return `## Tech Stack
+
+${rows.join("\n")}`;
+}
+function buildDirectorySection(projectRoot) {
+  const tree = scanDirectoryStructure(projectRoot);
+  return `## Directory Structure
+
+\`\`\`
+${tree}
+\`\`\``;
+}
+function buildCodingConventions(framework, python) {
+  const rules = [];
+  if (framework.type === "typescript") {
+    rules.push("- Use ESM imports (`import`), not CommonJS (`require`)");
+    rules.push("- Enable strict TypeScript (`strict: true` in tsconfig.json)");
+    rules.push("- Prefer explicit types over `any`");
+  }
+  switch (framework.ui) {
+    case "nextjs":
+      rules.push("- Use App Router conventions (`app/` directory)");
+      rules.push('- Default to Server Components; add `"use client"` only when needed');
+      rules.push("- Use `next/image` for images, `next/link` for navigation");
+      rules.push("- API routes go in `app/api/` using Route Handlers");
+      break;
+    case "sveltekit":
+      rules.push("- Use load functions for data fetching (`+page.server.ts`)");
+      rules.push("- Use form actions for mutations");
+      rules.push("- Server-only code in `+server.ts` files");
+      break;
+    case "react":
+      rules.push("- Prefer functional components with hooks");
+      rules.push("- Colocate component, styles, and tests");
+      break;
+  }
+  if (framework.router === "trpc") {
+    rules.push("- Define tRPC routers with Zod input validation");
+    rules.push("- Keep router files focused (one domain per router)");
+  }
+  if (framework.orm === "prisma") {
+    rules.push("- Define models in `prisma/schema.prisma`");
+    rules.push("- Run `npx prisma generate` after schema changes");
+  } else if (framework.orm === "drizzle") {
+    rules.push("- Define schemas with Drizzle table builders");
+    rules.push("- Run migrations with `drizzle-kit`");
+  }
+  if (python.detected) {
+    rules.push("- Use type hints for function signatures");
+    rules.push("- Use `async def` for async endpoints");
+    if (python.hasFastapi) {
+      rules.push("- Use Pydantic models for request/response schemas");
+      rules.push("- Organize routes with `APIRouter`");
+    }
+    if (python.hasSqlalchemy) {
+      rules.push("- Use SQLAlchemy 2.0 style (select/insert builders)");
+    }
+  }
+  if (rules.length === 0) {
+    rules.push("- Follow consistent naming conventions");
+    rules.push("- Keep functions small and focused");
+  }
+  return `## Coding Conventions
+
+${rules.join("\n")}`;
+}
+function buildTestingSection(framework, python) {
+  const lines = [];
+  if (framework.type === "typescript") {
+    lines.push("- Test framework: vitest (or jest)");
+    lines.push("- Test files: `__tests__/*.test.ts` or `*.test.ts` colocated");
+    lines.push("- Run tests: `npm test`");
+  }
+  if (python.detected) {
+    lines.push("- Python tests: pytest");
+    lines.push("- Test files: `tests/` directory or `test_*.py` files");
+    lines.push("- Run: `pytest`");
+  }
+  if (lines.length === 0) {
+    lines.push("- Configure a test framework for this project");
+    lines.push("- Run tests before committing changes");
+  }
+  return `## Testing
+
+${lines.join("\n")}`;
+}
+function buildMassuWorkflow() {
+  return `## Massu Workflow
+
+This project uses [Massu AI](https://massu.ai) for development governance.
+
+### Common Commands
+
+| Command | Purpose |
+|---------|---------|
+| \`/massu-create-plan\` | Create an implementation plan |
+| \`/massu-plan\` | Audit and improve a plan |
+| \`/massu-golden-path\` | Full implementation flow (plan to push) |
+| \`/massu-test\` | Run tests with failure analysis |
+| \`/massu-commit\` | Pre-commit verification gate |
+| \`/massu-push\` | Pre-push verification gate |
+| \`/massu-status\` | Project health dashboard |
+| \`/massu-debug\` | Systematic debugging |
+
+### Workflow Flow
+
+\`\`\`
+/massu-create-plan -> /massu-plan (audit) -> /massu-golden-path (implement + push)
+\`\`\``;
+}
+function buildMemorySystem() {
+  return `## Memory System
+
+Massu maintains persistent memory across sessions in \`~/.claude/projects/.../memory/\`.
+
+- **User memories**: Your role, preferences, and expertise
+- **Feedback memories**: Corrections and validated approaches
+- **Project memories**: Ongoing work, decisions, deadlines
+- **Reference memories**: External resources and tools
+
+Memory is automatically loaded at session start and updated as you work.`;
+}
+function buildCriticalRules() {
+  return `## Critical Rules
+
+1. **Never commit secrets** \u2014 no API keys, tokens, or credentials in code
+2. **Run tests before committing** \u2014 all tests must pass
+3. **Verify before claiming done** \u2014 use VR-* verification checks
+4. **Fix all issues encountered** \u2014 pre-existing issues get fixed too
+5. **Read before editing** \u2014 understand existing code before modifying
+
+<!-- Add project-specific rules as you discover them -->`;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function formatUiName(name) {
+  const names = {
+    nextjs: "Next.js",
+    sveltekit: "SvelteKit",
+    nuxt: "Nuxt",
+    angular: "Angular",
+    vue: "Vue",
+    react: "React"
+  };
+  return names[name] ?? capitalize(name);
+}
+var EXCLUDED_DIRS;
+var init_claude_md_templates = __esm({
+  "src/claude-md-templates.ts"() {
+    "use strict";
+    EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".venv",
+      "venv",
+      "__pycache__",
+      "dist",
+      "build",
+      ".next",
+      ".nuxt",
+      ".svelte-kit",
+      "coverage",
+      ".massu",
+      ".turbo",
+      ".cache",
+      ".output"
+    ]);
+  }
+});
+
 // src/commands/install-commands.ts
 var install_commands_exports = {};
 __export(install_commands_exports, {
@@ -1567,20 +1831,20 @@ __export(install_commands_exports, {
   resolveCommandsDir: () => resolveCommandsDir,
   runInstallCommands: () => runInstallCommands
 });
-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 readdirSync3, statSync as statSync2 } from "fs";
+import { resolve as resolve4, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 function resolveAssetDir(assetName) {
   const cwd = process.cwd();
-  const nodeModulesPath = resolve3(cwd, "node_modules/@massu/core", assetName);
+  const nodeModulesPath = resolve4(cwd, "node_modules/@massu/core", assetName);
   if (existsSync4(nodeModulesPath)) {
     return nodeModulesPath;
   }
-  const distRelPath = resolve3(__dirname, "..", assetName);
+  const distRelPath = resolve4(__dirname, "..", assetName);
   if (existsSync4(distRelPath)) {
     return distRelPath;
   }
-  const srcRelPath = resolve3(__dirname, "../..", assetName);
+  const srcRelPath = resolve4(__dirname, "../..", assetName);
   if (existsSync4(srcRelPath)) {
     return srcRelPath;
   }
@@ -1594,11 +1858,11 @@ function syncDirectory(sourceDir, targetDir) {
   if (!existsSync4(targetDir)) {
     mkdirSync2(targetDir, { recursive: true });
   }
-  const entries = readdirSync2(sourceDir);
+  const entries = readdirSync3(sourceDir);
   for (const entry of entries) {
-    const sourcePath = resolve3(sourceDir, entry);
-    const targetPath = resolve3(targetDir, entry);
-    const entryStat = statSync(sourcePath);
+    const sourcePath = resolve4(sourceDir, entry);
+    const targetPath = resolve4(targetDir, entry);
+    const entryStat = statSync2(sourcePath);
     if (entryStat.isDirectory()) {
       const subStats = syncDirectory(sourcePath, targetPath);
       stats.installed += subStats.installed;
@@ -1624,7 +1888,7 @@ function syncDirectory(sourceDir, targetDir) {
 }
 function installCommands(projectRoot) {
   const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
-  const targetDir = resolve3(projectRoot, claudeDirName, "commands");
+  const targetDir = resolve4(projectRoot, claudeDirName, "commands");
   if (!existsSync4(targetDir)) {
     mkdirSync2(targetDir, { recursive: true });
   }
@@ -1639,7 +1903,7 @@ function installCommands(projectRoot) {
 }
 function installAll(projectRoot) {
   const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
-  const claudeDir = resolve3(projectRoot, claudeDirName);
+  const claudeDir = resolve4(projectRoot, claudeDirName);
   const assets = {};
   let totalInstalled = 0;
   let totalUpdated = 0;
@@ -1649,7 +1913,7 @@ function installAll(projectRoot) {
     if (!sourceDir) {
       continue;
     }
-    const targetDir = resolve3(claudeDir, assetType.targetSubdir);
+    const targetDir = resolve4(claudeDir, assetType.targetSubdir);
     const stats = syncDirectory(sourceDir, targetDir);
     assets[assetType.name] = stats;
     totalInstalled += stats.installed;
@@ -1709,6 +1973,7 @@ __export(init_exports, {
   buildHooksConfig: () => buildHooksConfig,
   detectFramework: () => detectFramework,
   detectPython: () => detectPython,
+  generateClaudeMd: () => generateClaudeMd,
   generateConfig: () => generateConfig,
   initMemoryDir: () => initMemoryDir,
   installHooks: () => installHooks,
@@ -1716,8 +1981,8 @@ __export(init_exports, {
   resolveHooksDir: () => resolveHooksDir,
   runInit: () => runInit
 });
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync3 } from "fs";
-import { resolve as resolve4, basename as basename2, dirname as dirname4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync4 } from "fs";
+import { resolve as resolve5, basename as basename3, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { homedir as homedir2 } from "os";
 import { stringify as yamlStringify } from "yaml";
@@ -1728,7 +1993,7 @@ function detectFramework(projectRoot) {
     orm: "none",
     ui: "none"
   };
-  const pkgPath = resolve4(projectRoot, "package.json");
+  const pkgPath = resolve5(projectRoot, "package.json");
   if (!existsSync5(pkgPath)) return result;
   try {
     const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
@@ -1765,7 +2030,7 @@ function detectPython(projectRoot) {
     alembicDir: null
   };
   const markers = ["pyproject.toml", "setup.py", "requirements.txt", "Pipfile"];
-  const hasMarker = markers.some((m) => existsSync5(resolve4(projectRoot, m)));
+  const hasMarker = markers.some((m) => existsSync5(resolve5(projectRoot, m)));
   if (!hasMarker) return result;
   result.detected = true;
   const depFiles = [
@@ -1775,7 +2040,7 @@ function detectPython(projectRoot) {
     { file: "Pipfile", parser: parsePipfileDeps }
   ];
   for (const { file, parser } of depFiles) {
-    const filePath = resolve4(projectRoot, file);
+    const filePath = resolve5(projectRoot, file);
     if (existsSync5(filePath)) {
       try {
         const content = readFileSync4(filePath, "utf-8");
@@ -1786,25 +2051,25 @@ function detectPython(projectRoot) {
       }
     }
   }
-  if (existsSync5(resolve4(projectRoot, "alembic.ini"))) {
+  if (existsSync5(resolve5(projectRoot, "alembic.ini"))) {
     result.hasAlembic = true;
-    if (existsSync5(resolve4(projectRoot, "alembic"))) {
+    if (existsSync5(resolve5(projectRoot, "alembic"))) {
       result.alembicDir = "alembic";
     }
-  } else if (existsSync5(resolve4(projectRoot, "alembic"))) {
+  } else if (existsSync5(resolve5(projectRoot, "alembic"))) {
     result.hasAlembic = true;
     result.alembicDir = "alembic";
   }
   const candidateRoots = ["app", "src", "backend", "api"];
   for (const candidate of candidateRoots) {
-    const candidatePath = resolve4(projectRoot, candidate);
-    if (existsSync5(candidatePath) && existsSync5(resolve4(candidatePath, "__init__.py"))) {
+    const candidatePath = resolve5(projectRoot, candidate);
+    if (existsSync5(candidatePath) && existsSync5(resolve5(candidatePath, "__init__.py"))) {
       result.root = candidate;
       break;
     }
     if (existsSync5(candidatePath)) {
       try {
-        const files = readdirSync3(candidatePath);
+        const files = readdirSync4(candidatePath);
         if (files.some((f) => f.endsWith(".py"))) {
           result.root = candidate;
           break;
@@ -1850,11 +2115,11 @@ function parsePipfileDeps(content) {
   return deps;
 }
 function generateConfig(projectRoot, framework) {
-  const configPath = resolve4(projectRoot, "massu.config.yaml");
+  const configPath = resolve5(projectRoot, "massu.config.yaml");
   if (existsSync5(configPath)) {
     return false;
   }
-  const projectName = basename2(projectRoot);
+  const projectName = basename3(projectRoot);
   const config = {
     project: {
       name: projectName,
@@ -1900,8 +2165,18 @@ ${yamlStringify(config)}`;
   writeFileSync2(configPath, yamlContent, "utf-8");
   return true;
 }
+function generateClaudeMd(projectRoot, framework, python) {
+  const claudeMdPath = resolve5(projectRoot, "CLAUDE.md");
+  if (existsSync5(claudeMdPath)) {
+    return { created: false, skipped: true };
+  }
+  const projectName = basename3(projectRoot);
+  const content = buildClaudeMdContent(projectName, projectRoot, framework, python);
+  writeFileSync2(claudeMdPath, content, "utf-8");
+  return { created: true, skipped: false };
+}
 function registerMcpServer(projectRoot) {
-  const mcpPath = resolve4(projectRoot, ".mcp.json");
+  const mcpPath = resolve5(projectRoot, ".mcp.json");
   let existing = {};
   if (existsSync5(mcpPath)) {
     try {
@@ -1924,19 +2199,11 @@ function registerMcpServer(projectRoot) {
   return true;
 }
 function resolveHooksDir() {
-  const cwd = process.cwd();
-  const nodeModulesPath = resolve4(cwd, "node_modules/@massu/core/dist/hooks");
-  if (existsSync5(nodeModulesPath)) {
-    return "node_modules/@massu/core/dist/hooks";
-  }
-  const localPath = resolve4(__dirname2, "../dist/hooks");
-  if (existsSync5(localPath)) {
-    return localPath;
-  }
   return "node_modules/@massu/core/dist/hooks";
 }
 function hookCmd(hooksDir, hookFile) {
-  return `node ${hooksDir}/${hookFile}`;
+  const hookPath = `${hooksDir}/${hookFile}`;
+  return `d="$PWD"; while [ "$d" != "/" ] && [ ! -f "$d/${hookPath}" ]; do d="$(dirname "$d")"; done; cd "$d" && node ${hookPath}`;
 }
 function buildHooksConfig(hooksDir) {
   return {
@@ -2012,8 +2279,8 @@ function buildHooksConfig(hooksDir) {
 }
 function installHooks(projectRoot) {
   const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
-  const claudeDir = resolve4(projectRoot, claudeDirName);
-  const settingsPath = resolve4(claudeDir, "settings.local.json");
+  const claudeDir = resolve5(projectRoot, claudeDirName);
+  const settingsPath = resolve5(claudeDir, "settings.local.json");
   if (!existsSync5(claudeDir)) {
     mkdirSync3(claudeDir, { recursive: true });
   }
@@ -2039,16 +2306,16 @@ function installHooks(projectRoot) {
 }
 function initMemoryDir(projectRoot) {
   const encodedRoot = "-" + projectRoot.replace(/\//g, "-");
-  const memoryDir = resolve4(homedir2(), `.claude/projects/${encodedRoot}/memory`);
+  const memoryDir = resolve5(homedir2(), `.claude/projects/${encodedRoot}/memory`);
   let created = false;
   if (!existsSync5(memoryDir)) {
     mkdirSync3(memoryDir, { recursive: true });
     created = true;
   }
-  const memoryMdPath = resolve4(memoryDir, "MEMORY.md");
+  const memoryMdPath = resolve5(memoryDir, "MEMORY.md");
   let memoryMdCreated = false;
   if (!existsSync5(memoryMdPath)) {
-    const projectName = basename2(projectRoot);
+    const projectName = basename3(projectRoot);
     const memoryContent = `# ${projectName} - Massu Memory
 
 ## Key Learnings
@@ -2076,9 +2343,9 @@ async function runInit() {
   console.log("");
   const framework = detectFramework(projectRoot);
   const frameworkParts = [];
-  if (framework.type !== "javascript") frameworkParts.push(capitalize(framework.type));
+  if (framework.type !== "javascript") frameworkParts.push(capitalize2(framework.type));
   if (framework.ui !== "none") frameworkParts.push(formatName(framework.ui));
-  if (framework.orm !== "none") frameworkParts.push(capitalize(framework.orm));
+  if (framework.orm !== "none") frameworkParts.push(capitalize2(framework.orm));
   if (framework.router !== "none") frameworkParts.push(framework.router.toUpperCase());
   const detected = frameworkParts.length > 0 ? frameworkParts.join(", ") : "JavaScript";
   console.log(`  Detected: ${detected}`);
@@ -2090,6 +2357,12 @@ async function runInit() {
     if (python.hasAlembic) pyParts.push("Alembic");
     console.log(`  Detected: ${pyParts.join(", ")} (root: ${python.root})`);
   }
+  const claudeMdResult = generateClaudeMd(projectRoot, framework, python);
+  if (claudeMdResult.created) {
+    console.log("  Created CLAUDE.md (project instructions for Claude Code)");
+  } else {
+    console.log("  CLAUDE.md already exists (preserved)");
+  }
   const configCreated = generateConfig(projectRoot, framework);
   if (configCreated) {
     console.log("  Created massu.config.yaml");
@@ -2123,8 +2396,8 @@ async function runInit() {
   try {
     const claudeDirName = ".claude";
     const encodedRoot = projectRoot.replace(/\//g, "-");
-    const computedMemoryDir = resolve4(homedir2(), claudeDirName, "projects", encodedRoot, "memory");
-    const memFiles = existsSync5(computedMemoryDir) ? readdirSync3(computedMemoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
+    const computedMemoryDir = resolve5(homedir2(), claudeDirName, "projects", encodedRoot, "memory");
+    const memFiles = existsSync5(computedMemoryDir) ? readdirSync4(computedMemoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
     if (memFiles.length > 0) {
       const { getMemoryDb: getMemoryDb2 } = await Promise.resolve().then(() => (init_memory_db(), memory_db_exports));
       const db = getMemoryDb2();
@@ -2150,7 +2423,7 @@ async function runInit() {
   console.log("Documentation: https://massu.ai/docs");
   console.log("");
 }
-function capitalize(str) {
+function capitalize2(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function formatName(name) {
@@ -2162,13 +2435,14 @@ function formatName(name) {
     vue: "Vue",
     react: "React"
   };
-  return names[name] ?? capitalize(name);
+  return names[name] ?? capitalize2(name);
 }
 var __filename2, __dirname2;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_memory_file_ingest();
+    init_claude_md_templates();
     init_config();
     init_install_commands();
     __filename2 = fileURLToPath2(import.meta.url);
@@ -2472,18 +2746,18 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor,
   runValidateConfig: () => runValidateConfig
 });
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "fs";
-import { resolve as resolve5, dirname as dirname5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync5 } from "fs";
+import { resolve as resolve6, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { parse as parseYaml3 } from "yaml";
+import { parse as parseYaml2 } from "yaml";
 function checkConfig(projectRoot) {
-  const configPath = resolve5(projectRoot, "massu.config.yaml");
+  const configPath = resolve6(projectRoot, "massu.config.yaml");
   if (!existsSync6(configPath)) {
     return { name: "Configuration", status: "fail", detail: "massu.config.yaml not found. Run: npx massu init" };
   }
   try {
     const content = readFileSync5(configPath, "utf-8");
-    const parsed = parseYaml3(content);
+    const parsed = parseYaml2(content);
     if (!parsed || typeof parsed !== "object") {
       return { name: "Configuration", status: "fail", detail: "massu.config.yaml is empty or invalid YAML" };
     }
@@ -2538,10 +2812,10 @@ function checkHooksConfig(projectRoot) {
   }
 }
 function checkHookFiles(projectRoot) {
-  const nodeModulesHooksDir = resolve5(projectRoot, "node_modules/@massu/core/dist/hooks");
+  const nodeModulesHooksDir = resolve6(projectRoot, "node_modules/@massu/core/dist/hooks");
   let hooksDir = nodeModulesHooksDir;
   if (!existsSync6(nodeModulesHooksDir)) {
-    const devHooksDir = resolve5(__dirname3, "../../dist/hooks");
+    const devHooksDir = resolve6(__dirname3, "../../dist/hooks");
     if (existsSync6(devHooksDir)) {
       hooksDir = devHooksDir;
     } else {
@@ -2550,7 +2824,7 @@ function checkHookFiles(projectRoot) {
   }
   const missing = [];
   for (const hookFile of EXPECTED_HOOKS) {
-    if (!existsSync6(resolve5(hooksDir, hookFile))) {
+    if (!existsSync6(resolve6(hooksDir, hookFile))) {
       missing.push(hookFile);
     }
   }
@@ -2576,7 +2850,7 @@ function checkNodeVersion() {
   return { name: "Node.js", status: "fail", detail: `v${version} \u2014 Node.js 18+ is required` };
 }
 async function checkGitRepo(projectRoot) {
-  const gitDir = resolve5(projectRoot, ".git");
+  const gitDir = resolve6(projectRoot, ".git");
   if (!existsSync6(gitDir)) {
     return { name: "Git Repository", status: "warn", detail: "Not a git repository (optional but recommended)" };
   }
@@ -2676,7 +2950,7 @@ async function checkLicenseStatus() {
 function checkPythonHealth(projectRoot) {
   const config = getConfig();
   if (!config.python?.root) return null;
-  const pythonRoot = resolve5(projectRoot, config.python.root);
+  const pythonRoot = resolve6(projectRoot, config.python.root);
   if (!existsSync6(pythonRoot)) {
     return {
       name: "Python",
@@ -2691,15 +2965,15 @@ function checkPythonHealth(projectRoot) {
   function scanDir(dir, depth) {
     if (depth > 5) return;
     try {
-      const entries = readdirSync4(dir, { withFileTypes: true });
+      const entries = readdirSync5(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           const excludeDirs = config.python?.exclude_dirs || ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"];
           if (!excludeDirs.includes(entry.name)) {
-            const subdir = resolve5(dir, entry.name);
-            if (depth <= 2 && !existsSync6(resolve5(subdir, "__init__.py"))) {
+            const subdir = resolve6(dir, entry.name);
+            if (depth <= 2 && !existsSync6(resolve6(subdir, "__init__.py"))) {
               try {
-                const subEntries = readdirSync4(subdir);
+                const subEntries = readdirSync5(subdir);
                 if (subEntries.some((f) => f.endsWith(".py") && f !== "__init__.py")) {
                   initPyMissing.push(entry.name);
                 }
@@ -2746,6 +3020,29 @@ function checkPythonHealth(projectRoot) {
     detail: parts.join(", ")
   };
 }
+function checkClaudeMd(projectRoot) {
+  const claudeMdPath = resolve6(projectRoot, "CLAUDE.md");
+  if (!existsSync6(claudeMdPath)) {
+    return {
+      name: "CLAUDE.md",
+      status: "warn",
+      detail: "CLAUDE.md not found. Run: npx massu init (or create manually)"
+    };
+  }
+  const content = readFileSync5(claudeMdPath, "utf-8");
+  if (content.trim().length < 50) {
+    return {
+      name: "CLAUDE.md",
+      status: "warn",
+      detail: "CLAUDE.md exists but appears empty or minimal"
+    };
+  }
+  return {
+    name: "CLAUDE.md",
+    status: "pass",
+    detail: "CLAUDE.md found and has content"
+  };
+}
 async function runDoctor() {
   const projectRoot = process.cwd();
   console.log("");
@@ -2763,7 +3060,8 @@ async function runDoctor() {
     await checkNativeModules(),
     checkNodeVersion(),
     await checkGitRepo(projectRoot),
-    await checkLicenseStatus()
+    await checkLicenseStatus(),
+    checkClaudeMd(projectRoot)
   ];
   const pythonCheck = checkPythonHealth(projectRoot);
   if (pythonCheck) checks.push(pythonCheck);
@@ -2792,7 +3090,7 @@ async function runDoctor() {
 }
 async function runValidateConfig() {
   const projectRoot = process.cwd();
-  const configPath = resolve5(projectRoot, "massu.config.yaml");
+  const configPath = resolve6(projectRoot, "massu.config.yaml");
   if (!existsSync6(configPath)) {
     console.error("Error: massu.config.yaml not found in current directory");
     console.error("Run: npx massu init");
@@ -2801,7 +3099,7 @@ async function runValidateConfig() {
   }
   try {
     const content = readFileSync5(configPath, "utf-8");
-    const parsed = parseYaml3(content);
+    const parsed = parseYaml2(content);
     if (!parsed || typeof parsed !== "object") {
       console.error("Error: massu.config.yaml is empty or not a valid YAML object");
       process.exit(1);
@@ -2883,7 +3181,7 @@ var init_install_hooks = __esm({
 // src/db.ts
 import Database2 from "better-sqlite3";
 import { dirname as dirname6, join as join3 } from "path";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
 function getCodeGraphDb() {
   const dbPath = getResolvedPaths().codegraphDbPath;
   if (!existsSync7(dbPath)) {
@@ -3167,14 +3465,14 @@ function isPythonDataStale(dataDb2, pythonRoot) {
   const lastBuildTime = new Date(lastBuild.value).getTime();
   function checkDir(dir) {
     try {
-      const entries = readdirSync5(dir, { withFileTypes: true });
+      const entries = readdirSync6(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = join3(dir, entry.name);
         if (entry.isDirectory()) {
           if (["__pycache__", ".venv", "venv", "node_modules", ".mypy_cache", ".pytest_cache"].includes(entry.name)) continue;
           if (checkDir(fullPath)) return true;
         } else if (entry.name.endsWith(".py")) {
-          if (statSync2(fullPath).mtimeMs > lastBuildTime) return true;
+          if (statSync3(fullPath).mtimeMs > lastBuildTime) return true;
         }
       }
     } catch {
@@ -3194,10 +3492,10 @@ var init_db = __esm({
 });
 
 // src/security-utils.ts
-import { resolve as resolve6, normalize } from "path";
+import { resolve as resolve7, normalize } from "path";
 function ensureWithinRoot(filePath, projectRoot) {
-  const resolvedRoot = resolve6(projectRoot);
-  const resolvedPath = resolve6(resolvedRoot, filePath);
+  const resolvedRoot = resolve7(projectRoot);
+  const resolvedPath = resolve7(resolvedRoot, filePath);
   const normalizedPath = normalize(resolvedPath);
   const normalizedRoot = normalize(resolvedRoot);
   if (!normalizedPath.startsWith(normalizedRoot + "/") && normalizedPath !== normalizedRoot) {
@@ -3270,8 +3568,8 @@ var init_rules = __esm({
 });
 
 // src/import-resolver.ts
-import { readFileSync as readFileSync6, existsSync as existsSync8, statSync as statSync3 } from "fs";
-import { resolve as resolve7, dirname as dirname7, join as join4 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync8, statSync as statSync4 } from "fs";
+import { resolve as resolve8, dirname as dirname7, join as join4 } from "path";
 function parseImports(source) {
   const imports = [];
   const lines = source.split("\n");
@@ -3327,9 +3625,9 @@ function resolveImportPath(specifier, fromFile) {
   let basePath;
   if (specifier.startsWith("@/")) {
     const paths = getResolvedPaths();
-    basePath = resolve7(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
+    basePath = resolve8(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
   } else {
-    basePath = resolve7(dirname7(fromFile), specifier);
+    basePath = resolve8(dirname7(fromFile), specifier);
   }
   if (existsSync8(basePath) && !isDirectory(basePath)) {
     return toRelative(basePath);
@@ -3351,7 +3649,7 @@ function resolveImportPath(specifier, fromFile) {
 }
 function isDirectory(path) {
   try {
-    return statSync3(path).isDirectory();
+    return statSync4(path).isDirectory();
   } catch {
     return false;
   }
@@ -3379,7 +3677,7 @@ function buildImportIndex(dataDb2, codegraphDb2) {
   const batchSize = 500;
   let batch = [];
   for (const file of files) {
-    const absPath = ensureWithinRoot(resolve7(projectRoot, file.path), projectRoot);
+    const absPath = ensureWithinRoot(resolve8(projectRoot, file.path), projectRoot);
     if (!existsSync8(absPath)) continue;
     let source;
     try {
@@ -3419,8 +3717,8 @@ var init_import_resolver = __esm({
 });
 
 // src/trpc-index.ts
-import { readFileSync as readFileSync7, existsSync as existsSync9, readdirSync as readdirSync6 } from "fs";
-import { resolve as resolve8, join as join5 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync9, readdirSync as readdirSync7 } from "fs";
+import { resolve as resolve9, join as join5 } from "path";
 function parseRootRouter() {
   const paths = getResolvedPaths();
   const rootPath = paths.rootRouterPath;
@@ -3435,7 +3733,7 @@ function parseRootRouter() {
   while ((match = importRegex.exec(source)) !== null) {
     const variable = match[1];
     let filePath = match[2];
-    const fullPath = resolve8(paths.routersDir, filePath);
+    const fullPath = resolve9(paths.routersDir, filePath);
     for (const ext of [".ts", ".tsx", ""]) {
       const candidate = fullPath + ext;
       const routersRelPath = getConfig().paths.routers ?? "src/server/api/routers";
@@ -3463,7 +3761,7 @@ function parseRootRouter() {
   return mappings;
 }
 function extractProcedures(routerFilePath) {
-  const absPath = resolve8(getProjectRoot(), routerFilePath);
+  const absPath = resolve9(getProjectRoot(), routerFilePath);
   if (!existsSync9(absPath)) return [];
   const source = readFileSync7(absPath, "utf-8");
   const procedures = [];
@@ -3488,9 +3786,9 @@ function findUICallSites(routerKey, procedureName) {
   const root = getProjectRoot();
   const src = config.paths.source;
   const searchDirs = [
-    resolve8(root, config.paths.pages ?? src + "/app"),
-    resolve8(root, config.paths.components ?? src + "/components"),
-    resolve8(root, config.paths.hooks ?? src + "/hooks")
+    resolve9(root, config.paths.pages ?? src + "/app"),
+    resolve9(root, config.paths.components ?? src + "/components"),
+    resolve9(root, config.paths.hooks ?? src + "/hooks")
   ];
   const searchPattern = `api.${routerKey}.${procedureName}`;
   for (const dir of searchDirs) {
@@ -3500,7 +3798,7 @@ function findUICallSites(routerKey, procedureName) {
   return callSites;
 }
 function searchDirectory(dir, pattern, results) {
-  const entries = readdirSync6(dir, { withFileTypes: true });
+  const entries = readdirSync7(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join5(dir, entry.name);
     if (entry.isDirectory()) {
@@ -3572,7 +3870,7 @@ var init_trpc_index = __esm({
 
 // src/page-deps.ts
 import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 function deriveRoute(pageFile) {
   let route = pageFile.replace(/^src\/app/, "").replace(/\/page\.tsx?$/, "").replace(/\/page\.jsx?$/, "");
   return route || "/";
@@ -3610,7 +3908,7 @@ function findRouterCalls(files) {
   const routers = /* @__PURE__ */ new Set();
   const projectRoot = getProjectRoot();
   for (const file of files) {
-    const absPath = ensureWithinRoot(resolve9(projectRoot, file), projectRoot);
+    const absPath = ensureWithinRoot(resolve10(projectRoot, file), projectRoot);
     if (!existsSync10(absPath)) continue;
     try {
       const source = readFileSync8(absPath, "utf-8");
@@ -3631,7 +3929,7 @@ 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(resolve9(getProjectRoot(), proc.router_file), getProjectRoot());
+      const absPath = ensureWithinRoot(resolve10(getProjectRoot(), proc.router_file), getProjectRoot());
       if (!existsSync10(absPath)) continue;
       try {
         const source = readFileSync8(absPath, "utf-8");
@@ -3903,7 +4201,7 @@ var init_domains = __esm({
 });
 
 // src/schema-mapper.ts
-import { readFileSync as readFileSync9, existsSync as existsSync11, readdirSync as readdirSync7 } from "fs";
+import { readFileSync as readFileSync9, existsSync as existsSync11, readdirSync as readdirSync8 } from "fs";
 import { join as join6 } from "path";
 function parsePrismaSchema() {
   const schemaPath = getResolvedPaths().prismaSchemaPath;
@@ -3973,7 +4271,7 @@ function findColumnUsageInRouters(tableName) {
   return usage;
 }
 function scanDirectory(dir, tableName, usage) {
-  const entries = readdirSync7(dir, { withFileTypes: true });
+  const entries = readdirSync8(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join6(dir, entry.name);
     if (entry.isDirectory()) {
@@ -4031,7 +4329,7 @@ function detectMismatches(models) {
 function findFilesUsingColumn(dir, column, tableName) {
   const result = [];
   if (!existsSync11(dir)) return result;
-  const entries = readdirSync7(dir, { withFileTypes: true });
+  const entries = readdirSync8(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join6(dir, entry.name);
     if (entry.isDirectory()) {
@@ -4183,12 +4481,12 @@ var init_import_parser = __esm({
 });
 
 // src/python/import-resolver.ts
-import { readFileSync as readFileSync10, existsSync as existsSync12, readdirSync as readdirSync8 } from "fs";
-import { resolve as resolve11, join as join7, relative as relative2, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync12, readdirSync as readdirSync9 } from "fs";
+import { resolve as resolve12, join as join7, relative as relative3, dirname as dirname8 } from "path";
 function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
   const projectRoot = getProjectRoot();
   if (level > 0) {
-    let baseDir = dirname8(resolve11(projectRoot, fromFile));
+    let baseDir = dirname8(resolve12(projectRoot, fromFile));
     for (let i = 1; i < level; i++) {
       baseDir = dirname8(baseDir);
     }
@@ -4200,25 +4498,25 @@ function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
     return tryResolvePythonPath(baseDir, projectRoot);
   }
   const parts = module.split(".");
-  const candidate = join7(resolve11(projectRoot, pythonRoot), ...parts);
+  const candidate = join7(resolve12(projectRoot, pythonRoot), ...parts);
   return tryResolvePythonPath(candidate, projectRoot);
 }
 function tryResolvePythonPath(basePath, projectRoot) {
   if (existsSync12(basePath + ".py")) {
-    return relative2(projectRoot, basePath + ".py");
+    return relative3(projectRoot, basePath + ".py");
   }
   if (existsSync12(join7(basePath, "__init__.py"))) {
-    return relative2(projectRoot, join7(basePath, "__init__.py"));
+    return relative3(projectRoot, join7(basePath, "__init__.py"));
   }
   if (basePath.endsWith(".py") && existsSync12(basePath)) {
-    return relative2(projectRoot, basePath);
+    return relative3(projectRoot, basePath);
   }
   return null;
 }
 function walkPythonFiles(dir, excludeDirs) {
   const files = [];
   try {
-    const entries = readdirSync8(dir, { withFileTypes: true });
+    const entries = readdirSync9(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
@@ -4233,7 +4531,7 @@ function walkPythonFiles(dir, excludeDirs) {
 }
 function buildPythonImportIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]) {
   const projectRoot = getProjectRoot();
-  const absRoot = resolve11(projectRoot, pythonRoot);
+  const absRoot = resolve12(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 (?, ?, ?, ?, ?)"
@@ -4247,7 +4545,7 @@ function buildPythonImportIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__
   });
   const batch = [];
   for (const absFile of files) {
-    const relFile = relative2(projectRoot, absFile);
+    const relFile = relative3(projectRoot, absFile);
     let source;
     try {
       source = readFileSync10(absFile, "utf-8");
@@ -4516,12 +4814,12 @@ var init_route_parser = __esm({
 });
 
 // src/python/route-indexer.ts
-import { readFileSync as readFileSync11, readdirSync as readdirSync9 } from "fs";
-import { join as join8, relative as relative3 } from "path";
+import { readFileSync as readFileSync11, readdirSync as readdirSync10 } from "fs";
+import { join as join8, relative as relative4 } from "path";
 function walkPyFiles(dir, excludeDirs) {
   const files = [];
   try {
-    const entries = readdirSync9(dir, { withFileTypes: true });
+    const entries = readdirSync10(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
@@ -4546,7 +4844,7 @@ function buildPythonRouteIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__"
   let count = 0;
   dataDb2.transaction(() => {
     for (const absFile of files) {
-      const relFile = relative3(projectRoot, absFile);
+      const relFile = relative4(projectRoot, absFile);
       let source;
       try {
         source = readFileSync11(absFile, "utf-8");
@@ -4760,12 +5058,12 @@ var init_model_parser = __esm({
 });
 
 // src/python/model-indexer.ts
-import { readFileSync as readFileSync12, readdirSync as readdirSync10 } from "fs";
-import { join as join9, relative as relative4 } from "path";
+import { readFileSync as readFileSync12, readdirSync as readdirSync11 } from "fs";
+import { join as join9, relative as relative5 } from "path";
 function walkPyFiles2(dir, excludeDirs) {
   const files = [];
   try {
-    const entries = readdirSync10(dir, { withFileTypes: true });
+    const entries = readdirSync11(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
@@ -4793,7 +5091,7 @@ function buildPythonModelIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__"
   let count = 0;
   dataDb2.transaction(() => {
     for (const absFile of files) {
-      const relFile = relative4(projectRoot, absFile);
+      const relFile = relative5(projectRoot, absFile);
       let source;
       try {
         source = readFileSync12(absFile, "utf-8");
@@ -5056,8 +5354,8 @@ var init_migration_parser = __esm({
 });
 
 // src/python/migration-indexer.ts
-import { readFileSync as readFileSync13, readdirSync as readdirSync11 } from "fs";
-import { join as join10, relative as relative5 } from "path";
+import { readFileSync as readFileSync13, readdirSync as readdirSync12 } from "fs";
+import { join as join10, relative as relative6 } from "path";
 function buildPythonMigrationIndex(dataDb2, alembicDir) {
   const projectRoot = getProjectRoot();
   const absDir = join10(projectRoot, alembicDir);
@@ -5065,10 +5363,10 @@ function buildPythonMigrationIndex(dataDb2, alembicDir) {
   const versionsDir = join10(absDir, "versions");
   let files = [];
   try {
-    files = readdirSync11(versionsDir).filter((f) => f.endsWith(".py")).map((f) => join10(versionsDir, f));
+    files = readdirSync12(versionsDir).filter((f) => f.endsWith(".py")).map((f) => join10(versionsDir, f));
   } catch {
     try {
-      files = readdirSync11(absDir).filter((f) => f.endsWith(".py") && f !== "env.py").map((f) => join10(absDir, f));
+      files = readdirSync12(absDir).filter((f) => f.endsWith(".py") && f !== "env.py").map((f) => join10(absDir, f));
     } catch {
     }
   }
@@ -5093,7 +5391,7 @@ function buildPythonMigrationIndex(dataDb2, alembicDir) {
     rows.push({
       revision: parsed.revision,
       downRevision: parsed.downRevision,
-      file: relative5(projectRoot, absFile),
+      file: relative6(projectRoot, absFile),
       description: parsed.description,
       operations: JSON.stringify(parsed.operations)
     });
@@ -5116,8 +5414,8 @@ var init_migration_indexer = __esm({
 });
 
 // src/python/coupling-detector.ts
-import { readFileSync as readFileSync14, readdirSync as readdirSync12 } from "fs";
-import { join as join11, relative as relative6 } from "path";
+import { readFileSync as readFileSync14, readdirSync as readdirSync13 } from "fs";
+import { join as join11, relative as relative7 } from "path";
 function buildPythonCouplingIndex(dataDb2) {
   const projectRoot = getProjectRoot();
   const config = getConfig();
@@ -5150,7 +5448,7 @@ function buildPythonCouplingIndex(dataDb2) {
   ];
   dataDb2.transaction(() => {
     for (const absFile of frontendFiles) {
-      const relFile = relative6(projectRoot, absFile);
+      const relFile = relative7(projectRoot, absFile);
       let source;
       try {
         source = readFileSync14(absFile, "utf-8");
@@ -5181,7 +5479,7 @@ function walkFrontendFiles(dir) {
   const files = [];
   const exclude = ["node_modules", ".next", "dist", ".git", "__pycache__", ".venv", "venv"];
   try {
-    const entries = readdirSync12(dir, { withFileTypes: true });
+    const entries = readdirSync13(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (exclude.includes(entry.name)) continue;
@@ -5559,7 +5857,7 @@ var init_memory_tools = __esm({
 
 // src/docs-tools.ts
 import { readFileSync as readFileSync15, existsSync as existsSync13 } from "fs";
-import { resolve as resolve12, basename as basename3 } from "path";
+import { resolve as resolve13, basename as basename4 } from "path";
 function p2(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -5626,7 +5924,7 @@ function matchesPattern(filePath, pattern) {
 function findAffectedMappings(docsMap, changedFiles) {
   const affected = /* @__PURE__ */ new Map();
   for (const file of changedFiles) {
-    const fileName = basename3(file);
+    const fileName = basename4(file);
     for (const mapping of docsMap.mappings) {
       let matched = false;
       for (const routePattern of mapping.appRoutes) {
@@ -5687,9 +5985,9 @@ function extractFrontmatter(content) {
 }
 function extractProcedureNames(routerPath) {
   const root = getProjectRoot();
-  const absPath = ensureWithinRoot(resolve12(getResolvedPaths().srcDir, "..", routerPath), root);
+  const absPath = ensureWithinRoot(resolve13(getResolvedPaths().srcDir, "..", routerPath), root);
   if (!existsSync13(absPath)) {
-    const altPath = ensureWithinRoot(resolve12(getResolvedPaths().srcDir, "../server/api/routers", basename3(routerPath)), root);
+    const altPath = ensureWithinRoot(resolve13(getResolvedPaths().srcDir, "../server/api/routers", basename4(routerPath)), root);
     if (!existsSync13(altPath)) return [];
     return extractProcedureNamesFromContent(readFileSync15(altPath, "utf-8"));
   }
@@ -5733,7 +6031,7 @@ function handleDocsAudit(args2) {
   for (const [mappingId, triggeringFiles] of affectedMappings) {
     const mapping = docsMap.mappings.find((m) => m.id === mappingId);
     if (!mapping) continue;
-    const helpPagePath = ensureWithinRoot(resolve12(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
+    const helpPagePath = ensureWithinRoot(resolve13(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
     if (!existsSync13(helpPagePath)) {
       results.push({
         helpPage: mapping.helpPage,
@@ -5751,7 +6049,7 @@ function handleDocsAudit(args2) {
     const frontmatter = extractFrontmatter(content);
     const staleReasons = [];
     for (const file of triggeringFiles) {
-      const fileName = basename3(file);
+      const fileName = basename4(file);
       if (mapping.routers.includes(fileName)) {
         const procedures = extractProcedureNames(file);
         const undocumented = procedures.filter((p19) => !contentMentions(content, p19));
@@ -5782,11 +6080,11 @@ function handleDocsAudit(args2) {
       reason: staleReasons.length > 0 ? staleReasons.join("; ") : "Content appears current",
       sections,
       changedFiles: triggeringFiles,
-      suggestedAction: status === "STALE" ? `Review and update ${mapping.helpPage} to reflect changes in: ${triggeringFiles.map((f) => basename3(f)).join(", ")}` : "No action needed"
+      suggestedAction: status === "STALE" ? `Review and update ${mapping.helpPage} to reflect changes in: ${triggeringFiles.map((f) => basename4(f)).join(", ")}` : "No action needed"
     });
     for (const [guideName, parentId] of Object.entries(docsMap.userGuideInheritance.examples)) {
       if (parentId === mappingId) {
-        const guidePath = ensureWithinRoot(resolve12(getResolvedPaths().helpSitePath, `pages/user-guides/${guideName}/index.mdx`), getProjectRoot());
+        const guidePath = ensureWithinRoot(resolve13(getResolvedPaths().helpSitePath, `pages/user-guides/${guideName}/index.mdx`), getProjectRoot());
         if (existsSync13(guidePath)) {
           const guideContent = readFileSync15(guidePath, "utf-8");
           const guideFrontmatter = extractFrontmatter(guideContent);
@@ -5821,7 +6119,7 @@ function handleDocsCoverage(args2) {
   const gaps = [];
   const mappings = filterDomain ? docsMap.mappings.filter((m) => m.id === filterDomain) : docsMap.mappings;
   for (const mapping of mappings) {
-    const helpPagePath = ensureWithinRoot(resolve12(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
+    const helpPagePath = ensureWithinRoot(resolve13(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
     const exists = existsSync13(helpPagePath);
     let hasContent = false;
     let lineCount = 0;
@@ -6170,7 +6468,7 @@ var init_observability_tools = __esm({
 
 // src/sentinel-db.ts
 import { existsSync as existsSync14 } from "fs";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 function parsePortalScope(raw) {
   if (!raw) return [];
   try {
@@ -6406,22 +6704,22 @@ function validateFeatures(db, domainFilter) {
     const missingProcedures = [];
     const missingPages = [];
     for (const comp of components) {
-      const absPath = resolve13(PROJECT_ROOT, comp.component_file);
+      const absPath = resolve14(PROJECT_ROOT, comp.component_file);
       if (!existsSync14(absPath)) {
         missingComponents.push(comp.component_file);
       }
     }
     for (const proc of procedures) {
-      const routerPath = resolve13(PROJECT_ROOT, `src/server/api/routers/${proc.router_name}.ts`);
+      const routerPath = resolve14(PROJECT_ROOT, `src/server/api/routers/${proc.router_name}.ts`);
       if (!existsSync14(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 = resolve13(PROJECT_ROOT, routeToPath);
+      const absPath = resolve14(PROJECT_ROOT, routeToPath);
       if (page.page_route.startsWith("/") && !existsSync14(absPath)) {
-        const altPath = resolve13(PROJECT_ROOT, `src/app${page.page_route}/page.tsx`);
+        const altPath = resolve14(PROJECT_ROOT, `src/app${page.page_route}/page.tsx`);
         if (!existsSync14(altPath)) {
           missingPages.push(page.page_route);
         }
@@ -6946,8 +7244,8 @@ var init_sentinel_tools = __esm({
 });
 
 // src/sentinel-scanner.ts
-import { readFileSync as readFileSync16, existsSync as existsSync15, readdirSync as readdirSync13, statSync as statSync4 } from "fs";
-import { resolve as resolve14, join as join12, basename as basename4, dirname as dirname9, relative as relative7 } from "path";
+import { readFileSync as readFileSync16, existsSync as existsSync15, readdirSync as readdirSync14, statSync as statSync5 } from "fs";
+import { resolve as resolve15, join as join12, basename as basename5, dirname as dirname9, relative as relative8 } from "path";
 function inferDomain(filePath) {
   const domains = getConfig().domains;
   const path = filePath.toLowerCase();
@@ -7076,10 +7374,10 @@ function scanComponentExports(dataDb2) {
   const projectRoot = getProjectRoot();
   const componentsBase = config.paths.components ?? config.paths.source + "/components";
   const componentDirs = [];
-  const basePath = resolve14(projectRoot, componentsBase);
+  const basePath = resolve15(projectRoot, componentsBase);
   if (existsSync15(basePath)) {
     try {
-      const entries = readdirSync13(basePath, { withFileTypes: true });
+      const entries = readdirSync14(basePath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           componentDirs.push(componentsBase + "/" + entry.name);
@@ -7089,11 +7387,11 @@ function scanComponentExports(dataDb2) {
     }
   }
   for (const dir of componentDirs) {
-    const absDir = resolve14(projectRoot, dir);
+    const absDir = resolve15(projectRoot, dir);
     if (!existsSync15(absDir)) continue;
     const files = walkDir(absDir).filter((f) => f.endsWith(".tsx") || f.endsWith(".ts"));
     for (const file of files) {
-      const relPath = relative7(projectRoot, file);
+      const relPath = relative8(projectRoot, file);
       const source = readFileSync16(file, "utf-8");
       const annotations = parseFeatureAnnotations(source);
       if (annotations.length > 0) {
@@ -7120,7 +7418,7 @@ function scanComponentExports(dataDb2) {
       if (hasHandlers && exportMatch) {
         const componentName = exportMatch[1];
         const domain = inferDomain(relPath);
-        const subdomain = basename4(dirname9(relPath));
+        const subdomain = basename5(dirname9(relPath));
         const featureKey = `component.${subdomain}.${componentName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "")}`;
         if (!annotations.some((a) => a.featureKey === featureKey)) {
           features.push({
@@ -7143,11 +7441,11 @@ function scanComponentExports(dataDb2) {
 function walkDir(dir) {
   const results = [];
   try {
-    const entries = readdirSync13(dir);
+    const entries = readdirSync14(dir);
     for (const entry of entries) {
       const fullPath = join12(dir, entry);
       try {
-        const stat = statSync4(fullPath);
+        const stat = statSync5(fullPath);
         if (stat.isDirectory()) {
           results.push(...walkDir(fullPath));
         } else {
@@ -8937,7 +9235,7 @@ var init_security_scorer = __esm({
 
 // src/dependency-scorer.ts
 import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 function p12(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -8969,7 +9267,7 @@ function calculateDepRisk(factors) {
   return Math.min(100, risk);
 }
 function getInstalledPackages(projectRoot) {
-  const pkgPath = resolve15(projectRoot, "package.json");
+  const pkgPath = resolve16(projectRoot, "package.json");
   if (!existsSync18(pkgPath)) return /* @__PURE__ */ new Map();
   try {
     const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
@@ -9575,8 +9873,8 @@ var init_regression_detector = __esm({
 
 // src/knowledge-indexer.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync20, readdirSync as readdirSync14, statSync as statSync5, existsSync as existsSync19 } from "fs";
-import { resolve as resolve16, relative as relative8, basename as basename5, extname } from "path";
+import { readFileSync as readFileSync20, readdirSync as readdirSync15, statSync as statSync6, existsSync as existsSync19 } from "fs";
+import { resolve as resolve17, relative as relative9, basename as basename6, extname } from "path";
 function getKnowledgePaths() {
   const resolved = getResolvedPaths();
   const config = getConfig();
@@ -9602,9 +9900,9 @@ function discoverMarkdownFiles(baseDir) {
   const files = [];
   function walk(dir) {
     try {
-      const entries = readdirSync14(dir, { withFileTypes: true });
+      const entries = readdirSync15(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = resolve16(dir, entry.name);
+        const fullPath = resolve17(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "archive" && dir.includes("session-state")) continue;
           if (entry.name === "archive" && dir.includes("status")) continue;
@@ -9624,7 +9922,7 @@ function categorizeFile(filePath) {
   const paths = getKnowledgePaths();
   if (filePath.startsWith(paths.plansDir)) return "plan";
   if (filePath.startsWith(paths.docsDir)) {
-    const relFromDocs = relative8(paths.docsDir, filePath).replace(/\\/g, "/").toLowerCase();
+    const relFromDocs = relative9(paths.docsDir, filePath).replace(/\\/g, "/").toLowerCase();
     if (relFromDocs.startsWith("plans/")) return "plan";
     if (relFromDocs.includes("architecture")) return "architecture";
     if (relFromDocs.includes("security")) return "security";
@@ -9640,7 +9938,7 @@ function categorizeFile(filePath) {
   }
   const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
   if (filePath.includes(`${claudeDirName}/projects/`) && filePath.includes("/memory/")) return "memory";
-  const rel = relative8(paths.claudeDir, filePath).replace(/\\/g, "/");
+  const rel = relative9(paths.claudeDir, filePath).replace(/\\/g, "/");
   const firstDir = rel.split("/")[0];
   const knownCategories = getConfig().conventions?.knowledgeCategories ?? [
     "patterns",
@@ -9781,7 +10079,7 @@ function parseCorrections(content) {
 function extractTitle(content, filePath) {
   const h1Match = content.match(/^#\s+(.+)/m);
   if (h1Match) return h1Match[1].trim();
-  return basename5(filePath, ".md");
+  return basename6(filePath, ".md");
 }
 function extractDescription2(content) {
   const fmMatch = content.match(/^---\s*\n[\s\S]*?description:\s*"?([^"\n]+)"?\s*\n[\s\S]*?---/);
@@ -9810,7 +10108,7 @@ function buildCrossReferences(db) {
       }
     }
     if (rule.reference_path) {
-      const patternName = basename5(rule.reference_path, ".md");
+      const patternName = basename6(rule.reference_path, ".md");
       insertEdge.run("cr", rule.rule_id, "pattern", patternName, "references");
       edgeCount++;
     }
@@ -9932,7 +10230,7 @@ function indexAllKnowledge(db) {
       if (!existsSync19(filePath)) continue;
       const content = readFileSync20(filePath, "utf-8");
       const hash = hashContent(content);
-      const relPath = filePath.startsWith(paths.claudeDir) ? relative8(paths.claudeDir, filePath) : filePath.startsWith(paths.plansDir) ? "plans/" + relative8(paths.plansDir, filePath) : filePath.startsWith(paths.docsDir) ? "docs/" + relative8(paths.docsDir, filePath) : filePath.startsWith(paths.memoryDir) ? `memory/${relative8(paths.memoryDir, filePath)}` : basename5(filePath);
+      const relPath = filePath.startsWith(paths.claudeDir) ? relative9(paths.claudeDir, filePath) : filePath.startsWith(paths.plansDir) ? "plans/" + relative9(paths.plansDir, filePath) : filePath.startsWith(paths.docsDir) ? "docs/" + relative9(paths.docsDir, filePath) : filePath.startsWith(paths.memoryDir) ? `memory/${relative9(paths.memoryDir, filePath)}` : basename6(filePath);
       const category = categorizeFile(filePath);
       const title = extractTitle(content, filePath);
       const description = extractDescription2(content);
@@ -9946,10 +10244,10 @@ function indexAllKnowledge(db) {
           stats.chunksCreated++;
         }
       }
-      const fileName = basename5(filePath);
+      const fileName = basename6(filePath);
       const fileNameLower = fileName.toLowerCase();
       const relPathLower = relPath.toLowerCase();
-      const claudeMdName = basename5(getResolvedPaths().claudeMdPath).toLowerCase();
+      const claudeMdName = basename6(getResolvedPaths().claudeMdPath).toLowerCase();
       if (fileNameLower === claudeMdName || relPathLower.includes(claudeMdName)) {
         const crRules = parseCRTable(content);
         for (const rule of crRules) {
@@ -9983,12 +10281,12 @@ function indexAllKnowledge(db) {
         }
       }
       if (category === "commands" && fileName !== "_shared-preamble.md") {
-        const cmdName = basename5(filePath, ".md");
+        const cmdName = basename6(filePath, ".md");
         insertChunk.run(docId, "command", cmdName, content.substring(0, 1e3), 1, null, JSON.stringify({ command_name: cmdName }));
         stats.chunksCreated++;
       }
       if (category === "plan") {
-        const planItemRegex = /^###\s+(P\d+-\d+):\s+(.+)$/gm;
+        const planItemRegex = /^###\s+(P[-A-Z]*\d*-?\w+):\s+(.+)$/gm;
         let planMatch;
         while ((planMatch = planItemRegex.exec(content)) !== null) {
           insertChunk.run(docId, "pattern", planMatch[1], `${planMatch[1]}: ${planMatch[2]}`, null, null, JSON.stringify({ plan_item_id: planMatch[1] }));
@@ -10060,7 +10358,7 @@ function isKnowledgeStale(db) {
   }
   for (const filePath of files) {
     try {
-      const stat = statSync5(filePath);
+      const stat = statSync6(filePath);
       if (stat.mtimeMs > lastIndexTime) return true;
     } catch {
       continue;
@@ -10082,8 +10380,8 @@ var init_knowledge_indexer = __esm({
 });
 
 // src/knowledge-tools.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync3, appendFileSync, readdirSync as readdirSync15 } from "fs";
-import { resolve as resolve17, basename as basename6 } from "path";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync3, appendFileSync, readdirSync as readdirSync16 } from "fs";
+import { resolve as resolve18, basename as basename7 } from "path";
 function p15(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -10820,7 +11118,7 @@ function handleCorrect(db, args2) {
   if (!wrong || !correction || !rule) {
     return text15("Error: wrong, correction, and rule are all required.");
   }
-  const correctionsPath = resolve17(getResolvedPaths().memoryDir, "corrections.md");
+  const correctionsPath = resolve18(getResolvedPaths().memoryDir, "corrections.md");
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const title = rule.slice(0, 60);
   const entry = `
@@ -10882,7 +11180,7 @@ function handlePlan(db, args2) {
       AND kc.content LIKE ?
       ORDER BY kd.file_path DESC
       LIMIT 20
-    `).all(`%${basename6(file)}%`);
+    `).all(`%${basename7(file)}%`);
     lines.push(`## Plans referencing \`${file}\` (${results.length} found)`);
     lines.push("");
     for (const r of results) {
@@ -11015,7 +11313,7 @@ function handleGaps(db, args2) {
   } else if (checkType === "routers") {
     try {
       const routersDir = getResolvedPaths().routersDir;
-      const routerFiles = readdirSync15(routersDir).filter((f) => f.endsWith(".ts") && !f.startsWith("_"));
+      const routerFiles = readdirSync16(routersDir).filter((f) => f.endsWith(".ts") && !f.startsWith("_"));
       lines.push(`| Router | Knowledge Hits | Status |`);
       lines.push(`|--------|----------------|--------|`);
       for (const file of routerFiles) {
@@ -11912,7 +12210,7 @@ var init_python_tools = __esm({
 // src/mcp-bridge-tools.ts
 import { spawn } from "child_process";
 import { readFileSync as readFileSync22, existsSync as existsSync22 } from "fs";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 function p17(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -11933,7 +12231,7 @@ function buildSubprocessEnv() {
 }
 function loadMcpConfig() {
   const root = getProjectRoot();
-  const mcpPath = resolve18(root, ".mcp.json");
+  const mcpPath = resolve19(root, ".mcp.json");
   if (!existsSync22(mcpPath)) return {};
   try {
     const raw = JSON.parse(readFileSync22(mcpPath, "utf-8"));
@@ -11961,7 +12259,7 @@ async function mcpRequest(conn, method, params = {}) {
     method,
     params
   };
-  return new Promise((resolve22, reject) => {
+  return new Promise((resolve23, reject) => {
     const timeout = setTimeout(() => {
       conn.process?.stdout?.removeListener("data", onData);
       reject(new Error(`MCP request timed out: ${method}`));
@@ -11981,7 +12279,7 @@ async function mcpRequest(conn, method, params = {}) {
             if (response.error) {
               reject(new Error(`MCP error ${response.error.code}: ${response.error.message}`));
             } else {
-              resolve22(response.result || {});
+              resolve23(response.result || {});
             }
             return;
           }
@@ -12003,7 +12301,7 @@ async function connectToServer(name, config) {
     return existing;
   }
   const root = getProjectRoot();
-  const cwd = config.cwd ? resolve18(root, config.cwd) : root;
+  const cwd = config.cwd ? resolve19(root, config.cwd) : root;
   const args2 = config.args || [];
   const proc = spawn(config.command, args2, {
     cwd,
@@ -12241,7 +12539,6 @@ var init_mcp_bridge_tools = __esm({
     });
     process.on("SIGTERM", () => {
       for (const [name] of connections) disconnectServer(name);
-      process.exit(0);
     });
     ENV_ALLOW_LIST = /* @__PURE__ */ new Set([
       "PATH",
@@ -12266,7 +12563,7 @@ var init_mcp_bridge_tools = __esm({
 
 // src/tools.ts
 import { readFileSync as readFileSync23, existsSync as existsSync23 } from "fs";
-import { resolve as resolve19, basename as basename7 } from "path";
+import { resolve as resolve20, basename as basename8 } from "path";
 function prefix() {
   return getConfig().toolPrefix;
 }
@@ -12301,7 +12598,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);
@@ -12705,7 +13002,7 @@ function handleContext(file, dataDb2, codegraphDb2) {
         try {
           const resolvedPaths = getResolvedPaths();
           const root = getProjectRoot();
-          const absFilePath = ensureWithinRoot(resolve19(resolvedPaths.srcDir, "..", file), root);
+          const absFilePath = ensureWithinRoot(resolve20(resolvedPaths.srcDir, "..", file), root);
           if (existsSync23(absFilePath)) {
             const fileContent = readFileSync23(absFilePath, "utf-8").slice(0, 3e3);
             const keywords = [];
@@ -12801,7 +13098,7 @@ function handleContext(file, dataDb2, codegraphDb2) {
       WHERE o.files_involved LIKE ?
       ORDER BY o.importance DESC, o.created_at_epoch DESC
       LIMIT 5
-    `).all(`%${basename7(file)}%`);
+    `).all(`%${basename8(file)}%`);
     if (fileObservations.length > 0) {
       lines.push("## Past Observations (This File)");
       for (const obs of fileObservations) {
@@ -12817,7 +13114,7 @@ function handleContext(file, dataDb2, codegraphDb2) {
       WHERE type = 'failed_attempt' AND files_involved LIKE ?
       ORDER BY recurrence_count DESC
       LIMIT 3
-    `).all(`%${basename7(file)}%`);
+    `).all(`%${basename8(file)}%`);
     if (failures.length > 0) {
       lines.push("## Failed Attempts (DO NOT RETRY)");
       for (const f of failures) {
@@ -13131,7 +13428,7 @@ function handleSchema(args2) {
     lines.push("Checking all column references against Prisma schema...");
     lines.push("");
     const projectRoot = getProjectRoot();
-    const absPath = ensureWithinRoot(resolve19(projectRoot, file), projectRoot);
+    const absPath = ensureWithinRoot(resolve20(projectRoot, file), projectRoot);
     if (!existsSync23(absPath)) {
       return text18(`File not found: ${file}`);
     }
@@ -13215,7 +13512,7 @@ var init_tools = __esm({
 // src/server.ts
 var server_exports = {};
 import { readFileSync as readFileSync24 } from "fs";
-import { resolve as resolve20, dirname as dirname11 } from "path";
+import { resolve as resolve21, dirname as dirname11 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function getDb() {
   if (!codegraphDb) codegraphDb = getCodeGraphDb();
@@ -13310,7 +13607,7 @@ var init_server = __esm({
     __dirname4 = dirname11(fileURLToPath4(import.meta.url));
     PKG_VERSION = (() => {
       try {
-        const pkg = JSON.parse(readFileSync24(resolve20(__dirname4, "..", "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync24(resolve21(__dirname4, "..", "package.json"), "utf-8"));
         return pkg.version ?? "0.0.0";
       } catch {
         return "0.0.0";
@@ -13375,7 +13672,7 @@ var init_server = __esm({
 
 // src/cli.ts
 import { readFileSync as readFileSync25 } from "fs";
-import { resolve as resolve21, dirname as dirname12 } from "path";
+import { resolve as resolve22, dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename4 = fileURLToPath5(import.meta.url);
 var __dirname5 = dirname12(__filename4);
@@ -13449,7 +13746,7 @@ Documentation: https://massu.ai/docs
 }
 function printVersion() {
   try {
-    const pkg = JSON.parse(readFileSync25(resolve21(__dirname5, "../package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync25(resolve22(__dirname5, "../package.json"), "utf-8"));
     console.log(`massu v${pkg.version}`);
   } catch {
     console.log("massu v0.1.0");