claude-launchpad 0.6.1 → 0.7.1

package/dist/cli.js

@@ -1,4 +1,15 @@
 #!/usr/bin/env node
+import {
+  readSettingsJson,
+  writeSettingsJson
+} from "./chunk-CSLWJEGD.js";
+import {
+  log,
+  printBanner,
+  printScoreCard,
+  renderDoctorReport
+} from "./chunk-6ZVXZ4EF.js";
+import "./chunk-2H7UOFLK.js";
 
 // src/cli.ts
 import { Command as Command5 } from "commander";
@@ -6,102 +17,11 @@ import { join as join11 } from "path";
 
 // src/commands/init/index.ts
 import { Command } from "commander";
-import { input, confirm } from "@inquirer/prompts";
+import { input, confirm, select } from "@inquirer/prompts";
 import { writeFile, mkdir, readFile as readFile2 } from "fs/promises";
+import { homedir } from "os";
 import { join as join2 } from "path";
 
-// src/lib/output.ts
-import chalk from "chalk";
-var colors = {
-  success: chalk.green,
-  error: chalk.red,
-  warn: chalk.yellow,
-  info: chalk.cyan,
-  dim: chalk.dim,
-  bold: chalk.bold,
-  score: (score) => {
-    if (score >= 80) return chalk.green.bold(`${score}%`);
-    if (score >= 60) return chalk.yellow.bold(`${score}%`);
-    return chalk.red.bold(`${score}%`);
-  },
-  severity: (sev) => {
-    const map = {
-      critical: chalk.bgRed.white.bold,
-      high: chalk.red.bold,
-      medium: chalk.yellow,
-      low: chalk.cyan,
-      info: chalk.dim
-    };
-    return map[sev](` ${sev.toUpperCase()} `);
-  }
-};
-var log = {
-  success: (msg) => console.log(`  ${chalk.green("\u2713")} ${msg}`),
-  error: (msg) => console.log(`  ${chalk.red("\u2717")} ${msg}`),
-  warn: (msg) => console.log(`  ${chalk.yellow("!")} ${msg}`),
-  step: (msg) => console.log(`  ${chalk.cyan("\u2192")} ${msg}`),
-  info: (msg) => console.log(`  ${chalk.dim("\xB7")} ${msg}`),
-  blank: () => console.log()
-};
-function printBanner() {
-  log.blank();
-  console.log(chalk.cyan.bold("  Claude Launchpad"));
-  console.log(chalk.dim("  Scaffold \xB7 Diagnose \xB7 Evaluate"));
-  log.blank();
-}
-function printScoreCard(label, score, max = 100) {
-  const pct = Math.round(score / max * 100);
-  const bar = renderBar(pct, 20);
-  console.log(`  ${chalk.bold(label.padEnd(22))} ${bar} ${colors.score(pct).padStart(12)}`);
-}
-function renderBar(pct, width) {
-  const filled = Math.round(pct / 100 * width);
-  const empty = width - filled;
-  const color = pct >= 80 ? chalk.green : pct >= 60 ? chalk.yellow : chalk.red;
-  return color("\u2501".repeat(filled)) + chalk.dim("\u2500".repeat(empty));
-}
-function printIssue(severity, _analyzer, message) {
-  const sevLabel = {
-    critical: chalk.bgRed.white.bold(" CRIT "),
-    high: chalk.red.bold("HIGH"),
-    medium: chalk.yellow("MED "),
-    low: chalk.dim("LOW "),
-    info: chalk.dim("INFO")
-  };
-  console.log(`   ${sevLabel[severity]}  ${message}`);
-}
-function renderDoctorReport(results, options) {
-  const overallScore = Math.round(
-    results.reduce((sum, r) => sum + r.score, 0) / results.length
-  );
-  for (const result of results) {
-    printScoreCard(result.name, result.score);
-  }
-  log.blank();
-  printScoreCard("Overall", overallScore);
-  log.blank();
-  const allIssues = results.flatMap((r) => r.issues);
-  const actionable = allIssues.filter((i) => i.severity !== "info");
-  if (actionable.length === 0) {
-    log.success("No issues found. Your configuration looks solid.");
-    return { overallScore, actionableCount: 0 };
-  }
-  const sorted = [...actionable].sort((a, b) => {
-    const order = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
-    return (order[a.severity] ?? 4) - (order[b.severity] ?? 4);
-  });
-  for (const issue of sorted) {
-    printIssue(issue.severity, issue.analyzer, issue.message);
-  }
-  log.blank();
-  if (options?.afterFix) {
-    log.info(`${actionable.length} remaining issue(s) require manual intervention.`);
-  } else {
-    log.info(`${actionable.length} issue(s). Run ${chalk.bold("--fix")} to auto-repair or ${chalk.bold("--fix --dry-run")} to preview.`);
-  }
-  return { overallScore, actionableCount: actionable.length };
-}
-
 // src/lib/fs-utils.ts
 import { readFile, access } from "fs/promises";
 async function fileExists(path) {
@@ -617,6 +537,62 @@ DerivedData/
   return sections.join("\n") + "\n";
 }
 
