claude-launchpad 1.12.0 → 1.14.0

package/dist/{chunk-KPO4YURF.js → chunk-QEPE3WVF.js}

@@ -1372,6 +1372,43 @@ Output goes into the session's context. Always exit 0; SessionStart blocking is
 `;
 }
 
+// src/commands/init/generators/verification-rule.ts
+var VERIFICATION_RULE_VERSION = 1;
+function generateVerificationRule() {
+  return `# Verification Rules
+
+<!-- lp-verification-version: ${VERIFICATION_RULE_VERSION} -->
+
+These rules govern every claim of "done", "fixed", "passing", or "works". A claim without evidence is a defect, no matter how good the code is.
+
+## Evidence before assertion
+
+- Never claim done/fixed/passing without having run the thing this session and quoting the output. The claim and its evidence travel together: "Done \u2014 14/14 tests pass (output below)", never a bare "done".
+- Verify the behavior, not the build. Compiling is not working; typechecking is not working. Exercise the changed flow end-to-end: run the command, hit the endpoint, click the path.
+- For bug fixes: reproduce the failure FIRST and capture the exact error. Then fix, then re-run the original reproduction AND the surrounding tests. If you cannot explain the root cause, you have hidden the bug, not fixed it.
+- Test the failure case, not just the happy path: feed the change the input that used to break it and confirm it now lands safely.
+
+## Label your claims
+
+Sort every load-bearing statement into one of three buckets, and say which out loud:
+
+- **verified** \u2014 you read it or ran it this session
+- **inferred** \u2014 follows logically from verified facts; state the chain
+- **assumed** \u2014 plausible from prior knowledge; check it before building on it
+
+Never let an assumption silently graduate into a fact. APIs, config keys, CLI flags, and package names cited from memory are the #1 hallucination vector \u2014 open the real source or current docs before citing them.
+
+## When you can't verify
+
+- If a step cannot be run (missing env, no credentials, no test data), the result is **done-with-gaps** \u2014 name each gap explicitly. Never round done-with-gaps up to done.
+- Report failure plainly. Failing tests, skipped steps, and partial work get named with the output shown. "2 failures remain, here's the state" preserves trust; a false "all green" destroys it.
+
+## End-of-turn check
+
+Before ending a turn, re-read your last paragraph. If it is a promise ("I'll\u2026", "next I would\u2026"), a plan, or a question you could answer yourself \u2014 do that work now, then end. A turn ends on delivered results, not intentions.
+`;
+}
+
 // src/commands/init/generators/agent-reviewer.ts
 var REVIEWER_AGENT_VERSION = 1;
 function generateReviewerAgent() {
@@ -1425,7 +1462,9 @@ async function createWorkflowRule(root) {
   if (await fileExists(workflowPath)) return false;
   await mkdir2(rulesDir, { recursive: true });
   await writeFile3(workflowPath, generateWorkflowRule());
-  log.success("Created .claude/rules/workflow.md (path-scoped BACKLOG/TASKS workflow rules)");
+  log.success(
+    "Created .claude/rules/workflow.md (path-scoped BACKLOG/TASKS workflow rules)"
+  );
   return true;
 }
 async function createReviewerAgent(root) {
@@ -1434,7 +1473,9 @@ async function createReviewerAgent(root) {
   if (await fileExists(agentPath)) return false;
   await mkdir2(agentsDir, { recursive: true });
   await writeFile3(agentPath, generateReviewerAgent());
-  log.success("Created .claude/agents/code-reviewer.md (fresh-context independent reviewer)");
+  log.success(
+    "Created .claude/agents/code-reviewer.md (fresh-context independent reviewer)"
+  );
   return true;
 }
 async function updateWorkflowRule(root) {
@@ -1450,8 +1491,13 @@ async function fixStaleSwarmPhrase(root) {
   const claudeMdPath = join4(root, "CLAUDE.md");
   const content = await readFile3(claudeMdPath, "utf-8").catch(() => null);
   if (content === null || !content.includes(STALE_SWARM_PHRASE)) return false;
-  await writeFile3(claudeMdPath, content.replaceAll(STALE_SWARM_PHRASE, SWARM_PHRASE_REPLACEMENT));
-  log.success("Modernized Stop-and-Swarm wording (Agent tool \u2192 Task tool subagents)");
+  await writeFile3(
+    claudeMdPath,
+    content.replaceAll(STALE_SWARM_PHRASE, SWARM_PHRASE_REPLACEMENT)
+  );
+  log.success(
+    "Modernized Stop-and-Swarm wording (Agent tool \u2192 Task tool subagents)"
+  );
   return true;
 }
 async function createHooksRule(root) {
@@ -1460,7 +1506,29 @@ async function createHooksRule(root) {
   if (await fileExists(hooksPath)) return false;
   await mkdir2(rulesDir, { recursive: true });
   await writeFile3(hooksPath, generateHooksRule());
-  log.success("Created .claude/rules/hooks.md (path-scoped hook authoring rules)");
+  log.success(
+    "Created .claude/rules/hooks.md (path-scoped hook authoring rules)"
+  );
+  return true;
+}
+async function createVerificationRule(root) {
+  const rulesDir = join4(root, ".claude", "rules");
+  const verificationPath = join4(rulesDir, "verification.md");
+  if (await fileExists(verificationPath)) return false;
+  await mkdir2(rulesDir, { recursive: true });
+  await writeFile3(verificationPath, generateVerificationRule());
+  log.success(
+    "Created .claude/rules/verification.md (evidence-before-assertion discipline)"
+  );
+  return true;
+}
+async function updateVerificationRule(root) {
+  const verificationPath = join4(root, ".claude", "rules", "verification.md");
+  const content = await readFile3(verificationPath, "utf-8").catch(() => null);
+  if (content === null) return false;
+  if (!/<!-- lp-verification-version: \d+ -->/.test(content)) return false;
+  await writeFile3(verificationPath, generateVerificationRule());
+  log.success("Updated .claude/rules/verification.md to the latest version");
   return true;
 }
 function isMemoryHeading(line) {
@@ -1477,7 +1545,11 @@ function findMemoryBlocks(lines) {
         break;
       }
     }
-    blocks.push({ startIdx: i, endIdx: end, tagged: lines[i].includes("(agentic-memory)") });
+    blocks.push({
+      startIdx: i,
+      endIdx: end,
+      tagged: lines[i].includes("(agentic-memory)")
+    });
     i = end - 1;
   }
   return blocks;
@@ -1512,7 +1584,9 @@ async function collapseMemoryHeadings(root) {
     (line) => /^## Memory\s*$/.test(line) ? "## Memory (agentic-memory)" : line
   );
   await writeFile3(claudeMdPath, canonical.join("\n"));
-  log.success(`Collapsed ${blocks.length - 1} duplicate ## Memory section(s) in CLAUDE.md`);
+  log.success(
+    `Collapsed ${blocks.length - 1} duplicate ## Memory section(s) in CLAUDE.md`
+  );
   return true;
 }
 
