claude-launchpad 0.14.3 → 0.15.1

package/README.md

@@ -56,6 +56,8 @@ Scores your config, auto-repairs everything it can.
 
 ## The Three-File System
 
+Without structure, CLAUDE.md becomes a dumping ground. Future ideas bury active guidance. Sprint notes push conventions off-screen. Past the ~200 line budget, Claude starts ignoring rules at the bottom. The three-file split keeps each concern where it belongs:
+
 | File | Purpose | Example |
 |---|---|---|
 | `CLAUDE.md` | What Claude needs to know | Stack, commands, conventions, guardrails |
@@ -201,6 +203,13 @@ claude-launchpad memory
 
 If memory is not installed, it runs interactive setup. If installed, it shows stats. Requires native deps first: `npm install better-sqlite3 sqlite-vec`.
 
+During setup, you choose where memory config lives:
+
+- **Shared** (default) — config goes to `CLAUDE.md` + `settings.json` (committed, team sees it)
+- **Local** — config goes to `.claude/CLAUDE.md` + `settings.local.json` (gitignored, only you)
+
+Use "local" when co-devs have different memory setups (e.g. you use agentic-memory, they use built-in). Your choice is persisted so `doctor --fix` won't re-ask.
+
 Every session, Claude loads what it needs to know and stores new knowledge as it works. Stale facts fade on their own. Knowledge Claude actually uses gets reinforced. Each project has its own isolated memory, and you can sync it across machines via private GitHub Gist.
 
 Browse everything with `--dashboard` -- a terminal UI with vim navigation, filtering, and search.
@@ -248,10 +257,10 @@ New to Claude Code? Here's what the terms mean.
 | **CLAUDE.md** | A markdown file in your project root that tells Claude how to work on your code. Think of it as instructions for your AI pair programmer. [Official docs](https://docs.anthropic.com/en/docs/claude-code/memory#claudemd) |
 | **TASKS.md** | Sprint tracker and session log. Claude reads this at session start to pick up where you left off. |
 | **BACKLOG.md** | Where deferred features live. Priority tiers (P0/P1/P2) keep future ideas organized without cluttering TASKS.md. |
-| **Hooks** | Shell commands that run automatically when Claude does something. Example: auto-format after edits, block reading `.env`. They live in `.claude/settings.json`. |
+| **Hooks** | Shell commands that run automatically when Claude does something. CLAUDE.md rules are ~80% reliable. Hooks are 100% enforced. A SessionStart hook that runs `cat TASKS.md` means Claude sees your task list at every session start. |
 | **Instruction budget** | CLAUDE.md has a soft limit of ~200 actionable lines. Past that, Claude starts ignoring rules at the bottom. Doctor counts your lines and warns you. |
 | **Rules** | Extra markdown files in `.claude/rules/` that Claude reads alongside CLAUDE.md. Use them to offload detailed conventions so CLAUDE.md stays under budget. |
-| **Compaction** | When a conversation gets too long, Claude compresses older messages. This can lose context. A PostCompact hook re-injects critical files (like TASKS.md) after compaction. |
+| **Compaction** | When a conversation gets too long, Claude compresses older messages. Without a PostCompact hook, Claude loses track of your sprint and session context mid-work. The hook re-injects TASKS.md after compaction so Claude stays on track. |
 | **MCP Servers** | External tools Claude can connect to (databases, APIs, docs). Configured in `.claude/settings.json`. Most projects don't need them. |
 | **.claudeignore** | Like `.gitignore` but for Claude. Tells Claude which files to skip so it doesn't waste time reading noise. |
 

package/dist/chunk-KOSJII4R.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+// src/lib/settings.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+async function readSettingsJson(root) {
+  const path = join(root, ".claude", "settings.json");
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeSettingsJson(root, settings) {
+  const dir = join(root, ".claude");
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "settings.json"), JSON.stringify(settings, null, 2) + "\n");
+}
+async function readSettingsLocalJson(root) {
+  const path = join(root, ".claude", "settings.local.json");
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeSettingsLocalJson(root, settings) {
+  const dir = join(root, ".claude");
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "settings.local.json"), JSON.stringify(settings, null, 2) + "\n");
+}
+
+// src/lib/memory-placement.ts
+import { select } from "@inquirer/prompts";
+async function getMemoryPlacement(root, skipPrompt = false) {
+  const local = await readSettingsLocalJson(root);
+  const persisted = local.memoryPlacement;
+  if (persisted === "shared" || persisted === "local") {
+    return persisted;
+  }
+  if (skipPrompt) return "shared";
+  const choice = await select({
+    message: "Where should memory config go?",
+    choices: [
+      { value: "shared", name: "Shared (team sees it) \u2014 CLAUDE.md + settings.json" },
+      { value: "local", name: "Local (only you) \u2014 .claude/CLAUDE.md + settings.local.json" }
+    ]
+  });
+  await writeSettingsLocalJson(root, { ...local, memoryPlacement: choice });
+  return choice;
+}
+
+export {
+  readSettingsJson,
+  writeSettingsJson,
+  readSettingsLocalJson,
+  writeSettingsLocalJson,
+  getMemoryPlacement
+};
+//# sourceMappingURL=chunk-KOSJII4R.js.map

