claude-launchpad 1.12.0 → 1.15.0

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

@@ -46,7 +46,7 @@ import { homedir } from "os";
 // src/lib/sections.ts
 var SESSION_START_CONTENT = "- ALWAYS read @TASKS.md first \u2014 it tracks progress across sessions\n- Check the Session Log at the bottom of TASKS.md for where we left off\n- Update TASKS.md as you complete work";
 var BACKLOG_CONTENT = "- When a feature is discussed but deferred, add it to BACKLOG.md immediately\n- Never leave future ideas only in TASKS.md or conversation \u2014 they get lost\n- BACKLOG.md is the single source of truth for parked features\n- Every WP uses the 7-field template in BACKLOG.md \u2014 no freeform entries\n- Pull a WP into a sprint = **move**, not copy. A WP lives in exactly one file at a time";
-var STOP_AND_SWARM_CONTENT = 'Three failed iterations on the same problem = stop iterating alone.\n(An iteration = an attempted fix that did not change the failing symptom. Announce "Attempt N" when retrying so the count stays visible.)\nFirst, one systematic pass \u2014 it usually resolves the loop without the swarm:\nreproduce the failure, read the FULL error output, state one hypothesis about the root cause, and verify it BEFORE writing any fix.\nOnly if that pass fails, swarm: dispatch at least 3 parallel subagents via the Task tool \u2014 in a single message so they run concurrently \u2014 each investigating from a different angle:\n1. Root-cause debug agent\n2. Upstream library/docs research agent\n3. Alternative architecture agent\nHand each agent the exact repro command, the full error text, and the list of already-failed fixes \u2014 subagents start with empty context.\nWait for all agents to return, synthesize their findings, then act.\nFor re-planning after repeated failure, switch to plan mode instead of attempting again.';
+var STOP_AND_SWARM_CONTENT = 'Three failed iterations on the same problem = stop iterating alone.\n(An iteration = an attempted fix that did not change the failing symptom. Announce "Attempt N" when retrying so the count stays visible.)\nFirst, one systematic pass \u2014 it usually resolves the loop without the swarm:\nreproduce the failure, read the FULL error output, state one hypothesis about the root cause, and verify it BEFORE writing any fix.\nOnly if that pass fails, swarm: dispatch at least 3 parallel subagents via the Task tool \u2014 in a single message so they run concurrently \u2014 each investigating from a different angle:\n1. Root-cause debug agent\n2. Upstream library/docs research agent\n3. Alternative architecture agent\nEvery agent brief has four parts \u2014 agents start with empty context: Mission (one sentence), Context (exact repro command, full error text, already-failed fixes), Scope fence (files/questions NOT to touch), Return format (findings as file:line + evidence).\nTreat agent output as testimony, not truth \u2014 spot-check load-bearing claims (open the cited file, re-run the cited command) before acting on them.\nWait for all agents to return, synthesize their findings, then act.\nFor re-planning after repeated failure, switch to plan mode instead of attempting again.';
 var STALE_SWARM_PHRASE = "spin up at least 3 parallel agents via the Agent tool";
 var SWARM_PHRASE_REPLACEMENT = "dispatch at least 3 parallel subagents via the Task tool (in a single message so they run concurrently)";
 var OFF_LIMITS_CONTENT = "- Never hardcode secrets \u2014 use environment variables\n- Never write to `.env` files\n- Never expose internal error details in API responses";
@@ -757,6 +757,7 @@ function isJqAvailable() {
   }
   return jqChecked;
 }
