@massu/core 0.4.2 → 0.6.0

package/dist/cli.js

@@ -344,687 +344,188 @@ var init_config = __esm({
   }
 });
 
-// src/commands/install-commands.ts
-var install_commands_exports = {};
-__export(install_commands_exports, {
-  installCommands: () => installCommands,
-  resolveCommandsDir: () => resolveCommandsDir,
-  runInstallCommands: () => runInstallCommands
+// src/memory-db.ts
+var memory_db_exports = {};
+__export(memory_db_exports, {
+  addConversationTurn: () => addConversationTurn,
+  addObservation: () => addObservation,
+  addSummary: () => addSummary,
+  addToolCallDetail: () => addToolCallDetail,
+  addUserPrompt: () => addUserPrompt,
+  assignImportance: () => assignImportance,
+  autoDetectTaskId: () => autoDetectTaskId,
+  createSession: () => createSession,
+  deduplicateFailedAttempt: () => deduplicateFailedAttempt,
+  dequeuePendingSync: () => dequeuePendingSync,
+  endSession: () => endSession,
+  enqueueSyncPayload: () => enqueueSyncPayload,
+  getConversationTurns: () => getConversationTurns,
+  getCrossTaskProgress: () => getCrossTaskProgress,
+  getDecisionsAbout: () => getDecisionsAbout,
+  getFailedAttempts: () => getFailedAttempts,
+  getLastProcessedLine: () => getLastProcessedLine,
+  getMemoryDb: () => getMemoryDb,
+  getObservabilityDbSize: () => getObservabilityDbSize,
+  getRecentObservations: () => getRecentObservations,
+  getSessionStats: () => getSessionStats,
+  getSessionSummaries: () => getSessionSummaries,
+  getSessionTimeline: () => getSessionTimeline,
+  getSessionsByTask: () => getSessionsByTask,
+  getToolPatterns: () => getToolPatterns,
+  incrementRetryCount: () => incrementRetryCount,
+  initMemorySchema: () => initMemorySchema,
+  linkSessionToTask: () => linkSessionToTask,
+  pruneOldConversationTurns: () => pruneOldConversationTurns,
+  pruneOldObservations: () => pruneOldObservations,
+  removePendingSync: () => removePendingSync,
+  sanitizeFts5Query: () => sanitizeFts5Query,
+  searchConversationTurns: () => searchConversationTurns,
+  searchObservations: () => searchObservations,
+  setLastProcessedLine: () => setLastProcessedLine
 });
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync, readdirSync } from "fs";
-import { resolve as resolve2, dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
-function resolveCommandsDir() {
-  const cwd = process.cwd();
-  const nodeModulesPath = resolve2(cwd, "node_modules/@massu/core/commands");
-  if (existsSync2(nodeModulesPath)) {
-    return nodeModulesPath;
-  }
-  const distRelPath = resolve2(__dirname, "../commands");
-  if (existsSync2(distRelPath)) {
-    return distRelPath;
-  }
-  const srcRelPath = resolve2(__dirname, "../../commands");
-  if (existsSync2(srcRelPath)) {
-    return srcRelPath;
-  }
-  return null;
-}
-function installCommands(projectRoot) {
-  const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
-  const targetDir = resolve2(projectRoot, claudeDirName, "commands");
-  if (!existsSync2(targetDir)) {
-    mkdirSync(targetDir, { recursive: true });
-  }
-  const sourceDir = resolveCommandsDir();
-  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 };
-  }
-  const sourceFiles = readdirSync(sourceDir).filter((f) => f.endsWith(".md"));
-  let installed = 0;
-  let updated = 0;
-  let skipped = 0;
-  for (const file of sourceFiles) {
-    const sourcePath = resolve2(sourceDir, file);
-    const targetPath = resolve2(targetDir, file);
-    const sourceContent = readFileSync2(sourcePath, "utf-8");
-    if (existsSync2(targetPath)) {
-      const existingContent = readFileSync2(targetPath, "utf-8");
-      if (existingContent === sourceContent) {
-        skipped++;
-        continue;
-      }
-      writeFileSync(targetPath, sourceContent, "utf-8");
-      updated++;
-    } else {
-      writeFileSync(targetPath, sourceContent, "utf-8");
-      installed++;
-    }
-  }
-  return { installed, updated, skipped, commandsDir: targetDir };
+import Database from "better-sqlite3";
+import { dirname as dirname2, basename } from "path";
+import { existsSync as existsSync2, mkdirSync } from "fs";
+function sanitizeFts5Query(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return '""';
+  const tokens = trimmed.replace(/"/g, "").split(/\s+/).filter(Boolean);
+  return tokens.map((t) => `"${t}"`).join(" ");
 }
-async function runInstallCommands() {
-  const projectRoot = process.cwd();
-  console.log("");
-  console.log("Massu AI - Install Slash Commands");
-  console.log("==================================");
-  console.log("");
-  const result = installCommands(projectRoot);
-  if (result.installed > 0) {
-    console.log(`  Installed ${result.installed} new commands`);
-  }
-  if (result.updated > 0) {
-    console.log(`  Updated ${result.updated} existing commands`);
-  }
-  if (result.skipped > 0) {
-    console.log(`  ${result.skipped} commands already up to date`);
+function getMemoryDb() {
+  const dbPath = getResolvedPaths().memoryDbPath;
+  const dir = dirname2(dbPath);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
   }
-  const total = result.installed + result.updated + result.skipped;
-  console.log("");
-  console.log(`  ${total} slash commands available in ${result.commandsDir}`);
-  console.log("");
-  console.log("  Restart your Claude Code session to use them.");
-  console.log("");
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  initMemorySchema(db);
+  return db;
 }
-var __filename, __dirname;
-var init_install_commands = __esm({
-  "src/commands/install-commands.ts"() {
-    "use strict";
-    init_config();
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = dirname2(__filename);
-  }
-});
+function initMemorySchema(db) {
+  db.exec(`
+    -- Sessions table (linked to Claude Code session IDs)
+    CREATE TABLE IF NOT EXISTS sessions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT UNIQUE NOT NULL,
+      project TEXT NOT NULL DEFAULT 'my-project',
+      git_branch TEXT,
+      started_at TEXT NOT NULL,
+      started_at_epoch INTEGER NOT NULL,
+      ended_at TEXT,
+      ended_at_epoch INTEGER,
+      status TEXT CHECK(status IN ('active', 'completed', 'abandoned')) NOT NULL DEFAULT 'active',
+      plan_file TEXT,
+      plan_phase TEXT,
+      task_id TEXT
+    );
 
-// src/commands/init.ts
-var init_exports = {};
-__export(init_exports, {
-  buildHooksConfig: () => buildHooksConfig,
-  detectFramework: () => detectFramework,
-  detectPython: () => detectPython,
-  generateConfig: () => generateConfig,
-  initMemoryDir: () => initMemoryDir,
-  installHooks: () => installHooks,
-  registerMcpServer: () => registerMcpServer,
-  resolveHooksDir: () => resolveHooksDir,
-  runInit: () => runInit
-});
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "fs";
-import { resolve as resolve3, basename, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { homedir as homedir2 } from "os";
-import { stringify as yamlStringify } from "yaml";
-function detectFramework(projectRoot) {
-  const result = {
-    type: "javascript",
-    router: "none",
-    orm: "none",
-    ui: "none"
-  };
-  const pkgPath = resolve3(projectRoot, "package.json");
-  if (!existsSync3(pkgPath)) return result;
+    CREATE INDEX IF NOT EXISTS idx_sessions_session_id ON sessions(session_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at_epoch DESC);
+    CREATE INDEX IF NOT EXISTS idx_sessions_task_id ON sessions(task_id);
+
+    -- Observations table (structured knowledge from tool usage)
+    CREATE TABLE IF NOT EXISTS observations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      type TEXT NOT NULL CHECK(type IN (
+        'decision', 'bugfix', 'feature', 'refactor', 'discovery',
+        'cr_violation', 'vr_check', 'pattern_compliance', 'failed_attempt',
+        'file_change', 'incident_near_miss'
+      )),
+      title TEXT NOT NULL,
+      detail TEXT,
+      files_involved TEXT DEFAULT '[]',
+      plan_item TEXT,
+      cr_rule TEXT,
+      vr_type TEXT,
+      evidence TEXT,
+      importance INTEGER NOT NULL DEFAULT 3 CHECK(importance BETWEEN 1 AND 5),
+      recurrence_count INTEGER NOT NULL DEFAULT 1,
+      original_tokens INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL,
+      created_at_epoch INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
+    CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type);
+    CREATE INDEX IF NOT EXISTS idx_observations_created ON observations(created_at_epoch DESC);
+    CREATE INDEX IF NOT EXISTS idx_observations_plan_item ON observations(plan_item);
+    CREATE INDEX IF NOT EXISTS idx_observations_cr_rule ON observations(cr_rule);
+    CREATE INDEX IF NOT EXISTS idx_observations_importance ON observations(importance DESC);
+  `);
   try {
-    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
-    const allDeps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies
-    };
-    if (allDeps["typescript"]) result.type = "typescript";
-    if (allDeps["next"]) result.ui = "nextjs";
-    else if (allDeps["@sveltejs/kit"]) result.ui = "sveltekit";
-    else if (allDeps["nuxt"]) result.ui = "nuxt";
-    else if (allDeps["@angular/core"]) result.ui = "angular";
-    else if (allDeps["vue"]) result.ui = "vue";
-    else if (allDeps["react"]) result.ui = "react";
-    if (allDeps["@trpc/server"]) result.router = "trpc";
-    else if (allDeps["graphql"] || allDeps["@apollo/server"]) result.router = "graphql";
-    else if (allDeps["express"] || allDeps["fastify"] || allDeps["hono"]) result.router = "rest";
-    if (allDeps["@prisma/client"] || allDeps["prisma"]) result.orm = "prisma";
-    else if (allDeps["drizzle-orm"]) result.orm = "drizzle";
-    else if (allDeps["typeorm"]) result.orm = "typeorm";
-    else if (allDeps["sequelize"]) result.orm = "sequelize";
-    else if (allDeps["mongoose"]) result.orm = "mongoose";
-  } catch {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS observations_fts USING fts5(
+        title, detail, evidence,
+        content='observations',
+        content_rowid='id'
+      );
+    `);
+  } catch (_e) {
   }
-  return result;
-}
-function detectPython(projectRoot) {
-  const result = {
-    detected: false,
-    root: "",
-    hasFastapi: false,
-    hasSqlalchemy: false,
-    hasAlembic: false,
-    alembicDir: null
-  };
-  const markers = ["pyproject.toml", "setup.py", "requirements.txt", "Pipfile"];
-  const hasMarker = markers.some((m) => existsSync3(resolve3(projectRoot, m)));
-  if (!hasMarker) return result;
-  result.detected = true;
-  const depFiles = [
-    { file: "pyproject.toml", parser: parsePyprojectDeps },
-    { file: "requirements.txt", parser: parseRequirementsDeps },
-    { file: "setup.py", parser: parseSetupPyDeps },
-    { file: "Pipfile", parser: parsePipfileDeps }
-  ];
-  for (const { file, parser } of depFiles) {
-    const filePath = resolve3(projectRoot, file);
-    if (existsSync3(filePath)) {
-      try {
-        const content = readFileSync3(filePath, "utf-8");
-        const deps = parser(content);
-        if (deps.includes("fastapi")) result.hasFastapi = true;
-        if (deps.includes("sqlalchemy")) result.hasSqlalchemy = true;
-      } catch {
-      }
-    }
-  }
-  if (existsSync3(resolve3(projectRoot, "alembic.ini"))) {
-    result.hasAlembic = true;
-    if (existsSync3(resolve3(projectRoot, "alembic"))) {
-      result.alembicDir = "alembic";
-    }
-  } else if (existsSync3(resolve3(projectRoot, "alembic"))) {
-    result.hasAlembic = true;
-    result.alembicDir = "alembic";
-  }
-  const candidateRoots = ["app", "src", "backend", "api"];
-  for (const candidate of candidateRoots) {
-    const candidatePath = resolve3(projectRoot, candidate);
-    if (existsSync3(candidatePath) && existsSync3(resolve3(candidatePath, "__init__.py"))) {
-      result.root = candidate;
-      break;
-    }
-    if (existsSync3(candidatePath)) {
-      try {
-        const files = readdirSync2(candidatePath);
-        if (files.some((f) => f.endsWith(".py"))) {
-          result.root = candidate;
-          break;
-        }
-      } catch {
-      }
-    }
-  }
-  if (!result.root) {
-    result.root = ".";
-  }
-  return result;
-}
-function parsePyprojectDeps(content) {
-  const deps = [];
-  const lower = content.toLowerCase();
-  if (lower.includes("fastapi")) deps.push("fastapi");
-  if (lower.includes("sqlalchemy")) deps.push("sqlalchemy");
-  return deps;
-}
-function parseRequirementsDeps(content) {
-  const deps = [];
-  const lower = content.toLowerCase();
-  for (const line of lower.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("fastapi")) deps.push("fastapi");
-    if (trimmed.startsWith("sqlalchemy")) deps.push("sqlalchemy");
-  }
-  return deps;
-}
-function parseSetupPyDeps(content) {
-  const deps = [];
-  const lower = content.toLowerCase();
-  if (lower.includes("fastapi")) deps.push("fastapi");
-  if (lower.includes("sqlalchemy")) deps.push("sqlalchemy");
-  return deps;
-}
-function parsePipfileDeps(content) {
-  const deps = [];
-  const lower = content.toLowerCase();
-  if (lower.includes("fastapi")) deps.push("fastapi");
-  if (lower.includes("sqlalchemy")) deps.push("sqlalchemy");
-  return deps;
-}
-function generateConfig(projectRoot, framework) {
-  const configPath = resolve3(projectRoot, "massu.config.yaml");
-  if (existsSync3(configPath)) {
-    return false;
-  }
-  const projectName = basename(projectRoot);
-  const config = {
-    project: {
-      name: projectName,
-      root: "auto"
-    },
-    framework: {
-      type: framework.type,
-      router: framework.router,
-      orm: framework.orm,
-      ui: framework.ui
-    },
-    paths: {
-      source: "src",
-      aliases: { "@": "src" }
-    },
-    toolPrefix: "massu",
-    domains: [],
-    rules: [
-      {
-        pattern: "src/**/*.ts",
-        rules: ["Use ESM imports, not CommonJS"]
-      }
-    ]
-  };
-  const python = detectPython(projectRoot);
-  if (python.detected) {
-    const pythonConfig = {
-      root: python.root,
-      exclude_dirs: ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]
-    };
-    if (python.hasFastapi) pythonConfig.framework = "fastapi";
-    if (python.hasSqlalchemy) pythonConfig.orm = "sqlalchemy";
-    if (python.hasAlembic && python.alembicDir) {
-      pythonConfig.alembic_dir = python.alembicDir;
-    }
-    config.python = pythonConfig;
-  }
-  const yamlContent = `# Massu AI Configuration
-# Generated by: npx massu init
-# Documentation: https://massu.ai/docs/getting-started/configuration
-
-${yamlStringify(config)}`;
-  writeFileSync2(configPath, yamlContent, "utf-8");
-  return true;
-}
-function registerMcpServer(projectRoot) {
-  const mcpPath = resolve3(projectRoot, ".mcp.json");
-  let existing = {};
-  if (existsSync3(mcpPath)) {
-    try {
-      existing = JSON.parse(readFileSync3(mcpPath, "utf-8"));
-    } catch {
-      existing = {};
-    }
-  }
-  const servers = existing.mcpServers ?? {};
-  if (servers.massu) {
-    return false;
-  }
-  servers.massu = {
-    type: "stdio",
-    command: "npx",
-    args: ["-y", "@massu/core"]
-  };
-  existing.mcpServers = servers;
-  writeFileSync2(mcpPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
-  return true;
-}
-function resolveHooksDir() {
-  const cwd = process.cwd();
-  const nodeModulesPath = resolve3(cwd, "node_modules/@massu/core/dist/hooks");
-  if (existsSync3(nodeModulesPath)) {
-    return "node_modules/@massu/core/dist/hooks";
-  }
-  const localPath = resolve3(__dirname2, "../dist/hooks");
-  if (existsSync3(localPath)) {
-    return localPath;
-  }
-  return "node_modules/@massu/core/dist/hooks";
-}
-function hookCmd(hooksDir, hookFile) {
-  return `node ${hooksDir}/${hookFile}`;
-}
-function buildHooksConfig(hooksDir) {
-  return {
-    SessionStart: [
-      {
-        hooks: [
-          { type: "command", command: hookCmd(hooksDir, "session-start.js"), timeout: 10 }
-        ]
-      }
-    ],
-    PreToolUse: [
-      {
-        matcher: "Bash",
-        hooks: [
-          { type: "command", command: hookCmd(hooksDir, "security-gate.js"), timeout: 5 }
-        ]
-      },
-      {
-        matcher: "Bash|Write",
-        hooks: [
-          { type: "command", command: hookCmd(hooksDir, "pre-delete-check.js"), timeout: 5 }
-        ]
-      }
-    ],
-    PostToolUse: [
-      {
-        hooks: [
-          { type: "command", command: hookCmd(hooksDir, "post-tool-use.js"), timeout: 10 },
-          { type: "command", command: hookCmd(hooksDir, "quality-event.js"), timeout: 5 },
-          { type: "command", command: hookCmd(hooksDir, "cost-tracker.js"), timeout: 5 }
-        ]
-      },
-      {
-        matcher: "Edit|Write",
-        hooks: [
-          { type: "command", command: hookCmd(hooksDir, "post-edit-context.js"), timeout: 5 }
-        ]
-      }
-    ],
-    Stop: [
-      {
-        hooks: [
-          { type: "command", command: hookCmd(hooksDir, "session-end.js"), timeout: 15 }
-        ]
-      }
-    ],
-    PreCompact: [
-      {
-        hooks: [
-          { type: "command", command: hookCmd(hooksDir, "pre-compact.js"), timeout: 10 }
-        ]
-      }
-    ],
-    UserPromptSubmit: [
-      {
-        hooks: [
-          { type: "command", command: hookCmd(hooksDir, "user-prompt.js"), timeout: 5 },
-          { type: "command", command: hookCmd(hooksDir, "intent-suggester.js"), timeout: 5 }
-        ]
-      }
-    ]
-  };
-}
-function installHooks(projectRoot) {
-  const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
-  const claudeDir = resolve3(projectRoot, claudeDirName);
-  const settingsPath = resolve3(claudeDir, "settings.local.json");
-  if (!existsSync3(claudeDir)) {
-    mkdirSync2(claudeDir, { recursive: true });
-  }
-  let settings = {};
-  if (existsSync3(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
-    } catch {
-      settings = {};
-    }
-  }
-  const hooksDir = resolveHooksDir();
-  const hooksConfig = buildHooksConfig(hooksDir);
-  let hookCount = 0;
-  for (const groups of Object.values(hooksConfig)) {
-    for (const group of groups) {
-      hookCount += group.hooks.length;
-    }
-  }
-  settings.hooks = hooksConfig;
-  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-  return { installed: true, count: hookCount };
-}
-function initMemoryDir(projectRoot) {
-  const encodedRoot = "-" + projectRoot.replace(/\//g, "-");
-  const memoryDir = resolve3(homedir2(), `.claude/projects/${encodedRoot}/memory`);
-  let created = false;
-  if (!existsSync3(memoryDir)) {
-    mkdirSync2(memoryDir, { recursive: true });
-    created = true;
-  }
-  const memoryMdPath = resolve3(memoryDir, "MEMORY.md");
-  let memoryMdCreated = false;
-  if (!existsSync3(memoryMdPath)) {
-    const projectName = basename(projectRoot);
-    const memoryContent = `# ${projectName} - Massu Memory
-
-## Key Learnings
-<!-- Important patterns and conventions discovered during development -->
-
-## Common Gotchas
-<!-- Non-obvious issues and how to avoid them -->
-
-## Corrections
-<!-- Wrong behaviors that were corrected and how to prevent them -->
-
-## File Index
-<!-- Significant files and directories -->
-`;
-    writeFileSync2(memoryMdPath, memoryContent, "utf-8");
-    memoryMdCreated = true;
-  }
-  return { created, memoryMdCreated };
-}
-async function runInit() {
-  const projectRoot = process.cwd();
-  console.log("");
-  console.log("Massu AI - Project Setup");
-  console.log("========================");
-  console.log("");
-  const framework = detectFramework(projectRoot);
-  const frameworkParts = [];
-  if (framework.type !== "javascript") frameworkParts.push(capitalize(framework.type));
-  if (framework.ui !== "none") frameworkParts.push(formatName(framework.ui));
-  if (framework.orm !== "none") frameworkParts.push(capitalize(framework.orm));
-  if (framework.router !== "none") frameworkParts.push(framework.router.toUpperCase());
-  const detected = frameworkParts.length > 0 ? frameworkParts.join(", ") : "JavaScript";
-  console.log(`  Detected: ${detected}`);
-  const python = detectPython(projectRoot);
-  if (python.detected) {
-    const pyParts = ["Python"];
-    if (python.hasFastapi) pyParts.push("FastAPI");
-    if (python.hasSqlalchemy) pyParts.push("SQLAlchemy");
-    if (python.hasAlembic) pyParts.push("Alembic");
-    console.log(`  Detected: ${pyParts.join(", ")} (root: ${python.root})`);
-  }
-  const configCreated = generateConfig(projectRoot, framework);
-  if (configCreated) {
-    console.log("  Created massu.config.yaml");
-  } else {
-    console.log("  massu.config.yaml already exists (preserved)");
-  }
-  const mcpRegistered = registerMcpServer(projectRoot);
-  if (mcpRegistered) {
-    console.log("  Registered MCP server in .mcp.json");
-  } else {
-    console.log("  MCP server already registered in .mcp.json");
-  }
-  const { count: hooksCount } = installHooks(projectRoot);
-  console.log(`  Installed ${hooksCount} hooks in .claude/settings.local.json`);
-  const cmdResult = installCommands(projectRoot);
-  const cmdTotal = cmdResult.installed + cmdResult.updated + cmdResult.skipped;
-  if (cmdResult.installed > 0 || cmdResult.updated > 0) {
-    console.log(`  Installed ${cmdTotal} slash commands (${cmdResult.installed} new, ${cmdResult.updated} updated)`);
-  } else {
-    console.log(`  ${cmdTotal} slash commands already up to date`);
-  }
-  const { created: memDirCreated, memoryMdCreated } = initMemoryDir(projectRoot);
-  if (memDirCreated) {
-    console.log("  Created memory directory (~/.claude/projects/.../memory/)");
-  } else {
-    console.log("  Memory directory already exists");
-  }
-  if (memoryMdCreated) {
-    console.log("  Created initial MEMORY.md");
-  }
-  console.log("  Databases will auto-create on first session");
-  console.log("");
-  console.log("Massu AI is ready. Start a Claude Code session to begin.");
-  console.log("");
-  console.log("Next steps:");
-  console.log("  claude                    # Start a session (hooks activate automatically)");
-  console.log("  npx massu doctor          # Verify installation health");
-  console.log("");
-  console.log("Documentation: https://massu.ai/docs");
-  console.log("");
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function formatName(name) {
-  const names = {
-    nextjs: "Next.js",
-    sveltekit: "SvelteKit",
-    nuxt: "Nuxt",
-    angular: "Angular",
-    vue: "Vue",
-    react: "React"
-  };
-  return names[name] ?? capitalize(name);
-}
-var __filename2, __dirname2;
-var init_init = __esm({
-  "src/commands/init.ts"() {
-    "use strict";
-    init_config();
-    init_install_commands();
-    __filename2 = fileURLToPath2(import.meta.url);
-    __dirname2 = dirname3(__filename2);
-  }
-});
-
-// src/memory-db.ts
-import Database from "better-sqlite3";
-import { dirname as dirname4, basename as basename2 } from "path";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
-function sanitizeFts5Query(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) return '""';
-  const tokens = trimmed.replace(/"/g, "").split(/\s+/).filter(Boolean);
-  return tokens.map((t) => `"${t}"`).join(" ");
-}
-function getMemoryDb() {
-  const dbPath = getResolvedPaths().memoryDbPath;
-  const dir = dirname4(dbPath);
-  if (!existsSync4(dir)) {
-    mkdirSync3(dir, { recursive: true });
-  }
-  const db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
-  db.pragma("foreign_keys = ON");
-  initMemorySchema(db);
-  return db;
-}
-function initMemorySchema(db) {
-  db.exec(`
-    -- Sessions table (linked to Claude Code session IDs)
-    CREATE TABLE IF NOT EXISTS sessions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT UNIQUE NOT NULL,
-      project TEXT NOT NULL DEFAULT 'my-project',
-      git_branch TEXT,
-      started_at TEXT NOT NULL,
-      started_at_epoch INTEGER NOT NULL,
-      ended_at TEXT,
-      ended_at_epoch INTEGER,
-      status TEXT CHECK(status IN ('active', 'completed', 'abandoned')) NOT NULL DEFAULT 'active',
-      plan_file TEXT,
-      plan_phase TEXT,
-      task_id TEXT
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_sessions_session_id ON sessions(session_id);
-    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at_epoch DESC);
-    CREATE INDEX IF NOT EXISTS idx_sessions_task_id ON sessions(task_id);
-
-    -- Observations table (structured knowledge from tool usage)
-    CREATE TABLE IF NOT EXISTS observations (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      type TEXT NOT NULL CHECK(type IN (
-        'decision', 'bugfix', 'feature', 'refactor', 'discovery',
-        'cr_violation', 'vr_check', 'pattern_compliance', 'failed_attempt',
-        'file_change', 'incident_near_miss'
-      )),
-      title TEXT NOT NULL,
-      detail TEXT,
-      files_involved TEXT DEFAULT '[]',
-      plan_item TEXT,
-      cr_rule TEXT,
-      vr_type TEXT,
-      evidence TEXT,
-      importance INTEGER NOT NULL DEFAULT 3 CHECK(importance BETWEEN 1 AND 5),
-      recurrence_count INTEGER NOT NULL DEFAULT 1,
-      original_tokens INTEGER DEFAULT 0,
-      created_at TEXT NOT NULL,
-      created_at_epoch INTEGER NOT NULL,
-      FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
-    CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type);
-    CREATE INDEX IF NOT EXISTS idx_observations_created ON observations(created_at_epoch DESC);
-    CREATE INDEX IF NOT EXISTS idx_observations_plan_item ON observations(plan_item);
-    CREATE INDEX IF NOT EXISTS idx_observations_cr_rule ON observations(cr_rule);
-    CREATE INDEX IF NOT EXISTS idx_observations_importance ON observations(importance DESC);
-  `);
-  try {
-    db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS observations_fts USING fts5(
-        title, detail, evidence,
-        content='observations',
-        content_rowid='id'
-      );
-    `);
-  } catch (_e) {
-  }
-  db.exec(`
-    CREATE TRIGGER IF NOT EXISTS observations_ai AFTER INSERT ON observations BEGIN
-      INSERT INTO observations_fts(rowid, title, detail, evidence)
-      VALUES (new.id, new.title, new.detail, new.evidence);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS observations_ad AFTER DELETE ON observations BEGIN
-      INSERT INTO observations_fts(observations_fts, rowid, title, detail, evidence)
-      VALUES ('delete', old.id, old.title, old.detail, old.evidence);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS observations_au AFTER UPDATE ON observations BEGIN
-      INSERT INTO observations_fts(observations_fts, rowid, title, detail, evidence)
-      VALUES ('delete', old.id, old.title, old.detail, old.evidence);
-      INSERT INTO observations_fts(rowid, title, detail, evidence)
-      VALUES (new.id, new.title, new.detail, new.evidence);
-    END;
-  `);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS session_summaries (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      request TEXT,
-      investigated TEXT,
-      decisions TEXT,
-      completed TEXT,
-      failed_attempts TEXT,
-      next_steps TEXT,
-      files_created TEXT DEFAULT '[]',
-      files_modified TEXT DEFAULT '[]',
-      verification_results TEXT DEFAULT '{}',
-      plan_progress TEXT DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      created_at_epoch INTEGER NOT NULL,
-      FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_summaries_session ON session_summaries(session_id);
-  `);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS user_prompts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      prompt_text TEXT NOT NULL,
-      prompt_number INTEGER NOT NULL DEFAULT 1,
-      created_at TEXT NOT NULL,
-      created_at_epoch INTEGER NOT NULL,
-      FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
-    );
-  `);
-  try {
-    db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS user_prompts_fts USING fts5(
-        prompt_text,
-        content='user_prompts',
-        content_rowid='id'
-      );
-    `);
-  } catch (_e) {
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS observations_ai AFTER INSERT ON observations BEGIN
+      INSERT INTO observations_fts(rowid, title, detail, evidence)
+      VALUES (new.id, new.title, new.detail, new.evidence);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS observations_ad AFTER DELETE ON observations BEGIN
+      INSERT INTO observations_fts(observations_fts, rowid, title, detail, evidence)
+      VALUES ('delete', old.id, old.title, old.detail, old.evidence);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS observations_au AFTER UPDATE ON observations BEGIN
+      INSERT INTO observations_fts(observations_fts, rowid, title, detail, evidence)
+      VALUES ('delete', old.id, old.title, old.detail, old.evidence);
+      INSERT INTO observations_fts(rowid, title, detail, evidence)
+      VALUES (new.id, new.title, new.detail, new.evidence);
+    END;
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_summaries (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      request TEXT,
+      investigated TEXT,
+      decisions TEXT,
+      completed TEXT,
+      failed_attempts TEXT,
+      next_steps TEXT,
+      files_created TEXT DEFAULT '[]',
+      files_modified TEXT DEFAULT '[]',
+      verification_results TEXT DEFAULT '{}',
+      plan_progress TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL,
+      created_at_epoch INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_summaries_session ON session_summaries(session_id);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS user_prompts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      prompt_text TEXT NOT NULL,
+      prompt_number INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      created_at_epoch INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
+    );
+  `);
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS user_prompts_fts USING fts5(
+        prompt_text,
+        content='user_prompts',
+        content_rowid='id'
+      );
+    `);
+  } catch (_e) {
   }
   db.exec(`
     CREATE TRIGGER IF NOT EXISTS prompts_ai AFTER INSERT ON user_prompts BEGIN
@@ -1378,6 +879,29 @@ function initMemorySchema(db) {
     );
   `);
 }
+function enqueueSyncPayload(db, payload) {
+  db.prepare("INSERT INTO pending_sync (payload) VALUES (?)").run(payload);
+}
+function dequeuePendingSync(db, limit = 10) {
+  const stale = db.prepare(
+    "SELECT id FROM pending_sync WHERE retry_count >= 10"
+  ).all();
+  if (stale.length > 0) {
+    const ids = stale.map((s) => s.id);
+    db.prepare(`DELETE FROM pending_sync WHERE id IN (${ids.map(() => "?").join(",")})`).run(...ids);
+  }
+  return db.prepare(
+    "SELECT id, payload, retry_count FROM pending_sync ORDER BY created_at ASC LIMIT ?"
+  ).all(limit);
+}
+function removePendingSync(db, id) {
+  db.prepare("DELETE FROM pending_sync WHERE id = ?").run(id);
+}
+function incrementRetryCount(db, id, error) {
+  db.prepare(
+    "UPDATE pending_sync SET retry_count = retry_count + 1, last_error = ? WHERE id = ?"
+  ).run(error, id);
+}
 function assignImportance(type, vrResult) {
   switch (type) {
     case "decision":
@@ -1399,230 +923,1082 @@ function assignImportance(type, vrResult) {
     case "discovery":
       return 1;
     default:
-      return 3;
+      return 3;
+  }
+}
+function autoDetectTaskId(planFile) {
+  if (!planFile) return null;
+  const base = basename(planFile);
+  return base.replace(/\.md$/, "");
+}
+function createSession(db, sessionId, opts) {
+  const now = /* @__PURE__ */ new Date();
+  const taskId = autoDetectTaskId(opts?.planFile);
+  db.prepare(`
+    INSERT OR IGNORE INTO sessions (session_id, git_branch, plan_file, task_id, started_at, started_at_epoch)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(sessionId, opts?.branch ?? null, opts?.planFile ?? null, taskId, now.toISOString(), Math.floor(now.getTime() / 1e3));
+}
+function endSession(db, sessionId, status = "completed") {
+  const now = /* @__PURE__ */ new Date();
+  db.prepare(`
+    UPDATE sessions SET status = ?, ended_at = ?, ended_at_epoch = ? WHERE session_id = ?
+  `).run(status, now.toISOString(), Math.floor(now.getTime() / 1e3), sessionId);
+}
+function addObservation(db, sessionId, type, title, detail, opts) {
+  const now = /* @__PURE__ */ new Date();
+  const importance = opts?.importance ?? assignImportance(type, opts?.evidence?.includes("PASS") ? "PASS" : void 0);
+  const result = db.prepare(`
+    INSERT INTO observations (session_id, type, title, detail, files_involved, plan_item, cr_rule, vr_type, evidence, importance, original_tokens, created_at, created_at_epoch)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    sessionId,
+    type,
+    title,
+    detail,
+    JSON.stringify(opts?.filesInvolved ?? []),
+    opts?.planItem ?? null,
+    opts?.crRule ?? null,
+    opts?.vrType ?? null,
+    opts?.evidence ?? null,
+    importance,
+    opts?.originalTokens ?? 0,
+    now.toISOString(),
+    Math.floor(now.getTime() / 1e3)
+  );
+  return Number(result.lastInsertRowid);
+}
+function addSummary(db, sessionId, summary) {
+  const now = /* @__PURE__ */ new Date();
+  db.prepare(`
+    INSERT INTO session_summaries (session_id, request, investigated, decisions, completed, failed_attempts, next_steps, files_created, files_modified, verification_results, plan_progress, created_at, created_at_epoch)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    sessionId,
+    summary.request ?? null,
+    summary.investigated ?? null,
+    summary.decisions ?? null,
+    summary.completed ?? null,
+    summary.failedAttempts ?? null,
+    summary.nextSteps ?? null,
+    JSON.stringify(summary.filesCreated ?? []),
+    JSON.stringify(summary.filesModified ?? []),
+    JSON.stringify(summary.verificationResults ?? {}),
+    JSON.stringify(summary.planProgress ?? {}),
+    now.toISOString(),
+    Math.floor(now.getTime() / 1e3)
+  );
+}
+function addUserPrompt(db, sessionId, text18, promptNumber) {
+  const now = /* @__PURE__ */ new Date();
+  db.prepare(`
+    INSERT INTO user_prompts (session_id, prompt_text, prompt_number, created_at, created_at_epoch)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(sessionId, text18, promptNumber, now.toISOString(), Math.floor(now.getTime() / 1e3));
+}
+function searchObservations(db, query, opts) {
+  const limit = opts?.limit ?? 20;
+  let sql = `
+    SELECT o.id, o.type, o.title, o.created_at, o.session_id, o.importance,
+           rank
+    FROM observations_fts
+    JOIN observations o ON observations_fts.rowid = o.id
+    WHERE observations_fts MATCH ?
+  `;
+  const params = [sanitizeFts5Query(query)];
+  if (opts?.type) {
+    sql += " AND o.type = ?";
+    params.push(opts.type);
+  }
+  if (opts?.crRule) {
+    sql += " AND o.cr_rule = ?";
+    params.push(opts.crRule);
+  }
+  if (opts?.dateFrom) {
+    sql += " AND o.created_at >= ?";
+    params.push(opts.dateFrom);
+  }
+  sql += " ORDER BY rank LIMIT ?";
+  params.push(limit);
+  return db.prepare(sql).all(...params);
+}
+function getRecentObservations(db, limit = 20, sessionId) {
+  if (sessionId) {
+    return db.prepare(`
+      SELECT id, type, title, detail, importance, created_at, session_id
+      FROM observations WHERE session_id = ?
+      ORDER BY created_at_epoch DESC LIMIT ?
+    `).all(sessionId, limit);
+  }
+  return db.prepare(`
+    SELECT id, type, title, detail, importance, created_at, session_id
+    FROM observations
+    ORDER BY created_at_epoch DESC LIMIT ?
+  `).all(limit);
+}
+function getSessionSummaries(db, limit = 10) {
+  return db.prepare(`
+    SELECT session_id, request, completed, failed_attempts, plan_progress, created_at
+    FROM session_summaries
+    ORDER BY created_at_epoch DESC LIMIT ?
+  `).all(limit);
+}
+function getSessionTimeline(db, sessionId) {
+  const session = db.prepare("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
+  const observations = db.prepare("SELECT * FROM observations WHERE session_id = ? ORDER BY created_at_epoch ASC").all(sessionId);
+  const summary = db.prepare("SELECT * FROM session_summaries WHERE session_id = ? ORDER BY created_at_epoch DESC LIMIT 1").get(sessionId);
+  const prompts = db.prepare("SELECT * FROM user_prompts WHERE session_id = ? ORDER BY prompt_number ASC").all(sessionId);
+  return {
+    session: session ?? null,
+    observations,
+    summary: summary ?? null,
+    prompts
+  };
+}
+function getFailedAttempts(db, query, limit = 20) {
+  if (query) {
+    return db.prepare(`
+      SELECT o.id, o.title, o.detail, o.session_id, o.recurrence_count, o.created_at
+      FROM observations_fts
+      JOIN observations o ON observations_fts.rowid = o.id
+      WHERE observations_fts MATCH ? AND o.type = 'failed_attempt'
+      ORDER BY o.recurrence_count DESC, rank LIMIT ?
+    `).all(sanitizeFts5Query(query), limit);
+  }
+  return db.prepare(`
+    SELECT id, title, detail, session_id, recurrence_count, created_at
+    FROM observations WHERE type = 'failed_attempt'
+    ORDER BY recurrence_count DESC, created_at_epoch DESC LIMIT ?
+  `).all(limit);
+}
+function getDecisionsAbout(db, query, limit = 20) {
+  return db.prepare(`
+    SELECT o.id, o.title, o.detail, o.session_id, o.created_at
+    FROM observations_fts
+    JOIN observations o ON observations_fts.rowid = o.id
+    WHERE observations_fts MATCH ? AND o.type = 'decision'
+    ORDER BY rank LIMIT ?
+  `).all(sanitizeFts5Query(query), limit);
+}
+function pruneOldObservations(db, retentionDays = 90) {
+  const cutoffEpoch = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
+  const result = db.prepare("DELETE FROM observations WHERE created_at_epoch < ?").run(cutoffEpoch);
+  return result.changes;
+}
+function deduplicateFailedAttempt(db, sessionId, title, detail, opts) {
+  const existing = db.prepare(`
+    SELECT id, recurrence_count FROM observations
+    WHERE type = 'failed_attempt' AND title = ?
+    ORDER BY created_at_epoch DESC LIMIT 1
+  `).get(title);
+  if (existing) {
+    db.prepare("UPDATE observations SET recurrence_count = recurrence_count + 1, detail = COALESCE(?, detail) WHERE id = ?").run(detail, existing.id);
+    return existing.id;
+  }
+  return addObservation(db, sessionId, "failed_attempt", title, detail, {
+    ...opts,
+    importance: 5
+  });
+}
+function getSessionsByTask(db, taskId) {
+  return db.prepare(`
+    SELECT session_id, status, started_at, ended_at, plan_phase
+    FROM sessions WHERE task_id = ?
+    ORDER BY started_at_epoch DESC
+  `).all(taskId);
+}
+function getCrossTaskProgress(db, taskId) {
+  const sessions = db.prepare(`
+    SELECT session_id FROM sessions WHERE task_id = ?
+  `).all(taskId);
+  const merged = {};
+  for (const session of sessions) {
+    const summaries = db.prepare(`
+      SELECT plan_progress FROM session_summaries WHERE session_id = ?
+    `).all(session.session_id);
+    for (const summary of summaries) {
+      try {
+        const progress = JSON.parse(summary.plan_progress);
+        for (const [key, value] of Object.entries(progress)) {
+          if (!merged[key] || value === "complete" || value === "in_progress" && merged[key] === "pending") {
+            merged[key] = value;
+          }
+        }
+      } catch (_e) {
+      }
+    }
+  }
+  return merged;
+}
+function linkSessionToTask(db, sessionId, taskId) {
+  db.prepare("UPDATE sessions SET task_id = ? WHERE session_id = ?").run(taskId, sessionId);
+}
+function addConversationTurn(db, sessionId, turnNumber, userPrompt, assistantResponse, toolCallsJson, toolCallCount, promptTokens, responseTokens) {
+  const result = db.prepare(`
+    INSERT INTO conversation_turns (session_id, turn_number, user_prompt, assistant_response, tool_calls_json, tool_call_count, prompt_tokens, response_tokens)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    sessionId,
+    turnNumber,
+    userPrompt,
+    assistantResponse ? assistantResponse.slice(0, 1e4) : null,
+    toolCallsJson,
+    toolCallCount,
+    promptTokens,
+    responseTokens
+  );
+  return Number(result.lastInsertRowid);
+}
+function addToolCallDetail(db, sessionId, turnNumber, toolName, inputSummary, inputSize, outputSize, success, filesInvolved) {
+  db.prepare(`
+    INSERT INTO tool_call_details (session_id, turn_number, tool_name, tool_input_summary, tool_input_size, tool_output_size, tool_success, files_involved)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    sessionId,
+    turnNumber,
+    toolName,
+    inputSummary ? inputSummary.slice(0, 500) : null,
+    inputSize,
+    outputSize,
+    success ? 1 : 0,
+    filesInvolved ? JSON.stringify(filesInvolved) : null
+  );
+}
+function getLastProcessedLine(db, sessionId) {
+  const row = db.prepare("SELECT value FROM memory_meta WHERE key = ?").get(`last_processed_line:${sessionId}`);
+  return row ? parseInt(row.value, 10) : 0;
+}
+function setLastProcessedLine(db, sessionId, lineNumber) {
+  db.prepare("INSERT OR REPLACE INTO memory_meta (key, value) VALUES (?, ?)").run(`last_processed_line:${sessionId}`, String(lineNumber));
+}
+function pruneOldConversationTurns(db, retentionDays = 90) {
+  const cutoffEpoch = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
+  const turnsResult = db.prepare("DELETE FROM conversation_turns WHERE created_at_epoch < ?").run(cutoffEpoch);
+  const detailsResult = db.prepare("DELETE FROM tool_call_details WHERE created_at_epoch < ?").run(cutoffEpoch);
+  return { turnsDeleted: turnsResult.changes, detailsDeleted: detailsResult.changes };
+}
+function getConversationTurns(db, sessionId, opts) {
+  let sql = "SELECT id, turn_number, user_prompt, assistant_response, tool_calls_json, tool_call_count, prompt_tokens, response_tokens, created_at FROM conversation_turns WHERE session_id = ?";
+  const params = [sessionId];
+  if (opts?.turnFrom !== void 0) {
+    sql += " AND turn_number >= ?";
+    params.push(opts.turnFrom);
+  }
+  if (opts?.turnTo !== void 0) {
+    sql += " AND turn_number <= ?";
+    params.push(opts.turnTo);
+  }
+  sql += " ORDER BY turn_number ASC";
+  return db.prepare(sql).all(...params);
+}
+function searchConversationTurns(db, query, opts) {
+  const limit = opts?.limit ?? 20;
+  let sql = `
+    SELECT ct.id, ct.session_id, ct.turn_number, ct.user_prompt, ct.tool_call_count, ct.response_tokens, ct.created_at, rank
+    FROM conversation_turns_fts
+    JOIN conversation_turns ct ON conversation_turns_fts.rowid = ct.id
+    WHERE conversation_turns_fts MATCH ?
+  `;
+  const params = [sanitizeFts5Query(query)];
+  if (opts?.sessionId) {
+    sql += " AND ct.session_id = ?";
+    params.push(opts.sessionId);
+  }
+  if (opts?.dateFrom) {
+    sql += " AND ct.created_at >= ?";
+    params.push(opts.dateFrom);
+  }
+  if (opts?.dateTo) {
+    sql += " AND ct.created_at <= ?";
+    params.push(opts.dateTo);
+  }
+  if (opts?.minToolCalls !== void 0) {
+    sql += " AND ct.tool_call_count >= ?";
+    params.push(opts.minToolCalls);
+  }
+  sql += " ORDER BY rank LIMIT ?";
+  params.push(limit);
+  return db.prepare(sql).all(...params);
+}
+function getToolPatterns(db, opts) {
+  const groupBy = opts?.groupBy ?? "tool";
+  const params = [];
+  let whereClause = "";
+  const conditions = [];
+  if (opts?.sessionId) {
+    conditions.push("session_id = ?");
+    params.push(opts.sessionId);
+  }
+  if (opts?.toolName) {
+    conditions.push("tool_name = ?");
+    params.push(opts.toolName);
+  }
+  if (opts?.dateFrom) {
+    conditions.push("created_at >= ?");
+    params.push(opts.dateFrom);
+  }
+  if (conditions.length > 0) {
+    whereClause = "WHERE " + conditions.join(" AND ");
+  }
+  let sql;
+  switch (groupBy) {
+    case "session":
+      sql = `SELECT session_id, COUNT(*) as call_count, COUNT(DISTINCT tool_name) as unique_tools,
+             SUM(CASE WHEN tool_success = 1 THEN 1 ELSE 0 END) as successes,
+             SUM(CASE WHEN tool_success = 0 THEN 1 ELSE 0 END) as failures,
+             AVG(tool_output_size) as avg_output_size
+             FROM tool_call_details ${whereClause}
+             GROUP BY session_id ORDER BY call_count DESC`;
+      break;
+    case "day":
+      sql = `SELECT date(created_at) as day, COUNT(*) as call_count, COUNT(DISTINCT tool_name) as unique_tools,
+             SUM(CASE WHEN tool_success = 1 THEN 1 ELSE 0 END) as successes
+             FROM tool_call_details ${whereClause}
+             GROUP BY date(created_at) ORDER BY day DESC`;
+      break;
+    default:
+      sql = `SELECT tool_name, COUNT(*) as call_count,
+             SUM(CASE WHEN tool_success = 1 THEN 1 ELSE 0 END) as successes,
+             SUM(CASE WHEN tool_success = 0 THEN 1 ELSE 0 END) as failures,
+             AVG(tool_output_size) as avg_output_size,
+             AVG(tool_input_size) as avg_input_size
+             FROM tool_call_details ${whereClause}
+             GROUP BY tool_name ORDER BY call_count DESC`;
+      break;
   }
+  return db.prepare(sql).all(...params);
 }
-function addObservation(db, sessionId, type, title, detail, opts) {
-  const now = /* @__PURE__ */ new Date();
-  const importance = opts?.importance ?? assignImportance(type, opts?.evidence?.includes("PASS") ? "PASS" : void 0);
-  const result = db.prepare(`
-    INSERT INTO observations (session_id, type, title, detail, files_involved, plan_item, cr_rule, vr_type, evidence, importance, original_tokens, created_at, created_at_epoch)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(
-    sessionId,
-    type,
-    title,
-    detail,
-    JSON.stringify(opts?.filesInvolved ?? []),
-    opts?.planItem ?? null,
-    opts?.crRule ?? null,
-    opts?.vrType ?? null,
-    opts?.evidence ?? null,
-    importance,
-    opts?.originalTokens ?? 0,
-    now.toISOString(),
-    Math.floor(now.getTime() / 1e3)
+function getSessionStats(db, opts) {
+  if (opts?.sessionId) {
+    const turns = db.prepare("SELECT COUNT(*) as turn_count, SUM(tool_call_count) as total_tool_calls, SUM(prompt_tokens) as total_prompt_tokens, SUM(response_tokens) as total_response_tokens FROM conversation_turns WHERE session_id = ?").get(opts.sessionId);
+    const toolBreakdown = db.prepare("SELECT tool_name, COUNT(*) as count FROM tool_call_details WHERE session_id = ? GROUP BY tool_name ORDER BY count DESC").all(opts.sessionId);
+    const session = db.prepare("SELECT * FROM sessions WHERE session_id = ?").get(opts.sessionId);
+    return [{
+      session_id: opts.sessionId,
+      status: session?.status ?? "unknown",
+      started_at: session?.started_at ?? null,
+      ended_at: session?.ended_at ?? null,
+      ...turns,
+      tool_breakdown: toolBreakdown
+    }];
+  }
+  const limit = opts?.limit ?? 10;
+  return db.prepare(`
+    SELECT s.session_id, s.status, s.started_at, s.ended_at,
+           COUNT(ct.id) as turn_count,
+           COALESCE(SUM(ct.tool_call_count), 0) as total_tool_calls,
+           COALESCE(SUM(ct.prompt_tokens), 0) as total_prompt_tokens,
+           COALESCE(SUM(ct.response_tokens), 0) as total_response_tokens
+    FROM sessions s
+    LEFT JOIN conversation_turns ct ON s.session_id = ct.session_id
+    GROUP BY s.session_id
+    ORDER BY s.started_at_epoch DESC
+    LIMIT ?
+  `).all(limit);
+}
+function getObservabilityDbSize(db) {
+  const turnsCount = db.prepare("SELECT COUNT(*) as c FROM conversation_turns").get().c;
+  const detailsCount = db.prepare("SELECT COUNT(*) as c FROM tool_call_details").get().c;
+  const obsCount = db.prepare("SELECT COUNT(*) as c FROM observations").get().c;
+  const pageCount = db.pragma("page_count")[0]?.page_count ?? 0;
+  const pageSize = db.pragma("page_size")[0]?.page_size ?? 4096;
+  return {
+    conversation_turns_count: turnsCount,
+    tool_call_details_count: detailsCount,
+    observations_count: obsCount,
+    db_page_count: pageCount,
+    db_page_size: pageSize,
+    estimated_size_mb: Math.round(pageCount * pageSize / (1024 * 1024) * 100) / 100
+  };
+}
+var init_memory_db = __esm({
+  "src/memory-db.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// 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 frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  let name = basename8;
+  let description = "";
+  let type = "discovery";
+  let confidence;
+  if (frontmatterMatch) {
+    try {
+      const fm = parseYaml2(frontmatterMatch[1]);
+      name = fm.name ?? basename8;
+      description = fm.description ?? "";
+      type = fm.type ?? "discovery";
+      confidence = fm.confidence != null ? Number(fm.confidence) : void 0;
+    } catch {
+    }
+  }
+  const obsType = mapMemoryTypeToObservationType(type);
+  const importance = confidence != null ? Math.max(1, Math.min(5, Math.round(confidence * 4 + 1))) : 4;
+  const bodyMatch = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
+  const body = bodyMatch ? bodyMatch[1].trim().slice(0, 500) : "";
+  const title = `[memory-file] ${name}`;
+  const detail = description ? `${description}
+
+${body}` : body;
+  const existing = db.prepare(
+    "SELECT id FROM observations WHERE title = ? LIMIT 1"
+  ).get(title);
+  if (existing) {
+    db.prepare("UPDATE observations SET detail = ?, importance = ? WHERE id = ?").run(detail, importance, existing.id);
+    return "updated";
+  } else {
+    addObservation(db, sessionId, obsType, title, detail, { importance });
+    return "inserted";
+  }
+}
+function backfillMemoryFiles(db, memoryDir, sessionId) {
+  const stats = { inserted: 0, updated: 0, skipped: 0, total: 0 };
+  if (!existsSync3(memoryDir)) return stats;
+  const files = readdirSync(memoryDir).filter(
+    (f) => f.endsWith(".md") && f !== "MEMORY.md"
   );
-  return Number(result.lastInsertRowid);
+  stats.total = files.length;
+  const sid = sessionId ?? `backfill-${Date.now()}`;
+  for (const file of files) {
+    const result = ingestMemoryFile(db, sid, join(memoryDir, file));
+    stats[result]++;
+  }
+  return stats;
 }
-function searchObservations(db, query, opts) {
-  const limit = opts?.limit ?? 20;
-  let sql = `
-    SELECT o.id, o.type, o.title, o.created_at, o.session_id, o.importance,
-           rank
-    FROM observations_fts
-    JOIN observations o ON observations_fts.rowid = o.id
-    WHERE observations_fts MATCH ?
-  `;
-  const params = [sanitizeFts5Query(query)];
-  if (opts?.type) {
-    sql += " AND o.type = ?";
-    params.push(opts.type);
+function mapMemoryTypeToObservationType(memoryType) {
+  switch (memoryType) {
+    case "user":
+    case "feedback":
+      return "decision";
+    case "project":
+      return "feature";
+    case "reference":
+      return "discovery";
+    default:
+      return "discovery";
+  }
+}
+var init_memory_file_ingest = __esm({
+  "src/memory-file-ingest.ts"() {
+    "use strict";
+    init_memory_db();
+  }
+});
+
+// src/commands/install-commands.ts
+var install_commands_exports = {};
+__export(install_commands_exports, {
+  installAll: () => installAll,
+  installCommands: () => installCommands,
+  resolveAssetDir: () => resolveAssetDir,
+  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 { fileURLToPath } from "url";
+function resolveAssetDir(assetName) {
+  const cwd = process.cwd();
+  const nodeModulesPath = resolve3(cwd, "node_modules/@massu/core", assetName);
+  if (existsSync4(nodeModulesPath)) {
+    return nodeModulesPath;
+  }
+  const distRelPath = resolve3(__dirname, "..", assetName);
+  if (existsSync4(distRelPath)) {
+    return distRelPath;
+  }
+  const srcRelPath = resolve3(__dirname, "../..", assetName);
+  if (existsSync4(srcRelPath)) {
+    return srcRelPath;
+  }
+  return null;
+}
+function resolveCommandsDir() {
+  return resolveAssetDir("commands");
+}
+function syncDirectory(sourceDir, targetDir) {
+  const stats = { installed: 0, updated: 0, skipped: 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);
+      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++;
+      }
+    }
+  }
+  return stats;
+}
+function installCommands(projectRoot) {
+  const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
+  const targetDir = resolve3(projectRoot, claudeDirName, "commands");
+  if (!existsSync4(targetDir)) {
+    mkdirSync2(targetDir, { recursive: true });
+  }
+  const sourceDir = resolveAssetDir("commands");
+  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 };
+  }
+  const stats = syncDirectory(sourceDir, targetDir);
+  return { ...stats, commandsDir: targetDir };
+}
+function installAll(projectRoot) {
+  const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
+  const claudeDir = resolve3(projectRoot, claudeDirName);
+  const assets = {};
+  let totalInstalled = 0;
+  let totalUpdated = 0;
+  let totalSkipped = 0;
+  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);
+    assets[assetType.name] = stats;
+    totalInstalled += stats.installed;
+    totalUpdated += stats.updated;
+    totalSkipped += stats.skipped;
+  }
+  return { assets, totalInstalled, totalUpdated, totalSkipped, claudeDir };
+}
+async function runInstallCommands() {
+  const projectRoot = process.cwd();
+  console.log("");
+  console.log("Massu AI - Install Project Assets");
+  console.log("==================================");
+  console.log("");
+  const result = installAll(projectRoot);
+  for (const assetType of ASSET_TYPES) {
+    const stats = result.assets[assetType.name];
+    if (!stats) {
+      continue;
+    }
+    const total = stats.installed + stats.updated + stats.skipped;
+    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`);
+    const description = assetType.description;
+    console.log(`  ${description}: ${parts.join(", ")} (${total} total)`);
+  }
+  const grandTotal = result.totalInstalled + result.totalUpdated + result.totalSkipped;
+  console.log("");
+  console.log(`  ${grandTotal} total files synced to ${result.claudeDir}`);
+  console.log("");
+  console.log("  Restart your Claude Code session to use them.");
+  console.log("");
+}
+var __filename, __dirname, ASSET_TYPES;
+var init_install_commands = __esm({
+  "src/commands/install-commands.ts"() {
+    "use strict";
+    init_config();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname3(__filename);
+    ASSET_TYPES = [
+      { name: "commands", targetSubdir: "commands", description: "slash commands" },
+      { name: "agents", targetSubdir: "agents", description: "agent definitions" },
+      { name: "patterns", targetSubdir: "patterns", description: "pattern files" },
+      { name: "protocols", targetSubdir: "protocols", description: "protocol files" },
+      { name: "reference", targetSubdir: "reference", description: "reference files" }
+    ];
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  buildHooksConfig: () => buildHooksConfig,
+  detectFramework: () => detectFramework,
+  detectPython: () => detectPython,
+  generateConfig: () => generateConfig,
+  initMemoryDir: () => initMemoryDir,
+  installHooks: () => installHooks,
+  registerMcpServer: () => registerMcpServer,
+  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 { fileURLToPath as fileURLToPath2 } from "url";
+import { homedir as homedir2 } from "os";
+import { stringify as yamlStringify } from "yaml";
+function detectFramework(projectRoot) {
+  const result = {
+    type: "javascript",
+    router: "none",
+    orm: "none",
+    ui: "none"
+  };
+  const pkgPath = resolve4(projectRoot, "package.json");
+  if (!existsSync5(pkgPath)) return result;
+  try {
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    if (allDeps["typescript"]) result.type = "typescript";
+    if (allDeps["next"]) result.ui = "nextjs";
+    else if (allDeps["@sveltejs/kit"]) result.ui = "sveltekit";
+    else if (allDeps["nuxt"]) result.ui = "nuxt";
+    else if (allDeps["@angular/core"]) result.ui = "angular";
+    else if (allDeps["vue"]) result.ui = "vue";
+    else if (allDeps["react"]) result.ui = "react";
+    if (allDeps["@trpc/server"]) result.router = "trpc";
+    else if (allDeps["graphql"] || allDeps["@apollo/server"]) result.router = "graphql";
+    else if (allDeps["express"] || allDeps["fastify"] || allDeps["hono"]) result.router = "rest";
+    if (allDeps["@prisma/client"] || allDeps["prisma"]) result.orm = "prisma";
+    else if (allDeps["drizzle-orm"]) result.orm = "drizzle";
+    else if (allDeps["typeorm"]) result.orm = "typeorm";
+    else if (allDeps["sequelize"]) result.orm = "sequelize";
+    else if (allDeps["mongoose"]) result.orm = "mongoose";
+  } catch {
+  }
+  return result;
+}
+function detectPython(projectRoot) {
+  const result = {
+    detected: false,
+    root: "",
+    hasFastapi: false,
+    hasSqlalchemy: false,
+    hasAlembic: false,
+    alembicDir: null
+  };
+  const markers = ["pyproject.toml", "setup.py", "requirements.txt", "Pipfile"];
+  const hasMarker = markers.some((m) => existsSync5(resolve4(projectRoot, m)));
+  if (!hasMarker) return result;
+  result.detected = true;
+  const depFiles = [
+    { file: "pyproject.toml", parser: parsePyprojectDeps },
+    { file: "requirements.txt", parser: parseRequirementsDeps },
+    { file: "setup.py", parser: parseSetupPyDeps },
+    { file: "Pipfile", parser: parsePipfileDeps }
+  ];
+  for (const { file, parser } of depFiles) {
+    const filePath = resolve4(projectRoot, file);
+    if (existsSync5(filePath)) {
+      try {
+        const content = readFileSync4(filePath, "utf-8");
+        const deps = parser(content);
+        if (deps.includes("fastapi")) result.hasFastapi = true;
+        if (deps.includes("sqlalchemy")) result.hasSqlalchemy = true;
+      } catch {
+      }
+    }
+  }
+  if (existsSync5(resolve4(projectRoot, "alembic.ini"))) {
+    result.hasAlembic = true;
+    if (existsSync5(resolve4(projectRoot, "alembic"))) {
+      result.alembicDir = "alembic";
+    }
+  } else if (existsSync5(resolve4(projectRoot, "alembic"))) {
+    result.hasAlembic = true;
+    result.alembicDir = "alembic";
   }
-  if (opts?.crRule) {
-    sql += " AND o.cr_rule = ?";
-    params.push(opts.crRule);
+  const candidateRoots = ["app", "src", "backend", "api"];
+  for (const candidate of candidateRoots) {
+    const candidatePath = resolve4(projectRoot, candidate);
+    if (existsSync5(candidatePath) && existsSync5(resolve4(candidatePath, "__init__.py"))) {
+      result.root = candidate;
+      break;
+    }
+    if (existsSync5(candidatePath)) {
+      try {
+        const files = readdirSync3(candidatePath);
+        if (files.some((f) => f.endsWith(".py"))) {
+          result.root = candidate;
+          break;
+        }
+      } catch {
+      }
+    }
   }
-  if (opts?.dateFrom) {
-    sql += " AND o.created_at >= ?";
-    params.push(opts.dateFrom);
+  if (!result.root) {
+    result.root = ".";
   }
-  sql += " ORDER BY rank LIMIT ?";
-  params.push(limit);
-  return db.prepare(sql).all(...params);
+  return result;
 }
-function getSessionSummaries(db, limit = 10) {
-  return db.prepare(`
-    SELECT session_id, request, completed, failed_attempts, plan_progress, created_at
-    FROM session_summaries
-    ORDER BY created_at_epoch DESC LIMIT ?
-  `).all(limit);
+function parsePyprojectDeps(content) {
+  const deps = [];
+  const lower = content.toLowerCase();
+  if (lower.includes("fastapi")) deps.push("fastapi");
+  if (lower.includes("sqlalchemy")) deps.push("sqlalchemy");
+  return deps;
 }
-function getFailedAttempts(db, query, limit = 20) {
-  if (query) {
-    return db.prepare(`
-      SELECT o.id, o.title, o.detail, o.session_id, o.recurrence_count, o.created_at
-      FROM observations_fts
-      JOIN observations o ON observations_fts.rowid = o.id
-      WHERE observations_fts MATCH ? AND o.type = 'failed_attempt'
-      ORDER BY o.recurrence_count DESC, rank LIMIT ?
-    `).all(sanitizeFts5Query(query), limit);
+function parseRequirementsDeps(content) {
+  const deps = [];
+  const lower = content.toLowerCase();
+  for (const line of lower.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("fastapi")) deps.push("fastapi");
+    if (trimmed.startsWith("sqlalchemy")) deps.push("sqlalchemy");
   }
-  return db.prepare(`
-    SELECT id, title, detail, session_id, recurrence_count, created_at
-    FROM observations WHERE type = 'failed_attempt'
-    ORDER BY recurrence_count DESC, created_at_epoch DESC LIMIT ?
-  `).all(limit);
+  return deps;
 }
-function pruneOldObservations(db, retentionDays = 90) {
-  const cutoffEpoch = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
-  const result = db.prepare("DELETE FROM observations WHERE created_at_epoch < ?").run(cutoffEpoch);
-  return result.changes;
+function parseSetupPyDeps(content) {
+  const deps = [];
+  const lower = content.toLowerCase();
+  if (lower.includes("fastapi")) deps.push("fastapi");
+  if (lower.includes("sqlalchemy")) deps.push("sqlalchemy");
+  return deps;
 }
-function pruneOldConversationTurns(db, retentionDays = 90) {
-  const cutoffEpoch = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
-  const turnsResult = db.prepare("DELETE FROM conversation_turns WHERE created_at_epoch < ?").run(cutoffEpoch);
-  const detailsResult = db.prepare("DELETE FROM tool_call_details WHERE created_at_epoch < ?").run(cutoffEpoch);
-  return { turnsDeleted: turnsResult.changes, detailsDeleted: detailsResult.changes };
+function parsePipfileDeps(content) {
+  const deps = [];
+  const lower = content.toLowerCase();
+  if (lower.includes("fastapi")) deps.push("fastapi");
+  if (lower.includes("sqlalchemy")) deps.push("sqlalchemy");
+  return deps;
 }
-function getConversationTurns(db, sessionId, opts) {
-  let sql = "SELECT id, turn_number, user_prompt, assistant_response, tool_calls_json, tool_call_count, prompt_tokens, response_tokens, created_at FROM conversation_turns WHERE session_id = ?";
-  const params = [sessionId];
-  if (opts?.turnFrom !== void 0) {
-    sql += " AND turn_number >= ?";
-    params.push(opts.turnFrom);
+function generateConfig(projectRoot, framework) {
+  const configPath = resolve4(projectRoot, "massu.config.yaml");
+  if (existsSync5(configPath)) {
+    return false;
   }
-  if (opts?.turnTo !== void 0) {
-    sql += " AND turn_number <= ?";
-    params.push(opts.turnTo);
+  const projectName = basename2(projectRoot);
+  const config = {
+    project: {
+      name: projectName,
+      root: "auto"
+    },
+    framework: {
+      type: framework.type,
+      router: framework.router,
+      orm: framework.orm,
+      ui: framework.ui
+    },
+    paths: {
+      source: "src",
+      aliases: { "@": "src" }
+    },
+    toolPrefix: "massu",
+    domains: [],
+    rules: [
+      {
+        pattern: "src/**/*.ts",
+        rules: ["Use ESM imports, not CommonJS"]
+      }
+    ]
+  };
+  const python = detectPython(projectRoot);
+  if (python.detected) {
+    const pythonConfig = {
+      root: python.root,
+      exclude_dirs: ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]
+    };
+    if (python.hasFastapi) pythonConfig.framework = "fastapi";
+    if (python.hasSqlalchemy) pythonConfig.orm = "sqlalchemy";
+    if (python.hasAlembic && python.alembicDir) {
+      pythonConfig.alembic_dir = python.alembicDir;
+    }
+    config.python = pythonConfig;
   }
-  sql += " ORDER BY turn_number ASC";
-  return db.prepare(sql).all(...params);
+  const yamlContent = `# Massu AI Configuration
+# Generated by: npx massu init
+# Documentation: https://massu.ai/docs/getting-started/configuration
+
+${yamlStringify(config)}`;
+  writeFileSync2(configPath, yamlContent, "utf-8");
+  return true;
 }
-function searchConversationTurns(db, query, opts) {
-  const limit = opts?.limit ?? 20;
-  let sql = `
-    SELECT ct.id, ct.session_id, ct.turn_number, ct.user_prompt, ct.tool_call_count, ct.response_tokens, ct.created_at, rank
-    FROM conversation_turns_fts
-    JOIN conversation_turns ct ON conversation_turns_fts.rowid = ct.id
-    WHERE conversation_turns_fts MATCH ?
-  `;
-  const params = [sanitizeFts5Query(query)];
-  if (opts?.sessionId) {
-    sql += " AND ct.session_id = ?";
-    params.push(opts.sessionId);
+function registerMcpServer(projectRoot) {
+  const mcpPath = resolve4(projectRoot, ".mcp.json");
+  let existing = {};
+  if (existsSync5(mcpPath)) {
+    try {
+      existing = JSON.parse(readFileSync4(mcpPath, "utf-8"));
+    } catch {
+      existing = {};
+    }
   }
-  if (opts?.dateFrom) {
-    sql += " AND ct.created_at >= ?";
-    params.push(opts.dateFrom);
+  const servers = existing.mcpServers ?? {};
+  if (servers.massu) {
+    return false;
+  }
+  servers.massu = {
+    type: "stdio",
+    command: "npx",
+    args: ["-y", "@massu/core"]
+  };
+  existing.mcpServers = servers;
+  writeFileSync2(mcpPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+  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}`;
+}
+function buildHooksConfig(hooksDir) {
+  return {
+    SessionStart: [
+      {
+        hooks: [
+          { type: "command", command: hookCmd(hooksDir, "session-start.js"), timeout: 10 }
+        ]
+      }
+    ],
+    PreToolUse: [
+      {
+        matcher: "Bash",
+        hooks: [
+          { type: "command", command: hookCmd(hooksDir, "security-gate.js"), timeout: 5 }
+        ]
+      },
+      {
+        matcher: "Bash|Write",
+        hooks: [
+          { type: "command", command: hookCmd(hooksDir, "pre-delete-check.js"), timeout: 5 }
+        ]
+      }
+    ],
+    PostToolUse: [
+      {
+        hooks: [
+          { type: "command", command: hookCmd(hooksDir, "post-tool-use.js"), timeout: 10 },
+          { type: "command", command: hookCmd(hooksDir, "quality-event.js"), timeout: 5 },
+          { type: "command", command: hookCmd(hooksDir, "cost-tracker.js"), timeout: 5 }
+        ]
+      },
+      {
+        matcher: "Edit|Write",
+        hooks: [
+          { type: "command", command: hookCmd(hooksDir, "post-edit-context.js"), timeout: 5 }
+        ]
+      }
+    ],
+    Stop: [
+      {
+        hooks: [
+          { type: "command", command: hookCmd(hooksDir, "session-end.js"), timeout: 15 }
+        ]
+      }
+    ],
+    PreCompact: [
+      {
+        hooks: [
+          { type: "command", command: hookCmd(hooksDir, "pre-compact.js"), timeout: 10 }
+        ]
+      }
+    ],
+    UserPromptSubmit: [
+      {
+        hooks: [
+          { type: "command", command: hookCmd(hooksDir, "user-prompt.js"), timeout: 5 },
+          { type: "command", command: hookCmd(hooksDir, "intent-suggester.js"), timeout: 5 }
+        ]
+      }
+    ]
+  };
+}
+function installHooks(projectRoot) {
+  const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
+  const claudeDir = resolve4(projectRoot, claudeDirName);
+  const settingsPath = resolve4(claudeDir, "settings.local.json");
+  if (!existsSync5(claudeDir)) {
+    mkdirSync3(claudeDir, { recursive: true });
+  }
+  let settings = {};
+  if (existsSync5(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+  const hooksDir = resolveHooksDir();
+  const hooksConfig = buildHooksConfig(hooksDir);
+  let hookCount = 0;
+  for (const groups of Object.values(hooksConfig)) {
+    for (const group of groups) {
+      hookCount += group.hooks.length;
+    }
   }
-  if (opts?.dateTo) {
-    sql += " AND ct.created_at <= ?";
-    params.push(opts.dateTo);
+  settings.hooks = hooksConfig;
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  return { installed: true, count: hookCount };
+}
+function initMemoryDir(projectRoot) {
+  const encodedRoot = "-" + projectRoot.replace(/\//g, "-");
+  const memoryDir = resolve4(homedir2(), `.claude/projects/${encodedRoot}/memory`);
+  let created = false;
+  if (!existsSync5(memoryDir)) {
+    mkdirSync3(memoryDir, { recursive: true });
+    created = true;
   }
-  if (opts?.minToolCalls !== void 0) {
-    sql += " AND ct.tool_call_count >= ?";
-    params.push(opts.minToolCalls);
+  const memoryMdPath = resolve4(memoryDir, "MEMORY.md");
+  let memoryMdCreated = false;
+  if (!existsSync5(memoryMdPath)) {
+    const projectName = basename2(projectRoot);
+    const memoryContent = `# ${projectName} - Massu Memory
+
+## Key Learnings
+<!-- Important patterns and conventions discovered during development -->
+
+## Common Gotchas
+<!-- Non-obvious issues and how to avoid them -->
+
+## Corrections
+<!-- Wrong behaviors that were corrected and how to prevent them -->
+
+## File Index
+<!-- Significant files and directories -->
+`;
+    writeFileSync2(memoryMdPath, memoryContent, "utf-8");
+    memoryMdCreated = true;
   }
-  sql += " ORDER BY rank LIMIT ?";
-  params.push(limit);
-  return db.prepare(sql).all(...params);
+  return { created, memoryMdCreated };
 }
-function getToolPatterns(db, opts) {
-  const groupBy = opts?.groupBy ?? "tool";
-  const params = [];
-  let whereClause = "";
-  const conditions = [];
-  if (opts?.sessionId) {
-    conditions.push("session_id = ?");
-    params.push(opts.sessionId);
+async function runInit() {
+  const projectRoot = process.cwd();
+  console.log("");
+  console.log("Massu AI - Project Setup");
+  console.log("========================");
+  console.log("");
+  const framework = detectFramework(projectRoot);
+  const frameworkParts = [];
+  if (framework.type !== "javascript") frameworkParts.push(capitalize(framework.type));
+  if (framework.ui !== "none") frameworkParts.push(formatName(framework.ui));
+  if (framework.orm !== "none") frameworkParts.push(capitalize(framework.orm));
+  if (framework.router !== "none") frameworkParts.push(framework.router.toUpperCase());
+  const detected = frameworkParts.length > 0 ? frameworkParts.join(", ") : "JavaScript";
+  console.log(`  Detected: ${detected}`);
+  const python = detectPython(projectRoot);
+  if (python.detected) {
+    const pyParts = ["Python"];
+    if (python.hasFastapi) pyParts.push("FastAPI");
+    if (python.hasSqlalchemy) pyParts.push("SQLAlchemy");
+    if (python.hasAlembic) pyParts.push("Alembic");
+    console.log(`  Detected: ${pyParts.join(", ")} (root: ${python.root})`);
   }
-  if (opts?.toolName) {
-    conditions.push("tool_name = ?");
-    params.push(opts.toolName);
+  const configCreated = generateConfig(projectRoot, framework);
+  if (configCreated) {
+    console.log("  Created massu.config.yaml");
+  } else {
+    console.log("  massu.config.yaml already exists (preserved)");
   }
-  if (opts?.dateFrom) {
-    conditions.push("created_at >= ?");
-    params.push(opts.dateFrom);
+  const mcpRegistered = registerMcpServer(projectRoot);
+  if (mcpRegistered) {
+    console.log("  Registered MCP server in .mcp.json");
+  } else {
+    console.log("  MCP server already registered in .mcp.json");
   }
-  if (conditions.length > 0) {
-    whereClause = "WHERE " + conditions.join(" AND ");
+  const { count: hooksCount } = installHooks(projectRoot);
+  console.log(`  Installed ${hooksCount} hooks in .claude/settings.local.json`);
+  const cmdResult = installCommands(projectRoot);
+  const cmdTotal = cmdResult.installed + cmdResult.updated + cmdResult.skipped;
+  if (cmdResult.installed > 0 || cmdResult.updated > 0) {
+    console.log(`  Installed ${cmdTotal} slash commands (${cmdResult.installed} new, ${cmdResult.updated} updated)`);
+  } else {
+    console.log(`  ${cmdTotal} slash commands already up to date`);
   }
-  let sql;
-  switch (groupBy) {
-    case "session":
-      sql = `SELECT session_id, COUNT(*) as call_count, COUNT(DISTINCT tool_name) as unique_tools,
-             SUM(CASE WHEN tool_success = 1 THEN 1 ELSE 0 END) as successes,
-             SUM(CASE WHEN tool_success = 0 THEN 1 ELSE 0 END) as failures,
-             AVG(tool_output_size) as avg_output_size
-             FROM tool_call_details ${whereClause}
-             GROUP BY session_id ORDER BY call_count DESC`;
-      break;
-    case "day":
-      sql = `SELECT date(created_at) as day, COUNT(*) as call_count, COUNT(DISTINCT tool_name) as unique_tools,
-             SUM(CASE WHEN tool_success = 1 THEN 1 ELSE 0 END) as successes
-             FROM tool_call_details ${whereClause}
-             GROUP BY date(created_at) ORDER BY day DESC`;
-      break;
-    default:
-      sql = `SELECT tool_name, COUNT(*) as call_count,
-             SUM(CASE WHEN tool_success = 1 THEN 1 ELSE 0 END) as successes,
-             SUM(CASE WHEN tool_success = 0 THEN 1 ELSE 0 END) as failures,
-             AVG(tool_output_size) as avg_output_size,
-             AVG(tool_input_size) as avg_input_size
-             FROM tool_call_details ${whereClause}
-             GROUP BY tool_name ORDER BY call_count DESC`;
-      break;
+  const { created: memDirCreated, memoryMdCreated } = initMemoryDir(projectRoot);
+  if (memDirCreated) {
+    console.log("  Created memory directory (~/.claude/projects/.../memory/)");
+  } else {
+    console.log("  Memory directory already exists");
   }
-  return db.prepare(sql).all(...params);
-}
-function getSessionStats(db, opts) {
-  if (opts?.sessionId) {
-    const turns = db.prepare("SELECT COUNT(*) as turn_count, SUM(tool_call_count) as total_tool_calls, SUM(prompt_tokens) as total_prompt_tokens, SUM(response_tokens) as total_response_tokens FROM conversation_turns WHERE session_id = ?").get(opts.sessionId);
-    const toolBreakdown = db.prepare("SELECT tool_name, COUNT(*) as count FROM tool_call_details WHERE session_id = ? GROUP BY tool_name ORDER BY count DESC").all(opts.sessionId);
-    const session = db.prepare("SELECT * FROM sessions WHERE session_id = ?").get(opts.sessionId);
-    return [{
-      session_id: opts.sessionId,
-      status: session?.status ?? "unknown",
-      started_at: session?.started_at ?? null,
-      ended_at: session?.ended_at ?? null,
-      ...turns,
-      tool_breakdown: toolBreakdown
-    }];
+  if (memoryMdCreated) {
+    console.log("  Created initial MEMORY.md");
   }
-  const limit = opts?.limit ?? 10;
-  return db.prepare(`
-    SELECT s.session_id, s.status, s.started_at, s.ended_at,
-           COUNT(ct.id) as turn_count,
-           COALESCE(SUM(ct.tool_call_count), 0) as total_tool_calls,
-           COALESCE(SUM(ct.prompt_tokens), 0) as total_prompt_tokens,
-           COALESCE(SUM(ct.response_tokens), 0) as total_response_tokens
-    FROM sessions s
-    LEFT JOIN conversation_turns ct ON s.session_id = ct.session_id
-    GROUP BY s.session_id
-    ORDER BY s.started_at_epoch DESC
-    LIMIT ?
-  `).all(limit);
+  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") : [];
+    if (memFiles.length > 0) {
+      const { getMemoryDb: getMemoryDb2 } = await Promise.resolve().then(() => (init_memory_db(), memory_db_exports));
+      const db = getMemoryDb2();
+      try {
+        const stats = backfillMemoryFiles(db, computedMemoryDir, `init-${Date.now()}`);
+        if (stats.inserted > 0 || stats.updated > 0) {
+          console.log(`  Backfilled ${stats.inserted + stats.updated} memory files into database (${stats.inserted} new, ${stats.updated} updated)`);
+        }
+      } finally {
+        db.close();
+      }
+    }
+  } catch (_backfillErr) {
+  }
+  console.log("  Databases will auto-create on first session");
+  console.log("");
+  console.log("Massu AI is ready. Start a Claude Code session to begin.");
+  console.log("");
+  console.log("Next steps:");
+  console.log("  claude                    # Start a session (hooks activate automatically)");
+  console.log("  npx massu doctor          # Verify installation health");
+  console.log("");
+  console.log("Documentation: https://massu.ai/docs");
+  console.log("");
 }
-function getObservabilityDbSize(db) {
-  const turnsCount = db.prepare("SELECT COUNT(*) as c FROM conversation_turns").get().c;
-  const detailsCount = db.prepare("SELECT COUNT(*) as c FROM tool_call_details").get().c;
-  const obsCount = db.prepare("SELECT COUNT(*) as c FROM observations").get().c;
-  const pageCount = db.pragma("page_count")[0]?.page_count ?? 0;
-  const pageSize = db.pragma("page_size")[0]?.page_size ?? 4096;
-  return {
-    conversation_turns_count: turnsCount,
-    tool_call_details_count: detailsCount,
-    observations_count: obsCount,
-    db_page_count: pageCount,
-    db_page_size: pageSize,
-    estimated_size_mb: Math.round(pageCount * pageSize / (1024 * 1024) * 100) / 100
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function formatName(name) {
+  const names = {
+    nextjs: "Next.js",
+    sveltekit: "SvelteKit",
+    nuxt: "Nuxt",
+    angular: "Angular",
+    vue: "Vue",
+    react: "React"
   };
+  return names[name] ?? capitalize(name);
 }
-var init_memory_db = __esm({
-  "src/memory-db.ts"() {
+var __filename2, __dirname2;
+var init_init = __esm({
+  "src/commands/init.ts"() {
     "use strict";
+    init_memory_file_ingest();
     init_config();
+    init_install_commands();
+    __filename2 = fileURLToPath2(import.meta.url);
+    __dirname2 = dirname4(__filename2);
   }
 });
 
@@ -1921,18 +2297,18 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor,
   runValidateConfig: () => runValidateConfig
 });
-import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "fs";
 import { resolve as resolve5, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { parse as parseYaml2 } from "yaml";
+import { parse as parseYaml3 } from "yaml";
 function checkConfig(projectRoot) {
   const configPath = resolve5(projectRoot, "massu.config.yaml");
-  if (!existsSync5(configPath)) {
+  if (!existsSync6(configPath)) {
     return { name: "Configuration", status: "fail", detail: "massu.config.yaml not found. Run: npx massu init" };
   }
   try {
-    const content = readFileSync4(configPath, "utf-8");
-    const parsed = parseYaml2(content);
+    const content = readFileSync5(configPath, "utf-8");
+    const parsed = parseYaml3(content);
     if (!parsed || typeof parsed !== "object") {
       return { name: "Configuration", status: "fail", detail: "massu.config.yaml is empty or invalid YAML" };
     }
@@ -1943,11 +2319,11 @@ function checkConfig(projectRoot) {
 }
 function checkMcpServer(projectRoot) {
   const mcpPath = getResolvedPaths().mcpJsonPath;
-  if (!existsSync5(mcpPath)) {
+  if (!existsSync6(mcpPath)) {
     return { name: "MCP Server", status: "fail", detail: ".mcp.json not found. Run: npx massu init" };
   }
   try {
-    const content = JSON.parse(readFileSync4(mcpPath, "utf-8"));
+    const content = JSON.parse(readFileSync5(mcpPath, "utf-8"));
     const servers = content.mcpServers ?? {};
     if (!servers.massu) {
       return { name: "MCP Server", status: "fail", detail: "massu not registered in .mcp.json. Run: npx massu init" };
@@ -1959,11 +2335,11 @@ function checkMcpServer(projectRoot) {
 }
 function checkHooksConfig(projectRoot) {
   const settingsPath = getResolvedPaths().settingsLocalPath;
-  if (!existsSync5(settingsPath)) {
+  if (!existsSync6(settingsPath)) {
     return { name: "Hooks Config", status: "fail", detail: ".claude/settings.local.json not found. Run: npx massu init" };
   }
   try {
-    const content = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    const content = JSON.parse(readFileSync5(settingsPath, "utf-8"));
     if (!content.hooks) {
       return { name: "Hooks Config", status: "fail", detail: "No hooks configured. Run: npx massu install-hooks" };
     }
@@ -1989,9 +2365,9 @@ function checkHooksConfig(projectRoot) {
 function checkHookFiles(projectRoot) {
   const nodeModulesHooksDir = resolve5(projectRoot, "node_modules/@massu/core/dist/hooks");
   let hooksDir = nodeModulesHooksDir;
-  if (!existsSync5(nodeModulesHooksDir)) {
+  if (!existsSync6(nodeModulesHooksDir)) {
     const devHooksDir = resolve5(__dirname3, "../../dist/hooks");
-    if (existsSync5(devHooksDir)) {
+    if (existsSync6(devHooksDir)) {
       hooksDir = devHooksDir;
     } else {
       return { name: "Hook Files", status: "fail", detail: "Compiled hooks not found. Run: npm install @massu/core" };
@@ -1999,7 +2375,7 @@ function checkHookFiles(projectRoot) {
   }
   const missing = [];
   for (const hookFile of EXPECTED_HOOKS) {
-    if (!existsSync5(resolve5(hooksDir, hookFile))) {
+    if (!existsSync6(resolve5(hooksDir, hookFile))) {
       missing.push(hookFile);
     }
   }
@@ -2026,7 +2402,7 @@ function checkNodeVersion() {
 }
 async function checkGitRepo(projectRoot) {
   const gitDir = resolve5(projectRoot, ".git");
-  if (!existsSync5(gitDir)) {
+  if (!existsSync6(gitDir)) {
     return { name: "Git Repository", status: "warn", detail: "Not a git repository (optional but recommended)" };
   }
   try {
@@ -2044,7 +2420,7 @@ async function checkGitRepo(projectRoot) {
 }
 function checkKnowledgeDb(projectRoot) {
   const knowledgeDbPath = getResolvedPaths().memoryDbPath;
-  if (!existsSync5(knowledgeDbPath)) {
+  if (!existsSync6(knowledgeDbPath)) {
     return {
       name: "Knowledge DB",
       status: "warn",
@@ -2055,7 +2431,7 @@ function checkKnowledgeDb(projectRoot) {
 }
 function checkMemoryDir(_projectRoot2) {
   const memoryDir = getResolvedPaths().memoryDir;
-  if (!existsSync5(memoryDir)) {
+  if (!existsSync6(memoryDir)) {
     return {
       name: "Memory Directory",
       status: "warn",
@@ -2066,7 +2442,7 @@ function checkMemoryDir(_projectRoot2) {
 }
 function checkShellHooksWired(_projectRoot2) {
   const settingsPath = getResolvedPaths().settingsLocalPath;
-  if (!existsSync5(settingsPath)) {
+  if (!existsSync6(settingsPath)) {
     return {
       name: "Shell Hooks",
       status: "fail",
@@ -2074,7 +2450,7 @@ function checkShellHooksWired(_projectRoot2) {
     };
   }
   try {
-    const content = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    const content = JSON.parse(readFileSync5(settingsPath, "utf-8"));
     const hooks = content.hooks ?? {};
     const hasSessionStart = Array.isArray(hooks.SessionStart) && hooks.SessionStart.length > 0;
     const hasPreToolUse = Array.isArray(hooks.PreToolUse) && hooks.PreToolUse.length > 0;
@@ -2126,7 +2502,7 @@ function checkPythonHealth(projectRoot) {
   const config = getConfig();
   if (!config.python?.root) return null;
   const pythonRoot = resolve5(projectRoot, config.python.root);
-  if (!existsSync5(pythonRoot)) {
+  if (!existsSync6(pythonRoot)) {
     return {
       name: "Python",
       status: "fail",
@@ -2140,15 +2516,15 @@ function checkPythonHealth(projectRoot) {
   function scanDir(dir, depth) {
     if (depth > 5) return;
     try {
-      const entries = readdirSync3(dir, { withFileTypes: true });
+      const entries = readdirSync4(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 && !existsSync5(resolve5(subdir, "__init__.py"))) {
+            if (depth <= 2 && !existsSync6(resolve5(subdir, "__init__.py"))) {
               try {
-                const subEntries = readdirSync3(subdir);
+                const subEntries = readdirSync4(subdir);
                 if (subEntries.some((f) => f.endsWith(".py") && f !== "__init__.py")) {
                   initPyMissing.push(entry.name);
                 }
@@ -2242,15 +2618,15 @@ async function runDoctor() {
 async function runValidateConfig() {
   const projectRoot = process.cwd();
   const configPath = resolve5(projectRoot, "massu.config.yaml");
-  if (!existsSync5(configPath)) {
+  if (!existsSync6(configPath)) {
     console.error("Error: massu.config.yaml not found in current directory");
     console.error("Run: npx massu init");
     process.exit(1);
     return;
   }
   try {
-    const content = readFileSync4(configPath, "utf-8");
-    const parsed = parseYaml2(content);
+    const content = readFileSync5(configPath, "utf-8");
+    const parsed = parseYaml3(content);
     if (!parsed || typeof parsed !== "object") {
       console.error("Error: massu.config.yaml is empty or not a valid YAML object");
       process.exit(1);
@@ -2331,11 +2707,11 @@ var init_install_hooks = __esm({
 
 // src/db.ts
 import Database2 from "better-sqlite3";
-import { dirname as dirname6, join } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync as readdirSync4, statSync } from "fs";
+import { dirname as dirname6, join as join3 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
 function getCodeGraphDb() {
   const dbPath = getResolvedPaths().codegraphDbPath;
-  if (!existsSync6(dbPath)) {
+  if (!existsSync7(dbPath)) {
     throw new Error(`CodeGraph database not found at ${dbPath}. Run 'npx @colbymchenry/codegraph sync' first.`);
   }
   const db = new Database2(dbPath, { readonly: true });
@@ -2345,7 +2721,7 @@ function getCodeGraphDb() {
 function getDataDb() {
   const dbPath = getResolvedPaths().dataDbPath;
   const dir = dirname6(dbPath);
-  if (!existsSync6(dir)) {
+  if (!existsSync7(dir)) {
     mkdirSync4(dir, { recursive: true });
   }
   const db = new Database2(dbPath);
@@ -2616,14 +2992,14 @@ function isPythonDataStale(dataDb2, pythonRoot) {
   const lastBuildTime = new Date(lastBuild.value).getTime();
   function checkDir(dir) {
     try {
-      const entries = readdirSync4(dir, { withFileTypes: true });
+      const entries = readdirSync5(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
+        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 (statSync(fullPath).mtimeMs > lastBuildTime) return true;
+          if (statSync2(fullPath).mtimeMs > lastBuildTime) return true;
         }
       }
     } catch {
@@ -2719,8 +3095,8 @@ var init_rules = __esm({
 });
 
 // src/import-resolver.ts
-import { readFileSync as readFileSync5, existsSync as existsSync7, statSync as statSync2 } from "fs";
-import { resolve as resolve7, dirname as dirname7, join as join2 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync8, statSync as statSync3 } from "fs";
+import { resolve as resolve7, dirname as dirname7, join as join4 } from "path";
 function parseImports(source) {
   const imports = [];
   const lines = source.split("\n");
@@ -2780,19 +3156,19 @@ function resolveImportPath(specifier, fromFile) {
   } else {
     basePath = resolve7(dirname7(fromFile), specifier);
   }
-  if (existsSync7(basePath) && !isDirectory(basePath)) {
+  if (existsSync8(basePath) && !isDirectory(basePath)) {
     return toRelative(basePath);
   }
   const resolvedPaths = getResolvedPaths();
   for (const ext of resolvedPaths.extensions) {
     const withExt = basePath + ext;
-    if (existsSync7(withExt)) {
+    if (existsSync8(withExt)) {
       return toRelative(withExt);
     }
   }
   for (const indexFile of resolvedPaths.indexFiles) {
-    const indexPath = join2(basePath, indexFile);
-    if (existsSync7(indexPath)) {
+    const indexPath = join4(basePath, indexFile);
+    if (existsSync8(indexPath)) {
       return toRelative(indexPath);
     }
   }
@@ -2800,7 +3176,7 @@ function resolveImportPath(specifier, fromFile) {
 }
 function isDirectory(path) {
   try {
-    return statSync2(path).isDirectory();
+    return statSync3(path).isDirectory();
   } catch {
     return false;
   }
@@ -2829,10 +3205,10 @@ function buildImportIndex(dataDb2, codegraphDb2) {
   let batch = [];
   for (const file of files) {
     const absPath = ensureWithinRoot(resolve7(projectRoot, file.path), projectRoot);
-    if (!existsSync7(absPath)) continue;
+    if (!existsSync8(absPath)) continue;
     let source;
     try {
-      source = readFileSync5(absPath, "utf-8");
+      source = readFileSync6(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -2868,15 +3244,15 @@ var init_import_resolver = __esm({
 });
 
 // src/trpc-index.ts
-import { readFileSync as readFileSync6, existsSync as existsSync8, readdirSync as readdirSync5 } from "fs";
-import { resolve as resolve8, join as join3 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync9, readdirSync as readdirSync6 } from "fs";
+import { resolve as resolve8, join as join5 } from "path";
 function parseRootRouter() {
   const paths = getResolvedPaths();
   const rootPath = paths.rootRouterPath;
-  if (!existsSync8(rootPath)) {
+  if (!existsSync9(rootPath)) {
     throw new Error(`Root router not found at ${rootPath}`);
   }
-  const source = readFileSync6(rootPath, "utf-8");
+  const source = readFileSync7(rootPath, "utf-8");
   const mappings = [];
   const importMap = /* @__PURE__ */ new Map();
   const importRegex = /import\s+\{[^}]*?(\w+Router)[^}]*\}\s+from\s+['"]\.\/routers\/([^'"]+)['"]/g;
@@ -2888,12 +3264,12 @@ function parseRootRouter() {
     for (const ext of [".ts", ".tsx", ""]) {
       const candidate = fullPath + ext;
       const routersRelPath = getConfig().paths.routers ?? "src/server/api/routers";
-      if (existsSync8(candidate)) {
+      if (existsSync9(candidate)) {
         filePath = routersRelPath + "/" + filePath + ext;
         break;
       }
-      const indexCandidate = join3(fullPath, "index.ts");
-      if (existsSync8(indexCandidate)) {
+      const indexCandidate = join5(fullPath, "index.ts");
+      if (existsSync9(indexCandidate)) {
         filePath = routersRelPath + "/" + filePath + "/index.ts";
         break;
       }
@@ -2913,8 +3289,8 @@ function parseRootRouter() {
 }
 function extractProcedures(routerFilePath) {
   const absPath = resolve8(getProjectRoot(), routerFilePath);
-  if (!existsSync8(absPath)) return [];
-  const source = readFileSync6(absPath, "utf-8");
+  if (!existsSync9(absPath)) return [];
+  const source = readFileSync7(absPath, "utf-8");
   const procedures = [];
   const seen = /* @__PURE__ */ new Set();
   const procRegex = /(\w+)\s*:\s*(protected|public)Procedure/g;
@@ -2943,21 +3319,21 @@ function findUICallSites(routerKey, procedureName) {
   ];
   const searchPattern = `api.${routerKey}.${procedureName}`;
   for (const dir of searchDirs) {
-    if (!existsSync8(dir)) continue;
+    if (!existsSync9(dir)) continue;
     searchDirectory(dir, searchPattern, callSites);
   }
   return callSites;
 }
 function searchDirectory(dir, pattern, results) {
-  const entries = readdirSync5(dir, { withFileTypes: true });
+  const entries = readdirSync6(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join3(dir, entry.name);
+    const fullPath = join5(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".next") continue;
       searchDirectory(fullPath, pattern, results);
     } else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
       try {
-        const source = readFileSync6(fullPath, "utf-8");
+        const source = readFileSync7(fullPath, "utf-8");
         const lines = source.split("\n");
         for (let i = 0; i < lines.length; i++) {
           if (lines[i].includes(pattern)) {
@@ -3020,7 +3396,7 @@ var init_trpc_index = __esm({
 });
 
 // src/page-deps.ts
-import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
 import { resolve as resolve9 } from "path";
 function deriveRoute(pageFile) {
   let route = pageFile.replace(/^src\/app/, "").replace(/\/page\.tsx?$/, "").replace(/\/page\.jsx?$/, "");
@@ -3060,9 +3436,9 @@ function findRouterCalls(files) {
   const projectRoot = getProjectRoot();
   for (const file of files) {
     const absPath = ensureWithinRoot(resolve9(projectRoot, file), projectRoot);
-    if (!existsSync9(absPath)) continue;
+    if (!existsSync10(absPath)) continue;
     try {
-      const source = readFileSync7(absPath, "utf-8");
+      const source = readFileSync8(absPath, "utf-8");
       const apiCallRegex = /api\.(\w+)\.\w+/g;
       let match;
       while ((match = apiCallRegex.exec(source)) !== null) {
@@ -3081,9 +3457,9 @@ function findTablesFromRouters(routerNames, dataDb2) {
     ).all(routerName);
     for (const proc of procs) {
       const absPath = ensureWithinRoot(resolve9(getProjectRoot(), proc.router_file), getProjectRoot());
-      if (!existsSync9(absPath)) continue;
+      if (!existsSync10(absPath)) continue;
       try {
-        const source = readFileSync7(absPath, "utf-8");
+        const source = readFileSync8(absPath, "utf-8");
         const dbPattern = getConfig().dbAccessPattern ?? "ctx.db.{table}";
         const regexStr = dbPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\{table\\}", "(\\w+)");
         const tableRegex = new RegExp(regexStr + "\\.", "g");
@@ -3352,14 +3728,14 @@ var init_domains = __esm({
 });
 
 // src/schema-mapper.ts
-import { readFileSync as readFileSync8, existsSync as existsSync10, readdirSync as readdirSync6 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync11, readdirSync as readdirSync7 } from "fs";
+import { join as join6 } from "path";
 function parsePrismaSchema() {
   const schemaPath = getResolvedPaths().prismaSchemaPath;
-  if (!existsSync10(schemaPath)) {
+  if (!existsSync11(schemaPath)) {
     throw new Error(`Prisma schema not found at ${schemaPath}`);
   }
-  const source = readFileSync8(schemaPath, "utf-8");
+  const source = readFileSync9(schemaPath, "utf-8");
   const models = [];
   const sourceLines = source.split("\n");
   let i = 0;
@@ -3417,14 +3793,14 @@ function toSnakeCase(str) {
 function findColumnUsageInRouters(tableName) {
   const usage = /* @__PURE__ */ new Map();
   const routersDir = getResolvedPaths().routersDir;
-  if (!existsSync10(routersDir)) return usage;
+  if (!existsSync11(routersDir)) return usage;
   scanDirectory(routersDir, tableName, usage);
   return usage;
 }
 function scanDirectory(dir, tableName, usage) {
-  const entries = readdirSync6(dir, { withFileTypes: true });
+  const entries = readdirSync7(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join4(dir, entry.name);
+    const fullPath = join6(dir, entry.name);
     if (entry.isDirectory()) {
       scanDirectory(fullPath, tableName, usage);
     } else if (entry.name.endsWith(".ts")) {
@@ -3434,7 +3810,7 @@ function scanDirectory(dir, tableName, usage) {
 }
 function scanFile(absPath, tableName, usage) {
   try {
-    const source = readFileSync8(absPath, "utf-8");
+    const source = readFileSync9(absPath, "utf-8");
     if (!source.includes(tableName)) return;
     const relPath = absPath.slice(getProjectRoot().length + 1);
     const lines = source.split("\n");
@@ -3479,15 +3855,15 @@ function detectMismatches(models) {
 }
 function findFilesUsingColumn(dir, column, tableName) {
   const result = [];
-  if (!existsSync10(dir)) return result;
-  const entries = readdirSync6(dir, { withFileTypes: true });
+  if (!existsSync11(dir)) return result;
+  const entries = readdirSync7(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join4(dir, entry.name);
+    const fullPath = join6(dir, entry.name);
     if (entry.isDirectory()) {
       result.push(...findFilesUsingColumn(fullPath, column, tableName));
     } else if (entry.name.endsWith(".ts")) {
       try {
-        const source = readFileSync8(fullPath, "utf-8");
+        const source = readFileSync9(fullPath, "utf-8");
         if (source.includes(tableName) && source.includes(column)) {
           result.push(fullPath.slice(getProjectRoot().length + 1));
         }
@@ -3632,8 +4008,8 @@ var init_import_parser = __esm({
 });
 
 // src/python/import-resolver.ts
-import { readFileSync as readFileSync9, existsSync as existsSync11, readdirSync as readdirSync7 } from "fs";
-import { resolve as resolve11, join as join5, relative, dirname as dirname8 } from "path";
+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";
 function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
   const projectRoot = getProjectRoot();
   if (level > 0) {
@@ -3644,36 +4020,36 @@ function resolvePythonModulePath(module, fromFile, pythonRoot, level) {
     const modulePart = module.replace(/^\.+/, "");
     if (modulePart) {
       const parts2 = modulePart.split(".");
-      return tryResolvePythonPath(join5(baseDir, ...parts2), projectRoot);
+      return tryResolvePythonPath(join7(baseDir, ...parts2), projectRoot);
     }
     return tryResolvePythonPath(baseDir, projectRoot);
   }
   const parts = module.split(".");
-  const candidate = join5(resolve11(projectRoot, pythonRoot), ...parts);
+  const candidate = join7(resolve11(projectRoot, pythonRoot), ...parts);
   return tryResolvePythonPath(candidate, projectRoot);
 }
 function tryResolvePythonPath(basePath, projectRoot) {
-  if (existsSync11(basePath + ".py")) {
-    return relative(projectRoot, basePath + ".py");
+  if (existsSync12(basePath + ".py")) {
+    return relative2(projectRoot, basePath + ".py");
   }
-  if (existsSync11(join5(basePath, "__init__.py"))) {
-    return relative(projectRoot, join5(basePath, "__init__.py"));
+  if (existsSync12(join7(basePath, "__init__.py"))) {
+    return relative2(projectRoot, join7(basePath, "__init__.py"));
   }
-  if (basePath.endsWith(".py") && existsSync11(basePath)) {
-    return relative(projectRoot, basePath);
+  if (basePath.endsWith(".py") && existsSync12(basePath)) {
+    return relative2(projectRoot, basePath);
   }
   return null;
 }
 function walkPythonFiles(dir, excludeDirs) {
   const files = [];
   try {
-    const entries = readdirSync7(dir, { withFileTypes: true });
+    const entries = readdirSync8(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (excludeDirs.includes(entry.name)) continue;
-        files.push(...walkPythonFiles(join5(dir, entry.name), excludeDirs));
+        files.push(...walkPythonFiles(join7(dir, entry.name), excludeDirs));
       } else if (entry.name.endsWith(".py")) {
-        files.push(join5(dir, entry.name));
+        files.push(join7(dir, entry.name));
       }
     }
   } catch {
@@ -3696,10 +4072,10 @@ function buildPythonImportIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__
   });
   const batch = [];
   for (const absFile of files) {
-    const relFile = relative(projectRoot, absFile);
+    const relFile = relative2(projectRoot, absFile);
     let source;
     try {
-      source = readFileSync9(absFile, "utf-8");
+      source = readFileSync10(absFile, "utf-8");
     } catch {
       continue;
     }
@@ -3965,18 +4341,18 @@ var init_route_parser = __esm({
 });
 
 // src/python/route-indexer.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync8 } from "fs";
-import { join as join6, relative as relative2 } from "path";
+import { readFileSync as readFileSync11, readdirSync as readdirSync9 } from "fs";
+import { join as join8, relative as relative3 } from "path";
 function walkPyFiles(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;
-        files.push(...walkPyFiles(join6(dir, entry.name), excludeDirs));
+        files.push(...walkPyFiles(join8(dir, entry.name), excludeDirs));
       } else if (entry.name.endsWith(".py")) {
-        files.push(join6(dir, entry.name));
+        files.push(join8(dir, entry.name));
       }
     }
   } catch {
@@ -3985,7 +4361,7 @@ function walkPyFiles(dir, excludeDirs) {
 }
 function buildPythonRouteIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]) {
   const projectRoot = getProjectRoot();
-  const absRoot = join6(projectRoot, pythonRoot);
+  const absRoot = join8(projectRoot, pythonRoot);
   dataDb2.exec("DELETE FROM massu_py_routes");
   dataDb2.exec("DELETE FROM massu_py_route_callers");
   const insertStmt = dataDb2.prepare(
@@ -3995,10 +4371,10 @@ function buildPythonRouteIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__"
   let count = 0;
   dataDb2.transaction(() => {
     for (const absFile of files) {
-      const relFile = relative2(projectRoot, absFile);
+      const relFile = relative3(projectRoot, absFile);
       let source;
       try {
-        source = readFileSync10(absFile, "utf-8");
+        source = readFileSync11(absFile, "utf-8");
       } catch {
         continue;
       }
@@ -4209,18 +4585,18 @@ var init_model_parser = __esm({
 });
 
 // src/python/model-indexer.ts
-import { readFileSync as readFileSync11, readdirSync as readdirSync9 } from "fs";
-import { join as join7, relative as relative3 } from "path";
+import { readFileSync as readFileSync12, readdirSync as readdirSync10 } from "fs";
+import { join as join9, relative as relative4 } from "path";
 function walkPyFiles2(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;
-        files.push(...walkPyFiles2(join7(dir, entry.name), excludeDirs));
+        files.push(...walkPyFiles2(join9(dir, entry.name), excludeDirs));
       } else if (entry.name.endsWith(".py")) {
-        files.push(join7(dir, entry.name));
+        files.push(join9(dir, entry.name));
       }
     }
   } catch {
@@ -4229,7 +4605,7 @@ function walkPyFiles2(dir, excludeDirs) {
 }
 function buildPythonModelIndex(dataDb2, pythonRoot, excludeDirs = ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"]) {
   const projectRoot = getProjectRoot();
-  const absRoot = join7(projectRoot, pythonRoot);
+  const absRoot = join9(projectRoot, pythonRoot);
   dataDb2.exec("DELETE FROM massu_py_models");
   dataDb2.exec("DELETE FROM massu_py_fk_edges");
   const insertModel = dataDb2.prepare(
@@ -4242,10 +4618,10 @@ function buildPythonModelIndex(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");
+        source = readFileSync12(absFile, "utf-8");
       } catch {
         continue;
       }
@@ -4505,19 +4881,19 @@ var init_migration_parser = __esm({
 });
 
 // src/python/migration-indexer.ts
-import { readFileSync as readFileSync12, readdirSync as readdirSync10 } from "fs";
-import { join as join8, relative as relative4 } from "path";
+import { readFileSync as readFileSync13, readdirSync as readdirSync11 } from "fs";
+import { join as join10, relative as relative5 } from "path";
 function buildPythonMigrationIndex(dataDb2, alembicDir) {
   const projectRoot = getProjectRoot();
-  const absDir = join8(projectRoot, alembicDir);
+  const absDir = join10(projectRoot, alembicDir);
   dataDb2.exec("DELETE FROM massu_py_migrations");
-  const versionsDir = join8(absDir, "versions");
+  const versionsDir = join10(absDir, "versions");
   let files = [];
   try {
-    files = readdirSync10(versionsDir).filter((f) => f.endsWith(".py")).map((f) => join8(versionsDir, f));
+    files = readdirSync11(versionsDir).filter((f) => f.endsWith(".py")).map((f) => join10(versionsDir, f));
   } catch {
     try {
-      files = readdirSync10(absDir).filter((f) => f.endsWith(".py") && f !== "env.py").map((f) => join8(absDir, f));
+      files = readdirSync11(absDir).filter((f) => f.endsWith(".py") && f !== "env.py").map((f) => join10(absDir, f));
     } catch {
     }
   }
@@ -4531,7 +4907,7 @@ function buildPythonMigrationIndex(dataDb2, alembicDir) {
   for (const absFile of files) {
     let source;
     try {
-      source = readFileSync12(absFile, "utf-8");
+      source = readFileSync13(absFile, "utf-8");
     } catch {
       continue;
     }
@@ -4542,7 +4918,7 @@ function buildPythonMigrationIndex(dataDb2, alembicDir) {
     rows.push({
       revision: parsed.revision,
       downRevision: parsed.downRevision,
-      file: relative4(projectRoot, absFile),
+      file: relative5(projectRoot, absFile),
       description: parsed.description,
       operations: JSON.stringify(parsed.operations)
     });
@@ -4565,12 +4941,12 @@ var init_migration_indexer = __esm({
 });
 
 // src/python/coupling-detector.ts
-import { readFileSync as readFileSync13, readdirSync as readdirSync11 } from "fs";
-import { join as join9, relative as relative5 } from "path";
+import { readFileSync as readFileSync14, readdirSync as readdirSync12 } from "fs";
+import { join as join11, relative as relative6 } from "path";
 function buildPythonCouplingIndex(dataDb2) {
   const projectRoot = getProjectRoot();
   const config = getConfig();
-  const srcDir = join9(projectRoot, config.paths.source);
+  const srcDir = join11(projectRoot, config.paths.source);
   const routes = dataDb2.prepare("SELECT id, method, path FROM massu_py_routes").all();
   if (routes.length === 0) return 0;
   dataDb2.exec("DELETE FROM massu_py_route_callers");
@@ -4599,10 +4975,10 @@ function buildPythonCouplingIndex(dataDb2) {
   ];
   dataDb2.transaction(() => {
     for (const absFile of frontendFiles) {
-      const relFile = relative5(projectRoot, absFile);
+      const relFile = relative6(projectRoot, absFile);
       let source;
       try {
-        source = readFileSync13(absFile, "utf-8");
+        source = readFileSync14(absFile, "utf-8");
       } catch {
         continue;
       }
@@ -4630,13 +5006,13 @@ function walkFrontendFiles(dir) {
   const files = [];
   const exclude = ["node_modules", ".next", "dist", ".git", "__pycache__", ".venv", "venv"];
   try {
-    const entries = readdirSync11(dir, { withFileTypes: true });
+    const entries = readdirSync12(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (exclude.includes(entry.name)) continue;
-        files.push(...walkFrontendFiles(join9(dir, entry.name)));
+        files.push(...walkFrontendFiles(join11(dir, entry.name)));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
-        files.push(join9(dir, entry.name));
+        files.push(join11(dir, entry.name));
       }
     }
   } catch {
@@ -4742,6 +5118,16 @@ function getMemoryToolDefinitions() {
         required: []
       }
     },
+    // P4-007: memory_backfill
+    {
+      name: p("memory_backfill"),
+      description: "Scan all memory/*.md files and ingest into database. Run after massu init or to recover from DB loss. Parses YAML frontmatter and deduplicates by title.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    },
     // P4-006: memory_ingest
     {
       name: p("memory_ingest"),
@@ -4786,6 +5172,8 @@ function handleMemoryToolCall(name, args2, memoryDb) {
         return handleFailures(args2, memoryDb);
       case "memory_ingest":
         return handleIngest(args2, memoryDb);
+      case "memory_backfill":
+        return handleBackfill(memoryDb);
       default:
         return text(`Unknown memory tool: ${name}`);
     }
@@ -4960,6 +5348,21 @@ Title: ${title}
 Importance: ${importance}
 Session: ${activeSession.session_id.slice(0, 8)}...`);
 }
+function handleBackfill(db) {
+  const memoryDir = getResolvedPaths().memoryDir;
+  const stats = backfillMemoryFiles(db, memoryDir);
+  const lines = [
+    "## Memory Backfill Results",
+    "",
+    `- **Total files scanned**: ${stats.total}`,
+    `- **Inserted (new)**: ${stats.inserted}`,
+    `- **Updated (existing)**: ${stats.updated}`,
+    `- **Skipped (not found)**: ${stats.skipped}`,
+    "",
+    stats.total === 0 ? "No memory files found in memory directory." : `Successfully processed ${stats.inserted + stats.updated} of ${stats.total} memory files.`
+  ];
+  return text(lines.join("\n"));
+}
 function text(content) {
   return { content: [{ type: "text", text: content }] };
 }
@@ -4975,11 +5378,12 @@ var init_memory_tools = __esm({
     "use strict";
     init_memory_db();
     init_config();
+    init_memory_file_ingest();
   }
 });
 
 // src/docs-tools.ts
-import { readFileSync as readFileSync14, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync15, existsSync as existsSync13 } from "fs";
 import { resolve as resolve12, basename as basename3 } from "path";
 function p2(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
@@ -5035,10 +5439,10 @@ function handleDocsToolCall(name, args2) {
 }
 function loadDocsMap() {
   const mapPath = getResolvedPaths().docsMapPath;
-  if (!existsSync12(mapPath)) {
+  if (!existsSync13(mapPath)) {
     throw new Error(`docs-map.json not found at ${mapPath}`);
   }
-  return JSON.parse(readFileSync14(mapPath, "utf-8"));
+  return JSON.parse(readFileSync15(mapPath, "utf-8"));
 }
 function matchesPattern(filePath, pattern) {
   const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
@@ -5109,12 +5513,12 @@ function extractFrontmatter(content) {
 function extractProcedureNames(routerPath) {
   const root = getProjectRoot();
   const absPath = ensureWithinRoot(resolve12(getResolvedPaths().srcDir, "..", routerPath), root);
-  if (!existsSync12(absPath)) {
+  if (!existsSync13(absPath)) {
     const altPath = ensureWithinRoot(resolve12(getResolvedPaths().srcDir, "../server/api/routers", basename3(routerPath)), root);
-    if (!existsSync12(altPath)) return [];
-    return extractProcedureNamesFromContent(readFileSync14(altPath, "utf-8"));
+    if (!existsSync13(altPath)) return [];
+    return extractProcedureNamesFromContent(readFileSync15(altPath, "utf-8"));
   }
-  return extractProcedureNamesFromContent(readFileSync14(absPath, "utf-8"));
+  return extractProcedureNamesFromContent(readFileSync15(absPath, "utf-8"));
 }
 function extractProcedureNamesFromContent(content) {
   const procRegex = /\.(?:query|mutation)\s*\(/g;
@@ -5155,7 +5559,7 @@ function handleDocsAudit(args2) {
     const mapping = docsMap.mappings.find((m) => m.id === mappingId);
     if (!mapping) continue;
     const helpPagePath = ensureWithinRoot(resolve12(getResolvedPaths().helpSitePath, mapping.helpPage), getProjectRoot());
-    if (!existsSync12(helpPagePath)) {
+    if (!existsSync13(helpPagePath)) {
       results.push({
         helpPage: mapping.helpPage,
         mappingId,
@@ -5167,7 +5571,7 @@ function handleDocsAudit(args2) {
       });
       continue;
     }
-    const content = readFileSync14(helpPagePath, "utf-8");
+    const content = readFileSync15(helpPagePath, "utf-8");
     const sections = extractSections(content);
     const frontmatter = extractFrontmatter(content);
     const staleReasons = [];
@@ -5208,8 +5612,8 @@ function handleDocsAudit(args2) {
     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());
-        if (existsSync12(guidePath)) {
-          const guideContent = readFileSync14(guidePath, "utf-8");
+        if (existsSync13(guidePath)) {
+          const guideContent = readFileSync15(guidePath, "utf-8");
           const guideFrontmatter = extractFrontmatter(guideContent);
           if (!guideFrontmatter?.lastVerified || status === "STALE") {
             results.push({
@@ -5243,13 +5647,13 @@ function handleDocsCoverage(args2) {
   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 exists = existsSync12(helpPagePath);
+    const exists = existsSync13(helpPagePath);
     let hasContent = false;
     let lineCount = 0;
     let lastVerified = null;
     let status = null;
     if (exists) {
-      const content = readFileSync14(helpPagePath, "utf-8");
+      const content = readFileSync15(helpPagePath, "utf-8");
       lineCount = content.split("\n").length;
       hasContent = lineCount > 10;
       const frontmatter = extractFrontmatter(content);
@@ -5590,7 +5994,7 @@ var init_observability_tools = __esm({
 });
 
 // src/sentinel-db.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { resolve as resolve13 } from "path";
 function parsePortalScope(raw) {
   if (!raw) return [];
@@ -5828,22 +6232,22 @@ function validateFeatures(db, domainFilter) {
     const missingPages = [];
     for (const comp of components) {
       const absPath = resolve13(PROJECT_ROOT, comp.component_file);
-      if (!existsSync13(absPath)) {
+      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`);
-      if (!existsSync13(routerPath)) {
+      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);
-      if (page.page_route.startsWith("/") && !existsSync13(absPath)) {
+      if (page.page_route.startsWith("/") && !existsSync14(absPath)) {
         const altPath = resolve13(PROJECT_ROOT, `src/app${page.page_route}/page.tsx`);
-        if (!existsSync13(altPath)) {
+        if (!existsSync14(altPath)) {
           missingPages.push(page.page_route);
         }
       }
@@ -6367,8 +6771,8 @@ var init_sentinel_tools = __esm({
 });
 
 // src/sentinel-scanner.ts
-import { readFileSync as readFileSync15, existsSync as existsSync14, readdirSync as readdirSync12, statSync as statSync3 } from "fs";
-import { resolve as resolve14, join as join10, basename as basename4, dirname as dirname9, relative as relative6 } from "path";
+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";
 function inferDomain(filePath) {
   const domains = getConfig().domains;
   const path = filePath.toLowerCase();
@@ -6498,9 +6902,9 @@ function scanComponentExports(dataDb2) {
   const componentsBase = config.paths.components ?? config.paths.source + "/components";
   const componentDirs = [];
   const basePath = resolve14(projectRoot, componentsBase);
-  if (existsSync14(basePath)) {
+  if (existsSync15(basePath)) {
     try {
-      const entries = readdirSync12(basePath, { withFileTypes: true });
+      const entries = readdirSync13(basePath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
           componentDirs.push(componentsBase + "/" + entry.name);
@@ -6511,11 +6915,11 @@ function scanComponentExports(dataDb2) {
   }
   for (const dir of componentDirs) {
     const absDir = resolve14(projectRoot, dir);
-    if (!existsSync14(absDir)) continue;
+    if (!existsSync15(absDir)) continue;
     const files = walkDir(absDir).filter((f) => f.endsWith(".tsx") || f.endsWith(".ts"));
     for (const file of files) {
-      const relPath = relative6(projectRoot, file);
-      const source = readFileSync15(file, "utf-8");
+      const relPath = relative7(projectRoot, file);
+      const source = readFileSync16(file, "utf-8");
       const annotations = parseFeatureAnnotations(source);
       if (annotations.length > 0) {
         for (const ann of annotations) {
@@ -6564,11 +6968,11 @@ function scanComponentExports(dataDb2) {
 function walkDir(dir) {
   const results = [];
   try {
-    const entries = readdirSync12(dir);
+    const entries = readdirSync13(dir);
     for (const entry of entries) {
-      const fullPath = join10(dir, entry);
+      const fullPath = join12(dir, entry);
       try {
-        const stat = statSync3(fullPath);
+        const stat = statSync4(fullPath);
         if (stat.isDirectory()) {
           results.push(...walkDir(fullPath));
         } else {
@@ -7554,7 +7958,7 @@ var init_audit_trail = __esm({
 });
 
 // src/validation-engine.ts
-import { existsSync as existsSync15, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync17 } from "fs";
 function p9(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -7585,7 +7989,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  if (!existsSync15(absPath)) {
+  if (!existsSync16(absPath)) {
     checks.push({
       name: "file_exists",
       severity: "error",
@@ -7594,7 +7998,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  const source = readFileSync16(absPath, "utf-8");
+  const source = readFileSync17(absPath, "utf-8");
   const lines = source.split("\n");
   if (activeChecks.rule_compliance !== false) {
     for (const ruleSet of config.rules) {
@@ -8039,7 +8443,7 @@ var init_adr_generator = __esm({
 });
 
 // src/security-scorer.ts
-import { existsSync as existsSync16, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync18 } from "fs";
 function p11(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
 }
@@ -8063,12 +8467,12 @@ function scoreFileSecurity(filePath, projectRoot) {
       }]
     };
   }
-  if (!existsSync16(absPath)) {
+  if (!existsSync17(absPath)) {
     return { riskScore: 0, findings: [] };
   }
   let source;
   try {
-    source = readFileSync17(absPath, "utf-8");
+    source = readFileSync18(absPath, "utf-8");
   } catch {
     return { riskScore: 0, findings: [] };
   }
@@ -8357,7 +8761,7 @@ var init_security_scorer = __esm({
 });
 
 // src/dependency-scorer.ts
-import { existsSync as existsSync17, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync19 } from "fs";
 import { resolve as resolve15 } from "path";
 function p12(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
@@ -8391,9 +8795,9 @@ function calculateDepRisk(factors) {
 }
 function getInstalledPackages(projectRoot) {
   const pkgPath = resolve15(projectRoot, "package.json");
-  if (!existsSync17(pkgPath)) return /* @__PURE__ */ new Map();
+  if (!existsSync18(pkgPath)) return /* @__PURE__ */ new Map();
   try {
-    const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
     const packages = /* @__PURE__ */ new Map();
     for (const [name, version] of Object.entries(pkg.dependencies ?? {})) {
       packages.set(name, version);
@@ -8996,8 +9400,8 @@ var init_regression_detector = __esm({
 
 // src/knowledge-indexer.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync19, readdirSync as readdirSync13, statSync as statSync4, existsSync as existsSync18 } from "fs";
-import { resolve as resolve16, relative as relative7, basename as basename5, extname } from "path";
+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";
 function getKnowledgePaths() {
   const resolved = getResolvedPaths();
   const config = getConfig();
@@ -9023,7 +9427,7 @@ function discoverMarkdownFiles(baseDir) {
   const files = [];
   function walk(dir) {
     try {
-      const entries = readdirSync13(dir, { withFileTypes: true });
+      const entries = readdirSync14(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = resolve16(dir, entry.name);
         if (entry.isDirectory()) {
@@ -9045,7 +9449,7 @@ function categorizeFile(filePath) {
   const paths = getKnowledgePaths();
   if (filePath.startsWith(paths.plansDir)) return "plan";
   if (filePath.startsWith(paths.docsDir)) {
-    const relFromDocs = relative7(paths.docsDir, filePath).replace(/\\/g, "/").toLowerCase();
+    const relFromDocs = relative8(paths.docsDir, filePath).replace(/\\/g, "/").toLowerCase();
     if (relFromDocs.startsWith("plans/")) return "plan";
     if (relFromDocs.includes("architecture")) return "architecture";
     if (relFromDocs.includes("security")) return "security";
@@ -9061,7 +9465,7 @@ function categorizeFile(filePath) {
   }
   const claudeDirName = getConfig().conventions?.claudeDirName ?? ".claude";
   if (filePath.includes(`${claudeDirName}/projects/`) && filePath.includes("/memory/")) return "memory";
-  const rel = relative7(paths.claudeDir, filePath).replace(/\\/g, "/");
+  const rel = relative8(paths.claudeDir, filePath).replace(/\\/g, "/");
   const firstDir = rel.split("/")[0];
   const knownCategories = getConfig().conventions?.knowledgeCategories ?? [
     "patterns",
@@ -9303,11 +9707,11 @@ function indexAllKnowledge(db) {
     files.push(...memFiles);
   } catch {
   }
-  if (existsSync18(paths.plansDir)) {
+  if (existsSync19(paths.plansDir)) {
     const planFiles = discoverMarkdownFiles(paths.plansDir);
     files.push(...planFiles);
   }
-  if (existsSync18(paths.docsDir)) {
+  if (existsSync19(paths.docsDir)) {
     const excludePatterns = getConfig().conventions?.excludePatterns ?? ["/ARCHIVE/", "/SESSION-HISTORY/"];
     const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f) => !f.includes("/plans/") && !excludePatterns.some((p18) => f.includes(p18)));
     files.push(...docsFiles);
@@ -9350,10 +9754,10 @@ function indexAllKnowledge(db) {
     } catch {
     }
     for (const filePath of files) {
-      if (!existsSync18(filePath)) continue;
-      const content = readFileSync19(filePath, "utf-8");
+      if (!existsSync19(filePath)) continue;
+      const content = readFileSync20(filePath, "utf-8");
       const hash = hashContent(content);
-      const relPath = filePath.startsWith(paths.claudeDir) ? relative7(paths.claudeDir, filePath) : filePath.startsWith(paths.plansDir) ? "plans/" + relative7(paths.plansDir, filePath) : filePath.startsWith(paths.docsDir) ? "docs/" + relative7(paths.docsDir, filePath) : filePath.startsWith(paths.memoryDir) ? `memory/${relative7(paths.memoryDir, filePath)}` : basename5(filePath);
+      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 category = categorizeFile(filePath);
       const title = extractTitle(content, filePath);
       const description = extractDescription2(content);
@@ -9471,17 +9875,17 @@ function isKnowledgeStale(db) {
     files.push(...discoverMarkdownFiles(paths.memoryDir));
   } catch {
   }
-  if (existsSync18(paths.plansDir)) {
+  if (existsSync19(paths.plansDir)) {
     files.push(...discoverMarkdownFiles(paths.plansDir));
   }
-  if (existsSync18(paths.docsDir)) {
+  if (existsSync19(paths.docsDir)) {
     const excludePatterns = getConfig().conventions?.excludePatterns ?? ["/ARCHIVE/", "/SESSION-HISTORY/"];
     const docsFiles = discoverMarkdownFiles(paths.docsDir).filter((f) => !f.includes("/plans/") && !excludePatterns.some((p18) => f.includes(p18)));
     files.push(...docsFiles);
   }
   for (const filePath of files) {
     try {
-      const stat = statSync4(filePath);
+      const stat = statSync5(filePath);
       if (stat.mtimeMs > lastIndexTime) return true;
     } catch {
       continue;
@@ -9503,7 +9907,7 @@ var init_knowledge_indexer = __esm({
 });
 
 // src/knowledge-tools.ts
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync3, appendFileSync, readdirSync as readdirSync14 } from "fs";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync3, appendFileSync, readdirSync as readdirSync15 } from "fs";
 import { resolve as resolve17, basename as basename6 } from "path";
 function p15(baseName) {
   return `${getConfig().toolPrefix}_${baseName}`;
@@ -10254,7 +10658,7 @@ ${crRule ? `- **CR**: ${crRule}
 `;
   let existing = "";
   try {
-    existing = readFileSync20(correctionsPath, "utf-8");
+    existing = readFileSync21(correctionsPath, "utf-8");
   } catch {
   }
   const archiveIdx = existing.indexOf("## Archived");
@@ -10436,7 +10840,7 @@ function handleGaps(db, args2) {
   } else if (checkType === "routers") {
     try {
       const routersDir = getResolvedPaths().routersDir;
-      const routerFiles = readdirSync14(routersDir).filter((f) => f.endsWith(".ts") && !f.startsWith("_"));
+      const routerFiles = readdirSync15(routersDir).filter((f) => f.endsWith(".ts") && !f.startsWith("_"));
       lines.push(`| Router | Knowledge Hits | Status |`);
       lines.push(`|--------|----------------|--------|`);
       for (const file of routerFiles) {
@@ -10593,11 +10997,11 @@ var init_knowledge_tools = __esm({
 // src/knowledge-db.ts
 import Database3 from "better-sqlite3";
 import { dirname as dirname10 } from "path";
-import { existsSync as existsSync20, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync5 } from "fs";
 function getKnowledgeDb() {
   const dbPath = getResolvedPaths().knowledgeDbPath;
   const dir = dirname10(dbPath);
-  if (!existsSync20(dir)) {
+  if (!existsSync21(dir)) {
     mkdirSync5(dir, { recursive: true });
   }
   const db = new Database3(dbPath);
@@ -11331,7 +11735,7 @@ var init_python_tools = __esm({
 });
 
 // src/tools.ts
-import { readFileSync as readFileSync21, existsSync as existsSync21 } from "fs";
+import { readFileSync as readFileSync22, existsSync as existsSync22 } from "fs";
 import { resolve as resolve18, basename as basename7 } from "path";
 function prefix() {
   return getConfig().toolPrefix;
@@ -11767,8 +12171,8 @@ function handleContext(file, dataDb2, codegraphDb2) {
           const resolvedPaths = getResolvedPaths();
           const root = getProjectRoot();
           const absFilePath = ensureWithinRoot(resolve18(resolvedPaths.srcDir, "..", file), root);
-          if (existsSync21(absFilePath)) {
-            const fileContent = readFileSync21(absFilePath, "utf-8").slice(0, 3e3);
+          if (existsSync22(absFilePath)) {
+            const fileContent = readFileSync22(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");
@@ -12193,10 +12597,10 @@ function handleSchema(args2) {
     lines.push("");
     const projectRoot = getProjectRoot();
     const absPath = ensureWithinRoot(resolve18(projectRoot, file), projectRoot);
-    if (!existsSync21(absPath)) {
+    if (!existsSync22(absPath)) {
       return text17(`File not found: ${file}`);
     }
-    const source = readFileSync21(absPath, "utf-8");
+    const source = readFileSync22(absPath, "utf-8");
     const config = getConfig();
     const dbPattern = config.dbAccessPattern ?? "ctx.db.{table}";
     const regexStr = dbPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("\\{table\\}", "(\\w+)");
@@ -12274,7 +12678,7 @@ var init_tools = __esm({
 
 // src/server.ts
 var server_exports = {};
-import { readFileSync as readFileSync22 } from "fs";
+import { readFileSync as readFileSync23 } from "fs";
 import { resolve as resolve19, dirname as dirname11 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function getDb() {
@@ -12370,7 +12774,7 @@ var init_server = __esm({
     __dirname4 = dirname11(fileURLToPath4(import.meta.url));
     PKG_VERSION = (() => {
       try {
-        const pkg = JSON.parse(readFileSync22(resolve19(__dirname4, "..", "package.json"), "utf-8"));
+        const pkg = JSON.parse(readFileSync23(resolve19(__dirname4, "..", "package.json"), "utf-8"));
         return pkg.version ?? "0.0.0";
       } catch {
         return "0.0.0";
@@ -12434,7 +12838,7 @@ var init_server = __esm({
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync23 } from "fs";
+import { readFileSync as readFileSync24 } from "fs";
 import { resolve as resolve20, dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename4 = fileURLToPath5(import.meta.url);
@@ -12509,7 +12913,7 @@ Documentation: https://massu.ai/docs
 }
 function printVersion() {
   try {
-    const pkg = JSON.parse(readFileSync23(resolve20(__dirname5, "../package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync24(resolve20(__dirname5, "../package.json"), "utf-8"));
     console.log(`massu v${pkg.version}`);
   } catch {
     console.log("massu v0.1.0");