claude-launchpad 0.3.4 → 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mboss37
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,25 +1,53 @@
 # Claude Launchpad
 
-**A linter for your Claude Code configuration.** Scores your setup, auto-fixes issues, and tests if Claude actually follows your rules.
+[![npm version](https://img.shields.io/npm/v/claude-launchpad?style=flat-square)](https://www.npmjs.com/package/claude-launchpad)
+[![npm downloads](https://img.shields.io/npm/dm/claude-launchpad?style=flat-square)](https://www.npmjs.com/package/claude-launchpad)
+[![GitHub stars](https://img.shields.io/github/stars/mboss37/claude-launchpad?style=flat-square)](https://github.com/mboss37/claude-launchpad)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](https://github.com/mboss37/claude-launchpad/blob/master/LICENSE)
 
-You write a `CLAUDE.md`, add some hooks, configure settings — but is any of it actually working? Claude Launchpad scans your config, gives you a score out of 100, fixes what's broken, and runs Claude against test scenarios to prove it.
+**Everything you need to launch a project with Claude Code — and keep it healthy.**
+
+A launchpad isn't just where you start. It's where you prepare, run checks, and make sure everything is ready before you go. Claude Launchpad does exactly that for your Claude Code setup:
+
+- **Launch new projects** with production-ready Claude Code config from day one
+- **Check existing projects** — score your config, find issues, auto-fix them
+- **Prove it works** — run Claude against test scenarios and see if your rules are actually followed
 
 ```bash
-npx claude-launchpad
+npm i -g claude-launchpad
+cd your-project
 ```
 
-That's it. One command. You get a score. You see what's wrong. You fix it.
+## Two Paths, One Tool
 
-## What It Does
+### Starting a new project?
 
-| Command | What it does | Cost |
-|---|---|---|
-| `claude-launchpad` | Scans your config, scores it 0-100, lists issues | Free |
-| `claude-launchpad doctor --fix` | Auto-fixes issues (adds hooks, rules, missing sections) | Free |
-| `claude-launchpad doctor --watch` | Live score that updates when you edit config files | Free |
-| `claude-launchpad init` | Detects your stack, generates config from scratch | Free |
-| `claude-launchpad enhance` | Opens Claude to read your code and complete CLAUDE.md | Uses Claude |
-| `claude-launchpad eval --suite security` | Runs Claude against test scenarios, proves your config works | Uses Claude |
+```bash
+claude-launchpad init
+```
+
+Detects your stack, generates `CLAUDE.md` with your commands and conventions, creates `TASKS.md` for sprint tracking and session continuity, sets up hooks for auto-formatting and `.env` protection, and adds a `.claudeignore` so Claude doesn't waste time reading `node_modules`.
+
+Then run `enhance` to have Claude read your codebase and fill in the architecture, conventions, and guardrails with real, project-specific content — not boilerplate.
+
+### Already have a project?
+
+```bash
+claude-launchpad
+```
+
+Scans your Claude Code config, gives you a score out of 100, and tells you exactly what's wrong. Run `--fix` to auto-apply fixes. Run `--watch` to see the score update live as you edit. Run `eval` to prove your config actually makes Claude behave.
+
+## All Commands
+
+| Command | What it does |
+|---|---|
+| `claude-launchpad init` | Launch a new project: detects stack, generates config, security rules, hooks, permissions |
+| `claude-launchpad` | Check your config: score it 0-100, list issues |
+| `claude-launchpad doctor --fix` | Auto-fix issues: adds hooks, rules, missing sections, .claudeignore |
+| `claude-launchpad doctor --watch` | Live score that updates when you save config files |
+| `claude-launchpad enhance` | Claude reads your code and completes CLAUDE.md with real content |
+| `claude-launchpad eval --suite security` | Run Claude against test scenarios, prove your config works |
 
 ## Quick Start
 
@@ -40,7 +68,7 @@ claude-launchpad doctor --fix
 claude-launchpad
 ```
 
-That takes you from ~42% to ~86% with zero manual work.
+That takes you from ~42% to ~93% with zero manual work.
 
 ## The Doctor
 
@@ -88,23 +116,26 @@ Detects your project and generates Claude Code config that fits. No templates, n
 
 ```
   → Detecting project...
-  ✓ Found Next.js (TypeScript) project
+  ✓ Found Next.js project
   · Package manager: pnpm
-  · Dev command: pnpm dev
 
   ✓ Generated CLAUDE.md
   ✓ Generated TASKS.md
-  ✓ Generated .claude/settings.json (with hooks)
+  ✓ Generated .claude/settings.json (schema, permissions, hooks)
+  ✓ Generated .claude/.gitignore
   ✓ Generated .claudeignore
+  ✓ Generated .claude/rules/conventions.md
 ```
 
 **Works with:** TypeScript, JavaScript, Python, Go, Ruby, Rust, Dart, PHP, Java, Kotlin, Swift, Elixir, C# — and detects frameworks (Next.js, FastAPI, Django, Rails, Laravel, Express, SvelteKit, Angular, NestJS, and 15+ more).
 
-**What you get:**
+**What you get (6 files):**
 - `CLAUDE.md` — your stack, commands, conventions, guardrails
-- `TASKS.md` — session continuity across Claude Code sessions
-- `.claude/settings.json` — auto-format hooks and .env file protection
-- `.claudeignore` — keeps Claude from reading node_modules, dist, lockfiles, etc.
+- `TASKS.md` — sprint tracking and session continuity
+- `.claude/settings.json` — `$schema` for IDE autocomplete, `permissions.deny` for security, hooks for .env protection + destructive command blocking + auto-format
+- `.claude/.gitignore` — prevents local settings and plans from being committed
+- `.claudeignore` — language-specific ignore patterns
+- `.claude/rules/conventions.md` — language-specific starter rules
 
 ## Enhance
 
@@ -210,7 +241,7 @@ Then use `/launchpad:doctor`, `/launchpad:init`, `/launchpad:enhance`, `/launchp
 
 **Doctor** reads your files and runs static analysis. No API calls. No network. No cost.
 
-**Init** scans manifest files (package.json, go.mod, pyproject.toml, etc.), detects your stack, and generates config with safe, hardcoded formatter hooks — never interpolates user-controlled strings.
+**Init** scans manifest files (package.json, go.mod, pyproject.toml, etc.), detects your stack, and generates 6 files: CLAUDE.md, TASKS.md, settings.json (with $schema, permissions.deny, and hooks), .claude/.gitignore, .claudeignore, and language-specific rules. Formatter hooks use hardcoded safe commands only.
 
 **Enhance** spawns `claude "prompt"` as an interactive child process. You see Claude's full UI. No data passes through the tool — it just launches Claude with a task.
 
@@ -225,6 +256,23 @@ Then use `/launchpad:doctor`, `/launchpad:init`, `/launchpad:enhance`, `/launchp
 
 This tool gives you a number. Fix the issues, re-run, watch the number go up.
 
+## Glossary
+
+New to Claude Code? Here's what the terms mean:
+
+| Term | What it is |
+|---|---|
+| **CLAUDE.md** | A markdown file in your project root that tells Claude how to work on your code. Think of it as instructions for your AI pair programmer. [Official docs](https://docs.anthropic.com/en/docs/claude-code/memory#claudemd) |
+| **Hooks** | Shell commands that run automatically when Claude does something. For example: auto-format a file after Claude edits it, or block Claude from reading your `.env` file. They live in `.claude/settings.json`. |
+| **Instruction budget** | CLAUDE.md has a soft limit of ~150 actionable lines. Past that, Claude starts ignoring rules at the bottom. Doctor counts your lines and warns you. |
+| **Rules** | Extra markdown files in `.claude/rules/` that Claude reads alongside CLAUDE.md. Use them to offload detailed conventions so CLAUDE.md stays under budget. |
+| **MCP Servers** | External tools Claude can connect to (databases, APIs, docs). Configured in `.claude/settings.json`. Most projects don't need them. |
+| **.claudeignore** | Like `.gitignore` but for Claude. Tells Claude which files to skip (node_modules, dist, lockfiles) so it doesn't waste time reading noise. |
+
+## Privacy
+
+No telemetry. No analytics. No data sent anywhere. Doctor, init, and fix are fully offline. Enhance and eval run through your local Claude CLI — no data passes through this tool. [Full privacy policy](https://mboss37.github.io/claude-launchpad/privacy.html).
+
 ## License
 
 MIT

package/dist/cli.js

@@ -248,98 +248,35 @@ function detectPackageManager(m, lockfiles) {
   if (m.composerJson) return "composer";
   return null;
 }
+var LANGUAGE_SCRIPTS = {
+  Go: { devCommand: "go run .", buildCommand: "go build .", testCommand: "go test ./...", lintCommand: "golangci-lint run", formatCommand: "gofmt -w ." },
+  Ruby: { devCommand: "bin/dev", buildCommand: null, testCommand: "bin/rails test", lintCommand: "bin/rubocop", formatCommand: null },
+  PHP: { devCommand: "php artisan serve", buildCommand: null, testCommand: "php artisan test", lintCommand: "vendor/bin/phpstan analyse", formatCommand: "vendor/bin/pint" },
+  Rust: { devCommand: "cargo run", buildCommand: "cargo build", testCommand: "cargo test", lintCommand: "cargo clippy", formatCommand: "cargo fmt" },
+  Java: { devCommand: null, buildCommand: "mvn package", testCommand: "mvn test", lintCommand: null, formatCommand: null },
+  Kotlin: { devCommand: null, buildCommand: "mvn package", testCommand: "mvn test", lintCommand: null, formatCommand: null },
+  Swift: { devCommand: null, buildCommand: "swift build", testCommand: "swift test", lintCommand: "swiftlint", formatCommand: "swift-format format -r ." },
+  Elixir: { devCommand: "mix phx.server", buildCommand: "mix compile", testCommand: "mix test", lintCommand: "mix credo", formatCommand: "mix format" },
+  "C#": { devCommand: "dotnet run", buildCommand: "dotnet build", testCommand: "dotnet test", lintCommand: null, formatCommand: "dotnet format" }
+};
 function detectScripts(m) {
-  const scripts = m.pkgJson?.scripts ?? {};
   if (m.pkgJson) {
+    const scripts = m.pkgJson.scripts ?? {};
+    const run = pmRun(m.pkgJson);
     return {
-      devCommand: scripts.dev ? `${pmRun(m.pkgJson)} dev` : null,
-      buildCommand: scripts.build ? `${pmRun(m.pkgJson)} build` : null,
-      testCommand: scripts.test ? `${pmRun(m.pkgJson)} test` : null,
-      lintCommand: scripts.lint ? `${pmRun(m.pkgJson)} lint` : null,
-      formatCommand: scripts.format ? `${pmRun(m.pkgJson)} format` : null
-    };
-  }
-  if (m.language === "Go") {
-    return {
-      devCommand: "go run .",
-      buildCommand: "go build .",
-      testCommand: "go test ./...",
-      lintCommand: "golangci-lint run",
-      formatCommand: "gofmt -w ."
+      devCommand: scripts.dev ? `${run} dev` : null,
+      buildCommand: scripts.build ? `${run} build` : null,
+      testCommand: scripts.test ? `${run} test` : null,
+      lintCommand: scripts.lint ? `${run} lint` : null,
+      formatCommand: scripts.format ? `${run} format` : null
     };
   }
   if (m.language === "Python") {
-    const runner = m.pyProject?.includes("[tool.uv]") ? "uv run" : "python -m";
-    return {
-      devCommand: null,
-      buildCommand: null,
-      testCommand: `${runner} pytest`,
-      lintCommand: `${runner} ruff check .`,
-      formatCommand: `${runner} ruff format .`
-    };
-  }
-  if (m.gemfile) {
-    return {
-      devCommand: "bin/dev",
-      buildCommand: null,
-      testCommand: "bin/rails test",
-      lintCommand: "bin/rubocop",
-      formatCommand: null
-    };
-  }
-  if (m.language === "PHP") {
-    return {
-      devCommand: "php artisan serve",
-      buildCommand: null,
-      testCommand: "php artisan test",
-      lintCommand: "vendor/bin/phpstan analyse",
-      formatCommand: "vendor/bin/pint"
-    };
+    const r = m.pyProject?.includes("[tool.uv]") ? "uv run" : "python -m";
+    return { devCommand: null, buildCommand: null, testCommand: `${r} pytest`, lintCommand: `${r} ruff check .`, formatCommand: `${r} ruff format .` };
   }
-  if (m.language === "Rust") {
-    return {
-      devCommand: "cargo run",
-      buildCommand: "cargo build",
-      testCommand: "cargo test",
-      lintCommand: "cargo clippy",
-      formatCommand: "cargo fmt"
-    };
-  }
-  if (m.language === "Java" || m.language === "Kotlin") {
-    return {
-      devCommand: null,
-      buildCommand: "mvn package",
-      testCommand: "mvn test",
-      lintCommand: null,
-      formatCommand: null
-    };
-  }
-  if (m.language === "Swift") {
-    return {
-      devCommand: null,
-      buildCommand: "swift build",
-      testCommand: "swift test",
-      lintCommand: "swiftlint",
-      formatCommand: "swift-format format -r ."
-    };
-  }
-  if (m.language === "Elixir") {
-    return {
-      devCommand: "mix phx.server",
-      buildCommand: "mix compile",
-      testCommand: "mix test",
-      lintCommand: "mix credo",
-      formatCommand: "mix format"
-    };
-  }
-  if (m.language === "C#") {
-    return {
-      devCommand: "dotnet run",
-      buildCommand: "dotnet build",
-      testCommand: "dotnet test",
-      lintCommand: null,
-      formatCommand: "dotnet format"
-    };
+  if (m.language && LANGUAGE_SCRIPTS[m.language]) {
+    return LANGUAGE_SCRIPTS[m.language];
   }
   return { devCommand: null, buildCommand: null, testCommand: null, lintCommand: null, formatCommand: null };
 }
@@ -440,7 +377,14 @@ function generateSettings(detected) {
     matcher: "Read|Write|Edit",
     hooks: [{
       type: "command",
-      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -qE '\\.(env|env\\..*)$' && ! echo "$TOOL_INPUT_FILE_PATH" | grep -q '.env.example' && echo 'BLOCKED: .env files contain secrets \u2014 use .env.example for documentation' && exit 1; exit 0`
+      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -qE '\\.(env|env\\..*)$' && ! echo "$TOOL_INPUT_FILE_PATH" | grep -q '.env.example' && echo 'BLOCKED: .env files contain secrets' && exit 1; exit 0`
+    }]
+  });
+  preToolUse.push({
+    matcher: "Bash",
+    hooks: [{
+      type: "command",
+      command: `echo "$TOOL_INPUT_COMMAND" | grep -qE 'rm\\s+-rf\\s+/|DROP\\s+TABLE|DROP\\s+DATABASE|push.*--force|push.*-f' && echo 'BLOCKED: Destructive command detected' && exit 1; exit 0`
     }]
   });
   const formatHook = buildFormatHook(detected);
@@ -450,7 +394,19 @@ function generateSettings(detected) {
   const hooks = {};
   if (preToolUse.length > 0) hooks.PreToolUse = preToolUse;
   if (postToolUse.length > 0) hooks.PostToolUse = postToolUse;
-  return Object.keys(hooks).length > 0 ? { hooks } : {};
+  return {
+    $schema: "https://json.schemastore.org/claude-code-settings.json",
+    permissions: {
+      deny: [
+        "Bash(rm -rf /)",
+        "Bash(rm -rf ~)",
+        "Read(.env)",
+        "Read(.env.*)",
+        "Read(secrets/**)"
+      ]
+    },
+    hooks
+  };
 }
 var SAFE_FORMATTERS = {
   TypeScript: { extensions: ["ts", "tsx"], command: "npx prettier --write" },
@@ -649,11 +605,15 @@ async function scaffold(root, options, detected) {
   const tasksMd = generateTasksMd(options);
   const settings = generateSettings(detected);
   const claudeignore = generateClaudeignore(detected);
-  await mkdir(join2(root, ".claude"), { recursive: true });
+  await mkdir(join2(root, ".claude", "rules"), { recursive: true });
   const settingsPath = join2(root, ".claude", "settings.json");
   const mergedSettings = await mergeSettings(settingsPath, settings);
   const claudeignorePath = join2(root, ".claudeignore");
   const hasClaudeignore = await fileExists(claudeignorePath);
+  const claudeGitignorePath = join2(root, ".claude", ".gitignore");
+  const hasClaudeGitignore = await fileExists(claudeGitignorePath);
+  const rulesPath = join2(root, ".claude", "rules", "conventions.md");
+  const hasRules = await fileExists(rulesPath);
   const writes = [
     writeFile(join2(root, "CLAUDE.md"), claudeMd),
     writeFile(join2(root, "TASKS.md"), tasksMd),
@@ -662,18 +622,61 @@ async function scaffold(root, options, detected) {
   if (!hasClaudeignore) {
     writes.push(writeFile(claudeignorePath, claudeignore));
   }
+  if (!hasClaudeGitignore) {
+    writes.push(writeFile(claudeGitignorePath, [
+      "# Local-only Claude Code files (never commit these)",
+      "settings.local.json",
+      "plans/",
+      "memory/",
+      "sessions/",
+      "tmp/",
+      ""
+    ].join("\n")));
+  }
+  if (!hasRules) {
+    const rulesContent = generateStarterRules(detected);
+    writes.push(writeFile(rulesPath, rulesContent));
+  }
   await Promise.all(writes);
   log.success("Generated CLAUDE.md");
   log.success("Generated TASKS.md");
-  log.success("Generated .claude/settings.json (merged with existing)");
-  if (!hasClaudeignore) {
-    log.success("Generated .claudeignore");
-  }
+  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");
   log.blank();
   log.success("Done! Run `claude` to start.");
   log.info("Run `claude-launchpad doctor` to check your config quality.");
   log.blank();
 }
+function generateStarterRules(detected) {
+  const lines = [
+    "# Project Conventions",
+    "",
+    "- Use conventional commits (feat:, fix:, docs:, refactor:, test:, chore:)",
+    "- Keep files under 400 lines, functions under 50 lines",
+    "- Handle errors explicitly - no empty catch blocks",
+    "- Validate input at system boundaries"
+  ];
+  if (detected.language === "TypeScript" || detected.language === "JavaScript") {
+    lines.push("- Use named exports, no default exports except Next.js pages");
+    lines.push("- No `any` types in TypeScript");
+  }
+  if (detected.language === "Python") {
+    lines.push("- Type hints on all function signatures");
+    lines.push("- Async everywhere for I/O operations");
+  }
+  if (detected.language === "Go") {
+    lines.push("- Table-driven tests");
+    lines.push("- Errors are values - handle them, don't ignore them");
+  }
+  if (detected.language === "Rust") {
+    lines.push("- Prefer Result over unwrap/expect in library code");
+    lines.push("- No unsafe blocks without a safety comment");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
 async function mergeSettings(existingPath, generated) {
   try {
     const existing = JSON.parse(await readFile2(existingPath, "utf-8"));
@@ -1247,50 +1250,35 @@ async function applyFixes(issues, projectRoot) {
   }
   return { fixed, skipped };
 }
-async function tryFix(issue, root, detected) {
-  if (issue.analyzer === "Hooks" && issue.message.includes("No hooks configured")) {
+var FIX_TABLE = [
+  { 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);
     return a || b || c;
-  }
-  if (issue.analyzer === "Hooks" && issue.message.includes(".env file protection")) {
-    return addEnvProtectionHook(root);
-  }
-  if (issue.analyzer === "Hooks" && issue.message.includes("auto-format")) {
-    return addAutoFormatHook(root, detected);
-  }
-  if (issue.analyzer === "Hooks" && issue.message.includes("No PreToolUse")) {
-    return addEnvProtectionHook(root);
-  }
-  if (issue.analyzer === "Quality" && issue.message.includes("Architecture")) {
-    return addClaudeMdSection(root, "## Architecture", "<!-- TODO: Describe your codebase structure. Run `claude-launchpad enhance` to auto-fill this. -->");
-  }
-  if (issue.analyzer === "Quality" && issue.message.includes("Off-Limits")) {
-    return addClaudeMdSection(root, "## Off-Limits", "- Never hardcode secrets \u2014 use environment variables\n- Never write to `.env` files\n- Never expose internal error details in API responses");
-  }
-  if (issue.analyzer === "Quality" && issue.message.includes("Commands")) {
-    return addClaudeMdSection(root, "## Commands", "<!-- TODO: Add your dev/build/test commands -->");
-  }
-  if (issue.analyzer === "Quality" && issue.message.includes("Stack")) {
-    const stackContent = detected.language ? `- **Language**: ${detected.language}${detected.framework ? `
+  } },
+  { 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", "<!-- TODO: Describe your codebase structure. Run `claude-launchpad enhance` to auto-fill this. -->") },
+  { analyzer: "Quality", match: "Off-Limits", fix: (root) => addClaudeMdSection(root, "## Off-Limits", "- Never hardcode secrets - use environment variables\n- Never write to `.env` files\n- Never expose internal error details in API responses") },
+  { analyzer: "Quality", match: "Commands", fix: (root) => addClaudeMdSection(root, "## Commands", "<!-- TODO: Add your dev/build/test commands -->") },
+  { analyzer: "Quality", match: "Stack", fix: (root, detected) => {
+    const content = detected.language ? `- **Language**: ${detected.language}${detected.framework ? `
 - **Framework**: ${detected.framework}` : ""}${detected.packageManager ? `
 - **Package Manager**: ${detected.packageManager}` : ""}` : "<!-- TODO: Define your tech stack -->";
-    return addClaudeMdSection(root, "## Stack", stackContent);
-  }
-  if (issue.analyzer === "Quality" && issue.message.includes("Session Start")) {
-    return addClaudeMdSection(root, "## Session Start", "- ALWAYS read @TASKS.md first \u2014 it tracks progress across sessions\n- Update TASKS.md as you complete work");
-  }
-  if (issue.analyzer === "Rules" && issue.message.includes("No .claudeignore")) {
-    return createClaudeignore(root, detected);
-  }
-  if (issue.analyzer === "Rules" && issue.message.includes("No .claude/rules/")) {
-    return createStarterRules(root);
-  }
-  if (issue.analyzer === "Permissions" && issue.message.includes("force-push")) {
-    return addForcePushProtection(root);
-  }
-  return false;
+    return addClaudeMdSection(root, "## Stack", content);
+  } },
+  { analyzer: "Quality", match: "Session Start", fix: (root) => addClaudeMdSection(root, "## Session Start", "- ALWAYS read @TASKS.md first - it tracks progress across sessions\n- Update TASKS.md as you complete work") },
+  { analyzer: "Rules", match: "No .claudeignore", fix: (root, detected) => createClaudeignore(root, detected) },
+  { analyzer: "Rules", match: "No .claude/rules/", fix: (root) => createStarterRules(root) },
+  { analyzer: "Permissions", match: "force-push", fix: (root) => addForcePushProtection(root) }
+];
+async function tryFix(issue, root, detected) {
+  const entry = FIX_TABLE.find(
+    (e) => e.analyzer === issue.analyzer && issue.message.includes(e.match)
+  );
+  return entry ? entry.fix(root, detected) : false;
 }
 async function addEnvProtectionHook(root) {
   const settings = await readSettingsJson(root);
@@ -2180,7 +2168,7 @@ function createEnhanceCommand() {
 }
 
 // src/cli.ts
-var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.3.4", "-v, --version").action(async () => {
+var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.4.0", "-v, --version").action(async () => {
   const hasConfig = await fileExists(join11(process.cwd(), "CLAUDE.md")) || await fileExists(join11(process.cwd(), ".claude", "settings.json"));
   if (hasConfig) {
     await program.commands.find((c) => c.name() === "doctor")?.parseAsync([], { from: "user" });