claude-launchpad 1.10.1 → 1.14.0

package/dist/cli.js

@@ -1,15 +1,24 @@
 #!/usr/bin/env node
 import {
   readSyncConfig
-} from "./chunk-6DQD6KVN.js";
+} from "./chunk-M6GVFN67.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,
+  VERIFICATION_RULE_VERSION,
+  WORKFLOW_CHECK_WRAPPER,
+  WORKFLOW_RULE_VERSION,
   applyFixes,
   detectProject,
   fileExists,
@@ -17,31 +26,35 @@ import {
   generateClaudeignore,
   generateEnhanceSkill,
   generateHooksRule,
+  generateReviewerAgent,
+  generateVerificationRule,
   generateWorkflowRule,
   hasEnvVarHookPattern,
+  isJqAvailable,
   jqField,
   log,
   printBanner,
   printScoreCard,
   readFileOrNull,
   renderDoctorReport,
+  sprintReviewsContent,
   writeSprintHygieneScripts,
   writeWorkflowCheckScript
-} from "./chunk-3OFOCOXM.js";
+} from "./chunk-QEPE3WVF.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) {
@@ -74,12 +87,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
@@ -139,56 +147,41 @@ function generateSettings(detected) {
       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: `fp=${jqField("file_path")}; echo "$fp" | 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: {
@@ -228,26 +221,53 @@ function buildFormatHook(detected) {
   if (!config) return null;
   const extChecks = config.extensions.map((ext) => `[ "$ext" = "${ext}" ]`).join(" || ");
   return {
-    matcher: "Write|Edit",
-    hooks: [{
-      type: "command",
-      command: `fp=${jqField("file_path")}; ext="\${fp##*.}"; (${extChecks}) && ${config.command} "$fp" 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) => {
+  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) => {
     printBanner();
     const root = process.cwd();
     log.step("Detecting project...");
     const detected = await detectProject(root);
     if (detected.language) {
       log.success(`Found ${detected.framework ?? detected.language} project`);
-      if (detected.packageManager) log.info(`Package manager: ${detected.packageManager}`);
-      if (detected.devCommand) log.info(`Dev command: ${detected.devCommand}`);
-      if (detected.testCommand) log.info(`Test command: ${detected.testCommand}`);
+      if (detected.packageManager)
+        log.info(`Package manager: ${detected.packageManager}`);
+      if (detected.devCommand)
+        log.info(`Dev command: ${detected.devCommand}`);
+      if (detected.testCommand)
+        log.info(`Test command: ${detected.testCommand}`);
     } else {
       log.warn("Could not detect project type \u2014 generating minimal config");
     }
@@ -259,13 +279,18 @@ function createInitCommand() {
     const description = opts.yes ? "" : await input({
       message: "One-line description (optional):"
     });
-    const options = { name: name.trim(), description: description.trim() };
-    const hasClaudeMd = await fileExists(join(root, "CLAUDE.md"));
+    const options = {
+      name: name.trim(),
+      description: description.trim()
+    };
+    const hasClaudeMd = await fileExists(join2(root, "CLAUDE.md"));
     if (hasClaudeMd) {
       if (opts.force) {
         log.warn("Overwriting existing CLAUDE.md (--force)");
       } else if (opts.yes) {
-        log.error("CLAUDE.md already exists. `--yes` will not overwrite existing files.");
+        log.error(
+          "CLAUDE.md already exists. `--yes` will not overwrite existing files."
+        );
         log.info("Run `claude-launchpad doctor --fix` to update in place,");
         log.info("or re-run with `--force` to overwrite.");
         process.exitCode = 1;
@@ -278,7 +303,9 @@ function createInitCommand() {
         if (!overwrite) {
           log.info("Keeping existing CLAUDE.md");
           await createEnhanceSkillPrompt(root, false);
-          log.step("Tip: run `claude-launchpad doctor` to check your existing config");
+          log.step(
+            "Tip: run `claude-launchpad doctor` to check your existing config"
+          );
           return;
         }
       }
@@ -288,29 +315,41 @@ 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");
-  const mergedSettings = await mergeSettings(settingsPath, settings);
-  const backlogPath = join(root, "BACKLOG.md");
+  await mkdir(join2(root, ".claude", "rules"), { recursive: true });
+  const settingsPath = join2(root, ".claude", "settings.json");
+  const mergedSettings = await mergeSettings(
+    settingsPath,
+    settings
+  );
+  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 = join(root, ".claude", "rules", "hooks.md");
+  const hooksRulePath = join2(root, ".claude", "rules", "hooks.md");
   const hasHooksRule = await fileExists(hooksRulePath);
+  const verificationRulePath = join2(
+    root,
+    ".claude",
+    "rules",
+    "verification.md"
+  );
+  const hasVerificationRule = await fileExists(verificationRulePath);
   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) {
@@ -320,16 +359,21 @@ async function scaffold(root, options, detected, skipPrompts) {
     writes.push(writeFile(claudeignorePath, claudeignore));
   }
   if (!hasClaudeGitignore) {
-    writes.push(writeFile(claudeGitignorePath, [
-      "# Local-only Claude Code files (never commit these)",
-      "CLAUDE.md",
-      "settings.local.json",
-      "plans/",
-      "memory/",
-      "sessions/",
-      "tmp/",
-      ""
-    ].join("\n")));
+    writes.push(
+      writeFile(
+        claudeGitignorePath,
+        [
+          "# Local-only Claude Code files (never commit these)",
+          "CLAUDE.md",
+          "settings.local.json",
+          "plans/",
+          "memory/",
+          "sessions/",
+          "tmp/",
+          ""
+        ].join("\n")
+      )
+    );
   }
   if (!hasRules) {
     const rulesContent = generateStarterRules(detected);
@@ -341,23 +385,60 @@ async function scaffold(root, options, detected, skipPrompts) {
   if (!hasHooksRule) {
     writes.push(writeFile(hooksRulePath, generateHooksRule()));
   }
+  if (!hasVerificationRule) {
+    writes.push(writeFile(verificationRulePath, generateVerificationRule()));
+  }
+  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)");
   if (!hasClaudeGitignore) log.success("Generated .claude/.gitignore");
   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");
+  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)"
+    );
+  if (!hasVerificationRule)
+    log.success(
+      "Generated .claude/rules/verification.md (evidence-before-assertion discipline)"
+    );
+  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(
+    "Use `/lp-enhance` inside Claude Code to have AI complete your CLAUDE.md."
+  );
   log.info("Run `claude-launchpad doctor` to check your config quality.");
   log.blank();
 }
@@ -386,16 +467,35 @@ 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");
-  if (await fileExists(projectPath) || await fileExists(globalPath) || await fileExists(legacyProject) || await fileExists(legacyGlobal)) return;
+  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):",
     choices: [
@@ -405,14 +505,16 @@ 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) {
   try {
-    const existing = JSON.parse(await readFile(existingPath, "utf-8"));
+    const existing = JSON.parse(
+      await readFile(existingPath, "utf-8")
+    );
     const existingHooks = existing.hooks ?? {};
     const generatedHooks = generated.hooks ?? {};
     const mergedHooks = { ...existingHooks };
@@ -437,7 +539,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";
@@ -445,26 +547,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,
@@ -472,23 +574,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");
@@ -507,7 +609,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 {
@@ -519,8 +621,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];
 }
@@ -566,14 +668,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 = [];
@@ -630,8 +732,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")
@@ -647,7 +749,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);
@@ -740,12 +842,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) {
@@ -780,7 +882,7 @@ 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) {
@@ -835,13 +937,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");
@@ -868,7 +992,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"))) {
@@ -888,18 +1012,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",
@@ -908,7 +1071,9 @@ 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",
@@ -917,7 +1082,43 @@ async function analyzeRules(config) {
       fix: "Run `doctor --fix` to generate it"
     });
   }
