claude-launchpad 0.15.2 → 0.16.0

package/dist/cli.js

@@ -5,7 +5,10 @@ import {
   readSettingsLocalJson,
   writeSettingsJson,
   writeSettingsLocalJson
-} from "./chunk-KOSJII4R.js";
+} from "./chunk-SBA5KYQU.js";
+import {
+  readSyncConfig
+} from "./chunk-JQDMBE7W.js";
 import {
   log,
   printBanner,
@@ -15,7 +18,7 @@ import {
 
 // src/cli.ts
 import { Command as Command5 } from "commander";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/commands/init/index.ts
 import { Command } from "commander";
@@ -945,7 +948,7 @@ async function parseClaudeConfig(projectRoot) {
     readSettingsFromFile(claudeDir, SETTINGS_LOCAL_FILE),
     readHooks(claudeDir),
     readRules(claudeDir),
-    readMcpServers(claudeDir),
+    readMcpServers(claudeDir, root),
     readSkills(claudeDir),
     readFileOrNull(join3(root, ".claudeignore"))
   ]);
@@ -995,7 +998,14 @@ async function readSettingsFromFile(claudeDir, filename) {
   }
 }
 async function readHooks(claudeDir) {
-  const settingsRaw = await readFileOrNull(join3(claudeDir, SETTINGS_FILE));
+  const [shared, local] = await Promise.all([
+    readHooksFromFile(join3(claudeDir, SETTINGS_FILE)),
+    readHooksFromFile(join3(claudeDir, SETTINGS_LOCAL_FILE))
+  ]);
+  return [...shared, ...local];
+}
+async function readHooksFromFile(settingsPath) {
+  const settingsRaw = await readFileOrNull(settingsPath);
   if (settingsRaw === null) return [];
   try {
     const settings = JSON.parse(settingsRaw);
@@ -1039,8 +1049,46 @@ async function readRules(claudeDir) {
   const rulesDir = join3(claudeDir, RULES_DIR);
   return listFilesRecursive(rulesDir, ".md");
 }
-async function readMcpServers(claudeDir) {
-  const settingsRaw = await readFileOrNull(join3(claudeDir, SETTINGS_FILE));
+async function readMcpServers(claudeDir, projectRoot) {
+  const [fromMcpJson, fromSettings, fromLocalSettings] = await Promise.all([
+    readMcpJsonFile(join3(projectRoot, ".mcp.json")),
+    readMcpServersFromSettings(join3(claudeDir, SETTINGS_FILE)),
+    readMcpServersFromSettings(join3(claudeDir, SETTINGS_LOCAL_FILE))
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const server of [...fromMcpJson, ...fromLocalSettings, ...fromSettings]) {
+    if (!seen.has(server.name)) {
+      seen.add(server.name);
+      result.push(server);
+    }
+  }
+  return result;
+}
+async function readMcpJsonFile(mcpJsonPath) {
+  const raw = await readFileOrNull(mcpJsonPath);
+  if (raw === null) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    const servers = parsed.mcpServers;
+    if (!servers || typeof servers !== "object") return [];
+    const result = [];
+    for (const [name, config] of Object.entries(servers)) {
+      const c = config;
+      result.push({
+        name,
+        transport: c.transport ?? "stdio",
+        command: c.command,
+        url: c.url
+      });
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+async function readMcpServersFromSettings(settingsPath) {
+  const settingsRaw = await readFileOrNull(settingsPath);
   if (settingsRaw === null) return [];
   try {
     const settings = JSON.parse(settingsRaw);
@@ -1524,6 +1572,32 @@ async function analyzeMcp(config) {
       }
     }
   }
+  if (servers.length > 0) {
+    const settings = config.settings ?? {};
+    const localSettings = config.localSettings ?? {};
+    const hasAllowList = settings.allowedMcpServers || localSettings.allowedMcpServers;
+    if (!hasAllowList) {
+      issues.push({
+        analyzer: "MCP",
+        severity: "medium",
+        message: "MCP servers configured but no allowedMcpServers list \u2014 any added server is auto-trusted",
+        fix: "Add allowedMcpServers to settings.json listing only trusted server names"
+      });
+    }
+  }
+  if (servers.length > 0) {
+    const sandbox = config.settings?.sandbox ?? config.localSettings?.sandbox;
+    const hasNetwork = sandbox?.network !== void 0;
+    const httpServers = servers.filter((s) => s.transport === "sse" || s.transport === "http");
+    if (sandbox?.enabled === true && httpServers.length > 0 && !hasNetwork) {
+      issues.push({
+        analyzer: "MCP",
+        severity: "low",
+        message: "Sandbox enabled with HTTP MCP servers but no network restrictions configured",
+        fix: "Add sandbox.network.allowedHosts to restrict which hosts MCP servers can reach"
+      });
+    }
+  }
   const score = Math.max(0, 100 - issues.filter((i) => i.severity !== "info").length * 25);
   return { name: "MCP Servers", issues, score };
 }
@@ -1539,7 +1613,16 @@ var MEMORY_MCP_TOOLS = [
   "mcp__agentic-memory__memory_update"
 ];
 function hasMemoryIndicators(config) {
-  return config.mcpServers.some((s) => s.name === "agentic-memory");
+  if (config.mcpServers.some((s) => s.name === "agentic-memory")) return true;
+  const permissions = config.settings?.permissions ?? {};
+  const localPermissions = config.localSettings?.permissions ?? {};
+  const allowList = [
+    ...permissions.allow ?? [],
+    ...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;
 }
 async function analyzeMemory(config) {
   if (!hasMemoryIndicators(config)) return null;
@@ -1599,6 +1682,31 @@ async function analyzeMemory(config) {
       fix: "Add all agentic-memory tool names to allowedTools in .claude/settings.json"
     });
   }
+  const syncConfig = readSyncConfig();
+  if (syncConfig) {
+    const hasSessionStartPull = config.hooks.some(
+      (h) => h.event === "SessionStart" && h.command?.includes("memory pull")
+    );
+    if (!hasSessionStartPull) {
+      issues.push({
+        analyzer: "Memory",
+        severity: "medium",
+        message: "Sync configured but no SessionStart hook to auto-pull memories before context injection",
+        fix: "Run `doctor --fix` to add a SessionStart hook that pulls memories automatically"
+      });
+    }
+    const hasSessionEndPush = config.hooks.some(
+      (h) => h.event === "SessionEnd" && h.command?.includes("memory push")
+    );
+    if (!hasSessionEndPush) {
+      issues.push({
+        analyzer: "Memory",
+        severity: "medium",
+        message: "Sync configured but no SessionEnd hook to auto-push memories after each session",
+        fix: "Run `doctor --fix` to add a SessionEnd hook that pushes memories automatically"
+      });
+    }
+  }
   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;
@@ -1694,9 +1802,127 @@ async function analyzeQuality(config) {
 }
 
 // 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 { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2, access as access4 } from "fs/promises";
+import { join as join6 } from "path";
 import { homedir as homedir3 } from "os";
+
+// src/commands/doctor/fixer-memory.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join5 } from "path";
+async function addPlacementHook(root, placement, event, dedupKeyword, entry, prepend, successMsg) {
+  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
+  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
+  const settings = await read(root);
+  const hooks = settings.hooks ?? {};
+  const hookList = hooks[event] ?? [];
+  const alreadyHas = hookList.some((g) => {
+    const nested = g.hooks;
+    return nested?.some((h) => String(h.command ?? "").includes(dedupKeyword));
+  });
+  if (alreadyHas) return false;
+  hooks[event] = prepend ? [entry, ...hookList] : [...hookList, entry];
+  settings.hooks = hooks;
+  await write(root, settings);
+  log.success(successMsg);
+  return true;
+}
+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 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, 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 = [
+    "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 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 addSessionStartPullHook(root, placement) {
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  return addPlacementHook(root, placement, "SessionStart", "memory pull", {
+    matcher: "startup",
+    hooks: [{ type: "command", command: "claude-launchpad memory pull -y 2>/dev/null; exit 0" }]
+  }, true, `Added SessionStart hook for memory sync to ${target}`);
+}
+async function addSessionEndPushHook(root, placement) {
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  return addPlacementHook(root, placement, "SessionEnd", "memory push", {
+    hooks: [{ type: "command", command: "claude-launchpad memory push -y >/dev/null 2>&1 & exit 0" }]
+  }, false, `Added SessionEnd hook for memory sync to ${target}`);
+}
+async function removeStaleStopHook(root) {
+  const settings = await readSettingsJson(root);
+  const hooks = settings.hooks;
+  if (!hooks?.Stop) return false;
+  const stopHooks = hooks.Stop;
+  const filtered = stopHooks.filter((h) => {
+    const innerHooks = h.hooks;
+    return !innerHooks?.some(
+      (ih) => typeof ih.command === "string" && ih.command.includes("memory extract")
+    );
+  });
+  if (filtered.length === stopHooks.length) return false;
+  const updated = filtered.length === 0 ? (({ Stop: _, ...rest }) => rest)(hooks) : { ...hooks, Stop: filtered };
+  settings.hooks = updated;
+  await writeSettingsJson(root, settings);
+  log.success("Removed deprecated Stop hook (memory extract)");
+  return true;
+}
+async function addAllowedMcpServers(root, placement) {
+  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
+  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
+  const settings = await read(root);
+  if (settings.allowedMcpServers) return false;
+  const other = placement === "local" ? await readSettingsJson(root) : await readSettingsLocalJson(root);
+  if (other.allowedMcpServers) return false;
+  const serverNames = /* @__PURE__ */ new Set();
+  const settingsServers = settings.mcpServers;
+  if (settingsServers && typeof settingsServers === "object") {
+    for (const name of Object.keys(settingsServers)) serverNames.add(name);
+  }
+  const mcpJsonPath = join5(root, ".mcp.json");
+  try {
+    const mcpJson = JSON.parse(await readFile4(mcpJsonPath, "utf-8"));
+    const mcpServers = mcpJson.mcpServers;
+    if (mcpServers && typeof mcpServers === "object") {
+      for (const name of Object.keys(mcpServers)) serverNames.add(name);
+    }
+  } catch {
+  }
+  if (serverNames.size === 0) return false;
+  settings.allowedMcpServers = [...serverNames].map(
+    (name) => ({ serverName: name })
+  );
+  await write(root, settings);
+  const target = placement === "local" ? "settings.local.json" : "settings.json";
+  log.success(`Added allowedMcpServers from configured servers to ${target}`);
+  return true;
+}
+
+// src/commands/doctor/fixer.ts
 async function applyFixes(issues, projectRoot) {
   const detected = await detectProject(projectRoot);
   const hasMemoryIssues = issues.some((i) => i.analyzer === "Memory");
@@ -1718,7 +1944,8 @@ var FIX_TABLE = [
     const a = await addEnvProtectionHook(root);
     const b = await addAutoFormatHook(root, detected);
     const c = await addForcePushProtection(root);
-    return a || b || c;
+    const d = await addSessionStartHook(root);
+    return a || b || c || d;
   } },
   { analyzer: "Hooks", match: ".env file protection", fix: (root) => addEnvProtectionHook(root) },
   { analyzer: "Hooks", match: "auto-format", fix: (root, detected) => addAutoFormatHook(root, detected) },
@@ -1750,9 +1977,12 @@ var FIX_TABLE = [
   { analyzer: "Memory", match: "Deprecated Stop hook", fix: (root) => removeStaleStopHook(root) },
   { 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: "MCP", match: "no allowedMcpServers", fix: (root, _det, placement) => addAllowedMcpServers(root, placement) },
+  { analyzer: "Memory", match: "SessionStart hook to auto-pull", fix: (root, _det, placement) => addSessionStartPullHook(root, placement) },
+  { analyzer: "Memory", match: "SessionEnd hook to auto-push", fix: (root, _det, placement) => addSessionEndPushHook(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;
+    const target = placement === "local" ? join6(root, ".claude", "CLAUDE.md") : void 0;
     return addClaudeMdSection(root, "## Memory", content, target);
   } }
 ];
@@ -1874,10 +2104,10 @@ async function addSandboxSettings(root) {
   return true;
 }
 async function addEnvToClaudeignore(root) {
-  const ignorePath = join5(root, ".claudeignore");
+  const ignorePath = join6(root, ".claudeignore");
   let content;
   try {
-    content = await readFile4(ignorePath, "utf-8");
+    content = await readFile5(ignorePath, "utf-8");
   } catch {
     return false;
   }
@@ -1888,13 +2118,13 @@ async function addEnvToClaudeignore(root) {
   return true;
 }
 async function addClaudeMdSection(root, heading, content, targetPath) {
-  const claudeMdPath = targetPath ?? join5(root, "CLAUDE.md");
+  const claudeMdPath = targetPath ?? join6(root, "CLAUDE.md");
   let existing;
   try {
-    existing = await readFile4(claudeMdPath, "utf-8");
+    existing = await readFile5(claudeMdPath, "utf-8");
   } catch {
     if (!targetPath) return false;
-    await mkdir2(join5(root, ".claude"), { recursive: true });
+    await mkdir2(join6(root, ".claude"), { recursive: true });
     existing = "# Local Claude Config\n";
   }
   if (existing.includes(heading)) return false;
@@ -1912,7 +2142,7 @@ ${content}
   return true;
 }
 async function createBacklogMd(root) {
-  const backlogPath = join5(root, "BACKLOG.md");
+  const backlogPath = join6(root, "BACKLOG.md");
   try {
     await access4(backlogPath);
     return false;
@@ -1928,7 +2158,7 @@ async function createBacklogMd(root) {
   return true;
 }
 async function createClaudeignore(root, detected) {
-  const ignorePath = join5(root, ".claudeignore");
+  const ignorePath = join6(root, ".claudeignore");
   try {
     await access4(ignorePath);
     return false;
@@ -1940,7 +2170,7 @@ async function createClaudeignore(root, detected) {
   return true;
 }
 async function createStarterRules(root) {
-  const rulesDir = join5(root, ".claude", "rules");
+  const rulesDir = join6(root, ".claude", "rules");
   try {
     await access4(rulesDir);
     return false;
@@ -1948,7 +2178,7 @@ async function createStarterRules(root) {
   }
   await mkdir2(rulesDir, { recursive: true });
   await writeFile2(
-    join5(rulesDir, "conventions.md"),
+    join6(rulesDir, "conventions.md"),
     `# Project Conventions
 
 - Use conventional commits (feat:, fix:, docs:, refactor:, test:, chore:)
@@ -1960,46 +2190,12 @@ async function createStarterRules(root) {
   log.success("Created .claude/rules/conventions.md with starter rules");
   return true;
 }
-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 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, 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 = [
-    "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 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) {
-  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");
+  const skillDir = join6(root, ".claude", "skills", "lp-enhance");
+  const skillPath = join6(skillDir, "SKILL.md");
+  const globalPath = join6(homedir3(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const legacyProject = join6(root, ".claude", "commands", "lp-enhance.md");
+  const legacyGlobal = join6(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());
@@ -2007,39 +2203,18 @@ async function createEnhanceSkill(root) {
   return true;
 }
 async function updateEnhanceSkill(root) {
-  const projectPath = join5(root, ".claude", "skills", "lp-enhance", "SKILL.md");
-  const globalPath = join5(homedir3(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const projectPath = join6(root, ".claude", "skills", "lp-enhance", "SKILL.md");
+  const globalPath = join6(homedir3(), ".claude", "skills", "lp-enhance", "SKILL.md");
   const targetPath = await fileExists(projectPath) ? projectPath : await fileExists(globalPath) ? globalPath : null;
   if (!targetPath) return false;
   await writeFile2(targetPath, generateEnhanceSkill());
   log.success("Updated /lp-enhance skill to latest version");
   return true;
 }
-async function removeStaleStopHook(root) {
-  const settings = await readSettingsJson(root);
-  const hooks = settings.hooks;
-  if (!hooks?.Stop) return false;
-  const stopHooks = hooks.Stop;
-  const filtered = stopHooks.filter((h) => {
-    const innerHooks = h.hooks;
-    return !innerHooks?.some(
-      (ih) => typeof ih.command === "string" && ih.command.includes("memory extract")
-    );
-  });
-  if (filtered.length === stopHooks.length) return false;
-  if (filtered.length === 0) {
-    delete hooks.Stop;
-  } else {
-    hooks.Stop = filtered;
-  }
-  await writeSettingsJson(root, settings);
-  log.success("Removed deprecated Stop hook (memory extract)");
-  return true;
-}
 
 // src/commands/doctor/watcher.ts
 import { readdir as readdir2, stat } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function watchConfig(projectRoot) {
   await runAndDisplay(projectRoot);
   log.blank();
@@ -2062,16 +2237,16 @@ async function watchConfig(projectRoot) {
 }
 async function getFileSnapshot(projectRoot) {
   const files = [
-    join6(projectRoot, "CLAUDE.md"),
-    join6(projectRoot, ".claudeignore")
+    join7(projectRoot, "CLAUDE.md"),
+    join7(projectRoot, ".claudeignore")
   ];
-  const claudeDir = join6(projectRoot, ".claude");
+  const claudeDir = join7(projectRoot, ".claude");
   try {
     const entries = await readdir2(claudeDir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile()) {
         const parentPath = entry.parentPath ?? claudeDir;
-        files.push(join6(parentPath, entry.name));
+        files.push(join7(parentPath, entry.name));
       }
     }
   } catch {
@@ -2216,11 +2391,11 @@ import { select as select2 } from "@inquirer/prompts";
 import ora from "ora";
 import chalk2 from "chalk";
 import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/commands/eval/loader.ts
-import { readFile as readFile5, readdir as readdir3, access as access5 } from "fs/promises";
-import { join as join7, resolve as resolve2, dirname as dirname2 } from "path";
+import { readFile as readFile6, readdir as readdir3, access as access5 } from "fs/promises";
+import { join as join8, resolve as resolve2, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import { parse as parseYaml } from "yaml";
 
@@ -2343,14 +2518,14 @@ async function dirExists(path) {
 async function loadScenarios(options) {
   const { suite, customPath } = options;
   const scenarioDir = customPath ? resolve2(customPath) : await findScenariosDir();
-  const dirs = suite ? [join7(scenarioDir, suite)] : await getSubdirectories(scenarioDir);
+  const dirs = suite ? [join8(scenarioDir, suite)] : await getSubdirectories(scenarioDir);
   const allDirs = [scenarioDir, ...dirs];
   const scenarios = [];
   for (const dir of allDirs) {
     const files = await listYamlFiles(dir);
     for (const file of files) {
       try {
-        const content = await readFile5(file, "utf-8");
+        const content = await readFile6(file, "utf-8");
         const raw = parseYaml(content);
         const scenario = validateScenario(raw, file);
         scenarios.push(scenario);
@@ -2365,7 +2540,7 @@ async function loadScenarios(options) {
 async function getSubdirectories(dir) {
   try {
     const entries = await readdir3(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).map((e) => join7(dir, e.name));
+    return entries.filter((e) => e.isDirectory()).map((e) => join8(dir, e.name));
   } catch {
     return [];
   }
@@ -2373,22 +2548,22 @@ async function getSubdirectories(dir) {
 async function listYamlFiles(dir) {
   try {
     const entries = await readdir3(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml"))).map((e) => join7(dir, e.name));
+    return entries.filter((e) => e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml"))).map((e) => join8(dir, e.name));
   } catch {
     return [];
   }
 }
 
 // src/commands/eval/runner.ts
-import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile6, readdir as readdir4, rm, cp } from "fs/promises";
-import { join as join8, dirname as dirname3 } from "path";
+import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile7, readdir as readdir4, rm, cp } from "fs/promises";
+import { join as join9, dirname as dirname3 } from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var exec = promisify(execFile);
 async function runScenario(scenario, options) {
-  const sandboxDir = join8(tmpdir(), `claude-eval-${randomUUID()}`);
+  const sandboxDir = join9(tmpdir(), `claude-eval-${randomUUID()}`);
   try {
     await setupSandbox(sandboxDir, scenario, options.projectRoot);
     await runClaudeInSandbox(sandboxDir, scenario.prompt, options.timeout, options.model);
@@ -2414,14 +2589,14 @@ async function runScenarioWithRetries(scenario, options) {
 async function setupSandbox(sandboxDir, scenario, projectRoot) {
   await mkdir3(sandboxDir, { recursive: true });
   for (const file of scenario.setup.files) {
-    const filePath = join8(sandboxDir, file.path);
+    const filePath = join9(sandboxDir, file.path);
     await mkdir3(dirname3(filePath), { recursive: true });
     await writeFile3(filePath, file.content);
   }
   await copyProjectConfig(sandboxDir, projectRoot);
   if (scenario.setup.instructions) {
     await writeFile3(
-      join8(sandboxDir, "CLAUDE.md"),
+      join9(sandboxDir, "CLAUDE.md"),
       `# Eval Scenario
 
 ${scenario.setup.instructions}
@@ -2442,20 +2617,20 @@ ${scenario.setup.instructions}
   ], { cwd: sandboxDir });
 }
 async function copyProjectConfig(sandboxDir, projectRoot) {
-  const claudeDir = join8(projectRoot, ".claude");
-  const sandboxClaudeDir = join8(sandboxDir, ".claude");
-  const settingsPath = join8(claudeDir, "settings.json");
+  const claudeDir = join9(projectRoot, ".claude");
+  const sandboxClaudeDir = join9(sandboxDir, ".claude");
+  const settingsPath = join9(claudeDir, "settings.json");
   if (await fileExists(settingsPath)) {
     await mkdir3(sandboxClaudeDir, { recursive: true });
-    await cp(settingsPath, join8(sandboxClaudeDir, "settings.json"));
+    await cp(settingsPath, join9(sandboxClaudeDir, "settings.json"));
   }
-  const rulesDir = join8(claudeDir, "rules");
+  const rulesDir = join9(claudeDir, "rules");
   if (await fileExists(rulesDir)) {
-    await cp(rulesDir, join8(sandboxClaudeDir, "rules"), { recursive: true });
+    await cp(rulesDir, join9(sandboxClaudeDir, "rules"), { recursive: true });
   }
-  const ignorePath = join8(projectRoot, ".claudeignore");
+  const ignorePath = join9(projectRoot, ".claudeignore");
   if (await fileExists(ignorePath)) {
-    await cp(ignorePath, join8(sandboxDir, ".claudeignore"));
+    await cp(ignorePath, join9(sandboxDir, ".claudeignore"));
   }
 }
 async function runClaudeInSandbox(cwd, prompt, timeout, model) {
@@ -2549,7 +2724,7 @@ async function evaluateSingleCheck(check, sandboxDir) {
 async function checkGrep(check, sandboxDir) {
   if (!check.pattern) return false;
   try {
-    const content = await readFile6(join8(sandboxDir, check.target), "utf-8");
+    const content = await readFile7(join9(sandboxDir, check.target), "utf-8");
     let found;
     try {
       found = new RegExp(check.pattern).test(content);
@@ -2563,7 +2738,7 @@ async function checkGrep(check, sandboxDir) {
 }
 async function checkFilePresence(check, sandboxDir) {
   try {
-    await readFile6(join8(sandboxDir, check.target));
+    await readFile7(join9(sandboxDir, check.target));
     return check.expect === "present";
   } catch {
     return check.expect === "absent";
@@ -2572,9 +2747,9 @@ async function checkFilePresence(check, sandboxDir) {
 async function checkMaxLines(check, sandboxDir) {
   const maxLines = parseInt(check.pattern ?? "800", 10);
   try {
-    const files = await listAllFiles(join8(sandboxDir, check.target));
+    const files = await listAllFiles(join9(sandboxDir, check.target));
     for (const file of files) {
-      const content = await readFile6(file, "utf-8");
+      const content = await readFile7(file, "utf-8");
       if (content.split("\n").length > maxLines) {
         return check.expect === "absent";
       }
@@ -2589,7 +2764,7 @@ async function listAllFiles(dir) {
   try {
     const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join8(dir, entry.name);
+      const fullPath = join9(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...await listAllFiles(fullPath));
       } else {
@@ -2775,10 +2950,10 @@ async function saveEvalReport(results, projectRoot, suite, model) {
       lines.push("");
     }
   }
-  const evalDir = join9(projectRoot, ".claude", "eval");
+  const evalDir = join10(projectRoot, ".claude", "eval");
   await mkdir4(evalDir, { recursive: true });
   const filename = `eval-${suite ?? "all"}-${timestamp}.md`;
-  await writeFile4(join9(evalDir, filename), lines.join("\n"));
+  await writeFile4(join10(evalDir, filename), lines.join("\n"));
   log.success(`Report saved to .claude/eval/${filename}`);
 }
 async function checkClaudeCli() {
@@ -2795,12 +2970,12 @@ async function checkClaudeCli() {
 
 // src/commands/memory/index.ts
 import { readFileSync } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } 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"));
+  return hasMemoryHook(join11(cwd, ".claude", "settings.json")) || hasMemoryHook(join11(cwd, ".claude", "settings.local.json"));
 }
 function hasMemoryHook(path) {
   try {
@@ -2825,12 +3000,12 @@ function createMemoryCommand() {
       }
       const { requireMemoryDeps } = await import("./require-deps-NKRCPVAO.js");
       await requireMemoryDeps();
-      const { startTui } = await import("./tui-GUCKDWDM.js");
+      const { startTui } = await import("./tui-XIYOOUP6.js");
       await startTui();
       return;
     }
     if (!isMemoryInstalled()) {
-      const { detectExistingSetup } = await import("./install-UXO5BISS.js");
+      const { detectExistingSetup } = await import("./install-MVATZUXZ.js");
       const existing = detectExistingSetup(process.cwd());
       if (existing) {
         const location = existing === "local" ? ".claude/CLAUDE.md + settings.local.json" : "CLAUDE.md + settings.json";
@@ -2856,18 +3031,18 @@ function createMemoryCommand() {
         log.info("Skipped.");
         return;
       }
-      const { runInstall } = await import("./install-UXO5BISS.js");
+      const { runInstall } = await import("./install-MVATZUXZ.js");
       await runInstall({});
     } else {
       const { requireMemoryDeps } = await import("./require-deps-NKRCPVAO.js");
       await requireMemoryDeps();
-      const { runStats } = await import("./stats-P7S3FTCQ.js");
+      const { runStats } = await import("./stats-QUBHHPV7.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-XPXKLF5V.js");
+      const { runContext } = await import("./context-CWJUUTTU.js");
       await runContext(opts);
     }).helpCommand(false),
     { hidden: true }
@@ -2881,13 +3056,13 @@ 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) => {
-      const { runPush } = await import("./push-BGN3DVV5.js");
+      const { runPush } = await import("./push-74XC5CUK.js");
       await runPush(opts);
     })
   );
   memory.addCommand(
     new Command4("pull").description("Pull current project's memories from GitHub Gist").option("--all", "Pull all projects").action(async (opts) => {
-      const { runPull } = await import("./pull-3O4B6EL2.js");
+      const { runPull } = await import("./pull-YOESZ3UC.js");
       await runPull(opts);
     })
   );
@@ -2895,8 +3070,8 @@ function createMemoryCommand() {
 }
 
 // src/cli.ts
-var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.15.2", "-v, --version").action(async () => {
-  const hasConfig = await fileExists(join11(process.cwd(), "CLAUDE.md")) || await fileExists(join11(process.cwd(), ".claude", "settings.json"));
+var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.16.0", "-v, --version").action(async () => {
+  const hasConfig = await fileExists(join12(process.cwd(), "CLAUDE.md")) || await fileExists(join12(process.cwd(), ".claude", "settings.json"));
   if (hasConfig) {
     await program.commands.find((c) => c.name() === "doctor")?.parseAsync([], { from: "user" });
   } else {