+// src/commands/init/generators/skill-enhance.ts
+function generateEnhanceSkill() {
+  return `---
+name: lp-enhance
+description: AI-improve your CLAUDE.md based on codebase analysis. Fills in architecture, conventions, guardrails, and suggests hooks and MCP servers.
+disable-model-invocation: true
+---
+
+# lp-enhance - AI-powered CLAUDE.md improver
+
+Read CLAUDE.md and the project's codebase, then update CLAUDE.md to fill in missing or incomplete sections.
+
+## Budget Rule
+
+CLAUDE.md must stay UNDER 120 lines of actionable content (not counting headings, blank lines, or comments). Claude Code starts ignoring rules past ~150 instructions. If you need more detail, create .claude/rules/ files instead:
+- Create .claude/rules/conventions.md for detailed coding patterns
+- Create .claude/rules/architecture.md for detailed structure docs
+- Keep CLAUDE.md to HIGH-LEVEL summaries only (3-5 bullets per section max)
+
+## Sections to fill or preserve (DO NOT remove existing sections)
+
+1. **## Stack** - if missing or incomplete, detect and add language, framework, package manager
+2. **## Architecture** - 3-5 bullet points describing the codebase shape (not a full directory tree)
+3. **## Conventions** - max 8 key patterns. Move detailed rules to .claude/rules/conventions.md
+4. **## Off-Limits** - max 8 guardrails specific to this project
+5. **## Memory & Learnings** - max 6 bullets. If missing, add instructions for using the built-in memory system: what to save (gotchas, decisions, deferred issues, references), where (project vs global memory), and the rule to check existing memories before creating duplicates
+6. **## Key Decisions** - only decisions that affect how Claude should work in this codebase
+7. **MCP server suggestions** - look at what external services the project uses (databases, APIs, storage). If you spot Postgres, Redis, Stripe, GitHub API, or similar, suggest relevant MCP servers. Print as suggestions at the end, not in CLAUDE.md.
+
+## Hook review
+
+Also review .claude/settings.json hooks:
+- Read the existing hooks in .claude/settings.json
+- If you see project-specific patterns that deserve hooks (e.g., protected directories, test file patterns, migration files), suggest adding them
+- If no PostCompact hook exists, suggest adding one that re-injects TASKS.md after context compaction
+- If no SessionStart hook exists, suggest adding one that injects TASKS.md at session startup
+- DO NOT overwrite existing hooks - only add new ones specific to this project
+- Print hook suggestions at the end with the exact JSON to add, don't modify settings.json directly
+
+## Advanced configuration opportunities
+
+- If the project has both app code and tests, suggest creating path-scoped .claude/rules/ files with paths: frontmatter
+- If the project uses external APIs, suggest sandbox.network.allowedDomains to restrict outbound traffic
+- If you detect a monorepo, suggest claudeMdExcludes in settings.json
+
+## Rules
+
+- Don't remove existing content - only add or improve
+- Be specific to THIS project, not generic advice
+- Use bullet points, not paragraphs
+- If a section would exceed 8 bullets, split into a .claude/rules/ file and reference it
+- After editing, count the actionable lines. If over 120, move content to rules files until under
+- Run \`claude-launchpad doctor\` after to verify score improved
+`;
+}
+
 // src/commands/init/index.ts
 function createInitCommand() {
   return new Command("init").description("Set up Claude Code configuration for any project").option("-n, --name <name>", "Project name").option("-y, --yes", "Accept all defaults").action(async (opts) => {
@@ -649,14 +625,15 @@ function createInitCommand() {
       });
       if (!overwrite) {
         log.info("Keeping existing CLAUDE.md");
+        await createEnhanceSkillPrompt(root, false);
         log.step("Tip: run `claude-launchpad doctor` to check your existing config");
         return;
       }
     }
-    await scaffold(root, options, detected);
+    await scaffold(root, options, detected, opts.yes);
   });
 }