-  const hasHooksRule = await fileExists(join3(projectRoot, ".claude", "rules", "hooks.md"));
+  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",
@@ -926,7 +1127,34 @@ async function analyzeRules(config) {
       fix: "Run `doctor --fix` to generate it"
     });
   }
-  const hasClaudeignore = await fileExists(join3(projectRoot, ".claudeignore"));
+  const verificationPath = join4(
+    projectRoot,
+    ".claude",
+    "rules",
+    "verification.md"
+  );
+  const hasVerificationRule = await fileExists(verificationPath);
+  if (!hasVerificationRule) {
+    issues.push({
+      analyzer: "Rules",
+      severity: "medium",
+      message: "No .claude/rules/verification.md found \u2014 nothing stops premature 'done' claims without evidence",
+      fix: "Run `doctor --fix` to generate it"
+    });
+  } else {
+    const vContent = await readFile2(verificationPath, "utf-8").catch(() => "");
+    const vMatch = vContent.match(/<!-- lp-verification-version: (\d+) -->/);
+    const vVersion = vMatch ? parseInt(vMatch[1], 10) : null;
+    if (vVersion !== null && vVersion < VERIFICATION_RULE_VERSION) {
+      issues.push({
+        analyzer: "Rules",
+        severity: "low",
+        message: `verification.md rule is outdated (v${vVersion}, latest v${VERIFICATION_RULE_VERSION})`,
+        fix: "Run `doctor --fix` to update it"
+      });
+    }
+  }
+  const hasClaudeignore = await fileExists(join4(projectRoot, ".claudeignore"));
   if (!hasClaudeignore) {
     issues.push({
       analyzer: "Rules",
@@ -938,7 +1166,9 @@ 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",
@@ -1012,13 +1242,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 {
@@ -1033,13 +1264,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) {
@@ -1050,8 +1312,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",
@@ -1068,12 +1330,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"));
@@ -1089,23 +1352,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({
@@ -1115,17 +1363,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) => {
@@ -1144,6 +1381,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";
@@ -1397,6 +1639,17 @@ async function analyzeMemory(config, projectRoot) {
       fix: "Run `doctor --fix` to add agentic-memory to allowedMcpServers"
     });
   }
+  const hasBareBinaryHook = config.hooks.some(
+    (h) => h.command?.includes("claude-launchpad memory") && !h.command.includes("npx claude-launchpad")
+  );
+  if (hasBareBinaryHook) {
+    issues.push({
+      analyzer: "Memory",
+      severity: "medium",
+      message: "Memory hook(s) call the bare claude-launchpad binary \u2014 fails silently on machines without a global install",
+      fix: "Run `doctor --fix` to rewrite them to the npx form"
+    });
+  }
   const syncConfig = readSyncConfig();
   if (syncConfig) {
     const hasSessionStartPull = config.hooks.some(
@@ -1706,6 +1959,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) {
@@ -1724,9 +1985,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();
@@ -1749,16 +2104,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 {
@@ -1787,9 +2142,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);
@@ -1813,19 +2168,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
@@ -1864,25 +2207,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.`);
@@ -1896,6 +2234,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";
@@ -1903,11 +2257,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";
 
@@ -1957,15 +2311,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) {
@@ -1975,12 +2341,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
     };
   });
 }
@@ -2012,32 +2380,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);
@@ -2052,7 +2412,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 [];
   }
@@ -2060,26 +2420,182 @@ 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 [];
   }
 }
+function resolveRuns(scenarioRuns, cliRuns, userChoseRuns) {
+  if (userChoseRuns) return cliRuns;
+  return scenarioRuns ?? cliRuns;
+}
 
 // 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}`);
@@ -2101,23 +2617,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",
@@ -2129,20 +2645,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) {
@@ -2150,25 +2666,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) {
@@ -2177,7 +2699,8 @@ async function runClaudeCli(cwd, prompt, timeout, model) {
       "-p",
       prompt,
       "--output-format",
-      "text",
+      "stream-json",
+      "--verbose",
       "--max-turns",
       "20",
       "--dangerously-skip-permissions",
@@ -2190,16 +2713,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 {
@@ -2210,97 +2737,31 @@ 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() {
-  return new Command3("eval").description("Test your Claude Code config against eval scenarios").option("-s, --suite <suite>", "Eval suite to run (e.g., security, conventions, workflow)").option("-p, --path <path>", "Project root path", process.cwd()).option("--scenarios <path>", "Custom scenarios directory").option("--runs <n>", "Runs per scenario (default: 3)", "3").option("--timeout <ms>", "Timeout per run in ms (default: 120000)", "120000").option("--json", "Output as JSON").option("--debug", "Keep sandbox directories for inspection").option("--model <model>", "Model to use for eval (e.g., sonnet, haiku, opus)").action(async (opts) => {
+  return new Command3("eval").description("Test your Claude Code config against eval scenarios").option(
+    "-s, --suite <suite>",
+    "Eval suite to run (e.g., security, conventions, workflow)"
+  ).option("-p, --path <path>", "Project root path", process.cwd()).option("--scenarios <path>", "Custom scenarios directory").option("--runs <n>", "Runs per scenario (default: 3)", "3").option(
+    "--timeout <ms>",
+    "Timeout per run in ms (default: 120000)",
+    "120000"
+  ).option("--json", "Output as JSON").option("--debug", "Keep sandbox directories for inspection").option(
+    "--model <model>",
+    "Model to use for eval (e.g., sonnet, haiku, opus)"
+  ).action(async (opts, command) => {
     printBanner();
+    let userChoseRuns = command.getOptionValueSource("runs") === "cli";
     const hasFlags = opts.suite || opts.model || opts.runs !== "3" || opts.timeout !== "120000" || opts.path !== process.cwd() || Boolean(opts.scenarios) || opts.json || opts.debug;
     if (!hasFlags) {
       opts.suite = await 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: "workflow (5 scenarios)", value: "workflow" },
+          { name: "all (17 scenarios)", value: void 0 }
         ]
       });
       opts.runs = await select2({
@@ -2311,6 +2772,7 @@ function createEvalCommand() {
           { name: "5 \u2014 thorough", value: "5" }
         ]
       });
+      userChoseRuns = true;
       opts.model = await select2({
         message: "Model",
         choices: [
@@ -2323,8 +2785,12 @@ function createEvalCommand() {
     }
     const claudeAvailable = await checkClaudeCli();
     if (!claudeAvailable) {
-      log.error("Claude CLI not found. Install it: https://docs.anthropic.com/en/docs/claude-code");
-      log.info("The eval command runs Claude headless against scenarios \u2014 it requires the CLI.");
+      log.error(
+        "Claude CLI not found. Install it: https://docs.anthropic.com/en/docs/claude-code"
+      );
+      log.info(
+        "The eval command runs Claude headless against scenarios \u2014 it requires the CLI."
+      );
       process.exit(1);
     }
     log.step("Loading eval scenarios...");
@@ -2335,7 +2801,9 @@ function createEvalCommand() {
     if (scenarios.length === 0) {
       log.warn("No matching scenarios found.");
       if (opts.suite) {
-        log.info(`Check that the suite "${opts.suite}" exists in the scenarios directory.`);
+        log.info(
+          `Check that the suite "${opts.suite}" exists in the scenarios directory.`
+        );
       }
       return;
     }
@@ -2344,10 +2812,11 @@ function createEvalCommand() {
       log.info(`Model: ${opts.model}`);
     }
     log.blank();
-    const runs = parseInt(opts.runs, 10);
+    const cliRuns = parseInt(opts.runs, 10);
     const timeout = parseInt(opts.timeout, 10);
     const results = [];
     for (const scenario of scenarios) {
+      const runs = resolveRuns(scenario.runs, cliRuns, userChoseRuns);
       const spinner = ora({
         text: `Running: ${scenario.name} (${runs} run${runs > 1 ? "s" : ""})`,
         prefixText: "  "
@@ -2355,13 +2824,22 @@ function createEvalCommand() {
       try {
         const result = await runScenarioWithRetries(
           { ...scenario, runs },
-          { projectRoot: opts.path, timeout, debug: opts.debug, model: opts.model }
+          {
+            projectRoot: opts.path,
+            timeout,
+            debug: opts.debug,
+            model: opts.model
+          }
         );
         results.push(result);
         if (result.passed) {
-          spinner.succeed(`${scenario.name}  ${result.score}/${result.maxScore}`);
+          spinner.succeed(
+            `${scenario.name}  ${result.score}/${result.maxScore}`
+          );
         } else {
-          spinner.fail(`${scenario.name}  ${result.score}/${result.maxScore}`);
+          spinner.fail(
+            `${scenario.name}  ${result.score}/${result.maxScore}`
+          );
         }
       } catch (error) {
         spinner.fail(`${scenario.name}  ERROR`);
@@ -2372,7 +2850,11 @@ function createEvalCommand() {
           score: 0,
           maxScore: scenario.checks.reduce((s, c) => s + c.points, 0),
           passed: false,
-          checks: scenario.checks.map((c) => ({ label: c.label, passed: false, points: c.points }))
+          checks: scenario.checks.map((c) => ({
+            label: c.label,
+            passed: false,
+            points: c.points
+          }))
         });
       }
     }
@@ -2380,13 +2862,19 @@ function createEvalCommand() {
     if (opts.json) {
       const overallScore = results.reduce((s, r) => s + r.score, 0);
       const overallMax = results.reduce((s, r) => s + r.maxScore, 0);
-      console.log(JSON.stringify({
-        results,
-        overallScore,
-        overallMax,
-        passed: overallScore >= overallMax * 0.8,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }, null, 2));
+      console.log(
+        JSON.stringify(
+          {
+            results,
+            overallScore,
+            overallMax,
+            passed: overallScore >= overallMax * 0.8,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          null,
+          2
+        )
+      );
       return;
     }
     renderEvalReport(results);
@@ -2398,7 +2886,9 @@ function renderEvalReport(results) {
     const icon = result.passed ? chalk2.green("\u2713") : chalk2.red("\u2717");
     const status = result.passed ? chalk2.green("PASS") : chalk2.red("FAIL");
     const score = `${result.score}/${result.maxScore}`;
-    console.log(`  ${icon} ${chalk2.bold(result.scenario)}  ${score}  ${status}`);
+    console.log(
+      `  ${icon} ${chalk2.bold(result.scenario)}  ${score}  ${status}`
+    );
     const failedChecks = result.checks.filter((c) => !c.passed);
     for (const check of failedChecks) {
       console.log(`    ${chalk2.red("\u2717")} ${chalk2.dim(check.label)}`);
@@ -2415,7 +2905,9 @@ function renderEvalReport(results) {
   if (failed === 0) {
     log.success(`All ${passed} scenario(s) passed.`);
   } else {
-    log.warn(`${passed} passed, ${failed} failed out of ${results.length} scenario(s).`);
+    log.warn(
+      `${passed} passed, ${failed} failed out of ${results.length} scenario(s).`
+    );
   }
 }
 async function saveEvalReport(results, projectRoot, suite, model) {
@@ -2439,7 +2931,9 @@ async function saveEvalReport(results, projectRoot, suite, model) {
   ];
   for (const result of results) {
     const status = result.passed ? "PASS" : "FAIL";
-    lines.push(`### ${result.scenario} \u2014 ${result.score}/${result.maxScore} ${status}`);
+    lines.push(
+      `### ${result.scenario} \u2014 ${result.score}/${result.maxScore} ${status}`
+    );
     const failedChecks = result.checks.filter((c) => !c.passed);
     const passedChecks = result.checks.filter((c) => c.passed);
     for (const check of passedChecks) {
@@ -2457,23 +2951,25 @@ async function saveEvalReport(results, projectRoot, suite, model) {
       lines.push(`### Fix: ${result.scenario}`);
       const failedChecks = result.checks.filter((c) => !c.passed);
       for (const check of failedChecks) {
-        lines.push(`- ${check.label} \u2014 update CLAUDE.md instructions or add hooks to enforce this behavior`);
+        lines.push(
+          `- ${check.label} \u2014 update CLAUDE.md instructions or add hooks to enforce this behavior`
+        );
       }
       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;
@@ -2481,9 +2977,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) {
@@ -2496,80 +2991,78 @@ 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;
     return sessionStart?.some((h) => {
       const inner = h.hooks;
-      return inner?.some((ih) => String(ih.command ?? "").includes("memory context"));
+      return inner?.some(
+        (ih) => String(ih.command ?? "").includes("memory context")
+      );
     }) ?? false;
   } catch {
     return false;
   }
 }
 function createMemoryCommand() {
-  const memory = new Command4("memory").description("Project-scoped memory with decay, sync, and a TUI dashboard").option("--dashboard", "Open the memory dashboard").action(async (opts) => {
+  const memory = new Command4("memory").description("Project-scoped memory with decay, sync, and a TUI dashboard").showHelpAfterError(
+    "(see `claude-launchpad memory --help` for the available subcommands)"
+  ).showSuggestionAfterError(true).option("--dashboard", "Open the memory dashboard").action(async (opts) => {
     if (opts.dashboard) {
       if (!isMemoryInstalled()) {
-        log.error("Knowledge base not set up yet. Run `claude-launchpad memory` first.");
+        log.error(
+          "Knowledge base not set up yet. Run `claude-launchpad memory` first."
+        );
         return;
       }
-      const { requireMemoryDeps } = await import("./require-deps-XUAKG226.js");
+      const { requireMemoryDeps } = await import("./require-deps-WDMHDGBN.js");
       await requireMemoryDeps();
-      const { startTui } = await import("./tui-GGUFB6WP.js");
+      const { startTui } = await import("./tui-HVJNLRY2.js");
       await startTui();
       return;
     }
     if (!isMemoryInstalled()) {
-      const { detectExistingSetup } = await import("./install-B5KISSFR.js");
+      if (!process.stdin.isTTY) {
+        log.error(
+          "Knowledge base not set up and no TTY to prompt. Run `claude-launchpad memory install -y`."
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const { detectExistingSetup } = await import("./install-D32PV7SF.js");
       const existing = detectExistingSetup(process.cwd());
       const mcpMissing = existing !== null && !isMemoryMcpRegistered(process.cwd());
       if (existing) {
         const location = existing === "local" ? ".claude/CLAUDE.md + settings.local.json" : "CLAUDE.md + settings.json";
         log.blank();
-        log.success(`Memory config found (${location}) but ${mcpMissing ? "MCP server not registered" : "database not set up"}.`);
+        log.success(
+          `Memory config found (${location}) but ${mcpMissing ? "MCP server not registered" : "database not set up"}.`
+        );
         log.info("Run `claude-launchpad memory install` to complete setup.");
         log.blank();
       } else {
         log.blank();
-        log.step("Claude doesn't have a knowledge base for this project yet.");
+        log.step(
+          "Claude doesn't have a knowledge base for this project yet."
+        );
         log.blank();
         log.info("After setup, Claude will:");
-        log.info("  - Remember decisions, gotchas, and learnings across sessions");
-        log.info("  - Automatically recall relevant context when you start a session");
-        log.info("  - Save important facts as you work, so nothing gets lost");
+        log.info(
+          "  - Remember decisions, gotchas, and learnings across sessions"
+        );
+        log.info(
+          "  - Automatically recall relevant context when you start a session"
+        );
+        log.info(
+          "  - Save important facts as you work, so nothing gets lost"
+        );
         log.blank();
       }
       const proceed = await confirm2({
@@ -2580,24 +3073,51 @@ function createMemoryCommand() {
         log.info("Skipped.");
         return;
       }
-      const { runInstall } = await import("./install-B5KISSFR.js");
+      const { runInstall } = await import("./install-D32PV7SF.js");
       await runInstall({});
     } else {
-      const { requireMemoryDeps } = await import("./require-deps-XUAKG226.js");
+      const { requireMemoryDeps } = await import("./require-deps-WDMHDGBN.js");
       await requireMemoryDeps();
-      const { runStats } = await import("./stats-ARO5UFFZ.js");
+      const { runStats } = await import("./stats-77BYLKYP.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-B5KISSFR.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-D32PV7SF.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("stats").description("Show memory counts, health, and injection stats").option("--json", "JSON output").action(async (opts) => {
+      const { requireMemoryDeps } = await import("./require-deps-WDMHDGBN.js");
+      await requireMemoryDeps();
+      const { runStats } = await import("./stats-77BYLKYP.js");
+      await runStats(opts);
+    })
+  );
+  memory.addCommand(
+    new Command4("doctor").description("Diagnose the memory setup (DB, hooks, MCP registration)").option("--json", "JSON output").action(async (opts) => {
+      const { runMemoryDoctor } = await import("./doctor-DCHFJ3XV.js");
+      await runMemoryDoctor(opts);
     })
   );
   memory.addCommand(
     new Command4("context").description("Load session context (hook handler)").option("--json", "JSON output").action(async (opts) => {
-      const { runContext } = await import("./context-76QJSCRJ.js");
+      const { runContext } = await import("./context-YIPO4LBS.js");
       await runContext(opts);
     }).helpCommand(false),
     { hidden: true }
@@ -2612,24 +3132,34 @@ 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-C3QMIEUQ.js");
+        const { runPush } = await import("./push-U4IVTFOU.js");
         await runPush(opts);
       });
     })
   );
   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) => {
+    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-4ZQSKFX7.js");
+        const { runPull } = await import("./pull-YUQTDRUP.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-DTCWK2CY.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-VZGZCZA3.js");
+        const { runSyncStatus } = await import("./sync-status-2V2RCYZO.js");
         await runSyncStatus();
       });
     })
@@ -2637,7 +3167,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-UHR2I27F.js");
+        const { runSyncClean } = await import("./sync-clean-ACZCB3NZ.js");
         await runSyncClean(project, opts);
       });
     })
@@ -2647,8 +3177,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.1", "-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.14.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 {