claude-launchpad 1.10.0 → 1.12.0

package/dist/cli.js

@@ -1,44 +1,58 @@
 #!/usr/bin/env node
 import {
   readSyncConfig
-} from "./chunk-OWOW5KFX.js";
+} from "./chunk-ZLI4LI33.js";
 import {
   BACKLOG_CONTENT,
   ENHANCE_SKILL_VERSION,
   LP_STUB_OPEN,
   OFF_LIMITS_CONTENT,
   SESSION_START_CONTENT,
+  SESSION_START_MATCHER,
   SKILL_AUTHORING_CONTENT,
+  SPRINT_COMPLETE_NUDGE,
+  SPRINT_OPEN_WRAPPER,
+  SPRINT_SIZE_WRAPPER,
+  STALE_SWARM_PHRASE,
   STOP_AND_SWARM_CONTENT,
+  TESTING_DISCIPLINE_CONTENT,
+  WORKFLOW_CHECK_WRAPPER,
+  WORKFLOW_RULE_VERSION,
   applyFixes,
   detectProject,
   fileExists,
   generateBacklogMd,
   generateClaudeignore,
   generateEnhanceSkill,
+  generateHooksRule,
+  generateReviewerAgent,
   generateWorkflowRule,
+  hasEnvVarHookPattern,
+  isJqAvailable,
+  jqField,
   log,
   printBanner,
   printScoreCard,
   readFileOrNull,
   renderDoctorReport,
+  sprintReviewsContent,
   writeSprintHygieneScripts,
   writeWorkflowCheckScript
-} from "./chunk-5KQ2JDZN.js";
+} from "./chunk-KPO4YURF.js";
 
 // src/cli.ts
 import { Command as Command5 } from "commander";
-import { join as join9 } from "path";
+import { join as join13 } from "path";
 
 // src/commands/init/index.ts
 import { Command } from "commander";
 import { input, confirm, select } from "@inquirer/prompts";
 import { writeFile, mkdir, readFile } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 
 // src/commands/init/generators/claude-md.ts
-function generateClaudeMd(options, detected) {
+function generateClaudeMd(options, detected, env) {
   const sections = [];
   sections.push(`# ${options.name}`);
   if (options.description) {
@@ -71,12 +85,7 @@ ${SESSION_START_CONTENT}`);
   sections.push("", `## Backlog
 ${BACKLOG_CONTENT}`);
   sections.push("", `## Sprint Reviews
-When all tasks in the current sprint are complete, do a quick quality check before committing:
-- Scan changed files for dead code, debug logs, and TODO hacks
-- Run tests and type-checker if available
-- Check for convention violations and hardcoded values
-- Fix any issues, then commit
-- Skip if the sprint was trivial (docs, config-only changes)`);
+${sprintReviewsContent(detected.testCommand, detected.lintCommand, env?.superpowers ?? false)}`);
   sections.push("", `## Conventions
 - Git: Conventional commits (\`feat:\`, \`fix:\`, \`docs:\`, \`refactor:\`, \`test:\`, \`chore:\`)`);
   sections.push("", `## Stop-and-Swarm
@@ -126,66 +135,51 @@ function generateSettings(detected) {
     matcher: "Read|Write|Edit",
     hooks: [{
       type: "command",
-      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -qE '\\.(env|env\\..*)$' && ! echo "$TOOL_INPUT_FILE_PATH" | grep -q '.env.example' && echo 'BLOCKED: .env files contain secrets' && exit 1; exit 0`
+      command: `fp=${jqField("file_path")}; echo "$fp" | grep -qE '\\.(env|env\\..*)$' && ! echo "$fp" | grep -q '.env.example' && { echo 'BLOCKED: .env files contain secrets' >&2; exit 2; }; exit 0`
     }]
   });
   preToolUse.push({
     matcher: "Bash",
     hooks: [{
       type: "command",
-      command: `echo "$TOOL_INPUT_COMMAND" | grep -qE 'rm\\s+-rf\\s+/|DROP\\s+TABLE|DROP\\s+DATABASE|push.*--force|push.*-f' && echo 'BLOCKED: Destructive command detected' && exit 1; exit 0`
+      command: `cmd=${jqField("command")}; echo "$cmd" | grep -qE 'rm\\s+-rf\\s+/|DROP\\s+TABLE|DROP\\s+DATABASE|push.*--force|push.*-f' && { echo 'BLOCKED: Destructive command detected' >&2; exit 2; }; exit 0`
     }]
   });
+  const editWriteHooks = [];
   const formatHook = buildFormatHook(detected);
   if (formatHook) {
-    postToolUse.push(formatHook);
+    editWriteHooks.push(formatHook);
   }
-  postToolUse.push({
-    matcher: "Edit|Write",
-    hooks: [{
-      type: "command",
-      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -q TASKS.md || exit 0; section=$(sed -n '/^## Current/,/^## /p' TASKS.md 2>/dev/null); [ -z "$section" ] && exit 0; unchecked=$(echo "$section" | grep -cF '- [ ]' || true); checked=$(echo "$section" | grep -cF '- [x]' || true); [ "$unchecked" -eq 0 ] && [ "$checked" -gt 0 ] && echo 'Sprint complete \u2014 all current tasks done. Consider a quick quality check before committing: scan for dead code, debug artifacts, TODO hacks, and convention violations. Run tests if available. Skip if trivial.'; exit 0`
-    }]
+  editWriteHooks.push({
+    type: "command",
+    command: SPRINT_COMPLETE_NUDGE
   });
-  postToolUse.push({
-    matcher: "Edit|Write",
-    hooks: [{
-      type: "command",
-      command: "bash .claude/hooks/workflow-check.sh 2>/dev/null; exit 0"
-    }]
+  editWriteHooks.push({
+    type: "command",
+    command: WORKFLOW_CHECK_WRAPPER
   });
-  preToolUse.push({
+  postToolUse.push({ matcher: "Edit|Write", hooks: editWriteHooks });
+  postToolUse.push({
     matcher: "Bash",
     hooks: [{
       type: "command",
-      command: "bash .claude/hooks/sprint-open-check.sh 2>/dev/null; exit 0"
+      command: SPRINT_OPEN_WRAPPER
     }]
   });
   const sessionStart = [{
-    matcher: "startup|resume",
+    matcher: SESSION_START_MATCHER,
     hooks: [{
       type: "command",
       command: "cat TASKS.md 2>/dev/null; exit 0"
-    }]
-  }, {
-    matcher: "startup|resume",
-    hooks: [{
+    }, {
       type: "command",
-      command: "bash .claude/hooks/sprint-size-check.sh TASKS.md 2>/dev/null; exit 0"
-    }]
-  }];
-  const postCompact = [{
-    matcher: "",
-    hooks: [{
-      type: "command",
-      command: "cat TASKS.md 2>/dev/null; exit 0"
+      command: SPRINT_SIZE_WRAPPER
     }]
   }];
   const hooks = {};
   hooks.SessionStart = sessionStart;
   if (preToolUse.length > 0) hooks.PreToolUse = preToolUse;
   if (postToolUse.length > 0) hooks.PostToolUse = postToolUse;
-  hooks.PostCompact = postCompact;
   return {
     $schema: "https://json.schemastore.org/claude-code-settings.json",
     permissions: {
@@ -225,14 +219,35 @@ function buildFormatHook(detected) {
   if (!config) return null;
   const extChecks = config.extensions.map((ext) => `[ "$ext" = "${ext}" ]`).join(" || ");
   return {
-    matcher: "Write|Edit",
-    hooks: [{
-      type: "command",
-      command: `ext=\${TOOL_INPUT_FILE_PATH##*.}; (${extChecks}) && ${config.command} "$TOOL_INPUT_FILE_PATH" 2>/dev/null; exit 0`
-    }]
+    type: "command",
+    command: `fp=${jqField("file_path")}; ext="\${fp##*.}"; (${extChecks}) && ${config.command} "$fp" 2>/dev/null; exit 0`
   };
 }
 
+// src/lib/plugins.ts
+import { readdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function isSuperpowersInstalled() {
+  const pluginsDir = join(homedir(), ".claude", "plugins");
+  if (!existsSync(pluginsDir)) return false;
+  try {
+    return dirTreeContains(pluginsDir, "superpowers", 3);
+  } catch {
+    return false;
+  }
+}
+function dirTreeContains(dir, needle, depth) {
+  if (depth === 0) return false;
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.toLowerCase().includes(needle)) return true;
+    if (dirTreeContains(join(dir, entry.name), needle, depth - 1)) return true;
+  }
+  return false;
+}
+
 // 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 (does not overwrite existing files)").option("-f, --force", "Overwrite existing CLAUDE.md").action(async (opts) => {
@@ -257,7 +272,7 @@ function createInitCommand() {
       message: "One-line description (optional):"
     });
     const options = { name: name.trim(), description: description.trim() };