-async function scaffold(root, options, detected) {
+async function scaffold(root, options, detected, skipPrompts) {
   log.step("Generating configuration...");
   const claudeMd = generateClaudeMd(options, detected);
   const tasksMd = generateTasksMd(options);
@@ -701,8 +678,10 @@ async function scaffold(root, options, detected) {
   if (!hasClaudeGitignore) log.success("Generated .claude/.gitignore");
   if (!hasClaudeignore) log.success("Generated .claudeignore");
   if (!hasRules) log.success("Generated .claude/rules/conventions.md");
+  await createEnhanceSkillPrompt(root, skipPrompts);
   log.blank();
   log.success("Done! Run `claude` to start.");
+  log.info("Use `/lp-enhance` inside Claude Code to have AI complete your CLAUDE.md.");
   log.info("Run `claude-launchpad doctor` to check your config quality.");
   log.blank();
 }
@@ -734,6 +713,26 @@ function generateStarterRules(detected) {
   lines.push("");
   return lines.join("\n");
 }
+async function createEnhanceSkillPrompt(root, skipPrompts) {
+  const projectPath = join2(root, ".claude", "skills", "lp-enhance", "SKILL.md");
+  const globalPath = join2(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const legacyProject = join2(root, ".claude", "commands", "lp-enhance.md");
+  const legacyGlobal = join2(homedir(), ".claude", "commands", "lp-enhance.md");
+  if (await fileExists(projectPath) || await fileExists(globalPath) || await fileExists(legacyProject) || await fileExists(legacyGlobal)) return;
+  const scope = skipPrompts ? "project" : await select({
+    message: "Install /lp-enhance skill (AI-powered CLAUDE.md improver):",
+    choices: [
+      { value: "project", name: "Project scope (.claude/skills/)" },
+      { value: "global", name: "Global scope (~/.claude/skills/)" },
+      { value: "skip", name: "Skip" }
+    ]
+  });
+  if (scope === "skip") return;
+  const targetDir = scope === "global" ? join2(homedir(), ".claude", "skills", "lp-enhance") : join2(root, ".claude", "skills", "lp-enhance");
+  await mkdir(targetDir, { recursive: true });
+  await writeFile(join2(targetDir, "SKILL.md"), generateEnhanceSkill());
+  log.success(`Generated /lp-enhance skill (${scope} scope)`);
+}
 async function mergeSettings(existingPath, generated) {
   try {
     const existing = JSON.parse(await readFile2(existingPath, "utf-8"));
@@ -757,7 +756,7 @@ async function mergeSettings(existingPath, generated) {
 
 // src/commands/doctor/index.ts
 import { Command as Command2 } from "commander";
-import chalk2 from "chalk";
+import chalk from "chalk";
 
 // src/lib/parser.ts
 import { readdir, access as access2 } from "fs/promises";
@@ -1027,18 +1026,6 @@ async function analyzeSettings(config) {
       message: "No claudeMdExcludes configured \u2014 consider adding this if you have a monorepo"
     });
   }
-  const broadMatchers = ["Bash", "Write", "Edit", "Read"];
-  const hooksWithoutTimeout = config.hooks.filter(
-    (h) => !h.timeout && broadMatchers.some((m) => h.matcher?.includes(m))
-  );
-  if (hooksWithoutTimeout.length > 0) {
-    issues.push({
-      analyzer: "Settings",
-      severity: "low",
-      message: `${hooksWithoutTimeout.length} hook(s) on broad matchers without timeout \u2014 defaults to 60s per invocation`,
-      fix: "Add timeout (in seconds) to hooks on Bash, Write, Edit, or Read matchers"
-    });
-  }
   if (config.settings.autoMemoryEnabled === false) {
     const hasMemorySection = config.claudeMdContent?.includes("## Memory") ?? false;
     if (!hasMemorySection) {
@@ -1125,6 +1112,7 @@ async function analyzeHooks(config) {
 // src/commands/doctor/analyzers/rules.ts
 import { readFile as readFile3 } from "fs/promises";
 import { basename as basename2, join as join4, dirname } from "path";
+import { homedir as homedir2 } from "os";
 async function analyzeRules(config) {
   const issues = [];
   const projectRoot = config.claudeMdPath ? dirname(config.claudeMdPath) : process.cwd();
@@ -1137,6 +1125,18 @@ async function analyzeRules(config) {
       fix: "Run `claude-launchpad init` or `doctor --fix` to generate one"
     });
   }
+  const hasSkillInProject = config.skills.some(
+    (s) => basename2(s) === "SKILL.md" && s.includes("lp-enhance") || basename2(s) === "lp-enhance.md"
+  );
+  const hasSkillGlobal = await fileExists(join4(homedir2(), ".claude", "skills", "lp-enhance", "SKILL.md")) || await fileExists(join4(homedir2(), ".claude", "commands", "lp-enhance.md"));
+  if (!hasSkillInProject && !hasSkillGlobal) {
+    issues.push({
+      analyzer: "Rules",
+      severity: "low",
+      message: "No /lp-enhance skill found \u2014 use it inside Claude Code to AI-complete your CLAUDE.md",
+      fix: "Run `claude-launchpad init` or `doctor --fix` to generate the skill"
+    });
+  }
   if (config.rules.length === 0) {
     issues.push({
       analyzer: "Rules",
@@ -1282,7 +1282,7 @@ async function analyzeMcp(config) {
     issues.push({
       analyzer: "MCP",
       severity: "info",
-      message: "No MCP servers configured. Run `claude-launchpad enhance` to get stack-specific recommendations."
+      message: "No MCP servers configured. Use `/lp-enhance` in Claude Code to get stack-specific recommendations."
     });
     return { name: "MCP Servers", issues, score: 50 };
   }
@@ -1406,9 +1406,97 @@ async function analyzeQuality(config) {
   return { name: "CLAUDE.md Quality", issues, score };
 }
 
+// src/commands/doctor/analyzers/memory.ts
+var MEMORY_MCP_TOOLS = [
+  "mcp__agentic-memory__memory_store",
+  "mcp__agentic-memory__memory_search",
+  "mcp__agentic-memory__memory_recent",
+  "mcp__agentic-memory__memory_forget",
+  "mcp__agentic-memory__memory_relate",
+  "mcp__agentic-memory__memory_stats",
+  "mcp__agentic-memory__memory_update"
+];
+function hasMemoryIndicators(config) {
+  const hasMcpServer = config.mcpServers.some((s) => s.name === "agentic-memory");
+  const hasHookRef = config.hooks.some(
+    (h) => h.command?.includes("memory context") || h.command?.includes("memory extract")
+  );
+  return hasMcpServer || hasHookRef;
+}
+async function analyzeMemory(config) {
+  if (!hasMemoryIndicators(config)) return null;
+  const issues = [];
+  const hasMcpServer = config.mcpServers.some((s) => s.name === "agentic-memory");
+  if (!hasMcpServer) {
+    issues.push({
+      analyzer: "Memory",
+      severity: "high",
+      message: "agentic-memory MCP server not found in mcpServers",
+      fix: "Add agentic-memory to mcpServers in .claude/settings.json"
+    });
+  }
+  const hasSessionStart = config.hooks.some(
+    (h) => h.event === "SessionStart" && h.command?.includes("memory context")
+  );
+  if (!hasSessionStart) {
+    issues.push({
+      analyzer: "Memory",
+      severity: "high",
+      message: "No SessionStart hook with memory context injection",
+      fix: "Add a SessionStart hook that runs `memory context` to inject relevant memories"
+    });
+  }
+  const hasStopHook = config.hooks.some(
+    (h) => h.event === "Stop" && h.command?.includes("memory extract")
+  );
+  if (!hasStopHook) {
+    issues.push({
+      analyzer: "Memory",
+      severity: "medium",
+      message: "No Stop hook with memory extract for session learnings",
+      fix: "Add a Stop hook that runs `memory extract` to capture session insights"
+    });
+  }
+  const autoMemoryDisabled = config.settings?.autoMemoryEnabled === false;
+  if (!autoMemoryDisabled) {
+    issues.push({
+      analyzer: "Memory",
+      severity: "medium",
+      message: "autoMemoryEnabled not disabled \u2014 built-in memory may conflict with agentic-memory",
+      fix: "Set autoMemoryEnabled: false in .claude/settings.json"
+    });
+  }
+  const hasMemoryGuidance = config.claudeMdContent?.includes("agentic-memory") || config.claudeMdContent?.includes("## Memory");
+  if (!hasMemoryGuidance) {
+    issues.push({
+      analyzer: "Memory",
+      severity: "low",
+      message: "CLAUDE.md missing memory guidance section",
+      fix: "Add a ## Memory section to CLAUDE.md describing when and how to use agentic-memory"
+    });
+  }
+  const allowList = config.settings?.allowedTools ?? [];
+  const missingTools = MEMORY_MCP_TOOLS.filter((t) => !allowList.includes(t));
+  if (missingTools.length > 0) {
+    issues.push({
+      analyzer: "Memory",
+      severity: "low",
+      message: `${missingTools.length} agentic-memory MCP tool permission(s) missing from allowedTools`,
+      fix: "Add all agentic-memory tool names to allowedTools in .claude/settings.json"
+    });
+  }
+  const critical = issues.filter((i) => i.severity === "critical").length;
+  const high = issues.filter((i) => i.severity === "high").length;
+  const medium = issues.filter((i) => i.severity === "medium").length;
+  const low = issues.filter((i) => i.severity === "low").length;
+  const score = Math.max(0, 100 - (critical * 40 + high * 20 + medium * 10 + low * 5));
+  return { name: "Memory", issues, score };
+}
+
 // src/commands/doctor/fixer.ts
 import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2, access as access4 } from "fs/promises";
 import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
 async function applyFixes(issues, projectRoot) {
   const detected = await detectProject(projectRoot);
   let fixed = 0;
@@ -1433,7 +1521,7 @@ var FIX_TABLE = [
   { analyzer: "Hooks", match: ".env file protection", fix: (root) => addEnvProtectionHook(root) },
   { analyzer: "Hooks", match: "auto-format", fix: (root, detected) => addAutoFormatHook(root, detected) },
   { analyzer: "Hooks", match: "No PreToolUse", fix: (root) => addEnvProtectionHook(root) },
-  { analyzer: "Quality", match: "Architecture", fix: (root) => addClaudeMdSection(root, "## Architecture", "<!-- TODO: Describe your codebase structure. Run `claude-launchpad enhance` to auto-fill this. -->") },
+  { analyzer: "Quality", match: "Architecture", fix: (root) => addClaudeMdSection(root, "## Architecture", "<!-- TODO: Describe your codebase structure. Run `/lp-enhance` to auto-fill this. -->") },
   { analyzer: "Quality", match: "Off-Limits", fix: (root) => addClaudeMdSection(root, "## Off-Limits", "- Never hardcode secrets - use environment variables\n- Never write to `.env` files\n- Never expose internal error details in API responses") },
   { analyzer: "Quality", match: "Commands", fix: (root) => addClaudeMdSection(root, "## Commands", "<!-- TODO: Add your dev/build/test commands -->") },
   { analyzer: "Quality", match: "Stack", fix: (root, detected) => {
@@ -1452,8 +1540,12 @@ var FIX_TABLE = [
   { analyzer: "Permissions", match: "Bypass permissions mode", fix: (root) => addBypassDisable(root) },
   { analyzer: "Permissions", match: "Sandbox not enabled", fix: (root) => addSandboxSettings(root) },
   { analyzer: "Permissions", match: ".env is protected by hooks but not in .claudeignore", fix: (root) => addEnvToClaudeignore(root) },
+  { analyzer: "Rules", match: "No /lp-enhance skill", fix: (root) => createEnhanceSkill(root) },
   { analyzer: "Settings", match: "Deprecated includeCoAuthoredBy", fix: (root) => migrateAttribution(root) },
-  { analyzer: "Hooks", match: "SessionStart", fix: (root) => addSessionStartHook(root) }
+  { analyzer: "Hooks", match: "SessionStart", fix: (root) => addSessionStartHook(root) },
+  { analyzer: "Memory", match: "autoMemoryEnabled not disabled", fix: (root) => disableAutoMemory(root) },
+  { analyzer: "Memory", match: "MCP tool permission", fix: (root) => addMemoryToolPermissions(root) },
+  { analyzer: "Memory", match: "CLAUDE.md missing memory guidance", fix: (root) => addClaudeMdSection(root, "## Memory", "Use agentic-memory to persist knowledge across sessions:\n- Memories are automatically injected at session start and extracted at session end\n- Save non-obvious decisions, gotchas, and deferred issues\n- Check memory for relevant context before starting work") }
 ];
 async function tryFix(issue, root, detected) {
   const entry = FIX_TABLE.find(
@@ -1678,19 +1770,45 @@ async function createStarterRules(root) {
   log.success("Created .claude/rules/conventions.md with starter rules");
   return true;
 }
-async function readSettingsJson(root) {
-  const path = join5(root, ".claude", "settings.json");
-  try {
-    const content = await readFile4(path, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
+async function disableAutoMemory(root) {
+  const settings = await readSettingsJson(root);
+  if (settings.autoMemoryEnabled === false) return false;
+  settings.autoMemoryEnabled = false;
+  await writeSettingsJson(root, settings);
+  log.success("Set autoMemoryEnabled: false (prevents conflict with agentic-memory)");
+  return true;
+}
+async function addMemoryToolPermissions(root) {
+  const settings = await readSettingsJson(root);
+  const permissions = settings.permissions ?? {};
+  const allow = permissions.allow ?? [];
+  const tools = [
+    "mcp__agentic-memory__memory_store",
+    "mcp__agentic-memory__memory_search",
+    "mcp__agentic-memory__memory_recent",
+    "mcp__agentic-memory__memory_forget",
+    "mcp__agentic-memory__memory_relate",
+    "mcp__agentic-memory__memory_stats",
+    "mcp__agentic-memory__memory_update"
+  ];
+  const missing = tools.filter((t) => !allow.includes(t));
+  if (missing.length === 0) return false;
+  settings.permissions = { ...permissions, allow: [...allow, ...missing] };
+  await writeSettingsJson(root, settings);
+  log.success("Added agentic-memory MCP tool permissions to allowedTools");
+  return true;
 }
-async function writeSettingsJson(root, settings) {
-  const dir = join5(root, ".claude");
-  await mkdir2(dir, { recursive: true });
-  await writeFile2(join5(dir, "settings.json"), JSON.stringify(settings, null, 2) + "\n");
+async function createEnhanceSkill(root) {
+  const skillDir = join5(root, ".claude", "skills", "lp-enhance");
+  const skillPath = join5(skillDir, "SKILL.md");
+  const globalPath = join5(homedir3(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const legacyProject = join5(root, ".claude", "commands", "lp-enhance.md");
+  const legacyGlobal = join5(homedir3(), ".claude", "commands", "lp-enhance.md");
+  if (await fileExists(skillPath) || await fileExists(globalPath) || await fileExists(legacyProject) || await fileExists(legacyGlobal)) return false;
+  await mkdir2(skillDir, { recursive: true });
+  await writeFile2(skillPath, generateEnhanceSkill());
+  log.success("Generated /lp-enhance skill (.claude/skills/lp-enhance/)");
+  return true;
 }
 
 // src/commands/doctor/watcher.ts
@@ -1745,7 +1863,7 @@ async function getFileSnapshot(projectRoot) {
 }
 async function runAndDisplay(projectRoot) {
   console.log("\x1B[36m\x1B[1m  Claude Launchpad\x1B[0m");
-  console.log("\x1B[2m  Scaffold \xB7 Diagnose \xB7 Evaluate\x1B[0m");
+  console.log("\x1B[2m  Scaffold \xB7 Diagnose \xB7 Evaluate \xB7 Remember\x1B[0m");
   log.blank();
   const config = await parseClaudeConfig(projectRoot);
   if (config.claudeMdContent === null && config.settings === null) {
@@ -1791,6 +1909,10 @@ function createDoctorCommand() {
       analyzePermissions(config),
       analyzeMcp(config)
     ]);
+    const memoryResult = await analyzeMemory(config);
+    if (memoryResult) {
+      results.push(memoryResult);
+    }
     if (opts.json) {
       const overallScore2 = Math.round(
         results.reduce((sum, r) => sum + r.score, 0) / results.length
@@ -1805,7 +1927,10 @@ function createDoctorCommand() {
     if (opts.fix) {
       const allIssues = results.flatMap((r) => r.issues);
       const fixable = allIssues.filter((i) => i.severity !== "info");
-      if (fixable.length > 0) {
+      if (fixable.length === 0) {
+        renderDoctorReport(results);
+        log.success("Nothing to fix.");
+      } else if (fixable.length > 0) {
         if (opts.dryRun) {
           const withFix = fixable.filter((i) => i.fix);
           log.blank();
@@ -1820,7 +1945,7 @@ function createDoctorCommand() {
           if (skipped > 0) {
             log.info(`${skipped} issue(s) require manual intervention.`);
           }
-          log.info(`Then run ${chalk2.bold("claude-launchpad enhance")} to have Claude restructure and complete your CLAUDE.md.`);
+          log.info(`Then use ${chalk.bold("/lp-enhance")} inside Claude Code to have Claude restructure and complete your CLAUDE.md.`);
           return;
         }
         log.blank();
@@ -1841,8 +1966,12 @@ function createDoctorCommand() {
             analyzePermissions(updatedConfig),
             analyzeMcp(updatedConfig)
           ]);
+          const updatedMemoryResult = await analyzeMemory(updatedConfig);
+          if (updatedMemoryResult) {
+            updatedResults.push(updatedMemoryResult);
+          }
           renderDoctorReport(updatedResults, { afterFix: true });
-          log.info(`Then run ${chalk2.bold("claude-launchpad enhance")} to have Claude restructure and complete your CLAUDE.md.`);
+          log.info(`Then use ${chalk.bold("/lp-enhance")} inside Claude Code to have Claude restructure and complete your CLAUDE.md.`);
         }
       }
     }
@@ -1857,9 +1986,9 @@ function createDoctorCommand() {
 
 // src/commands/eval/index.ts
 import { Command as Command3 } from "commander";
-import { select } from "@inquirer/prompts";
+import { select as select2 } from "@inquirer/prompts";
 import ora from "ora";
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
 import { join as join9 } from "path";
 
@@ -2267,18 +2396,18 @@ async function listAllFiles(dir) {
 function createEvalCommand() {
   return new Command3("eval").description("Test your Claude Code config against eval scenarios").option("-s, --suite <suite>", "Eval suite to run (e.g., security, conventions, workflow)").option("-p, --path <path>", "Project root path", process.cwd()).option("--scenarios <path>", "Custom scenarios directory").option("--runs <n>", "Runs per scenario (default: 3)", "3").option("--timeout <ms>", "Timeout per run in ms (default: 120000)", "120000").option("--json", "Output as JSON").option("--debug", "Keep sandbox directories for inspection").option("--model <model>", "Model to use for eval (e.g., sonnet, haiku, opus)").action(async (opts) => {
     printBanner();
-    const hasFlags = opts.suite || opts.model || opts.runs !== "3" || opts.json || opts.debug;
+    const hasFlags = opts.suite || opts.model || opts.runs !== "3" || opts.timeout !== "120000" || opts.path !== process.cwd() || Boolean(opts.scenarios) || opts.json || opts.debug;
     if (!hasFlags) {
-      opts.suite = await select({
+      opts.suite = await select2({
         message: "Suite",
         choices: [
           { name: "security (6 scenarios)", value: "security" },
           { name: "conventions (5 scenarios)", value: "conventions" },
-          { name: "workflow (2 scenarios)", value: "workflow" },
-          { name: "all (13 scenarios)", value: void 0 }
+          { name: "workflow (4 scenarios)", value: "workflow" },
+          { name: "all (15 scenarios)", value: void 0 }
         ]
       });
-      opts.runs = await select({
+      opts.runs = await select2({
         message: "Runs per scenario",
         choices: [
           { name: "1 \u2014 fast", value: "1" },
@@ -2286,7 +2415,7 @@ function createEvalCommand() {
           { name: "5 \u2014 thorough", value: "5" }
         ]
       });
-      opts.model = await select({
+      opts.model = await select2({
         message: "Model",
         choices: [
           { name: "haiku \u2014 cheapest", value: "haiku" },
@@ -2370,13 +2499,13 @@ function createEvalCommand() {
 }
 function renderEvalReport(results) {
   for (const result of results) {
-    const icon = result.passed ? chalk3.green("\u2713") : chalk3.red("\u2717");
-    const status = result.passed ? chalk3.green("PASS") : chalk3.red("FAIL");
+    const icon = result.passed ? chalk2.green("\u2713") : chalk2.red("\u2717");
+    const status = result.passed ? chalk2.green("PASS") : chalk2.red("FAIL");
     const score = `${result.score}/${result.maxScore}`;
-    console.log(`  ${icon} ${chalk3.bold(result.scenario)}  ${score}  ${status}`);
+    console.log(`  ${icon} ${chalk2.bold(result.scenario)}  ${score}  ${status}`);
     const failedChecks = result.checks.filter((c) => !c.passed);
     for (const check of failedChecks) {
-      console.log(`    ${chalk3.red("\u2717")} ${chalk3.dim(check.label)}`);
+      console.log(`    ${chalk2.red("\u2717")} ${chalk2.dim(check.label)}`);
     }
   }
   log.blank();
@@ -2444,9 +2573,9 @@ async function saveEvalReport(results, projectRoot, suite, model) {
   log.success(`Report saved to .claude/eval/${filename}`);
 }
 async function checkClaudeCli() {
-  const { execFile: execFile3 } = await import("child_process");
-  const { promisify: promisify3 } = await import("util");
-  const exec2 = promisify3(execFile3);
+  const { execFile: execFile2 } = await import("child_process");
+  const { promisify: promisify2 } = await import("util");
+  const exec2 = promisify2(execFile2);
   try {
     await exec2("claude", ["--version"]);
     return true;
@@ -2455,82 +2584,88 @@ async function checkClaudeCli() {
   }
 }
 
-// src/commands/enhance/index.ts
-import { Command as Command4 } from "commander";
-import { spawn, execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-import { access as access7 } from "fs/promises";
+// src/commands/memory/index.ts
+import { readFileSync } from "fs";
 import { join as join10 } from "path";
-var execAsync = promisify2(execFile2);
-var ENHANCE_PROMPT = `Read CLAUDE.md and the project's codebase, then update CLAUDE.md to fill in missing or incomplete sections.
-
-CRITICAL BUDGET RULE: CLAUDE.md must stay UNDER 120 lines of actionable content (not counting headings, blank lines, or comments). Claude Code starts ignoring rules past ~150 instructions. If you need more detail, create .claude/rules/ files instead:
-- Create .claude/rules/conventions.md for detailed coding patterns
-- Create .claude/rules/architecture.md for detailed structure docs
-- Keep CLAUDE.md to HIGH-LEVEL summaries only (3-5 bullets per section max)
-
-Sections to fill in or preserve (DO NOT remove any existing section):
-1. **## Stack** \u2014 if missing or incomplete, detect and add language, framework, package manager
-2. **## Architecture** \u2014 3-5 bullet points describing the codebase shape (not a full directory tree)
-3. **## Conventions** \u2014 max 8 key patterns. Move detailed rules to .claude/rules/conventions.md
-4. **## Off-Limits** \u2014 max 8 guardrails specific to this project
-5. **## Memory & Learnings** \u2014 max 6 bullets. If missing, add instructions for using the built-in memory system: what to save (gotchas, decisions, deferred issues, references), where (project vs global memory), and the rule to check existing memories before creating duplicates
-6. **## Key Decisions** \u2014 only decisions that affect how Claude should work in this codebase
-7. **MCP server suggestions** \u2014 look at what external services the project uses (databases, APIs, storage). If you spot Postgres, Redis, Stripe, GitHub API, or similar, suggest relevant MCP servers the user could add. Print these as suggestions at the end, not in CLAUDE.md.
-
-Also review .claude/settings.json hooks:
-- Read the existing hooks in .claude/settings.json
-- If you see project-specific patterns that deserve hooks (e.g., protected directories, test file patterns, migration files), suggest adding them
-- If no PostCompact hook exists, suggest adding one that re-injects TASKS.md after context compaction (critical for session continuity)
-- If no SessionStart hook exists, suggest adding one that injects TASKS.md at session startup
-- DO NOT overwrite existing hooks \u2014 only add new ones that are specific to this project
-- Print hook suggestions at the end with the exact JSON to add, don't modify settings.json directly
-
-Also check for advanced configuration opportunities:
-- If the project has both app code and tests, suggest creating path-scoped .claude/rules/ files with paths: frontmatter (e.g., test conventions only load when editing test files)
-- If the project uses external APIs (Stripe, GitHub, AWS SDKs, etc.), suggest sandbox.network.allowedDomains to restrict outbound traffic
-- If you detect a monorepo (Turborepo, Lerna, pnpm workspaces, multiple package.json), suggest claudeMdExcludes in settings.json
-
-Rules:
-- Don't remove existing content \u2014 only add or improve
-- Be specific to THIS project, not generic advice
-- Use bullet points, not paragraphs
-- If a section would exceed 8 bullets, split into a .claude/rules/ file and reference it
-- After editing, count the actionable lines. If over 120, move content to rules files until under`;
-function createEnhanceCommand() {
-  return new Command4("enhance").description("Use Claude to analyze your codebase and complete CLAUDE.md").option("-p, --path <path>", "Project root path", process.cwd()).action(async (opts) => {
-    printBanner();
-    const root = opts.path;
-    const claudeMdPath = join10(root, "CLAUDE.md");
-    try {
-      await access7(claudeMdPath);
-    } catch {
-      log.error("No CLAUDE.md found. Run `claude-launchpad init` first.");
-      process.exit(1);
+import { Command as Command4 } from "commander";
+import { confirm as confirm2 } from "@inquirer/prompts";
+function isMemoryInstalled() {
+  try {
+    const settingsPath = join10(process.cwd(), ".claude", "settings.json");
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    const hooks = settings.hooks;
+    if (!hooks) return false;
+    const sessionStart = hooks.SessionStart;
+    return sessionStart?.some((h) => {
+      const inner = h.hooks;
+      return inner?.some((ih) => String(ih.command ?? "").includes("memory context"));
+    }) ?? false;
+  } catch {
+    return false;
+  }
+}
+function createMemoryCommand() {
+  const memory = new Command4("memory").description("Persistent memory system for Claude Code sessions").option("--dashboard", "Open the memory dashboard").action(async (opts) => {
+    if (opts.dashboard) {
+      if (!isMemoryInstalled()) {
+        log.error("Memory system is not installed. Run `claude-launchpad memory` first.");
+        return;
+      }
+      const { startTui } = await import("./tui-R25NTQ4K.js");
+      await startTui();
+      return;
     }
-    try {
-      await execAsync("claude", ["--version"]);
-    } catch {
-      log.error("Claude CLI not found. Install it: https://docs.anthropic.com/en/docs/claude-code");
-      process.exit(1);
+    if (!isMemoryInstalled()) {
+      log.blank();
+      log.step("Agentic memory is not set up for this project.");
+      log.blank();
+      log.info("This will (skipping what's already in place):");
+      log.info("  - Set up SQLite database at ~/.agentic-memory/");
+      log.info("  - Add SessionStart + Stop hooks to .claude/settings.json");
+      log.info("  - Register the MCP server with Claude Code (global)");
+      log.info("  - Add memory guidance to CLAUDE.md");
+      log.blank();
+      const proceed = await confirm2({
+        message: "Install agentic-memory?",
+        default: true
+      });
+      if (!proceed) {
+        log.info("Skipped.");
+        return;
+      }
+      const { runInstall } = await import("./install-65P6LMUN.js");
+      await runInstall({});
+    } else {
+      const { runStats } = await import("./stats-FYAK7KZW.js");
+      await runStats({});
     }
-    log.step("Launching Claude to enhance your CLAUDE.md...");
-    log.blank();
-    const child = spawn(
-      "claude",
-      [ENHANCE_PROMPT],
-      { cwd: root, stdio: "inherit" }
-    );
-    await new Promise((resolve3) => {
-      child.on("close", (code) => resolve3(code ?? 0));
-    });
-    log.blank();
-    log.success("Run `claude-launchpad doctor` to check your updated score.");
   });
+  memory.addCommand(
+    new Command4("context").description("Load session context (hook handler)").option("--json", "JSON output").action(async (opts) => {
+      const { runContext } = await import("./context-LNUZ4GCF.js");
+      await runContext(opts);
+    }).helpCommand(false),
+    { hidden: true }
+  );
+  memory.addCommand(
+    new Command4("extract").description("Extract facts from transcript (hook handler)").action(async () => {
+      const { runExtract } = await import("./extract-NVAXO5CK.js");
+      await runExtract();
+    }).helpCommand(false),
+    { hidden: true }
+  );
+  memory.addCommand(
+    new Command4("serve").description("Start MCP server (Claude Code)").action(async () => {
+      const { startServer } = await import("./commands/memory/server.js");
+      await startServer();
+    }).helpCommand(false),
+    { hidden: true }
+  );
+  return memory;
 }
 
 // src/cli.ts
-var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.4.0", "-v, --version").action(async () => {
+var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.7.1", "-v, --version").action(async () => {
   const hasConfig = await fileExists(join11(process.cwd(), "CLAUDE.md")) || await fileExists(join11(process.cwd(), ".claude", "settings.json"));
   if (hasConfig) {
     await program.commands.find((c) => c.name() === "doctor")?.parseAsync([], { from: "user" });
@@ -2540,13 +2675,14 @@ var program = new Command5().name("claude-launchpad").description("CLI toolkit t
     log.blank();
     log.step("Run `claude-launchpad init` to set up your project");
     log.step("Run `claude-launchpad doctor` to diagnose an existing config");
+    log.step("Use `/lp-enhance` skill inside Claude Code to AI-complete your CLAUDE.md");
     log.step("Run `claude-launchpad eval` to test your config quality");
     log.blank();
   }
 });
 program.addCommand(createInitCommand());
 program.addCommand(createDoctorCommand());
-program.addCommand(createEnhanceCommand());
 program.addCommand(createEvalCommand());
+program.addCommand(createMemoryCommand());
 program.parse();
 //# sourceMappingURL=cli.js.map