package/dist/chunk-KOSJII4R.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/settings.ts","../src/lib/memory-placement.ts"],"sourcesContent":["import { readFile, writeFile, mkdir } from \"node:fs/promises\";\nimport { join } from \"node:path\";\n\nexport async function readSettingsJson(root: string): Promise<Record<string, unknown>> {\n  const path = join(root, \".claude\", \"settings.json\");\n  try {\n    const content = await readFile(path, \"utf-8\");\n    return JSON.parse(content) as Record<string, unknown>;\n  } catch {\n    return {};\n  }\n}\n\nexport async function writeSettingsJson(root: string, settings: Record<string, unknown>): Promise<void> {\n  const dir = join(root, \".claude\");\n  await mkdir(dir, { recursive: true });\n  await writeFile(join(dir, \"settings.json\"), JSON.stringify(settings, null, 2) + \"\\n\");\n}\n\nexport async function readSettingsLocalJson(root: string): Promise<Record<string, unknown>> {\n  const path = join(root, \".claude\", \"settings.local.json\");\n  try {\n    const content = await readFile(path, \"utf-8\");\n    return JSON.parse(content) as Record<string, unknown>;\n  } catch {\n    return {};\n  }\n}\n\nexport async function writeSettingsLocalJson(root: string, settings: Record<string, unknown>): Promise<void> {\n  const dir = join(root, \".claude\");\n  await mkdir(dir, { recursive: true });\n  await writeFile(join(dir, \"settings.local.json\"), JSON.stringify(settings, null, 2) + \"\\n\");\n}\n","import { select } from \"@inquirer/prompts\";\nimport { readSettingsLocalJson, writeSettingsLocalJson } from \"./settings.js\";\nimport type { MemoryPlacement } from \"../types/index.js\";\n\nexport async function getMemoryPlacement(root: string, skipPrompt = false): Promise<MemoryPlacement> {\n  const local = await readSettingsLocalJson(root);\n  const persisted = local.memoryPlacement;\n  if (persisted === \"shared\" || persisted === \"local\") {\n    return persisted;\n  }\n\n  if (skipPrompt) return \"shared\";\n\n  const choice = await select<MemoryPlacement>({\n    message: \"Where should memory config go?\",\n    choices: [\n      { value: \"shared\", name: \"Shared (team sees it) — CLAUDE.md + settings.json\" },\n      { value: \"local\", name: \"Local (only you) — .claude/CLAUDE.md + settings.local.json\" },\n    ],\n  });\n\n  await writeSettingsLocalJson(root, { ...local, memoryPlacement: choice });\n  return choice;\n}\n"],"mappings":";;;AAAA,SAAS,UAAU,WAAW,aAAa;AAC3C,SAAS,YAAY;AAErB,eAAsB,iBAAiB,MAAgD;AACrF,QAAM,OAAO,KAAK,MAAM,WAAW,eAAe;AAClD,MAAI;AACF,UAAM,UAAU,MAAM,SAAS,MAAM,OAAO;AAC5C,WAAO,KAAK,MAAM,OAAO;AAAA,EAC3B,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAEA,eAAsB,kBAAkB,MAAc,UAAkD;AACtG,QAAM,MAAM,KAAK,MAAM,SAAS;AAChC,QAAM,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AACpC,QAAM,UAAU,KAAK,KAAK,eAAe,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,IAAI,IAAI;AACtF;AAEA,eAAsB,sBAAsB,MAAgD;AAC1F,QAAM,OAAO,KAAK,MAAM,WAAW,qBAAqB;AACxD,MAAI;AACF,UAAM,UAAU,MAAM,SAAS,MAAM,OAAO;AAC5C,WAAO,KAAK,MAAM,OAAO;AAAA,EAC3B,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAEA,eAAsB,uBAAuB,MAAc,UAAkD;AAC3G,QAAM,MAAM,KAAK,MAAM,SAAS;AAChC,QAAM,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AACpC,QAAM,UAAU,KAAK,KAAK,qBAAqB,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,IAAI,IAAI;AAC5F;;;ACjCA,SAAS,cAAc;AAIvB,eAAsB,mBAAmB,MAAc,aAAa,OAAiC;AACnG,QAAM,QAAQ,MAAM,sBAAsB,IAAI;AAC9C,QAAM,YAAY,MAAM;AACxB,MAAI,cAAc,YAAY,cAAc,SAAS;AACnD,WAAO;AAAA,EACT;AAEA,MAAI,WAAY,QAAO;AAEvB,QAAM,SAAS,MAAM,OAAwB;AAAA,IAC3C,SAAS;AAAA,IACT,SAAS;AAAA,MACP,EAAE,OAAO,UAAU,MAAM,yDAAoD;AAAA,MAC7E,EAAE,OAAO,SAAS,MAAM,kEAA6D;AAAA,IACvF;AAAA,EACF,CAAC;AAED,QAAM,uBAAuB,MAAM,EAAE,GAAG,OAAO,iBAAiB,OAAO,CAAC;AACxE,SAAO;AACT;","names":[]}