@@ -1753,13 +1827,13 @@ async function addSessionStartPullHook(root, placement) {
   const target = placement === "local" ? "settings.local.json" : "settings.json";
   return addPlacementHook(root, placement, "SessionStart", "memory pull", {
     matcher: "startup",
-    hooks: [{ type: "command", command: "claude-launchpad memory pull -y 2>/dev/null; exit 0" }]
+    hooks: [{ type: "command", command: "npx claude-launchpad memory pull -y 2>/dev/null; exit 0" }]
   }, true, `Added SessionStart hook for memory sync to ${target}`);
 }
 async function addSessionEndPushHook(root, placement) {
   const target = placement === "local" ? "settings.local.json" : "settings.json";
   return addPlacementHook(root, placement, "SessionEnd", "memory push", {
-    hooks: [{ type: "command", command: "nohup claude-launchpad memory push -y </dev/null >/dev/null 2>&1 & exit 0" }]
+    hooks: [{ type: "command", command: "nohup npx claude-launchpad memory push -y </dev/null >/dev/null 2>&1 & exit 0" }]
   }, false, `Added SessionEnd hook for memory sync to ${target}`);
 }
 async function upgradeStaleSessionEndPushHook(root) {
@@ -1780,7 +1854,7 @@ async function upgradeStaleSessionEndPushHook(root) {
         const cmd = typeof h.command === "string" ? h.command : "";
         if (!cmd.includes("memory push") || cmd.includes("nohup")) return h;
         changed = true;
-        return { ...h, command: "nohup claude-launchpad memory push -y </dev/null >/dev/null 2>&1 & exit 0" };
+        return { ...h, command: "nohup npx claude-launchpad memory push -y </dev/null >/dev/null 2>&1 & exit 0" };
       });
       return { ...group, hooks: rewritten };
     });