-    const hasClaudeMd = await fileExists(join(root, "CLAUDE.md"));
+    const hasClaudeMd = await fileExists(join2(root, "CLAUDE.md"));
     if (hasClaudeMd) {
       if (opts.force) {
         log.warn("Overwriting existing CLAUDE.md (--force)");
@@ -285,27 +300,29 @@ function createInitCommand() {
 }
 async function scaffold(root, options, detected, skipPrompts) {
   log.step("Generating configuration...");
-  const claudeMd = generateClaudeMd(options, detected);
+  const claudeMd = generateClaudeMd(options, detected, { superpowers: isSuperpowersInstalled() });
   const tasksMd = generateTasksMd(options);
   const backlogMd = generateBacklogMd(options);
   const settings = generateSettings(detected);
   const claudeignore = generateClaudeignore(detected);
-  await mkdir(join(root, ".claude", "rules"), { recursive: true });
-  const settingsPath = join(root, ".claude", "settings.json");
+  await mkdir(join2(root, ".claude", "rules"), { recursive: true });
+  const settingsPath = join2(root, ".claude", "settings.json");
   const mergedSettings = await mergeSettings(settingsPath, settings);
-  const backlogPath = join(root, "BACKLOG.md");
+  const backlogPath = join2(root, "BACKLOG.md");
   const hasBacklog = await fileExists(backlogPath);
-  const claudeignorePath = join(root, ".claudeignore");
+  const claudeignorePath = join2(root, ".claudeignore");
   const hasClaudeignore = await fileExists(claudeignorePath);
-  const claudeGitignorePath = join(root, ".claude", ".gitignore");
+  const claudeGitignorePath = join2(root, ".claude", ".gitignore");
   const hasClaudeGitignore = await fileExists(claudeGitignorePath);
-  const rulesPath = join(root, ".claude", "rules", "conventions.md");
+  const rulesPath = join2(root, ".claude", "rules", "conventions.md");
   const hasRules = await fileExists(rulesPath);
-  const workflowRulePath = join(root, ".claude", "rules", "workflow.md");
+  const workflowRulePath = join2(root, ".claude", "rules", "workflow.md");
   const hasWorkflowRule = await fileExists(workflowRulePath);
+  const hooksRulePath = join2(root, ".claude", "rules", "hooks.md");
+  const hasHooksRule = await fileExists(hooksRulePath);
   const writes = [
-    writeFile(join(root, "CLAUDE.md"), claudeMd),
-    writeFile(join(root, "TASKS.md"), tasksMd),
+    writeFile(join2(root, "CLAUDE.md"), claudeMd),
+    writeFile(join2(root, "TASKS.md"), tasksMd),
     writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n")
   ];
   if (!hasBacklog) {
@@ -333,10 +350,20 @@ async function scaffold(root, options, detected, skipPrompts) {
   if (!hasWorkflowRule) {
     writes.push(writeFile(workflowRulePath, generateWorkflowRule()));
   }
+  if (!hasHooksRule) {
+    writes.push(writeFile(hooksRulePath, generateHooksRule()));
+  }
+  const reviewerAgentPath = join2(root, ".claude", "agents", "code-reviewer.md");
+  const hasReviewerAgent = await fileExists(reviewerAgentPath);
+  if (!hasReviewerAgent) {
+    await mkdir(join2(root, ".claude", "agents"), { recursive: true });
+    writes.push(writeFile(reviewerAgentPath, generateReviewerAgent()));
+  }
   await Promise.all(writes);
   await writeSprintHygieneScripts(root);
   await writeWorkflowCheckScript(root);
   log.success("Generated CLAUDE.md");
+  if (!hasReviewerAgent) log.success("Generated .claude/agents/code-reviewer.md (independent sprint reviewer)");
   log.success("Generated TASKS.md");
   if (!hasBacklog) log.success("Generated BACKLOG.md");
   log.success("Generated .claude/settings.json (schema, permissions, hooks)");
@@ -344,9 +371,16 @@ async function scaffold(root, options, detected, skipPrompts) {
   if (!hasClaudeignore) log.success("Generated .claudeignore");
   if (!hasRules) log.success("Generated .claude/rules/conventions.md");
   if (!hasWorkflowRule) log.success("Generated .claude/rules/workflow.md (workflow rules, path-scoped)");
+  if (!hasHooksRule) log.success("Generated .claude/rules/hooks.md (hook authoring rules, path-scoped)");
   log.success("Generated .claude/hooks/sprint-{size,open}-check.sh + workflow-check.sh");
   await createEnhanceSkillPrompt(root, skipPrompts);
   log.blank();
+  if (!isJqAvailable()) {
+    log.warn("jq not found on PATH \u2014 the generated hooks (including the .env and destructive-command guards) will silently no-op until you install it: https://jqlang.github.io/jq/download/");
+  }
+  if (!isSuperpowersInstalled()) {
+    log.info("Optional: the superpowers plugin adds brainstorm/plan/TDD/review discipline \u2014 /plugin install superpowers@claude-plugins-official");
+  }
   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.");
@@ -377,15 +411,21 @@ function generateStarterRules(detected) {
     lines.push("- Prefer Result over unwrap/expect in library code");
     lines.push("- No unsafe blocks without a safety comment");
   }
+  lines.push("", "## Testing Discipline", "", TESTING_DISCIPLINE_CONTENT);
+  const verify = [detected.testCommand, detected.lintCommand].filter((c) => !!c).map((c) => `\`${c}\``).join(" && ");
+  lines.push("", "## Pre-Commit Checklist", "");
+  lines.push(verify ? `1. Run ${verify} \u2014 never commit if either fails` : "1. Run the project's test and typecheck commands \u2014 never commit if either fails");
+  lines.push("2. For hard-TDD surfaces, confirm the test was written before the implementation");
+  lines.push("3. Before sprint-ending commits: run /code-review on the sprint diff (see ## Sprint Reviews in CLAUDE.md)");
   lines.push("", "## Skill Authoring", "", SKILL_AUTHORING_CONTENT);
   lines.push("");
   return lines.join("\n");
 }
 async function createEnhanceSkillPrompt(root, skipPrompts) {
-  const projectPath = join(root, ".claude", "skills", "lp-enhance", "SKILL.md");
-  const globalPath = join(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
-  const legacyProject = join(root, ".claude", "commands", "lp-enhance.md");
-  const legacyGlobal = join(homedir(), ".claude", "commands", "lp-enhance.md");
+  const projectPath = join2(root, ".claude", "skills", "lp-enhance", "SKILL.md");
+  const globalPath = join2(homedir2(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const legacyProject = join2(root, ".claude", "commands", "lp-enhance.md");
+  const legacyGlobal = join2(homedir2(), ".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):",
@@ -396,9 +436,9 @@ async function createEnhanceSkillPrompt(root, skipPrompts) {
     ]
   });
   if (scope === "skip") return;
-  const targetDir = scope === "global" ? join(homedir(), ".claude", "skills", "lp-enhance") : join(root, ".claude", "skills", "lp-enhance");
+  const targetDir = scope === "global" ? join2(homedir2(), ".claude", "skills", "lp-enhance") : join2(root, ".claude", "skills", "lp-enhance");
   await mkdir(targetDir, { recursive: true });
-  await writeFile(join(targetDir, "SKILL.md"), generateEnhanceSkill());
+  await writeFile(join2(targetDir, "SKILL.md"), generateEnhanceSkill());
   log.success(`Generated /lp-enhance skill (${scope} scope)`);
 }
 async function mergeSettings(existingPath, generated) {
@@ -428,7 +468,7 @@ import chalk from "chalk";
 
 // src/lib/parser.ts
 import { readdir, access } from "fs/promises";
-import { join as join2, resolve } from "path";
+import { join as join3, resolve } from "path";
 var CLAUDE_MD = "CLAUDE.md";
 var CLAUDE_DIR = ".claude";
 var SETTINGS_FILE = "settings.json";
@@ -436,26 +476,26 @@ var SETTINGS_LOCAL_FILE = "settings.local.json";
 var RULES_DIR = "rules";
 async function parseClaudeConfig(projectRoot) {
   const root = resolve(projectRoot);
-  const claudeDir = join2(root, CLAUDE_DIR);
+  const claudeDir = join3(root, CLAUDE_DIR);
   const [claudeMd, localClaudeMd, settings, localSettings, hooks, rules, mcpServers, skills, claudeignore, worktreeInclude, gitWorktreesActive] = await Promise.all([
     readClaudeMd(root),
-    readFileOrNull(join2(claudeDir, CLAUDE_MD)),
+    readFileOrNull(join3(claudeDir, CLAUDE_MD)),
     readSettings(claudeDir),
     readSettingsFromFile(claudeDir, SETTINGS_LOCAL_FILE),
     readHooks(claudeDir),
     readRules(claudeDir),
     readMcpServers(claudeDir, root),
     readSkills(claudeDir),
-    readFileOrNull(join2(root, ".claudeignore")),
-    readFileOrNull(join2(root, ".worktreeinclude")),
+    readFileOrNull(join3(root, ".claudeignore")),
+    readFileOrNull(join3(root, ".worktreeinclude")),
     detectGitWorktrees(root)
   ]);
   const instructionCount = claudeMd ? countInstructions(claudeMd) : 0;
   return {
-    claudeMdPath: claudeMd !== null ? join2(root, CLAUDE_MD) : null,
+    claudeMdPath: claudeMd !== null ? join3(root, CLAUDE_MD) : null,
     claudeMdContent: claudeMd,
     claudeMdInstructionCount: instructionCount,
-    settingsPath: settings !== null ? join2(claudeDir, SETTINGS_FILE) : null,
+    settingsPath: settings !== null ? join3(claudeDir, SETTINGS_FILE) : null,
     settings,
     localClaudeMdContent: localClaudeMd,
     localSettings,
@@ -463,23 +503,23 @@ async function parseClaudeConfig(projectRoot) {
     rules,
     mcpServers,
     skills,
-    claudeignorePath: claudeignore !== null ? join2(root, ".claudeignore") : null,
+    claudeignorePath: claudeignore !== null ? join3(root, ".claudeignore") : null,
     claudeignoreContent: claudeignore,
-    worktreeIncludePath: worktreeInclude !== null ? join2(root, ".worktreeinclude") : null,
+    worktreeIncludePath: worktreeInclude !== null ? join3(root, ".worktreeinclude") : null,
     worktreeIncludeContent: worktreeInclude,
     gitWorktreesActive
   };
 }
 async function detectGitWorktrees(root) {
   try {
-    const entries = await readdir(join2(root, ".git", "worktrees"));
+    const entries = await readdir(join3(root, ".git", "worktrees"));
     return entries.length > 0;
   } catch {
     return false;
   }
 }
 async function readClaudeMd(root) {
-  return readFileOrNull(join2(root, CLAUDE_MD));
+  return readFileOrNull(join3(root, CLAUDE_MD));
 }
 function countInstructions(content) {
   const lines = content.split("\n");
@@ -498,7 +538,7 @@ async function readSettings(claudeDir) {
   return readSettingsFromFile(claudeDir, SETTINGS_FILE);
 }
 async function readSettingsFromFile(claudeDir, filename) {
-  const path = join2(claudeDir, filename);
+  const path = join3(claudeDir, filename);
   const raw = await readFileOrNull(path);
   if (raw === null) return null;
   try {
@@ -510,8 +550,8 @@ async function readSettingsFromFile(claudeDir, filename) {
 }
 async function readHooks(claudeDir) {
   const [shared, local] = await Promise.all([
-    readHooksFromFile(join2(claudeDir, SETTINGS_FILE)),
-    readHooksFromFile(join2(claudeDir, SETTINGS_LOCAL_FILE))
+    readHooksFromFile(join3(claudeDir, SETTINGS_FILE)),
+    readHooksFromFile(join3(claudeDir, SETTINGS_LOCAL_FILE))
   ]);
   return [...shared, ...local];
 }
@@ -557,14 +597,14 @@ async function readHooksFromFile(settingsPath) {
   }
 }
 async function readRules(claudeDir) {
-  const rulesDir = join2(claudeDir, RULES_DIR);
+  const rulesDir = join3(claudeDir, RULES_DIR);
   return listFilesRecursive(rulesDir, ".md");
 }
 async function readMcpServers(claudeDir, projectRoot) {
   const [fromMcpJson, fromSettings, fromLocalSettings] = await Promise.all([
-    readMcpJsonFile(join2(projectRoot, ".mcp.json")),
-    readMcpServersFromSettings(join2(claudeDir, SETTINGS_FILE)),
-    readMcpServersFromSettings(join2(claudeDir, SETTINGS_LOCAL_FILE))
+    readMcpJsonFile(join3(projectRoot, ".mcp.json")),
+    readMcpServersFromSettings(join3(claudeDir, SETTINGS_FILE)),
+    readMcpServersFromSettings(join3(claudeDir, SETTINGS_LOCAL_FILE))
   ]);
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -621,8 +661,8 @@ async function readMcpServersFromSettings(settingsPath) {
   }
 }
 async function readSkills(claudeDir) {
-  const commandsDir = join2(claudeDir, "commands");
-  const skillsDir = join2(claudeDir, "skills");
+  const commandsDir = join3(claudeDir, "commands");
+  const skillsDir = join3(claudeDir, "skills");
   const [commands, skills] = await Promise.all([
     listFilesRecursive(commandsDir, ".md"),
     listFilesRecursive(skillsDir, ".md")
@@ -638,7 +678,7 @@ async function listFilesRecursive(dir, ext) {
   const results = [];
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join2(dir, entry.name);
+    const fullPath = join3(dir, entry.name);
     if (entry.isDirectory()) {
       const nested = await listFilesRecursive(fullPath, ext);
       results.push(...nested);
@@ -731,12 +771,12 @@ async function analyzeSettings(config) {
     });
   }
   const allowedTools = config.settings.allowedTools;
-  if (allowedTools && allowedTools.length > 0 && config.hooks.length === 0) {
+  if (allowedTools && allowedTools.length > 0) {
     issues.push({
       analyzer: "Settings",
-      severity: "medium",
-      message: "Tools auto-allowed without any hooks \u2014 no safety net for dangerous operations",
-      fix: "Add PreToolUse hooks for security or remove allowedTools to use interactive prompting"
+      severity: "low",
+      message: "Legacy allowedTools key in settings.json \u2014 superseded by permissions.allow",
+      fix: 'Move entries to permissions.allow (e.g. "Bash(npm test)") and remove allowedTools'
     });
   }
   if (config.settings.includeCoAuthoredBy !== void 0) {
@@ -771,9 +811,20 @@ async function analyzeSettings(config) {
 }
 
 // src/commands/doctor/analyzers/hooks.ts
-async function analyzeHooks(config) {
+async function analyzeHooks(config, projectRoot = "") {
   const issues = [];
   const hooks = config.hooks;
+  for (const h of hooks) {
+    if (h.command && hasEnvVarHookPattern(h.command)) {
+      const preview = h.command.slice(0, 60).replace(/\s+/g, " ");
+      issues.push({
+        analyzer: "Hooks",
+        severity: "high",
+        message: `Hook reads non-existent $TOOL_INPUT_* env var (silently inert): ${h.event}/${h.matcher || "*"} \u2014 ${preview}\u2026`,
+        fix: "Run `doctor --fix` to rewrite known shapes to jq stdin form. User-customized hooks need manual rewrite to `jq -r '.tool_input.X' < /dev/stdin`."
+      });
+    }
+  }
   if (hooks.length === 0) {
     issues.push({
       analyzer: "Hooks",
@@ -815,13 +866,35 @@ async function analyzeHooks(config) {
       fix: "Add PreToolUse hooks for file protection and dangerous command blocking"
     });
   }
-  const hasPostCompact = hooks.some((h) => h.event === "PostCompact");
-  if (!hasPostCompact) {
+  const usesJq = hooks.some((h) => h.command?.includes("jq "));
+  if (usesJq && !isJqAvailable()) {
     issues.push({
       analyzer: "Hooks",
-      severity: "low",
-      message: "No PostCompact hook \u2014 session context is lost when conversation is compacted",
-      fix: "Add a PostCompact hook that re-injects TASKS.md after compaction"
+      severity: "medium",
+      message: "jq not found on PATH \u2014 every generated hook (including the .env and destructive-command guards) silently no-ops without it",
+      fix: "Install jq (https://jqlang.github.io/jq/download/) \u2014 hooks read tool input as JSON from stdin"
+    });
+  }
+  const hasInertPostCompact = hooks.some(
+    (h) => h.event === "PostCompact" && !!h.command && h.command.includes("TASKS.md")
+  );
+  if (hasInertPostCompact) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "high",
+      message: "PostCompact hooks can't inject context \u2014 this TASKS.md re-injection never reaches the model. Session continuity after compaction is silently broken",
+      fix: "Run `doctor --fix` to move the injection to a SessionStart hook with a compact matcher"
+    });
+  }
+  const hasCompactMatcher = hooks.some(
+    (h) => h.event === "SessionStart" && ((h.matcher ?? "") === "" || (h.matcher ?? "").includes("compact"))
+  );
+  if (!hasCompactMatcher) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "medium",
+      message: "No SessionStart hook with a compact matcher \u2014 session context is lost when the conversation is compacted",
+      fix: "Run `doctor --fix` to widen the SessionStart matcher to startup|resume|compact|clear"
     });
   }
   const hasSessionStart = hooks.some((h) => h.event === "SessionStart");
@@ -848,7 +921,7 @@ async function analyzeHooks(config) {
         analyzer: "Hooks",
         severity: "low",
         message: "No sprint-open-check hook \u2014 opening a new sprint without removing pulled WPs from BACKLOG silently drifts",
-        fix: "Add PreToolUse Bash hook calling .claude/hooks/sprint-open-check.sh"
+        fix: "Add PostToolUse Bash hook calling .claude/hooks/sprint-open-check.sh"
       });
     }
     if (!hooks.some((h) => h.command?.includes("Sprint complete"))) {
@@ -868,18 +941,57 @@ async function analyzeHooks(config) {
       });
     }
   }
+  const sprintOpenOnPreToolUse = hooks.some(
+    (h) => h.event === "PreToolUse" && !!h.command && h.command.includes("sprint-open-check.sh")
+  );
+  if (sprintOpenOnPreToolUse) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "medium",
+      message: "sprint-open-check.sh is registered on PreToolUse \u2014 context injection is impossible there and the current script inspects the last commit. It belongs on PostToolUse",
+      fix: "Run `doctor --fix` to move it to PostToolUse and refresh the script"
+    });
+  }
+  const staleEchoNudge = hooks.some(
+    (h) => !!h.command && h.command.includes("Sprint complete") && !h.command.includes("additionalContext")
+  );
+  if (staleEchoNudge) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "medium",
+      message: "sprint-complete nudge uses bare stdout \u2014 PostToolUse stdout never reaches the model, so the nudge is invisible",
+      fix: "Run `doctor --fix` to upgrade it to additionalContext JSON"
+    });
+  }
+  if (projectRoot !== "" && await hasStaleHygieneScript(projectRoot)) {
+    issues.push({
+      analyzer: "Hooks",
+      severity: "medium",
+      message: "Outdated hygiene script(s) in .claude/hooks \u2014 their warnings use bare stdout and never reach the model",
+      fix: "Run `doctor --fix` to refresh workflow-check.sh / sprint-open-check.sh"
+    });
+  }
   const score = Math.max(0, 100 - issues.length * 15);
   return { name: "Hooks", issues, score };
 }
+async function hasStaleHygieneScript(projectRoot) {
+  const { readFile: readFile7 } = await import("fs/promises");
+  const { join: join14 } = await import("path");
+  for (const name of ["workflow-check.sh", "sprint-open-check.sh"]) {
+    const content = await readFile7(join14(projectRoot, ".claude", "hooks", name), "utf-8").catch(() => null);
+    if (content !== null && !content.includes("hookSpecificOutput")) return true;
+  }
+  return false;
+}
 
 // src/commands/doctor/analyzers/rules.ts
 import { readFile as readFile2 } from "fs/promises";
-import { basename, join as join3, dirname } from "path";
-import { homedir as homedir2 } from "os";
+import { basename, join as join4, dirname } from "path";
+import { homedir as homedir3 } from "os";
 async function analyzeRules(config) {
   const issues = [];
   const projectRoot = config.claudeMdPath ? dirname(config.claudeMdPath) : process.cwd();
-  const hasBacklog = await fileExists(join3(projectRoot, "BACKLOG.md"));
+  const hasBacklog = await fileExists(join4(projectRoot, "BACKLOG.md"));
   if (!hasBacklog) {
     issues.push({
       analyzer: "Rules",
@@ -888,7 +1000,7 @@ async function analyzeRules(config) {
       fix: "Run `claude-launchpad init` or `doctor --fix` to generate one"
     });
   }
-  const hasWorkflowRule = await fileExists(join3(projectRoot, ".claude", "rules", "workflow.md"));
+  const hasWorkflowRule = await fileExists(join4(projectRoot, ".claude", "rules", "workflow.md"));
   if (!hasWorkflowRule) {
     issues.push({
       analyzer: "Rules",
@@ -897,7 +1009,45 @@ async function analyzeRules(config) {
       fix: "Run `doctor --fix` to generate it"
     });
   }
-  const hasClaudeignore = await fileExists(join3(projectRoot, ".claudeignore"));
+  const hasReviewerAgent = await fileExists(join4(projectRoot, ".claude", "agents", "code-reviewer.md"));
+  if (!hasReviewerAgent) {
+    issues.push({
+      analyzer: "Rules",
+      severity: "low",
+      message: "No .claude/agents/code-reviewer.md \u2014 sprint reviews run as same-model self-checks",
+      fix: "Run `doctor --fix` to generate a fresh-context reviewer agent"
+    });
+  }
+  if (!isSuperpowersInstalled()) {
+    issues.push({
+      analyzer: "Rules",
+      severity: "info",
+      message: "Optional: the superpowers plugin adds brainstorm/plan/TDD/review discipline \u2014 /plugin install superpowers@claude-plugins-official"
+    });
+  }
+  if (hasWorkflowRule) {
+    const wfContent = await readFile2(join4(projectRoot, ".claude", "rules", "workflow.md"), "utf-8").catch(() => "");
+    const wfMatch = wfContent.match(/<!-- lp-workflow-version: (\d+) -->/);
+    const wfVersion = wfMatch ? parseInt(wfMatch[1], 10) : null;
+    if (wfVersion !== null && wfVersion < WORKFLOW_RULE_VERSION) {
+      issues.push({
+        analyzer: "Rules",
+        severity: "low",
+        message: `workflow.md rule is outdated (v${wfVersion}, latest v${WORKFLOW_RULE_VERSION})`,
+        fix: "Run `doctor --fix` to update it"
+      });
+    }
+  }
+  const hasHooksRule = await fileExists(join4(projectRoot, ".claude", "rules", "hooks.md"));
+  if (!hasHooksRule) {
+    issues.push({
+      analyzer: "Rules",
+      severity: "medium",
+      message: "No .claude/rules/hooks.md found \u2014 hook authoring rules unenforced (env-var bug, exit-code 2 vs 1, multi-matcher caveats)",
+      fix: "Run `doctor --fix` to generate it"
+    });
+  }
+  const hasClaudeignore = await fileExists(join4(projectRoot, ".claudeignore"));
   if (!hasClaudeignore) {
     issues.push({
       analyzer: "Rules",
@@ -909,7 +1059,7 @@ async function analyzeRules(config) {
   const hasSkillInProject = config.skills.some(
     (s) => basename(s) === "SKILL.md" && s.includes("lp-enhance") || basename(s) === "lp-enhance.md"
   );
-  const hasSkillGlobal = await fileExists(join3(homedir2(), ".claude", "skills", "lp-enhance", "SKILL.md")) || await fileExists(join3(homedir2(), ".claude", "commands", "lp-enhance.md"));
+  const hasSkillGlobal = await fileExists(join4(homedir3(), ".claude", "skills", "lp-enhance", "SKILL.md")) || await fileExists(join4(homedir3(), ".claude", "commands", "lp-enhance.md"));
   if (!hasSkillInProject && !hasSkillGlobal) {
     issues.push({
       analyzer: "Rules",
@@ -983,13 +1133,14 @@ async function analyzeRules(config) {
       });
     }
   }
-  const score = Math.max(0, 100 - issues.length * 10);
+  const actionable = issues.filter((i) => i.severity !== "info").length;
+  const score = Math.max(0, 100 - actionable * 10);
   return { name: "Rules", issues, score };
 }
 async function getSkillVersion(projectRoot) {
   const paths = [
-    join3(projectRoot, ".claude", "skills", "lp-enhance", "SKILL.md"),
-    join3(homedir2(), ".claude", "skills", "lp-enhance", "SKILL.md")
+    join4(projectRoot, ".claude", "skills", "lp-enhance", "SKILL.md"),
+    join4(homedir3(), ".claude", "skills", "lp-enhance", "SKILL.md")
   ];
   for (const p of paths) {
     try {
@@ -1004,13 +1155,44 @@ async function getSkillVersion(projectRoot) {
   return null;
 }
 
+// src/lib/memory-registration.ts
+import { readFileSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+function isMemoryMcpRegistered(projectRoot) {
+  return hasMemoryServerInJson(join5(projectRoot, ".mcp.json"), "mcpServers") || hasMemoryServerInJson(join5(projectRoot, ".claude", "settings.local.json"), "mcpServers") || hasMemoryServerInUserConfig(projectRoot);
+}
+function hasMemoryServerInJson(path, key) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    const servers = parsed[key];
+    return !!servers && typeof servers === "object" && "agentic-memory" in servers;
+  } catch {
+    return false;
+  }
+}
+function hasMemoryServerInUserConfig(projectRoot) {
+  try {
+    const parsed = JSON.parse(readFileSync(join5(homedir4(), ".claude.json"), "utf-8"));
+    const projects = parsed.projects;
+    const project = projects?.[projectRoot];
+    const scoped = project?.mcpServers;
+    if (scoped && "agentic-memory" in scoped) return true;
+    const global = parsed.mcpServers;
+    return !!global && "agentic-memory" in global;
+  } catch {
+    return false;
+  }
+}
+
 // src/commands/doctor/analyzers/permissions.ts
-async function analyzePermissions(config) {
+async function analyzePermissions(config, projectRoot) {
   const issues = [];
   const settings = config.settings;
   const permissions = settings?.permissions;
   const denyList = permissions?.deny ?? [];
   const allowList = permissions?.allow ?? [];
+  const legacyAllowList = settings?.allowedTools ?? [];
   const credentialPatterns = ["Read(~/.ssh/*)", "Read(~/.aws/*)", "Read(~/.npmrc)"];
   const missingCreds = credentialPatterns.filter((p) => !denyList.includes(p));
   if (missingCreds.length > 0) {
@@ -1021,8 +1203,8 @@ async function analyzePermissions(config) {
       fix: "Add Read(~/.ssh/*), Read(~/.aws/*), Read(~/.npmrc) to permissions.deny"
     });
   }
-  const hasBlanketBash = allowList.some((a) => a === "Bash" || a.startsWith("Bash") && !a.includes("("));
-  if (hasBlanketBash) {
+  const isBlanketBash = (a) => a === "Bash";
+  if ([...allowList, ...legacyAllowList].some(isBlanketBash)) {
     issues.push({
       analyzer: "Permissions",
       severity: "high",
@@ -1039,12 +1221,13 @@ async function analyzePermissions(config) {
     });
   }
   const sandbox = settings?.sandbox;
-  if (sandbox?.enabled === true) {
+  const memoryInUse = config.mcpServers.some((s) => s.name === "agentic-memory") || isMemoryMcpRegistered(projectRoot);
+  if (sandbox?.enabled === true && memoryInUse && !sandboxAllowsMemoryWrites(sandbox)) {
     issues.push({
       analyzer: "Permissions",
-      severity: "high",
-      message: "Filesystem sandbox enabled \u2014 blocks memory MCP and other cross-project tooling. Deny rules already cover the threat model.",
-      fix: 'Remove the "sandbox" block from settings.json'
+      severity: "medium",
+      message: "Sandbox lacks a write grant for ~/.agentic-memory \u2014 Bash-run memory commands (push/pull hooks, CLI) may fail inside the sandbox",
+      fix: `Add "~/.agentic-memory" to sandbox.filesystem.allowWrite \u2014 scope the sandbox, don't disable it`
     });
   }
   const hasEnvHook = config.hooks.some((h) => h.command?.includes(".env"));
@@ -1060,23 +1243,8 @@ async function analyzePermissions(config) {
       });
     }
   }
-  const hasBashSecurity = config.hooks.some(
-    (h) => h.event === "PreToolUse" && (h.matcher?.includes("Bash") || !h.matcher)
-  );
-  const bashAllowed = settings?.allowedTools;
-  const hasBashAutoAllow = bashAllowed?.some(
-    (t) => typeof t === "string" && t.toLowerCase().includes("bash")
-  );
-  if (hasBashAutoAllow && !hasBashSecurity) {
-    issues.push({
-      analyzer: "Permissions",
-      severity: "high",
-      message: "Bash is auto-allowed without a security hook \u2014 dangerous commands could run unchecked",
-      fix: "Add a PreToolUse hook for Bash that blocks destructive commands"
-    });
-  }
   const hasForceProtection = config.hooks.some(
-    (h) => h.event === "PreToolUse" && h.command?.includes("force")
+    (h) => h.event === "PreToolUse" && !!h.command && /push/i.test(h.command) && /--force|-f\b|force/i.test(h.command)
   );
   if (!hasForceProtection) {
     issues.push({
@@ -1086,17 +1254,6 @@ async function analyzePermissions(config) {
       fix: "Add a PreToolUse hook that warns on `git push --force` commands"
     });
   }
-  if (config.claudeMdContent) {
-    const hasOffLimits = config.claudeMdContent.includes("## Off-Limits") || config.claudeMdContent.includes("## off-limits");
-    if (!hasOffLimits) {
-      issues.push({
-        analyzer: "Permissions",
-        severity: "medium",
-        message: "No Off-Limits section in CLAUDE.md \u2014 Claude has no guardrails beyond defaults",
-        fix: "Add an ## Off-Limits section with project-specific restrictions"
-      });
-    }
-  }
   if (config.gitWorktreesActive) {
     const content = config.worktreeIncludeContent;
     const hasEntries = content !== null && content.split("\n").some((l) => {
@@ -1115,6 +1272,11 @@ async function analyzePermissions(config) {
   const score = Math.max(0, 100 - issues.length * 15);
   return { name: "Permissions", issues, score };
 }
+function sandboxAllowsMemoryWrites(sandbox) {
+  const filesystem = sandbox.filesystem;
+  const allowWrite = filesystem?.allowWrite ?? [];
+  return allowWrite.some((p) => p.includes(".agentic-memory"));
+}
 
 // src/commands/doctor/analyzers/mcp.ts
 import { access as access2 } from "fs/promises";
@@ -1677,6 +1839,14 @@ async function analyzeQuality(config, projectRoot) {
       fix: "Fill in the TODO sections or remove them"
     });
   }
+  if (content.includes(STALE_SWARM_PHRASE)) {
+    issues.push({
+      analyzer: "Quality",
+      severity: "low",
+      message: "Stop-and-Swarm section is outdated \u2014 it references the nonexistent 'Agent tool' (subagents are dispatched via the Task tool)",
+      fix: "Run `doctor --fix` to modernize the known phrase (custom content is left alone)"
+    });
+  }
   const plainMemory = (content.match(/^## Memory\s*$/gm) ?? []).length;
   const taggedMemory = (content.match(/^## Memory \(agentic-memory\)\s*$/gm) ?? []).length;
   if (plainMemory + taggedMemory > 1) {
@@ -1695,9 +1865,103 @@ async function analyzeQuality(config, projectRoot) {
   return { name: "CLAUDE.md Quality", issues, score };
 }
 
+// src/commands/doctor/analyzers/workflow.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join6 } from "path";
+var WP_FIELDS = [
+  "Priority:",
+  "Proposed:",
+  "Stories / Docs:",
+  "Depends on:",
+  "Estimate:",
+  "Trigger to pull:",
+  "Definition of done:"
+];
+var STALE_P0_DAYS = 14;
+var STALE_CHANGELOG_DAYS = 30;
+async function analyzeWorkflow(projectRoot, now = /* @__PURE__ */ new Date()) {
+  const backlog = await readFile4(join6(projectRoot, "BACKLOG.md"), "utf-8").catch(() => null);
+  if (backlog === null) return null;
+  const issues = [];
+  const pSections = extractPSections(backlog);
+  const entries = parseWpEntries(pSections);
+  const incomplete = entries.map((e) => ({ id: e.id, missing: WP_FIELDS.filter((f) => !e.body.includes(f)) })).filter((e) => e.missing.length > 0);
+  if (incomplete.length > 0) {
+    const sample = incomplete.slice(0, 3).map((e) => `${e.id} (missing ${e.missing.map((f) => f.replace(":", "")).join(", ")})`).join("; ");
+    issues.push({
+      analyzer: "Workflow",
+      severity: "medium",
+      message: `${incomplete.length} WP entr${incomplete.length === 1 ? "y" : "ies"} missing mandatory template fields: ${sample}`,
+      fix: "Fill in all 7 fields per the template in BACKLOG.md \u2014 unpullable WPs rot"
+    });
+  }
+  const p0Section = extractSection(backlog, /^## P0/m);
+  const staleP0 = parseWpEntries(p0Section).filter((e) => {
+    const proposed = e.body.match(/Proposed:\*{0,2}\s*(\d{4}-\d{2}-\d{2})/);
+    return proposed !== null && daysBetween(proposed[1], now) > STALE_P0_DAYS;
+  });
+  if (staleP0.length > 0) {
+    issues.push({
+      analyzer: "Workflow",
+      severity: "medium",
+      message: `${staleP0.length} P0 item(s) older than ${STALE_P0_DAYS} days (${staleP0.map((e) => e.id).join(", ")}) \u2014 P0 means next sprint`,
+      fix: "Pull them into a sprint or demote them (workflow.md priority discipline)"
+    });
+  }
+  const changelog = extractSection(backlog, /^## Changelog/m);
+  const dates = [...changelog.matchAll(/(\d{4}-\d{2}-\d{2})/g)].map((m) => m[1]).sort();
+  const lastDate = dates[dates.length - 1];
+  if (entries.length > 0 && lastDate !== void 0 && daysBetween(lastDate, now) > STALE_CHANGELOG_DAYS) {
+    issues.push({
+      analyzer: "Workflow",
+      severity: "low",
+      message: `BACKLOG.md changelog has been silent for ${daysBetween(lastDate, now)} days while ${entries.length} WP(s) sit in the backlog \u2014 force a review`,
+      fix: "Review priorities: promote, demote, or delete stale WPs, and log the pass in ## Changelog"
+    });
+  }
+  const score = Math.max(0, 100 - issues.length * 15);
+  return { name: "Workflow", issues, score };
+}
+function extractPSections(backlog) {
+  const lines = backlog.split("\n");
+  const out = [];
+  let inP = false;
+  for (const line of lines) {
+    if (/^## P[0-3]/.test(line)) inP = true;
+    else if (/^## /.test(line)) inP = false;
+    if (inP) out.push(line);
+  }
+  return out.join("\n");
+}
+function extractSection(content, heading) {
+  const lines = content.split("\n");
+  const out = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (heading.test(line)) {
+      inSection = true;
+      continue;
+    } else if (/^## /.test(line)) inSection = false;
+    if (inSection) out.push(line);
+  }
+  return out.join("\n");
+}
+function parseWpEntries(section) {
+  const entries = [];
+  const parts = section.split(/^### /m).slice(1);
+  for (const part of parts) {
+    const idMatch = part.match(/^(WP-\d{3,})/);
+    if (idMatch) entries.push({ id: idMatch[1], body: part });
+  }
+  return entries;
+}
+function daysBetween(isoDate, now) {
+  return Math.floor((now.getTime() - new Date(isoDate).getTime()) / 864e5);
+}
+
 // src/commands/doctor/watcher.ts
 import { readdir as readdir2, stat } from "fs/promises";
-import { join as join4 } from "path";
+import { join as join7 } from "path";
 async function watchConfig(projectRoot) {
   await runAndDisplay(projectRoot);
   log.blank();
@@ -1720,16 +1984,16 @@ async function watchConfig(projectRoot) {
 }
 async function getFileSnapshot(projectRoot) {
   const files = [
-    join4(projectRoot, "CLAUDE.md"),
-    join4(projectRoot, ".claudeignore")
+    join7(projectRoot, "CLAUDE.md"),
+    join7(projectRoot, ".claudeignore")
   ];
-  const claudeDir = join4(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(join4(parentPath, entry.name));
+        files.push(join7(parentPath, entry.name));
       }
     }
   } catch {
@@ -1758,9 +2022,9 @@ async function runAndDisplay(projectRoot) {
     analyzeBudget(config),
     analyzeQuality(config, projectRoot),
     analyzeSettings(config),
-    analyzeHooks(config),
+    analyzeHooks(config, projectRoot),
     analyzeRules(config),
-    analyzePermissions(config),
+    analyzePermissions(config, projectRoot),
     analyzeMcp(config)
   ]);
   renderDoctorReport(results);
@@ -1784,19 +2048,7 @@ function createDoctorCommand() {
       log.info("Run `claude-launchpad init` to set up a project, or cd into a configured project.");
       process.exit(1);
     }
-    const results = await Promise.all([
-      analyzeBudget(config),
-      analyzeQuality(config, opts.path),
-      analyzeSettings(config),
-      analyzeHooks(config),
-      analyzeRules(config),
-      analyzePermissions(config),
-      analyzeMcp(config)
-    ]);
-    const memoryResult = await analyzeMemory(config, opts.path);
-    if (memoryResult) {
-      results.push(memoryResult);
-    }
+    const results = await runAnalyzers(config, opts.path);
     if (opts.json) {
       const overallScore2 = Math.round(
         results.reduce((sum, r) => sum + r.score, 0) / results.length
@@ -1835,25 +2087,20 @@ function createDoctorCommand() {
         log.blank();
         log.step("Applying fixes...");
         log.blank();
-        const { fixed } = await applyFixes(fixable, opts.path);
-        log.blank();
-        if (fixed > 0) {
-          log.success(`Applied ${fixed} fix(es). Re-scanning...`);
-          log.blank();
+        let updatedResults = results;
+        let pending = fixable;
+        let totalFixed = 0;
+        for (let pass = 0; pass < 3 && pending.length > 0; pass++) {
+          const { fixed } = await applyFixes(pending, opts.path);
+          totalFixed += fixed;
+          updatedResults = await runAnalyzers(await parseClaudeConfig(opts.path), opts.path);
+          if (fixed === 0) break;
+          pending = updatedResults.flatMap((r) => r.issues).filter((i) => i.severity !== "info");
         }
-        const updatedConfig = await parseClaudeConfig(opts.path);
-        const updatedResults = await Promise.all([
-          analyzeBudget(updatedConfig),
-          analyzeQuality(updatedConfig, opts.path),
-          analyzeSettings(updatedConfig),
-          analyzeHooks(updatedConfig),
-          analyzeRules(updatedConfig),
-          analyzePermissions(updatedConfig),
-          analyzeMcp(updatedConfig)
-        ]);
-        const updatedMemoryResult = await analyzeMemory(updatedConfig, opts.path);
-        if (updatedMemoryResult) {
-          updatedResults.push(updatedMemoryResult);
+        if (totalFixed > 0) {
+          log.blank();
+          log.success(`Applied ${totalFixed} fix(es). Re-scanning...`);
+          log.blank();
         }
         renderDoctorReport(updatedResults, { afterFix: true });
         log.info(`Then use ${chalk.bold("/lp-enhance")} inside Claude Code to have Claude restructure and complete your CLAUDE.md.`);
@@ -1867,6 +2114,22 @@ function createDoctorCommand() {
     }
   });
 }
+async function runAnalyzers(config, path) {
+  const results = await Promise.all([
+    analyzeBudget(config),
+    analyzeQuality(config, path),
+    analyzeSettings(config),
+    analyzeHooks(config, path),
+    analyzeRules(config),
+    analyzePermissions(config, path),
+    analyzeMcp(config)
+  ]);
+  const workflowResult = await analyzeWorkflow(path);
+  if (workflowResult) results.push(workflowResult);
+  const memoryResult = await analyzeMemory(config, path);
+  if (memoryResult) results.push(memoryResult);
+  return results;
+}
 
 // src/commands/eval/index.ts
 import { Command as Command3 } from "commander";
@@ -1874,11 +2137,11 @@ import { select as select2 } from "@inquirer/prompts";
 import ora from "ora";
 import chalk2 from "chalk";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join11 } from "path";
 
 // src/commands/eval/loader.ts
-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 { readFile as readFile5, readdir as readdir3 } from "fs/promises";
+import { join as join8, resolve as resolve3, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import { parse as parseYaml } from "yaml";
 
@@ -1928,15 +2191,27 @@ function validateChecks(raw, filePath) {
       throw new ScenarioError(filePath, `checks[${i}] must be an object`);
     }
     const check = c;
-    const validTypes = ["grep", "file-exists", "file-absent", "max-lines", "custom"];
-    if (!validTypes.includes(check.type)) {
+    const validTypes = ["grep", "file-exists", "file-absent", "max-lines", "custom", "transcript", "judge"];
+    const type = check.type;
+    if (!validTypes.includes(type)) {
       throw new ScenarioError(filePath, `checks[${i}].type must be one of: ${validTypes.join(", ")}`);
     }
-    if (typeof check.target !== "string") {
-      throw new ScenarioError(filePath, `checks[${i}].target must be a string`);
+    const fileBasedTypes = ["grep", "file-exists", "file-absent", "max-lines"];
+    if (fileBasedTypes.includes(type) && typeof check.target !== "string") {
+      throw new ScenarioError(filePath, `checks[${i}].target must be a string for ${type} checks`);
+    }
+    if (type === "custom" && typeof check.script !== "string") {
+      throw new ScenarioError(filePath, `checks[${i}].script must be a string (shell command, exit 0 = pass)`);
+    }
+    if (type === "transcript" && typeof check.pattern !== "string") {
+      throw new ScenarioError(filePath, `checks[${i}].pattern must be a string for transcript checks`);
+    }
+    if (type === "judge" && typeof check.rubric !== "string") {
+      throw new ScenarioError(filePath, `checks[${i}].rubric must be a string for judge checks`);
     }
     const validExpect = ["present", "absent"];
-    if (!validExpect.includes(check.expect)) {
+    const expect = check.expect ?? "present";
+    if (!validExpect.includes(expect)) {
       throw new ScenarioError(filePath, `checks[${i}].expect must be "present" or "absent"`);
     }
     if (typeof check.points !== "number" || check.points < 0) {
@@ -1946,12 +2221,14 @@ function validateChecks(raw, filePath) {
       throw new ScenarioError(filePath, `checks[${i}].label must be a string`);
     }
     return {
-      type: check.type,
+      type,
       pattern: typeof check.pattern === "string" ? check.pattern : void 0,
-      target: check.target,
-      expect: check.expect,
+      target: typeof check.target === "string" ? check.target : void 0,
+      expect,
       points: check.points,
-      label: check.label
+      label: check.label,
+      script: typeof check.script === "string" ? check.script : void 0,
+      rubric: typeof check.rubric === "string" ? check.rubric : void 0
     };
   });
 }
@@ -1983,32 +2260,24 @@ var ScenarioError = class extends Error {
 async function findScenariosDir() {
   const thisDir = dirname2(fileURLToPath(import.meta.url));
   const devPath = resolve3(thisDir, "../../../scenarios");
-  if (await dirExists(devPath)) return devPath;
+  if (await fileExists(devPath)) return devPath;
   const bundledPath = resolve3(thisDir, "../scenarios");
-  if (await dirExists(bundledPath)) return bundledPath;
+  if (await fileExists(bundledPath)) return bundledPath;
   const rootPath = resolve3(thisDir, "../../scenarios");
-  if (await dirExists(rootPath)) return rootPath;
+  if (await fileExists(rootPath)) return rootPath;
   return devPath;
 }
-async function dirExists(path) {
-  try {
-    await access3(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function loadScenarios(options) {
   const { suite, customPath } = options;
   const scenarioDir = customPath ? resolve3(customPath) : await findScenariosDir();
-  const dirs = suite ? [join5(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 readFile4(file, "utf-8");
+        const content = await readFile5(file, "utf-8");
         const raw = parseYaml(content);
         const scenario = validateScenario(raw, file);
         scenarios.push(scenario);
@@ -2023,7 +2292,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) => join5(dir, e.name));
+    return entries.filter((e) => e.isDirectory()).map((e) => join8(dir, e.name));
   } catch {
     return [];
   }
@@ -2031,26 +2300,178 @@ 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) => join5(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 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 { mkdir as mkdir2, writeFile as writeFile2, rm, cp } from "fs/promises";
+import { join as join10, dirname as dirname3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 import { randomUUID } from "crypto";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/commands/eval/checks.ts
+import { readFile as readFile6, readdir as readdir4 } from "fs/promises";
+import { join as join9 } from "path";
+import { tmpdir } from "os";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var exec = promisify(execFile);
+async function evaluateChecks(checks, sandboxDir, context) {
+  const results = [];
+  for (const check of checks) {
+    const passed = await evaluateSingleCheck(check, sandboxDir, context);
+    results.push({ label: check.label, passed, points: check.points });
+  }
+  return results;
+}
+async function evaluateSingleCheck(check, sandboxDir, context) {
+  switch (check.type) {
+    case "grep":
+      return checkGrep(check, sandboxDir);
+    case "file-exists":
+    case "file-absent":
+      return checkFilePresence(check, sandboxDir);
+    case "max-lines":
+      return checkMaxLines(check, sandboxDir);
+    case "custom":
+      return checkCustom(check, sandboxDir);
+    case "transcript":
+      return checkTranscript(check, context.transcript);
+    case "judge":
+      return checkJudge(check, context);
+    default:
+      return false;
+  }
+}
+async function checkGrep(check, sandboxDir) {
+  if (!check.pattern || !check.target) return false;
+  try {
+    const content = await readFile6(join9(sandboxDir, check.target), "utf-8");
+    let found;
+    try {
+      found = new RegExp(check.pattern).test(content);
+    } catch {
+      return false;
+    }
+    return check.expect === "present" ? found : !found;
+  } catch {
+    return check.expect === "absent";
+  }
+}
+async function checkFilePresence(check, sandboxDir) {
+  if (!check.target) return false;
+  try {
+    await readFile6(join9(sandboxDir, check.target));
+    return check.expect === "present";
+  } catch {
+    return check.expect === "absent";
+  }
+}
+async function checkMaxLines(check, sandboxDir) {
+  if (!check.target) return false;
+  const maxLines = parseInt(check.pattern ?? "800", 10);
+  try {
+    const files = await listAllFiles(join9(sandboxDir, check.target));
+    for (const file of files) {
+      const content = await readFile6(file, "utf-8");
+      if (content.split("\n").length > maxLines) {
+        return check.expect === "absent";
+      }
+    }
+    return check.expect === "present";
+  } catch {
+    return check.expect === "absent";
+  }
+}
+async function checkCustom(check, sandboxDir) {
+  if (!check.script) return false;
+  const env = {
+    PATH: process.env.PATH ?? "",
+    HOME: process.env.HOME ?? "",
+    TMPDIR: process.env.TMPDIR ?? ""
+  };
+  try {
+    await exec("bash", ["-c", check.script], { cwd: sandboxDir, timeout: 3e4, env });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkTranscript(check, transcript) {
+  if (!check.pattern) return false;
+  let found;
+  try {
+    found = new RegExp(check.pattern).test(transcript);
+  } catch {
+    return false;
+  }
+  return check.expect === "present" ? found : !found;
+}
+async function checkJudge(check, context) {
+  if (!check.rubric) return false;
+  try {
+    return await context.judge(check.rubric, context.transcript);
+  } catch (err) {
+    log.warnOnce("judge-check-error", `judge check could not run (scoring FAIL): ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}
+var JUDGE_TRANSCRIPT_CHARS = 15e3;
+function makeClaudeJudge(model) {
+  return async (rubric, transcript) => {
+    const prompt = [
+      "You are grading an AI coding session against a rubric.",
+      `Rubric: ${rubric}`,
+      "Session transcript (stream-json, oldest lines truncated):",
+      transcript.slice(-JUDGE_TRANSCRIPT_CHARS),
+      "",
+      "Does the session satisfy the rubric? Reply with exactly one word: PASS or FAIL."
+    ].join("\n");
+    const args = ["-p", prompt, "--output-format", "text", "--max-turns", "1"];
+    if (model) args.push("--model", model);
+    try {
+      const { stdout } = await exec("claude", args, {
+        cwd: tmpdir(),
+        timeout: 6e4,
+        maxBuffer: 1024 * 1024
+      });
+      return /\bPASS\b/.test(stdout) && !/\bFAIL\b/.test(stdout);
+    } catch (err) {
+      log.warnOnce("judge-cli-error", `judge could not invoke the claude CLI (scoring FAIL): ${err instanceof Error ? err.message : String(err)}`);
+      return false;
+    }
+  };
+}
+async function listAllFiles(dir) {
+  const results = [];
+  try {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join9(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await listAllFiles(fullPath));
+      } else {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+
+// src/commands/eval/runner.ts
+var exec2 = promisify2(execFile2);
 async function runScenario(scenario, options) {
-  const sandboxDir = join6(tmpdir(), `claude-eval-${randomUUID()}`);
+  const sandboxDir = join10(tmpdir2(), `claude-eval-${randomUUID()}`);
   try {
     await setupSandbox(sandboxDir, scenario, options.projectRoot);
-    await runClaudeInSandbox(sandboxDir, scenario.prompt, options.timeout, options.model);
-    return await scoreResults(scenario, sandboxDir);
+    const transcript = await runClaudeInSandbox(sandboxDir, scenario.prompt, options.timeout, options.model);
+    return await scoreResults(scenario, sandboxDir, transcript, options.model);
   } finally {
     if (options.debug) {
       console.log(`  DEBUG: Sandbox preserved at ${sandboxDir}`);
@@ -2072,23 +2493,23 @@ async function runScenarioWithRetries(scenario, options) {
 async function setupSandbox(sandboxDir, scenario, projectRoot) {
   await mkdir2(sandboxDir, { recursive: true });
   for (const file of scenario.setup.files) {
-    const filePath = join6(sandboxDir, file.path);
+    const filePath = join10(sandboxDir, file.path);
     await mkdir2(dirname3(filePath), { recursive: true });
     await writeFile2(filePath, file.content);
   }
   await copyProjectConfig(sandboxDir, projectRoot);
   if (scenario.setup.instructions) {
     await writeFile2(
-      join6(sandboxDir, "CLAUDE.md"),
+      join10(sandboxDir, "CLAUDE.md"),
       `# Eval Scenario
 
 ${scenario.setup.instructions}
 `
     );
   }
-  await exec("git", ["init", "-q"], { cwd: sandboxDir });
-  await exec("git", ["add", "-A"], { cwd: sandboxDir });
-  await exec("git", [
+  await exec2("git", ["init", "-q"], { cwd: sandboxDir });
+  await exec2("git", ["add", "-A"], { cwd: sandboxDir });
+  await exec2("git", [
     "-c",
     "user.name=eval",
     "-c",
@@ -2100,20 +2521,20 @@ ${scenario.setup.instructions}
   ], { cwd: sandboxDir });
 }
 async function copyProjectConfig(sandboxDir, projectRoot) {
-  const claudeDir = join6(projectRoot, ".claude");
-  const sandboxClaudeDir = join6(sandboxDir, ".claude");
-  const settingsPath = join6(claudeDir, "settings.json");
+  const claudeDir = join10(projectRoot, ".claude");
+  const sandboxClaudeDir = join10(sandboxDir, ".claude");
+  const settingsPath = join10(claudeDir, "settings.json");
   if (await fileExists(settingsPath)) {
     await mkdir2(sandboxClaudeDir, { recursive: true });
-    await cp(settingsPath, join6(sandboxClaudeDir, "settings.json"));
+    await cp(settingsPath, join10(sandboxClaudeDir, "settings.json"));
   }
-  const rulesDir = join6(claudeDir, "rules");
+  const rulesDir = join10(claudeDir, "rules");
   if (await fileExists(rulesDir)) {
-    await cp(rulesDir, join6(sandboxClaudeDir, "rules"), { recursive: true });
+    await cp(rulesDir, join10(sandboxClaudeDir, "rules"), { recursive: true });
   }
-  const ignorePath = join6(projectRoot, ".claudeignore");
+  const ignorePath = join10(projectRoot, ".claudeignore");
   if (await fileExists(ignorePath)) {
-    await cp(ignorePath, join6(sandboxDir, ".claudeignore"));
+    await cp(ignorePath, join10(sandboxDir, ".claudeignore"));
   }
 }
 async function runClaudeInSandbox(cwd, prompt, timeout, model) {
@@ -2121,25 +2542,31 @@ async function runClaudeInSandbox(cwd, prompt, timeout, model) {
     const sdk = await import("@anthropic-ai/claude-agent-sdk");
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const lines = [];
     try {
-      for await (const _message of sdk.query({
+      for await (const message of sdk.query({
         prompt,
         options: {
           cwd,
           allowedTools: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
           permissionMode: "dontAsk",
-          settingSources: [],
+          // "project" is required or the SDK loads NOTHING from the sandbox —
+          // no CLAUDE.md, no .claude/settings.json hooks. Eval exists to test
+          // that config surface, and transcript checks assert hooks fire.
+          settingSources: ["project"],
           maxTurns: 20,
           abortController: controller,
           ...model ? { model } : {}
         }
       })) {
+        lines.push(JSON.stringify(message));
       }
     } finally {
       clearTimeout(timeoutId);
     }
+    return lines.join("\n");
   } catch {
-    await runClaudeCli(cwd, prompt, timeout, model);
+    return runClaudeCli(cwd, prompt, timeout, model);
   }
 }
 async function runClaudeCli(cwd, prompt, timeout, model) {
@@ -2148,7 +2575,8 @@ async function runClaudeCli(cwd, prompt, timeout, model) {
       "-p",
       prompt,
       "--output-format",
-      "text",
+      "stream-json",
+      "--verbose",
       "--max-turns",
       "20",
       "--dangerously-skip-permissions",
@@ -2161,16 +2589,20 @@ async function runClaudeCli(cwd, prompt, timeout, model) {
       "Grep"
     ];
     if (model) args.push("--model", model);
-    await exec("claude", args, { cwd, timeout, maxBuffer: 10 * 1024 * 1024 });
+    const { stdout } = await exec2("claude", args, { cwd, timeout, maxBuffer: 10 * 1024 * 1024 });
+    return stdout;
   } catch (error) {
     if (error && typeof error === "object" && "stdout" in error) {
-      return;
+      return String(error.stdout ?? "");
     }
     throw error;
   }
 }
-async function scoreResults(scenario, sandboxDir) {
-  const checkResults = await evaluateChecks(scenario.checks, sandboxDir);
+async function scoreResults(scenario, sandboxDir, transcript, model) {
+  const checkResults = await evaluateChecks(scenario.checks, sandboxDir, {
+    transcript,
+    judge: makeClaudeJudge(model)
+  });
   const score = checkResults.filter((c) => c.passed).reduce((sum, c) => sum + c.points, 0);
   const maxScore = scenario.checks.reduce((sum, c) => sum + c.points, 0);
   return {
@@ -2181,83 +2613,6 @@ async function scoreResults(scenario, sandboxDir) {
     checks: checkResults
   };
 }
-async function evaluateChecks(checks, sandboxDir) {
-  const results = [];
-  for (const check of checks) {
-    const passed = await evaluateSingleCheck(check, sandboxDir);
-    results.push({ label: check.label, passed, points: check.points });
-  }
-  return results;
-}
-async function evaluateSingleCheck(check, sandboxDir) {
-  switch (check.type) {
-    case "grep":
-      return checkGrep(check, sandboxDir);
-    case "file-exists":
-    case "file-absent":
-      return checkFilePresence(check, sandboxDir);
-    case "max-lines":
-      return checkMaxLines(check, sandboxDir);
-    case "custom":
-      return false;
-    default:
-      return false;
-  }
-}
-async function checkGrep(check, sandboxDir) {
-  if (!check.pattern) return false;
-  try {
-    const content = await readFile5(join6(sandboxDir, check.target), "utf-8");
-    let found;
-    try {
-      found = new RegExp(check.pattern).test(content);
-    } catch {
-      return false;
-    }
-    return check.expect === "present" ? found : !found;
-  } catch {
-    return check.expect === "absent";
-  }
-}
-async function checkFilePresence(check, sandboxDir) {
-  try {
-    await readFile5(join6(sandboxDir, check.target));
-    return check.expect === "present";
-  } catch {
-    return check.expect === "absent";
-  }
-}
-async function checkMaxLines(check, sandboxDir) {
-  const maxLines = parseInt(check.pattern ?? "800", 10);
-  try {
-    const files = await listAllFiles(join6(sandboxDir, check.target));
-    for (const file of files) {
-      const content = await readFile5(file, "utf-8");
-      if (content.split("\n").length > maxLines) {
-        return check.expect === "absent";
-      }
-    }
-    return check.expect === "present";
-  } catch {
-    return check.expect === "absent";
-  }
-}
-async function listAllFiles(dir) {
-  const results = [];
-  try {
-    const entries = await readdir4(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join6(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...await listAllFiles(fullPath));
-      } else {
-        results.push(fullPath);
-      }
-    }
-  } catch {
-  }
-  return results;
-}
 
 // src/commands/eval/index.ts
 function createEvalCommand() {
@@ -2268,10 +2623,10 @@ function createEvalCommand() {
       opts.suite = await select2({
         message: "Suite",
         choices: [
-          { name: "security (6 scenarios)", value: "security" },
+          { name: "security (7 scenarios)", value: "security" },
           { name: "conventions (5 scenarios)", value: "conventions" },
           { name: "workflow (4 scenarios)", value: "workflow" },
-          { name: "all (15 scenarios)", value: void 0 }
+          { name: "all (16 scenarios)", value: void 0 }
         ]
       });
       opts.runs = await select2({
@@ -2433,18 +2788,18 @@ async function saveEvalReport(results, projectRoot, suite, model) {
       lines.push("");
     }
   }
-  const evalDir = join7(projectRoot, ".claude", "eval");
+  const evalDir = join11(projectRoot, ".claude", "eval");
   await mkdir3(evalDir, { recursive: true });
   const filename = `eval-${suite ?? "all"}-${timestamp}.md`;
-  await writeFile3(join7(evalDir, filename), lines.join("\n"));
+  await writeFile3(join11(evalDir, filename), lines.join("\n"));
   log.success(`Report saved to .claude/eval/${filename}`);
 }
 async function checkClaudeCli() {
-  const { execFile: execFile2 } = await import("child_process");
-  const { promisify: promisify2 } = await import("util");
-  const exec2 = promisify2(execFile2);
+  const { execFile: execFile3 } = await import("child_process");
+  const { promisify: promisify3 } = await import("util");
+  const exec3 = promisify3(execFile3);
   try {
-    await exec2("claude", ["--version"]);
+    await exec3("claude", ["--version"]);
     return true;
   } catch {
     return false;
@@ -2452,9 +2807,8 @@ async function checkClaudeCli() {
 }
 
 // src/commands/memory/index.ts
-import { readFileSync } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir3 } from "os";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join12 } from "path";
 import { Command as Command4 } from "commander";
 import { confirm as confirm2 } from "@inquirer/prompts";
 async function handleSyncErrors(fn) {
@@ -2467,38 +2821,13 @@ async function handleSyncErrors(fn) {
 }
 function isMemoryInstalled() {
   const cwd = process.cwd();
-  const hookPresent = hasMemoryHook(join8(cwd, ".claude", "settings.json")) || hasMemoryHook(join8(cwd, ".claude", "settings.local.json"));
+  const hookPresent = hasMemoryHook(join12(cwd, ".claude", "settings.json")) || hasMemoryHook(join12(cwd, ".claude", "settings.local.json"));
   if (!hookPresent) return false;
   return isMemoryMcpRegistered(cwd);
 }
-function isMemoryMcpRegistered(projectRoot) {
-  return hasMemoryServerInJson(join8(projectRoot, ".mcp.json"), "mcpServers") || hasMemoryServerInJson(join8(projectRoot, ".claude", "settings.local.json"), "mcpServers") || hasMemoryServerInUserConfig(projectRoot);
-}
-function hasMemoryServerInJson(path, key) {
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf-8"));
-    const servers = parsed[key];
-    return !!servers && typeof servers === "object" && "agentic-memory" in servers;
-  } catch {
-    return false;
-  }
-}
-function hasMemoryServerInUserConfig(projectRoot) {
-  try {
-    const parsed = JSON.parse(readFileSync(join8(homedir3(), ".claude.json"), "utf-8"));
-    const projects = parsed.projects;
-    const project = projects?.[projectRoot];
-    const scoped = project?.mcpServers;
-    if (scoped && "agentic-memory" in scoped) return true;
-    const global = parsed.mcpServers;
-    return !!global && "agentic-memory" in global;
-  } catch {
-    return false;
-  }
-}
 function hasMemoryHook(path) {
   try {
-    const settings = JSON.parse(readFileSync(path, "utf-8"));
+    const settings = JSON.parse(readFileSync2(path, "utf-8"));
     const hooks = settings.hooks;
     if (!hooks) return false;
     const sessionStart = hooks.SessionStart;
@@ -2517,14 +2846,14 @@ function createMemoryCommand() {
         log.error("Knowledge base not set up yet. Run `claude-launchpad memory` first.");
         return;
       }
-      const { requireMemoryDeps } = await import("./require-deps-H4SHQWD2.js");
+      const { requireMemoryDeps } = await import("./require-deps-ZISUZLYD.js");
       await requireMemoryDeps();
-      const { startTui } = await import("./tui-XXYVOGJL.js");
+      const { startTui } = await import("./tui-2UJ2OIHB.js");
       await startTui();
       return;
     }
     if (!isMemoryInstalled()) {
-      const { detectExistingSetup } = await import("./install-5XZFLN3C.js");
+      const { detectExistingSetup } = await import("./install-Q23F37GK.js");
       const existing = detectExistingSetup(process.cwd());
       const mcpMissing = existing !== null && !isMemoryMcpRegistered(process.cwd());
       if (existing) {
@@ -2551,24 +2880,29 @@ function createMemoryCommand() {
         log.info("Skipped.");
         return;
       }
-      const { runInstall } = await import("./install-5XZFLN3C.js");
+      const { runInstall } = await import("./install-Q23F37GK.js");
       await runInstall({});
     } else {
-      const { requireMemoryDeps } = await import("./require-deps-H4SHQWD2.js");
+      const { requireMemoryDeps } = await import("./require-deps-ZISUZLYD.js");
       await requireMemoryDeps();
-      const { runStats } = await import("./stats-YGK6PZ3A.js");
+      const { runStats } = await import("./stats-SV53G6PQ.js");
       await runStats({});
     }
   });
   memory.addCommand(
-    new Command4("install").description("Install (or re-install) the knowledge base for this project").option("--db-path <path>", "Override the default data directory").action(async (opts) => {
-      const { runInstall } = await import("./install-5XZFLN3C.js");
-      await runInstall(opts.dbPath ? { dbPath: opts.dbPath } : {});
+    new Command4("install").description("Install (or re-install) the knowledge base for this project").option("--db-path <path>", "Override the default data directory").option("-y, --yes", "Non-interactive: accept defaults (shared placement)").action(async (opts) => {
+      try {
+        const { runInstall } = await import("./install-Q23F37GK.js");
+        await runInstall({ ...opts.dbPath ? { dbPath: opts.dbPath } : {}, yes: opts.yes === true });
+      } catch (err) {
+        log.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+      }
     })
   );
   memory.addCommand(
     new Command4("context").description("Load session context (hook handler)").option("--json", "JSON output").action(async (opts) => {
-      const { runContext } = await import("./context-QLQLJOR2.js");
+      const { runContext } = await import("./context-JALSYDYO.js");
       await runContext(opts);
     }).helpCommand(false),
     { hidden: true }
@@ -2583,7 +2917,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-FMAHNK4U.js");
+        const { runPush } = await import("./push-QSBK7BQU.js");
         await runPush(opts);
       });
     })
@@ -2591,16 +2925,21 @@ 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-46YFKQ6S.js");
+        const { runPull } = await import("./pull-FYKNNLYC.js");
         await runPull(opts);
       });
     })
   );
-  const sync = new Command4("sync").description("Manage memory sync");
+  const sync = new Command4("sync").description("Sync memories with the gist (pull + push); subcommands manage sync state").option("--all", "Sync all projects").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {
+    await handleSyncErrors(async () => {
+      const { runSync } = await import("./sync-2LDM44U4.js");
+      await runSync(opts);
+    });
+  });
   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-KZSPPHPY.js");
+        const { runSyncStatus } = await import("./sync-status-V6WTI32X.js");
         await runSyncStatus();
       });
     })
@@ -2608,7 +2947,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-PCR3QCZK.js");
+        const { runSyncClean } = await import("./sync-clean-HQ523N7V.js");
         await runSyncClean(project, opts);
       });
     })
@@ -2618,8 +2957,8 @@ function createMemoryCommand() {
 }
 
 // src/cli.ts
-var program = new Command5().name("claude-launchpad").description("Score your Claude Code config, fix the gaps, prove Claude follows your rules.").version("1.10.0", "-v, --version").action(async () => {
-  const hasConfig = await fileExists(join9(process.cwd(), "CLAUDE.md")) || await fileExists(join9(process.cwd(), ".claude", "settings.json"));
+var program = new Command5().name("claude-launchpad").description("Score your Claude Code config, fix the gaps, prove Claude follows your rules.").version("1.12.0", "-v, --version").action(async () => {
+  const hasConfig = await fileExists(join13(process.cwd(), "CLAUDE.md")) || await fileExists(join13(process.cwd(), ".claude", "settings.json"));
   if (hasConfig) {
     await program.commands.find((c) => c.name() === "doctor")?.parseAsync([], { from: "user" });
   } else {