package/dist/cli.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 import {
+  getMemoryPlacement,
   readSettingsJson,
-  writeSettingsJson
-} from "./chunk-CSLWJEGD.js";
+  readSettingsLocalJson,
+  writeSettingsJson,
+  writeSettingsLocalJson
+} from "./chunk-KOSJII4R.js";
 import {
   log,
   printBanner,
@@ -284,30 +287,17 @@ When all tasks in the current sprint are complete, do a quick quality check befo
 function generateTasksMd(options) {
   return `# ${options.name} \u2014 Task Tracker
 
-> Claude: Read this at session start. Keep this file SHORT \u2014 only current state matters.
-> Rules: (1) Only show current + next sprint tasks. (2) Completed sprints get one summary line. (3) Session log: max 3 lines per session, keep only last 3 sessions. (4) Target: under 80 lines total.
+> Claude: Read at session start. Keep SHORT \u2014 only current state matters.
+> Completed sprints: one-liner. Session log: 3 lines max, last 3 sessions. Under 80 lines.
 
 ## Completed Sprints
 
-## Current Sprint: Sprint 1 \u2014 Setup
-
-### In Progress
-
-### To Do
+## Current: Sprint 1 \u2014 Setup
 - [ ] Project scaffolding and environment setup
 - [ ] Core feature implementation
 - [ ] Test infrastructure
 
-### Done
-
-## Deferred
-<!-- Known issues not urgent enough for the current sprint. Include date and reason. -->
-
-## Next Sprint: Sprint 2 \u2014 Core Features
-- [ ] ...
-
 ## Session Log
-<!-- Keep last 3 sessions only. Max 3 lines each. -->
 `;
 }
 
@@ -824,6 +814,7 @@ async function scaffold(root, options, detected, skipPrompts) {
   if (!hasClaudeGitignore) {
     writes.push(writeFile(claudeGitignorePath, [
       "# Local-only Claude Code files (never commit these)",
+      "CLAUDE.md",
       "settings.local.json",
       "plans/",
       "memory/",
@@ -942,13 +933,16 @@ import { join as join3, resolve } from "path";
 var CLAUDE_MD = "CLAUDE.md";
 var CLAUDE_DIR = ".claude";
 var SETTINGS_FILE = "settings.json";
+var SETTINGS_LOCAL_FILE = "settings.local.json";
 var RULES_DIR = "rules";
 async function parseClaudeConfig(projectRoot) {
   const root = resolve(projectRoot);
   const claudeDir = join3(root, CLAUDE_DIR);
-  const [claudeMd, settings, hooks, rules, mcpServers, skills, claudeignore] = await Promise.all([
+  const [claudeMd, localClaudeMd, settings, localSettings, hooks, rules, mcpServers, skills, claudeignore] = await Promise.all([
     readClaudeMd(root),
+    readFileOrNull(join3(claudeDir, CLAUDE_MD)),
     readSettings(claudeDir),
+    readSettingsFromFile(claudeDir, SETTINGS_LOCAL_FILE),
     readHooks(claudeDir),
     readRules(claudeDir),
     readMcpServers(claudeDir),
@@ -962,6 +956,8 @@ async function parseClaudeConfig(projectRoot) {
     claudeMdInstructionCount: instructionCount,
     settingsPath: settings !== null ? join3(claudeDir, SETTINGS_FILE) : null,
     settings,
+    localClaudeMdContent: localClaudeMd,
+    localSettings,
     hooks,
     rules,
     mcpServers,
@@ -987,7 +983,10 @@ function countInstructions(content) {
   return count;
 }
 async function readSettings(claudeDir) {
-  const raw = await readFileOrNull(join3(claudeDir, SETTINGS_FILE));
+  return readSettingsFromFile(claudeDir, SETTINGS_FILE);
+}
+async function readSettingsFromFile(claudeDir, filename) {
+  const raw = await readFileOrNull(join3(claudeDir, filename));
   if (raw === null) return null;
   try {
     return JSON.parse(raw);
@@ -1567,16 +1566,16 @@ async function analyzeMemory(config) {
       fix: "Run `doctor --fix` to remove the stale Stop hook"
     });
   }
-  const autoMemoryDisabled = config.settings?.autoMemoryEnabled === false;
+  const autoMemoryDisabled = config.settings?.autoMemoryEnabled === false || config.localSettings?.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"
+      fix: "Set autoMemoryEnabled: false in settings.json or settings.local.json"
     });
   }
-  const hasMemoryGuidance = config.claudeMdContent?.includes("agentic-memory") || config.claudeMdContent?.includes("## Memory");
+  const hasMemoryGuidance = config.claudeMdContent?.includes("agentic-memory") || config.claudeMdContent?.includes("## Memory") || config.localClaudeMdContent?.includes("agentic-memory") || config.localClaudeMdContent?.includes("## Memory");
   if (!hasMemoryGuidance) {
     issues.push({
       analyzer: "Memory",
@@ -1586,7 +1585,11 @@ async function analyzeMemory(config) {
     });
   }
   const permissions = config.settings?.permissions ?? {};
-  const allowList = permissions.allow ?? [];
+  const localPermissions = config.localSettings?.permissions ?? {};
+  const allowList = [
+    ...permissions.allow ?? [],
+    ...localPermissions.allow ?? []
+  ];
   const missingTools = MEMORY_MCP_TOOLS.filter((t) => !allowList.includes(t));
   if (missingTools.length > 0) {
     issues.push({
@@ -1639,9 +1642,10 @@ async function analyzeQuality(config) {
     return { name: "CLAUDE.md Quality", issues, score: 0 };
   }
   const sections = hasMemoryIndicators(config) ? [...BASE_SECTIONS, MEMORY_SECTION] : [...BASE_SECTIONS];
+  const combinedContent = [content, config.localClaudeMdContent].filter(Boolean).join("\n");
   let sectionsFound = 0;
   for (const section of sections) {
-    if (section.pattern.test(content)) {
+    if (section.pattern.test(combinedContent)) {
       sectionsFound++;
     } else {
       issues.push({
@@ -1695,10 +1699,12 @@ import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 async function applyFixes(issues, projectRoot) {
   const detected = await detectProject(projectRoot);
+  const hasMemoryIssues = issues.some((i) => i.analyzer === "Memory");
+  const placement = hasMemoryIssues ? await getMemoryPlacement(projectRoot) : "shared";
   let fixed = 0;
   let skipped = 0;
   for (const issue of issues) {
-    const applied = await tryFix(issue, projectRoot, detected);
+    const applied = await tryFix(issue, projectRoot, detected, placement);
     if (applied) {
       fixed++;
     } else {
@@ -1742,15 +1748,19 @@ var FIX_TABLE = [
   { analyzer: "Settings", match: "Deprecated includeCoAuthoredBy", fix: (root) => migrateAttribution(root) },
   { analyzer: "Hooks", match: "SessionStart", fix: (root) => addSessionStartHook(root) },
   { analyzer: "Memory", match: "Deprecated Stop hook", fix: (root) => removeStaleStopHook(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\n- STORE IMMEDIATELY when: a dependency strategy changes, an architecture decision is made, a convention is established, a bug pattern is discovered, or a feature is killed/added\n- Use memory_search before memory_store to check for duplicates\n- NEVER store credentials, API keys, tokens, or secrets in memories") }
+  { analyzer: "Memory", match: "autoMemoryEnabled not disabled", fix: (root, _det, placement) => disableAutoMemory(root, placement) },
+  { analyzer: "Memory", match: "MCP tool permission", fix: (root, _det, placement) => addMemoryToolPermissions(root, placement) },
+  { analyzer: "Memory", match: "CLAUDE.md missing memory guidance", fix: (root, _det, placement) => {
+    const content = "Use agentic-memory to persist knowledge across sessions:\n- Memories are automatically injected at session start\n- STORE IMMEDIATELY when: a dependency strategy changes, an architecture decision is made, a convention is established, a bug pattern is discovered, or a feature is killed/added\n- Use memory_search before memory_store to check for duplicates\n- NEVER store credentials, API keys, tokens, or secrets in memories";
+    const target = placement === "local" ? join5(root, ".claude", "CLAUDE.md") : void 0;
+    return addClaudeMdSection(root, "## Memory", content, target);
+  } }
 ];
-async function tryFix(issue, root, detected) {
+async function tryFix(issue, root, detected, placement) {
   const entry = FIX_TABLE.find(
     (e) => e.analyzer === issue.analyzer && issue.message.includes(e.match)
   );
-  return entry ? entry.fix(root, detected) : false;
+  return entry ? entry.fix(root, detected, placement) : false;
 }
 async function addHook(root, event, dedupKeyword, entry, successMsg) {
   const settings = await readSettingsJson(root);
@@ -1877,13 +1887,15 @@ async function addEnvToClaudeignore(root) {
   log.success("Added .env to .claudeignore");
   return true;
 }
-async function addClaudeMdSection(root, heading, content) {
-  const claudeMdPath = join5(root, "CLAUDE.md");
+async function addClaudeMdSection(root, heading, content, targetPath) {
+  const claudeMdPath = targetPath ?? join5(root, "CLAUDE.md");
   let existing;
   try {
     existing = await readFile4(claudeMdPath, "utf-8");
   } catch {
-    return false;
+    if (!targetPath) return false;
+    await mkdir2(join5(root, ".claude"), { recursive: true });
+    existing = "# Local Claude Config\n";
   }
   if (existing.includes(heading)) return false;
   const keyDecisionsIdx = existing.indexOf("## Key Decisions");
@@ -1895,7 +1907,8 @@ ${content}
 `;
   const updated = existing.slice(0, insertAt) + section + existing.slice(insertAt);
   await writeFile2(claudeMdPath, updated);
-  log.success(`Added "${heading}" section to CLAUDE.md`);
+  const label = targetPath ? ".claude/CLAUDE.md" : "CLAUDE.md";
+  log.success(`Added "${heading}" section to ${label}`);
   return true;
 }
 async function createBacklogMd(root) {
@@ -1947,16 +1960,21 @@ async function createStarterRules(root) {
   log.success("Created .claude/rules/conventions.md with starter rules");
   return true;
 }
-async function disableAutoMemory(root) {
-  const settings = await readSettingsJson(root);
+async function disableAutoMemory(root, placement) {
+  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
+  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
+  const settings = await read(root);
   if (settings.autoMemoryEnabled === false) return false;
   settings.autoMemoryEnabled = false;
-  await writeSettingsJson(root, settings);
-  log.success("Set autoMemoryEnabled: false (prevents conflict with agentic-memory)");
+  await write(root, settings);
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  log.success(`Set autoMemoryEnabled: false in ${target}`);
   return true;
 }
-async function addMemoryToolPermissions(root) {
-  const settings = await readSettingsJson(root);
+async function addMemoryToolPermissions(root, placement) {
+  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
+  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
+  const settings = await read(root);
   const permissions = settings.permissions ?? {};
   const allow = permissions.allow ?? [];
   const tools = [
@@ -1971,8 +1989,9 @@ async function addMemoryToolPermissions(root) {
   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");
+  await write(root, settings);
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  log.success(`Added agentic-memory MCP tool permissions to ${target}`);
   return true;
 }
 async function createEnhanceSkill(root) {
@@ -2780,9 +2799,12 @@ import { join as join10 } from "path";
 import { Command as Command4 } from "commander";
 import { confirm as confirm2 } from "@inquirer/prompts";
 function isMemoryInstalled() {
+  const cwd = process.cwd();
+  return hasMemoryHook(join10(cwd, ".claude", "settings.json")) || hasMemoryHook(join10(cwd, ".claude", "settings.local.json"));
+}
+function hasMemoryHook(path) {
   try {
-    const settingsPath = join10(process.cwd(), ".claude", "settings.json");
-    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    const settings = JSON.parse(readFileSync(path, "utf-8"));
     const hooks = settings.hooks;
     if (!hooks) return false;
     const sessionStart = hooks.SessionStart;
@@ -2808,14 +2830,24 @@ function createMemoryCommand() {
       return;
     }
     if (!isMemoryInstalled()) {
-      log.blank();
-      log.step("Claude doesn't have a knowledge base for this project yet.");
-      log.blank();
-      log.info("After setup, Claude will:");
-      log.info("  - Remember decisions, gotchas, and learnings across sessions");
-      log.info("  - Automatically recall relevant context when you start a session");
-      log.info("  - Save important facts as you work, so nothing gets lost");
-      log.blank();
+      const { detectExistingSetup } = await import("./install-U6WARER4.js");
+      const existing = detectExistingSetup(process.cwd());
+      if (existing) {
+        const location = existing === "local" ? ".claude/CLAUDE.md + settings.local.json" : "CLAUDE.md + settings.json";
+        log.blank();
+        log.success(`Memory config found (${location}) but database not set up.`);
+        log.info("Run the install to complete setup.");
+        log.blank();
+      } else {
+        log.blank();
+        log.step("Claude doesn't have a knowledge base for this project yet.");
+        log.blank();
+        log.info("After setup, Claude will:");
+        log.info("  - Remember decisions, gotchas, and learnings across sessions");
+        log.info("  - Automatically recall relevant context when you start a session");
+        log.info("  - Save important facts as you work, so nothing gets lost");
+        log.blank();
+      }
       const proceed = await confirm2({
         message: "Set up knowledge base?",
         default: true
@@ -2824,7 +2856,7 @@ function createMemoryCommand() {
         log.info("Skipped.");
         return;
       }
-      const { runInstall } = await import("./install-4GQ57KCQ.js");
+      const { runInstall } = await import("./install-U6WARER4.js");
       await runInstall({});
     } else {
       const { requireMemoryDeps } = await import("./require-deps-NKRCPVAO.js");
@@ -2863,7 +2895,7 @@ function createMemoryCommand() {
 }
 
 // src/cli.ts
-var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.14.3", "-v, --version").action(async () => {
+var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.15.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" });