@@ -1868,6 +1942,38 @@ async function addAllowedMcpServers(root, placement) {
   log.success(`Added allowedMcpServers from configured servers to ${target}`);
   return true;
 }
+async function upgradeBareMemoryHooks(root) {
+  let any = false;
+  for (const placement of ["shared", "local"]) {
+    const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
+    const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
+    const settings = await read(root);
+    if (settings === null) continue;
+    const hooks = settings.hooks;
+    if (!hooks) continue;
+    let changed = false;
+    const upgradedHooks = {};
+    for (const [event, groups] of Object.entries(hooks)) {
+      upgradedHooks[event] = groups.map((group) => {
+        const inner = group.hooks;
+        if (!inner) return group;
+        const rewritten = inner.map((h) => {
+          const cmd = typeof h.command === "string" ? h.command : "";
+          if (!cmd.includes("claude-launchpad memory") || cmd.includes("npx claude-launchpad")) return h;
+          changed = true;
+          return { ...h, command: cmd.replace("claude-launchpad memory", "npx claude-launchpad memory") };
+        });
+        return { ...group, hooks: rewritten };
+      });
+    }
+    if (!changed) continue;
+    await write(root, { ...settings, hooks: upgradedHooks });
+    const target = placement === "local" ? "settings.local.json" : "settings.json";
+    log.success(`Rewrote bare memory hook commands to npx form in ${target}`);
+    any = true;
+  }
+  return any;
+}
 
 // src/commands/doctor/fixer.ts
 async function applyFixes(issues, projectRoot) {
@@ -1887,74 +1993,311 @@ async function applyFixes(issues, projectRoot) {
   return { fixed, skipped };
 }
 var FIX_TABLE = [
-  { analyzer: "Hooks", match: "$TOOL_INPUT_* env var", fix: (root) => rewriteEnvVarHooks(root) },
-  { analyzer: "Hooks", match: "No hooks configured", fix: async (root, detected) => {
-    const a = await addEnvProtectionHook(root);
-    const b = await addAutoFormatHook(root, detected);
-    const c = await addForcePushProtection(root);
-    const d = await addSessionStartHook(root);
-    return a || b || c || d;
-  } },
-  { analyzer: "Hooks", match: ".env file protection", fix: (root) => addEnvProtectionHook(root) },
-  { analyzer: "Hooks", match: "auto-format", fix: (root, detected) => addAutoFormatHook(root, detected) },
-  { analyzer: "Hooks", match: "No PreToolUse", fix: (root) => addEnvProtectionHook(root) },
-  { analyzer: "Quality", match: "Architecture", fix: (root) => addClaudeMdSection(root, "## Architecture", wrapStub("<!-- TODO: Describe your codebase structure. Run `/lp-enhance` to auto-fill this. -->")) },
-  { analyzer: "Quality", match: "Off-Limits", fix: (root) => addClaudeMdSection(root, "## Off-Limits", wrapStub(OFF_LIMITS_CONTENT)) },
-  { analyzer: "Quality", match: "Commands", fix: (root) => addClaudeMdSection(root, "## Commands", wrapStub("<!-- TODO: Add your dev/build/test commands -->")) },
-  { analyzer: "Quality", match: "Stack", fix: (root, detected) => {
-    if (detected.language) {
-      const content = `- **Language**: ${detected.language}${detected.framework ? `
+  {
+    analyzer: "Hooks",
+    match: "$TOOL_INPUT_* env var",
+    fix: (root) => rewriteEnvVarHooks(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "No hooks configured",
+    fix: async (root, detected) => {
+      const a = await addEnvProtectionHook(root);
+      const b = await addAutoFormatHook(root, detected);
+      const c = await addForcePushProtection(root);
+      const d = await addSessionStartHook(root);
+      return a || b || c || d;
+    }
+  },
+  {
+    analyzer: "Hooks",
+    match: ".env file protection",
+    fix: (root) => addEnvProtectionHook(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "auto-format",
+    fix: (root, detected) => addAutoFormatHook(root, detected)
+  },
+  {
+    analyzer: "Hooks",
+    match: "No PreToolUse",
+    fix: (root) => addEnvProtectionHook(root)
+  },
+  {
+    analyzer: "Quality",
+    match: "Architecture",
+    fix: (root) => addClaudeMdSection(
+      root,
+      "## Architecture",
+      wrapStub(
+        "<!-- TODO: Describe your codebase structure. Run `/lp-enhance` to auto-fill this. -->"
+      )
+    )
+  },
+  {
+    analyzer: "Quality",
+    match: "Off-Limits",
+    fix: (root) => addClaudeMdSection(root, "## Off-Limits", wrapStub(OFF_LIMITS_CONTENT))
+  },
+  {
+    analyzer: "Quality",
+    match: "Commands",
+    fix: (root) => addClaudeMdSection(
+      root,
+      "## Commands",
+      wrapStub("<!-- TODO: Add your dev/build/test commands -->")
+    )
+  },
+  {
+    analyzer: "Quality",
+    match: "Stack",
+    fix: (root, detected) => {
+      if (detected.language) {
+        const content = `- **Language**: ${detected.language}${detected.framework ? `
 - **Framework**: ${detected.framework}` : ""}${detected.packageManager ? `
 - **Package Manager**: ${detected.packageManager}` : ""}`;
-      return addClaudeMdSection(root, "## Stack", content);
+        return addClaudeMdSection(root, "## Stack", content);
+      }
+      return addClaudeMdSection(
+        root,
+        "## Stack",
+        wrapStub("<!-- TODO: Define your tech stack -->")
+      );
     }
-    return addClaudeMdSection(root, "## Stack", wrapStub("<!-- TODO: Define your tech stack -->"));
-  } },
-  { analyzer: "Quality", match: "Session Start", fix: (root) => addClaudeMdSection(root, "## Session Start", wrapStub(SESSION_START_CONTENT)) },
-  { analyzer: "Quality", match: "Backlog", fix: (root) => addClaudeMdSection(root, "## Backlog", wrapStub(BACKLOG_CONTENT)) },
-  { analyzer: "Quality", match: "Stop-and-Swarm section is outdated", fix: (root) => fixStaleSwarmPhrase(root) },
-  { analyzer: "Quality", match: "Stop-and-Swarm", fix: (root) => addClaudeMdSection(root, "## Stop-and-Swarm", wrapStub(STOP_AND_SWARM_CONTENT)) },
-  { analyzer: "Rules", match: "workflow.md rule is outdated", fix: (root) => updateWorkflowRule(root) },
-  { analyzer: "Rules", match: "No .claude/agents/code-reviewer.md", fix: (root) => createReviewerAgent(root) },
-  { analyzer: "Quality", match: "Duplicate ## Memory", fix: (root) => collapseMemoryHeadings(root) },
-  { analyzer: "Rules", match: "No BACKLOG.md", fix: (root) => createBacklogMd(root) },
-  { analyzer: "Rules", match: "No .claudeignore", fix: (root, detected) => createClaudeignore(root, detected) },
-  { analyzer: "Rules", match: "No .claude/rules/workflow.md", fix: (root) => createWorkflowRule(root) },
-  { analyzer: "Rules", match: "No .claude/rules/hooks.md", fix: (root) => createHooksRule(root) },
-  { analyzer: "Rules", match: "No .claude/rules/", fix: (root) => createStarterRules(root) },
-  { analyzer: "Hooks", match: "PostCompact hooks can't inject context", fix: (root) => migratePostCompactHook(root) },
-  { analyzer: "Hooks", match: "compact matcher", fix: (root) => addCompactMatcherHook(root) },
-  { analyzer: "Permissions", match: "force-push", fix: (root) => addForcePushProtection(root) },
-  { analyzer: "Permissions", match: "Credential files not blocked", fix: (root) => addCredentialDenyRules(root) },
-  { analyzer: "Permissions", match: "Bypass permissions mode", fix: (root) => addBypassDisable(root) },
-  { analyzer: "Permissions", match: "Sandbox lacks a write grant", fix: (root) => addSandboxMemoryWriteGrant(root) },
-  { analyzer: "Permissions", match: ".env is protected by hooks but not in .claudeignore", fix: (root) => addEnvToClaudeignore(root) },
-  { analyzer: "Permissions", match: ".worktreeinclude is missing or empty", fix: (root) => createWorktreeInclude(root) },
-  { analyzer: "Hooks", match: "registered on PreToolUse", fix: (root) => migrateSprintOpenHookEvent(root) },
-  { analyzer: "Hooks", match: "nudge uses bare stdout", fix: (root) => upgradeStaleNudge(root) },
-  { analyzer: "Hooks", match: "Outdated hygiene script", fix: (root) => refreshHygieneScripts(root) },
-  { analyzer: "Hooks", match: "sprint-size-check", fix: (root) => addSprintSizeHook(root) },
-  { analyzer: "Hooks", match: "sprint-open-check", fix: (root) => addSprintOpenHook(root) },
-  { analyzer: "Hooks", match: "sprint-complete nudge", fix: (root) => addSprintCompleteNudge(root) },
-  { analyzer: "Hooks", match: "workflow-check.sh", fix: (root) => addWorkflowCheckHook(root) },
-  { analyzer: "Rules", match: "No skill authoring conventions", fix: (root) => addSkillAuthoringConventions(root) },
-  { analyzer: "Rules", match: "No /lp-enhance skill", fix: (root) => createEnhanceSkill(root) },
-  { analyzer: "Rules", match: "lp-enhance skill is outdated", fix: (root) => updateEnhanceSkill(root) },
-  { analyzer: "Settings", match: "Deprecated includeCoAuthoredBy", fix: (root) => migrateAttribution(root) },
-  { analyzer: "Hooks", match: "SessionStart", fix: (root) => addSessionStartHook(root) },
-  { analyzer: "Memory", match: "Deprecated Stop hook", fix: (root) => removeStaleStopHook(root) },
-  { analyzer: "Memory", match: "autoMemoryEnabled not disabled", fix: (root, _det, placement) => disableAutoMemory(root, placement) },
-  { analyzer: "Memory", match: "MCP tool permission", fix: (root, _det, placement) => addMemoryToolPermissions(root, placement) },
-  { analyzer: "MCP", match: "no allowedMcpServers", fix: (root, _det, placement) => addAllowedMcpServers(root, placement) },
-  { analyzer: "Memory", match: "allowedMcpServers is set but does not include agentic-memory", fix: (root) => addMemoryToAllowedMcpServers(root) },
-  { analyzer: "Memory", match: "SessionStart hook to auto-pull", fix: (root, _det, placement) => addSessionStartPullHook(root, placement) },
-  { analyzer: "Memory", match: "SessionEnd hook to auto-push", fix: (root, _det, placement) => addSessionEndPushHook(root, placement) },
-  { analyzer: "Memory", match: "SessionEnd push hook is not nohup-wrapped", fix: (root) => upgradeStaleSessionEndPushHook(root) },
-  { analyzer: "Memory", match: "CLAUDE.md missing memory guidance", fix: (root, _det, placement) => {
-    const content = "Use agentic-memory to persist knowledge across sessions:\n- Memories are automatically injected at session start\n- STORE IMMEDIATELY when: a dependency strategy changes, an architecture decision is made, a convention is established, a bug pattern is discovered, or a feature is killed/added\n- Use memory_search before memory_store to check for duplicates\n- NEVER store credentials, API keys, tokens, or secrets in memories";
-    const target = placement === "local" ? join7(root, ".claude", "CLAUDE.md") : void 0;
-    return addClaudeMdSection(root, "## Memory", wrapStub(content), target);
-  } }
+  },
+  {
+    analyzer: "Quality",
+    match: "Session Start",
+    fix: (root) => addClaudeMdSection(
+      root,
+      "## Session Start",
+      wrapStub(SESSION_START_CONTENT)
+    )
+  },
+  {
+    analyzer: "Quality",
+    match: "Backlog",
+    fix: (root) => addClaudeMdSection(root, "## Backlog", wrapStub(BACKLOG_CONTENT))
+  },
+  {
+    analyzer: "Quality",
+    match: "Stop-and-Swarm section is outdated",
+    fix: (root) => fixStaleSwarmPhrase(root)
+  },
+  {
+    analyzer: "Quality",
+    match: "Stop-and-Swarm",
+    fix: (root) => addClaudeMdSection(
+      root,
+      "## Stop-and-Swarm",
+      wrapStub(STOP_AND_SWARM_CONTENT)
+    )
+  },
+  {
+    analyzer: "Rules",
+    match: "workflow.md rule is outdated",
+    fix: (root) => updateWorkflowRule(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "verification.md rule is outdated",
+    fix: (root) => updateVerificationRule(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "No .claude/agents/code-reviewer.md",
+    fix: (root) => createReviewerAgent(root)
+  },
+  {
+    analyzer: "Quality",
+    match: "Duplicate ## Memory",
+    fix: (root) => collapseMemoryHeadings(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "No BACKLOG.md",
+    fix: (root) => createBacklogMd(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "No .claudeignore",
+    fix: (root, detected) => createClaudeignore(root, detected)
+  },
+  {
+    analyzer: "Rules",
+    match: "No .claude/rules/workflow.md",
+    fix: (root) => createWorkflowRule(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "No .claude/rules/hooks.md",
+    fix: (root) => createHooksRule(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "No .claude/rules/verification.md",
+    fix: (root) => createVerificationRule(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "No .claude/rules/",
+    fix: (root) => createStarterRules(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "PostCompact hooks can't inject context",
+    fix: (root) => migratePostCompactHook(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "compact matcher",
+    fix: (root) => addCompactMatcherHook(root)
+  },
+  {
+    analyzer: "Permissions",
+    match: "force-push",
+    fix: (root) => addForcePushProtection(root)
+  },
+  {
+    analyzer: "Permissions",
+    match: "Credential files not blocked",
+    fix: (root) => addCredentialDenyRules(root)
+  },
+  {
+    analyzer: "Permissions",
+    match: "Bypass permissions mode",
+    fix: (root) => addBypassDisable(root)
+  },
+  {
+    analyzer: "Permissions",
+    match: "Sandbox lacks a write grant",
+    fix: (root) => addSandboxMemoryWriteGrant(root)
+  },
+  {
+    analyzer: "Permissions",
+    match: ".env is protected by hooks but not in .claudeignore",
+    fix: (root) => addEnvToClaudeignore(root)
+  },
+  {
+    analyzer: "Permissions",
+    match: ".worktreeinclude is missing or empty",
+    fix: (root) => createWorktreeInclude(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "registered on PreToolUse",
+    fix: (root) => migrateSprintOpenHookEvent(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "nudge uses bare stdout",
+    fix: (root) => upgradeStaleNudge(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "Outdated hygiene script",
+    fix: (root) => refreshHygieneScripts(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "sprint-size-check",
+    fix: (root) => addSprintSizeHook(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "sprint-open-check",
+    fix: (root) => addSprintOpenHook(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "sprint-complete nudge",
+    fix: (root) => addSprintCompleteNudge(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "workflow-check.sh",
+    fix: (root) => addWorkflowCheckHook(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "No skill authoring conventions",
+    fix: (root) => addSkillAuthoringConventions(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "No /lp-enhance skill",
+    fix: (root) => createEnhanceSkill(root)
+  },
+  {
+    analyzer: "Rules",
+    match: "lp-enhance skill is outdated",
+    fix: (root) => updateEnhanceSkill(root)
+  },
+  {
+    analyzer: "Settings",
+    match: "Deprecated includeCoAuthoredBy",
+    fix: (root) => migrateAttribution(root)
+  },
+  {
+    analyzer: "Hooks",
+    match: "SessionStart",
+    fix: (root) => addSessionStartHook(root)
+  },
+  {
+    analyzer: "Memory",
+    match: "bare claude-launchpad binary",
+    fix: (root) => upgradeBareMemoryHooks(root)
+  },
+  {
+    analyzer: "Memory",
+    match: "Deprecated Stop hook",
+    fix: (root) => removeStaleStopHook(root)
+  },
+  {
+    analyzer: "Memory",
+    match: "autoMemoryEnabled not disabled",
+    fix: (root, _det, placement) => disableAutoMemory(root, placement)
+  },
+  {
+    analyzer: "Memory",
+    match: "MCP tool permission",
+    fix: (root, _det, placement) => addMemoryToolPermissions(root, placement)
+  },
+  {
+    analyzer: "MCP",
+    match: "no allowedMcpServers",
+    fix: (root, _det, placement) => addAllowedMcpServers(root, placement)
+  },
+  {
+    analyzer: "Memory",
+    match: "allowedMcpServers is set but does not include agentic-memory",
+    fix: (root) => addMemoryToAllowedMcpServers(root)
+  },
+  {
+    analyzer: "Memory",
+    match: "SessionStart hook to auto-pull",
+    fix: (root, _det, placement) => addSessionStartPullHook(root, placement)
+  },
+  {
+    analyzer: "Memory",
+    match: "SessionEnd hook to auto-push",
+    fix: (root, _det, placement) => addSessionEndPushHook(root, placement)
+  },
+  {
+    analyzer: "Memory",
+    match: "SessionEnd push hook is not nohup-wrapped",
+    fix: (root) => upgradeStaleSessionEndPushHook(root)
+  },
+  {
+    analyzer: "Memory",
+    match: "CLAUDE.md missing memory guidance",
+    fix: (root, _det, placement) => {
+      const content = "Use agentic-memory to persist knowledge across sessions:\n- Memories are automatically injected at session start\n- STORE IMMEDIATELY when: a dependency strategy changes, an architecture decision is made, a convention is established, a bug pattern is discovered, or a feature is killed/added\n- Use memory_search before memory_store to check for duplicates\n- NEVER store credentials, API keys, tokens, or secrets in memories";
+      const target = placement === "local" ? join7(root, ".claude", "CLAUDE.md") : void 0;
+      return addClaudeMdSection(root, "## Memory", wrapStub(content), target);
+    }
+  }
 ];
 function hasAutoFix(issue) {
   return FIX_TABLE.some(
@@ -1985,7 +2328,10 @@ async function addCredentialDenyRules(root) {
   const toAdd = ["Read(~/.ssh/*)", "Read(~/.aws/*)", "Read(~/.npmrc)"];
   const missing = toAdd.filter((p) => !deny.includes(p));
   if (missing.length === 0) return false;
-  const updated = { ...settings, permissions: { ...permissions, deny: [...deny, ...missing] } };
+  const updated = {
+    ...settings,
+    permissions: { ...permissions, deny: [...deny, ...missing] }
+  };
   await writeSettingsJson(root, updated);
   log.success("Added credential deny rules (SSH, AWS, npm)");
   return true;
@@ -2011,11 +2357,16 @@ async function addSandboxMemoryWriteGrant(root) {
     ...settings,
     sandbox: {
       ...sandbox,
-      filesystem: { ...filesystem, allowWrite: [...allowWrite, "~/.agentic-memory"] }
+      filesystem: {
+        ...filesystem,
+        allowWrite: [...allowWrite, "~/.agentic-memory"]
+      }
     }
   };
   await writeSettingsJson(root, updated);
-  log.success("Added ~/.agentic-memory to sandbox.filesystem.allowWrite (sandbox stays enabled)");
+  log.success(
+    "Added ~/.agentic-memory to sandbox.filesystem.allowWrite (sandbox stays enabled)"
+  );
   return true;
 }
 async function addEnvToClaudeignore(root) {
@@ -2027,7 +2378,8 @@ async function addEnvToClaudeignore(root) {
     return false;
   }
   const lines = content.split("\n").map((l) => l.trim());
-  if (lines.some((l) => l === ".env" || l === ".env.*" || l === ".env*")) return false;
+  if (lines.some((l) => l === ".env" || l === ".env.*" || l === ".env*"))
+    return false;
   await writeFile4(ignorePath, content.trimEnd() + "\n.env\n.env.*\n");
   log.success("Added .env to .claudeignore");
   return true;
@@ -2061,7 +2413,9 @@ async function createBacklogMd(root) {
   if (await fileExists(backlogPath)) return false;
   const name = root.split("/").pop() ?? "Project";
   await writeFile4(backlogPath, generateBacklogMd({ name, description: "" }));
-  log.success("Generated BACKLOG.md (WP template + P0\u2013P3 sections + changelog)");
+  log.success(
+    "Generated BACKLOG.md (WP template + P0\u2013P3 sections + changelog)"
+  );
   return true;
 }
 async function createClaudeignore(root, detected) {
@@ -2103,17 +2457,27 @@ async function addSkillAuthoringConventions(root) {
     return false;
   }
   if (/^##\s+Skill\s+Authoring/im.test(content)) return false;
-  await writeFile4(conventionsPath, content.trimEnd() + "\n" + SKILL_AUTHORING_SECTION);
+  await writeFile4(
+    conventionsPath,
+    content.trimEnd() + "\n" + SKILL_AUTHORING_SECTION
+  );
   log.success("Added Skill Authoring section to .claude/rules/conventions.md");
   return true;
 }
 async function createEnhanceSkill(root) {
   const skillDir = join7(root, ".claude", "skills", "lp-enhance");
   const skillPath = join7(skillDir, "SKILL.md");
-  const globalPath = join7(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const globalPath = join7(
+    homedir(),
+    ".claude",
+    "skills",
+    "lp-enhance",
+    "SKILL.md"
+  );
   const legacyProject = join7(root, ".claude", "commands", "lp-enhance.md");
   const legacyGlobal = join7(homedir(), ".claude", "commands", "lp-enhance.md");
-  if (await fileExists(skillPath) || await fileExists(globalPath) || await fileExists(legacyProject) || await fileExists(legacyGlobal)) return false;
+  if (await fileExists(skillPath) || await fileExists(globalPath) || await fileExists(legacyProject) || await fileExists(legacyGlobal))
+    return false;
   await mkdir3(skillDir, { recursive: true });
   await writeFile4(skillPath, generateEnhanceSkill());
   log.success("Generated /lp-enhance skill (.claude/skills/lp-enhance/)");
@@ -2121,7 +2485,13 @@ async function createEnhanceSkill(root) {
 }
 async function updateEnhanceSkill(root) {
   const projectPath = join7(root, ".claude", "skills", "lp-enhance", "SKILL.md");
-  const globalPath = join7(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const globalPath = join7(
+    homedir(),
+    ".claude",
+    "skills",
+    "lp-enhance",
+    "SKILL.md"
+  );
   const targetPath = await fileExists(projectPath) ? projectPath : await fileExists(globalPath) ? globalPath : null;
   if (!targetPath) return false;
   await writeFile4(targetPath, generateEnhanceSkill());
@@ -2303,6 +2673,8 @@ export {
   WORKFLOW_RULE_VERSION,
   generateWorkflowRule,
   generateHooksRule,
+  VERIFICATION_RULE_VERSION,
+  generateVerificationRule,
   generateReviewerAgent,
   applyFixes,
   log,
@@ -2310,4 +2682,4 @@ export {
   printScoreCard,
   renderDoctorReport
 };
-//# sourceMappingURL=chunk-KPO4YURF.js.map
+//# sourceMappingURL=chunk-QEPE3WVF.js.map