+var FORCE_PUSH_ERE = "git +(-[cC][^ ]* +([^ ]+ +)?)*push([^|;&]*( -[a-zA-Z]*f[a-zA-Z]*| --force| --force-with-lease(=[^ ;|&]*)?)( |$|;|&)|[^|;&]* \\+[^ ;|&]+)";
 
 // src/lib/hook-scripts.ts
 var SPRINT_SIZE_CHECK = `#!/usr/bin/env bash
@@ -1372,6 +1373,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 +1463,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 +1474,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 +1492,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 +1507,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 +1546,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 +1585,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;
 }
 
@@ -1553,7 +1628,7 @@ async function addForcePushProtection(root) {
     matcher: "Bash",
     hooks: [{
       type: "command",
-      command: `cmd=${jqField("command")}; echo "$cmd" | grep -qE 'push.*--force|push.*-f' && { echo 'WARNING: Force push detected \u2014 this can destroy remote history' >&2; exit 2; }; exit 0`
+      command: `cmd=${jqField("command")}; echo "$cmd" | grep -qE "${FORCE_PUSH_ERE}" && { echo 'WARNING: Force push detected \u2014 this can destroy remote history' >&2; exit 2; }; exit 0`
     }]
   }, "Added force-push protection hook (PreToolUse \u2192 Bash)");
 }
@@ -1611,6 +1686,42 @@ async function addSessionStartHook(root) {
     hooks: [{ type: "command", command: "cat TASKS.md 2>/dev/null; exit 0" }]
   }, "Added SessionStart hook (injects TASKS.md at startup/resume/compact/clear)");
 }
+async function upgradeForcePushPattern(root) {
+  const stale = "push.*--force|push.*-f";
+  let any = false;
+  for (const [read, write, label] of [
+    [readSettingsJson, writeSettingsJson, "settings.json"],
+    [readSettingsLocalJson, writeSettingsLocalJson, "settings.local.json"]
+  ]) {
+    const settings = await read(root);
+    if (settings === null) continue;
+    const raw = JSON.stringify(settings);
+    if (!raw.includes(stale.replace(/\\/g, "\\\\"))) {
+      if (!raw.includes(stale)) continue;
+    }
+    const hooks = settings.hooks;
+    if (!hooks) continue;
+    let changed = false;
+    for (const groups of Object.values(hooks)) {
+      for (const group of groups) {
+        const inner = group.hooks;
+        if (!inner) continue;
+        for (const h of inner) {
+          const cmd = typeof h.command === "string" ? h.command : "";
+          if (cmd.includes(stale)) {
+            h.command = cmd.replace(stale, FORCE_PUSH_ERE);
+            changed = true;
+          }
+        }
+      }
+    }
+    if (!changed) continue;
+    await write(root, settings);
+    log.success(`Upgraded force-push guard pattern in ${label}`);
+    any = true;
+  }
+  return any;
+}
 
 // src/commands/doctor/fixer-hook-input.ts
 import { readFile as readFile4 } from "fs/promises";
@@ -1621,10 +1732,10 @@ function rewriteEnvVarHookCommand(cmd) {
     return `fp=${jqField("file_path")}; echo "$fp" | grep -qE '\\.(env|env\\..*)$' && ! echo "$fp" | grep -q '.env.example' && { echo 'BLOCKED: .env files contain secrets' >&2; exit 2; }; exit 0`;
   }
   if (cmd.includes("BLOCKED: Destructive command detected")) {
-    return `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`;
+    return `cmd=${jqField("command")}; echo "$cmd" | grep -qE 'rm\\s+-rf\\s+/|DROP\\s+TABLE|DROP\\s+DATABASE|${FORCE_PUSH_ERE}' && { echo 'BLOCKED: Destructive command detected' >&2; exit 2; }; exit 0`;
   }
   if (cmd.includes("WARNING: Force push detected") || cmd.includes("Force push detected")) {
-    return `cmd=${jqField("command")}; echo "$cmd" | grep -qE 'push.*--force|push.*-f' && { echo 'WARNING: Force push detected \u2014 this can destroy remote history' >&2; exit 2; }; exit 0`;
+    return `cmd=${jqField("command")}; echo "$cmd" | grep -qE '${FORCE_PUSH_ERE}' && { echo 'WARNING: Force push detected \u2014 this can destroy remote history' >&2; exit 2; }; exit 0`;
   }
   if (cmd.includes("Sprint complete") && cmd.includes("TASKS.md")) {
     return SPRINT_COMPLETE_NUDGE;
@@ -1680,6 +1791,15 @@ async function rewriteEnvVarHooks(root) {
       didFix = true;
     }
   }
+  const localSettings = await readSettingsLocalJson(root);
+  if (localSettings !== null) {
+    const outcome = rewriteSettingsHooks(localSettings);
+    if (outcome.changed) {
+      await writeSettingsLocalJson(root, outcome.settings);
+      log.success("Rewrote inert $TOOL_INPUT_* hooks in settings.local.json to canonical jq+stdin form");
+      didFix = true;
+    }
+  }
   const workflowCheckPath = join5(root, ".claude", "hooks", "workflow-check.sh");
   if (await rewriteWrapperScript(workflowCheckPath, () => writeWorkflowCheckScript(root))) {
     log.success("Rewrote .claude/hooks/workflow-check.sh to canonical jq+stdin form");
@@ -1753,13 +1873,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 +1900,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 +1988,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 +2039,316 @@ 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: "outdated pattern",
+    fix: (root) => upgradeForcePushPattern(root)
+  },
+  {
+    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 -->")
+      );
+    }
+  },
+  {
+    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);
     }
-    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);
-  } }
+  }
 ];
 function hasAutoFix(issue) {
   return FIX_TABLE.some(
@@ -1985,7 +2379,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 +2408,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 +2429,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 +2464,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 +2508,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 +2536,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());
@@ -2293,6 +2714,7 @@ export {
   jqField,
   hasEnvVarHookPattern,
   isJqAvailable,
+  FORCE_PUSH_ERE,
   SPRINT_COMPLETE_NUDGE,
   WORKFLOW_CHECK_WRAPPER,
   SPRINT_OPEN_WRAPPER,
@@ -2303,6 +2725,8 @@ export {
   WORKFLOW_RULE_VERSION,
   generateWorkflowRule,
   generateHooksRule,
+  VERIFICATION_RULE_VERSION,
+  generateVerificationRule,
   generateReviewerAgent,
   applyFixes,
   log,
@@ -2310,4 +2734,4 @@ export {
   printScoreCard,
   renderDoctorReport
 };
-//# sourceMappingURL=chunk-KPO4YURF.js.map
+//# sourceMappingURL=chunk-U2TFIUGE.js.map