claude-launchpad 1.4.0 → 1.5.0

package/dist/cli.js

@@ -5,6 +5,7 @@ import {
 import {
   BACKLOG_CONTENT,
   ENHANCE_SKILL_VERSION,
+  LP_STUB_OPEN,
   OFF_LIMITS_CONTENT,
   SESSION_START_CONTENT,
   SKILL_AUTHORING_CONTENT,
@@ -19,7 +20,7 @@ import {
   printScoreCard,
   readFileOrNull,
   renderDoctorReport
-} from "./chunk-UQOBOHKN.js";
+} from "./chunk-GLFJ2B43.js";
 
 // src/cli.ts
 import { Command as Command5 } from "commander";
@@ -1084,6 +1085,60 @@ async function analyzeMcp(config) {
   return { name: "MCP Servers", issues, score };
 }
 
+// src/commands/doctor/analyzers/hook-resolver.ts
+import { readFile as readFile3, realpath } from "fs/promises";
+import { resolve as resolve2, sep } from "path";
+import { parse } from "shell-quote";
+async function resolveHookCommand(hook, projectRoot) {
+  const command = hook.command ?? "";
+  if (!command) return { command: "", expansions: [], missingScripts: [] };
+  const scriptPaths = extractShellScripts(command);
+  if (scriptPaths.length === 0) return { command, expansions: [], missingScripts: [] };
+  let projectRootReal;
+  try {
+    projectRootReal = await realpath(projectRoot);
+  } catch {
+    return { command, expansions: [], missingScripts: [] };
+  }
+  const expansions = [];
+  const missingScripts = [];
+  for (const relPath of scriptPaths) {
+    const resolved = resolve2(projectRoot, relPath);
+    let realResolved;
+    try {
+      realResolved = await realpath(resolved);
+    } catch {
+      missingScripts.push(relPath);
+      continue;
+    }
+    if (realResolved !== projectRootReal && !realResolved.startsWith(projectRootReal + sep)) {
+      continue;
+    }
+    try {
+      const body = await readFile3(realResolved, "utf-8");
+      expansions.push({ path: relPath, body });
+    } catch {
+      missingScripts.push(relPath);
+    }
+  }
+  return { command, expansions, missingScripts };
+}
+function effectiveCommandText(resolved) {
+  if (resolved.expansions.length === 0) return resolved.command;
+  return resolved.command + "\n" + resolved.expansions.map((e) => e.body).join("\n");
+}
+function extractShellScripts(command) {
+  const tokens = parse(command);
+  const scripts = [];
+  for (const token of tokens) {
+    if (typeof token !== "string") continue;
+    if (!token.endsWith(".sh")) continue;
+    if (token.startsWith("~") || token.startsWith("$")) continue;
+    scripts.push(token);
+  }
+  return scripts;
+}
+
 // src/commands/doctor/analyzers/memory.ts
 var MEMORY_MCP_TOOLS = [
   "mcp__agentic-memory__memory_store",
@@ -1094,7 +1149,10 @@ var MEMORY_MCP_TOOLS = [
   "mcp__agentic-memory__memory_stats",
   "mcp__agentic-memory__memory_update"
 ];
-function hasMemoryIndicators(config) {
+async function resolveAllHooks(hooks, projectRoot) {
+  return Promise.all(hooks.map((h) => resolveHookCommand(h, projectRoot)));
+}
+async function hasMemoryIndicators(config, projectRoot) {
   if (config.mcpServers.some((s) => s.name === "agentic-memory")) return true;
   const permissions = config.settings?.permissions ?? {};
   const localPermissions = config.localSettings?.permissions ?? {};
@@ -1103,14 +1161,18 @@ function hasMemoryIndicators(config) {
     ...localPermissions.allow ?? []
   ];
   if (allowList.some((t) => t.startsWith("mcp__agentic-memory__"))) return true;
-  if (config.hooks.some((h) => h.event === "SessionStart" && h.command?.includes("memory context"))) return true;
-  return false;
+  const resolved = await resolveAllHooks(config.hooks, projectRoot);
+  return config.hooks.some(
+    (h, i) => h.event === "SessionStart" && effectiveCommandText(resolved[i]).includes("memory context")
+  );
 }
-async function analyzeMemory(config) {
-  if (!hasMemoryIndicators(config)) return null;
+async function analyzeMemory(config, projectRoot) {
+  if (!await hasMemoryIndicators(config, projectRoot)) return null;
   const issues = [];
+  const resolved = await resolveAllHooks(config.hooks, projectRoot);
+  const effectiveAt = (i) => effectiveCommandText(resolved[i]);
   const hasSessionStart = config.hooks.some(
-    (h) => h.event === "SessionStart" && h.command?.includes("memory context")
+    (h, i) => h.event === "SessionStart" && effectiveAt(i).includes("memory context")
   );
   if (!hasSessionStart) {
     issues.push({
@@ -1121,7 +1183,7 @@ async function analyzeMemory(config) {
     });
   }
   const hasStaleStopHook = config.hooks.some(
-    (h) => h.event === "Stop" && h.command?.includes("memory extract")
+    (h, i) => h.event === "Stop" && effectiveAt(i).includes("memory extract")
   );
   if (hasStaleStopHook) {
     issues.push({
@@ -1167,7 +1229,7 @@ async function analyzeMemory(config) {
   const syncConfig = readSyncConfig();
   if (syncConfig) {
     const hasSessionStartPull = config.hooks.some(
-      (h) => h.event === "SessionStart" && h.command?.includes("memory pull")
+      (h, i) => h.event === "SessionStart" && effectiveAt(i).includes("memory pull")
     );
     if (!hasSessionStartPull) {
       issues.push({
@@ -1178,7 +1240,7 @@ async function analyzeMemory(config) {
       });
     }
     const hasSessionEndPush = config.hooks.some(
-      (h) => h.event === "SessionEnd" && h.command?.includes("memory push")
+      (h, i) => h.event === "SessionEnd" && effectiveAt(i).includes("memory push")
     );
     if (!hasSessionEndPush) {
       issues.push({
@@ -1200,6 +1262,18 @@ async function analyzeMemory(config) {
       });
     }
   }
+  for (let i = 0; i < config.hooks.length; i++) {
+    const h = config.hooks[i];
+    if (h.event !== "SessionStart" && h.event !== "SessionEnd") continue;
+    for (const missing of resolved[i].missingScripts) {
+      issues.push({
+        analyzer: "Memory",
+        severity: "low",
+        message: `${h.event} hook references \`${missing}\` but the file is missing \u2014 wrapper can't run`,
+        fix: `Create ${missing} or remove the broken hook from .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;
@@ -1208,17 +1282,189 @@ async function analyzeMemory(config) {
   return { name: "Memory", issues, score };
 }
 
-// src/commands/doctor/analyzers/quality.ts
-var BASE_SECTIONS = [
-  { pattern: /^##\s+(Tech )?Stack/m, name: "Stack", why: "Claude performs worse without knowing the tech stack" },
-  { pattern: /^##\s+Commands/m, name: "Commands", why: "Claude guesses wrong without explicit dev/build/test commands" },
-  { pattern: /^##\s+Session Start/m, name: "Session Start", why: "Without this, Claude won't read TASKS.md or maintain continuity" },
-  { pattern: /^##\s+Off.?Limits/m, name: "Off-Limits", why: "Without guardrails, Claude has no boundaries beyond defaults" },
-  { pattern: /^##\s+(Architecture|Project Structure)/m, name: "Architecture/Structure", why: "Claude makes better decisions when it understands the codebase shape" },
-  { pattern: /^##\s+Backlog/m, name: "Backlog", why: "Without backlog instructions, deferred features get lost in conversation history" },
-  { pattern: /^##\s+(Stop.and.Swarm|When Stuck|Debug)/m, name: "Stop-and-Swarm", why: "Without a stop-and-swarm rule, Claude keeps guessing in circles instead of parallelizing research" }
+// src/commands/doctor/analyzers/quality-intents.ts
+var INTENT_RULES = [
+  {
+    name: "Stack",
+    why: "Claude performs worse without knowing the tech stack",
+    headingPatterns: [/^tech\s+stack$/i, /^stack$/i, /^technology$/i, /^tech$/i],
+    bodyKeywords: [
+      /\blanguage:/i,
+      /\bframework:/i,
+      /\bpackage\s+manager:/i,
+      /\bruntime:/i,
+      /\b(typescript|javascript|python|ruby|go|rust|java|php|swift|kotlin)\b/i,
+      /\b(react|next\.?js|vue|svelte|angular|express|fastify|laravel|rails|django|flask)\b/i,
+      /\b(node(?:\.?js)?|deno|bun|cpython)\b/i
+    ],
+    minBodyKeywords: 2
+  },
+  {
+    name: "Commands",
+    why: "Claude guesses wrong without explicit dev/build/test commands",
+    headingPatterns: [/^commands?$/i, /^scripts$/i, /^dev\s+commands$/i, /^development$/i],
+    bodyKeywords: [
+      /\b(pnpm|npm|yarn|bun)\s+\w+/i,
+      /\b(build|test|dev|lint|typecheck|start):/i,
+      /\brun\s+(tests?|build|dev)/i,
+      /\bmake\s+\w+/i,
+      /\bcargo\s+\w+/i
+    ],
+    minBodyKeywords: 2
+  },
+  {
+    name: "Session Start",
+    why: "Without this, Claude won't read TASKS.md or maintain continuity",
+    headingPatterns: [
+      /^session\s+start$/i,
+      /^session$/i,
+      /^sprint\s+planning$/i,
+      /^workflow$/i,
+      /^getting\s+started$/i,
+      /^at\s+session\s+start$/i
+    ],
+    bodyKeywords: [
+      /\btasks?\.md\b/i,
+      /\bsession\s+(start|log)\b/i,
+      /\bsprint\s+(log|planning)\b/i,
+      /\b(read|check).*at\s+(session|start)/i,
+      /\btrack\s+progress/i
+    ],
+    minBodyKeywords: 1
+  },
+  {
+    name: "Off-Limits",
+    why: "Without guardrails, Claude has no boundaries beyond defaults",
+    headingPatterns: [
+      /^off.?limits$/i,
+      /^constraints$/i,
+      /^don'?t$/i,
+      /^rules$/i,
+      /^guardrails$/i,
+      /^forbidden$/i,
+      /^security\s+notes$/i
+    ],
+    bodyKeywords: [
+      /\bnever\s+\w+/i,
+      /\bforbidden/i,
+      /\bdo\s+not\b/i,
+      /\b(secret|credential|api\s+key|password|token)/i,
+      /\.env\b/
+    ],
+    minBodyKeywords: 2
+  },
+  {
+    name: "Architecture/Structure",
+    why: "Claude makes better decisions when it understands the codebase shape",
+    headingPatterns: [
+      /^architecture$/i,
+      /^project\s+structure$/i,
+      /^structure$/i,
+      /^codebase$/i,
+      /^layout$/i,
+      /^repo\s+layout$/i
+    ],
+    bodyKeywords: [
+      /\bsrc\//,
+      /\b(directory|directories|folder|module|layer)\b/i,
+      /\barchitecture\b/i
+    ],
+    minBodyKeywords: 1
+  },
+  {
+    name: "Backlog",
+    why: "Without backlog instructions, deferred features get lost in conversation history",
+    headingPatterns: [
+      /^backlog$/i,
+      /^roadmap$/i,
+      /^parked$/i,
+      /^future\s+work$/i,
+      /^parked\s+features?$/i
+    ],
+    bodyKeywords: [
+      /\bbacklog\.md\b/i,
+      /\bbacklog\b/i,
+      /\bdeferred\b/i,
+      /\bparked\s+features?\b/i
+    ],
+    minBodyKeywords: 1
+  },
+  {
+    name: "Stop-and-Swarm",
+    why: "Without a stop-and-swarm rule, Claude keeps guessing in circles instead of parallelizing research",
+    headingPatterns: [
+      /^stop.and.swarm$/i,
+      /^when\s+stuck$/i,
+      /^debug$/i,
+      /^escalation$/i,
+      /^swarm$/i,
+      /^parallel\s+agents?$/i
+    ],
+    bodyKeywords: [
+      /\bstop-and-swarm\b/i,
+      /\bparallel\s+agents?\b/i,
+      /\bspin\s+up\b/i,
+      /\b(3|three)\s+(parallel\s+)?agents?\b/i,
+      /\bfailed\s+iterations?\b/i
+    ],
+    minBodyKeywords: 1
+  }
 ];
-var MEMORY_SECTION = { pattern: /^##\s+Memory/m, name: "Memory & Learnings", why: "Without memory instructions, Claude forgets learnings and repeats mistakes across sessions" };
+var MEMORY_INTENT = {
+  name: "Memory & Learnings",
+  why: "Without memory instructions, Claude forgets learnings and repeats mistakes across sessions",
+  headingPatterns: [/^memory$/i, /^learnings?$/i, /^memory\s*(&|and)\s*learnings?$/i],
+  bodyKeywords: [
+    /\bmemory_search\b/i,
+    /\bmemory_store\b/i,
+    /\bagentic-memory\b/i,
+    /\bstore\s+memories?\b/i,
+    /\binject(ed)?\s+(at|in|into)\s+(session|startup)/i
+  ],
+  minBodyKeywords: 1
+};
+function parseSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  let currentHeading = null;
+  let currentBody = [];
+  const flush = () => {
+    if (currentHeading === null) return;
+    const body = currentBody.join("\n");
+    sections.push({
+      heading: currentHeading,
+      body,
+      isStub: body.includes(LP_STUB_OPEN)
+    });
+  };
+  for (const line of lines) {
+    const match = line.match(/^##\s+(.+?)\s*$/);
+    if (match) {
+      flush();
+      currentHeading = match[1];
+      currentBody = [];
+    } else if (currentHeading !== null) {
+      currentBody.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
+function sectionSatisfiesIntent(section, rule) {
+  if (section.isStub) return false;
+  const headingMatch = rule.headingPatterns.some((p) => p.test(section.heading));
+  if (headingMatch) return true;
+  const keywordHits = rule.bodyKeywords.reduce(
+    (n, p) => p.test(section.body) ? n + 1 : n,
+    0
+  );
+  return keywordHits >= rule.minBodyKeywords;
+}
+function documentSatisfiesIntent(sections, rule) {
+  return sections.some((s) => sectionSatisfiesIntent(s, rule));
+}
+
+// src/commands/doctor/analyzers/quality.ts
 var VAGUE_PATTERNS = [
   { pattern: /write (good|clean|quality|nice) code/i, label: "write good code" },
   { pattern: /be (careful|thorough|diligent)/i, label: "be careful" },
@@ -1231,7 +1477,7 @@ var SECRET_PATTERNS = [
   { pattern: /AKIA[0-9A-Z]{16}/, label: "AWS access key" },
   { pattern: /xoxb-[0-9]+-[a-zA-Z0-9]+/, label: "Slack bot token" }
 ];
-async function analyzeQuality(config) {
+async function analyzeQuality(config, projectRoot) {
   const issues = [];
   const content = config.claudeMdContent;
   if (content === null) {
@@ -1243,18 +1489,16 @@ 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(combinedContent)) {
-      sectionsFound++;
-    } else {
+  const rules = await hasMemoryIndicators(config, projectRoot) ? [...INTENT_RULES, MEMORY_INTENT] : [...INTENT_RULES];
+  const combinedContent = [content, config.localClaudeMdContent].filter(Boolean).join("\n\n");
+  const sections = parseSections(combinedContent);
+  for (const rule of rules) {
+    if (!documentSatisfiesIntent(sections, rule)) {
       issues.push({
         analyzer: "Quality",
         severity: "medium",
-        message: `Missing "## ${section.name}" section \u2014 ${section.why}`,
-        fix: `Add a ## ${section.name} section to CLAUDE.md`
+        message: `Missing "## ${rule.name}" section \u2014 ${rule.why}`,
+        fix: `Add a ## ${rule.name} section to CLAUDE.md`
       });
     }
   }
@@ -1356,7 +1600,7 @@ async function runAndDisplay(projectRoot) {
   }
   const results = await Promise.all([
     analyzeBudget(config),
-    analyzeQuality(config),
+    analyzeQuality(config, projectRoot),
     analyzeSettings(config),
     analyzeHooks(config),
     analyzeRules(config),
@@ -1386,14 +1630,14 @@ function createDoctorCommand() {
     }
     const results = await Promise.all([
       analyzeBudget(config),
-      analyzeQuality(config),
+      analyzeQuality(config, opts.path),
       analyzeSettings(config),
       analyzeHooks(config),
       analyzeRules(config),
       analyzePermissions(config),
       analyzeMcp(config)
     ]);
-    const memoryResult = await analyzeMemory(config);
+    const memoryResult = await analyzeMemory(config, opts.path);
     if (memoryResult) {
       results.push(memoryResult);
     }
@@ -1444,14 +1688,14 @@ function createDoctorCommand() {
         const updatedConfig = await parseClaudeConfig(opts.path);
         const updatedResults = await Promise.all([
           analyzeBudget(updatedConfig),
-          analyzeQuality(updatedConfig),
+          analyzeQuality(updatedConfig, opts.path),
           analyzeSettings(updatedConfig),
           analyzeHooks(updatedConfig),
           analyzeRules(updatedConfig),
           analyzePermissions(updatedConfig),
           analyzeMcp(updatedConfig)
         ]);
-        const updatedMemoryResult = await analyzeMemory(updatedConfig);
+        const updatedMemoryResult = await analyzeMemory(updatedConfig, opts.path);
         if (updatedMemoryResult) {
           updatedResults.push(updatedMemoryResult);
         }
@@ -1477,8 +1721,8 @@ import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import { join as join7 } from "path";
 
 // src/commands/eval/loader.ts
-import { readFile as readFile3, readdir as readdir3, access as access3 } from "fs/promises";
-import { join as join5, resolve as resolve2, dirname as dirname2 } from "path";
+import { readFile as readFile4, readdir as readdir3, access as access3 } from "fs/promises";
+import { join as join5, resolve as resolve3, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import { parse as parseYaml } from "yaml";
 
@@ -1582,11 +1826,11 @@ var ScenarioError = class extends Error {
 // src/commands/eval/loader.ts
 async function findScenariosDir() {
   const thisDir = dirname2(fileURLToPath(import.meta.url));
-  const devPath = resolve2(thisDir, "../../../scenarios");
+  const devPath = resolve3(thisDir, "../../../scenarios");
   if (await dirExists(devPath)) return devPath;
-  const bundledPath = resolve2(thisDir, "../scenarios");
+  const bundledPath = resolve3(thisDir, "../scenarios");
   if (await dirExists(bundledPath)) return bundledPath;
-  const rootPath = resolve2(thisDir, "../../scenarios");
+  const rootPath = resolve3(thisDir, "../../scenarios");
   if (await dirExists(rootPath)) return rootPath;
   return devPath;
 }
@@ -1600,7 +1844,7 @@ async function dirExists(path) {
 }
 async function loadScenarios(options) {
   const { suite, customPath } = options;
-  const scenarioDir = customPath ? resolve2(customPath) : await findScenariosDir();
+  const scenarioDir = customPath ? resolve3(customPath) : await findScenariosDir();
   const dirs = suite ? [join5(scenarioDir, suite)] : await getSubdirectories(scenarioDir);
   const allDirs = [scenarioDir, ...dirs];
   const scenarios = [];
@@ -1608,7 +1852,7 @@ async function loadScenarios(options) {
     const files = await listYamlFiles(dir);
     for (const file of files) {
       try {
-        const content = await readFile3(file, "utf-8");
+        const content = await readFile4(file, "utf-8");
         const raw = parseYaml(content);
         const scenario = validateScenario(raw, file);
         scenarios.push(scenario);
@@ -1638,7 +1882,7 @@ async function listYamlFiles(dir) {
 }
 
 // src/commands/eval/runner.ts
-import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile4, readdir as readdir4, rm, cp } from "fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile5, readdir as readdir4, rm, cp } from "fs/promises";
 import { join as join6, dirname as dirname3 } from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
@@ -1807,7 +2051,7 @@ async function evaluateSingleCheck(check, sandboxDir) {
 async function checkGrep(check, sandboxDir) {
   if (!check.pattern) return false;
   try {
-    const content = await readFile4(join6(sandboxDir, check.target), "utf-8");
+    const content = await readFile5(join6(sandboxDir, check.target), "utf-8");
     let found;
     try {
       found = new RegExp(check.pattern).test(content);
@@ -1821,7 +2065,7 @@ async function checkGrep(check, sandboxDir) {
 }
 async function checkFilePresence(check, sandboxDir) {
   try {
-    await readFile4(join6(sandboxDir, check.target));
+    await readFile5(join6(sandboxDir, check.target));
     return check.expect === "present";
   } catch {
     return check.expect === "absent";
@@ -1832,7 +2076,7 @@ async function checkMaxLines(check, sandboxDir) {
   try {
     const files = await listAllFiles(join6(sandboxDir, check.target));
     for (const file of files) {
-      const content = await readFile4(file, "utf-8");
+      const content = await readFile5(file, "utf-8");
       if (content.split("\n").length > maxLines) {
         return check.expect === "absent";
       }
@@ -2088,14 +2332,14 @@ function createMemoryCommand() {
         log.error("Knowledge base not set up yet. Run `claude-launchpad memory` first.");
         return;
       }
-      const { requireMemoryDeps } = await import("./require-deps-RUXTMQUV.js");
+      const { requireMemoryDeps } = await import("./require-deps-MCFEZOIF.js");
       await requireMemoryDeps();
-      const { startTui } = await import("./tui-ELOJ37ZA.js");
+      const { startTui } = await import("./tui-JE5L7SXC.js");
       await startTui();
       return;
     }
     if (!isMemoryInstalled()) {
-      const { detectExistingSetup } = await import("./install-DORMJYCU.js");
+      const { detectExistingSetup } = await import("./install-P4TFYUJT.js");
       const existing = detectExistingSetup(process.cwd());
       if (existing) {
         const location = existing === "local" ? ".claude/CLAUDE.md + settings.local.json" : "CLAUDE.md + settings.json";
@@ -2121,18 +2365,18 @@ function createMemoryCommand() {
         log.info("Skipped.");
         return;
       }
-      const { runInstall } = await import("./install-DORMJYCU.js");
+      const { runInstall } = await import("./install-P4TFYUJT.js");
       await runInstall({});
     } else {
-      const { requireMemoryDeps } = await import("./require-deps-RUXTMQUV.js");
+      const { requireMemoryDeps } = await import("./require-deps-MCFEZOIF.js");
       await requireMemoryDeps();
-      const { runStats } = await import("./stats-DFV24AJW.js");
+      const { runStats } = await import("./stats-MLWRNOHU.js");
       await runStats({});
     }
   });
   memory.addCommand(
     new Command4("context").description("Load session context (hook handler)").option("--json", "JSON output").action(async (opts) => {
-      const { runContext } = await import("./context-NCV46PTY.js");
+      const { runContext } = await import("./context-4X4CLMU3.js");
       await runContext(opts);
     }).helpCommand(false),
     { hidden: true }
@@ -2147,7 +2391,7 @@ function createMemoryCommand() {
   memory.addCommand(
     new Command4("push").description("Push current project's memories to GitHub Gist").option("--all", "Push all projects").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {
       await handleSyncErrors(async () => {
-        const { runPush } = await import("./push-HWXJGSTL.js");
+        const { runPush } = await import("./push-SCTO5TZQ.js");
         await runPush(opts);
       });
     })
@@ -2155,7 +2399,7 @@ function createMemoryCommand() {
   memory.addCommand(
     new Command4("pull").description("Pull current project's memories from GitHub Gist").option("--all", "Pull all projects").option("-y, --yes", "Non-interactive (accepted for symmetry with push; pull never prompts)").action(async (opts) => {
       await handleSyncErrors(async () => {
-        const { runPull } = await import("./pull-UYLUGILU.js");
+        const { runPull } = await import("./pull-7SR7P3US.js");
         await runPull(opts);
       });
     })
@@ -2164,7 +2408,7 @@ function createMemoryCommand() {
   sync.addCommand(
     new Command4("status").description("Show local vs remote memory counts per project").action(async () => {
       await handleSyncErrors(async () => {
-        const { runSyncStatus } = await import("./sync-status-VXMDWDRG.js");
+        const { runSyncStatus } = await import("./sync-status-J7BVY6KF.js");
         await runSyncStatus();
       });
     })
@@ -2172,7 +2416,7 @@ function createMemoryCommand() {
   sync.addCommand(
     new Command4("clean").description("Remove a project from the sync gist").argument("<project>", "Project slug to remove").option("-y, --yes", "Skip confirmation prompt").action(async (project, opts) => {
       await handleSyncErrors(async () => {
-        const { runSyncClean } = await import("./sync-clean-GFX5F55E.js");
+        const { runSyncClean } = await import("./sync-clean-2BMOFDV7.js");
         await runSyncClean(project, opts);
       });
     })
@@ -2182,7 +2426,7 @@ function createMemoryCommand() {
 }
 
 // src/cli.ts
-var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("1.4.0", "-v, --version").action(async () => {
+var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("1.5.0", "-v, --version").action(async () => {
   const hasConfig = await fileExists(join9(process.cwd(), "CLAUDE.md")) || await fileExists(join9(process.cwd(), ".claude", "settings.json"));
   if (hasConfig) {
     await program.commands.find((c) => c.name() === "doctor")?.parseAsync([], { from: "user" });