claude-launchpad 0.16.0 → 0.16.1

package/dist/cli.js

@@ -1,234 +1,31 @@
 #!/usr/bin/env node
-import {
-  getMemoryPlacement,
-  readSettingsJson,
-  readSettingsLocalJson,
-  writeSettingsJson,
-  writeSettingsLocalJson
-} from "./chunk-SBA5KYQU.js";
 import {
   readSyncConfig
 } from "./chunk-JQDMBE7W.js";
 import {
+  ENHANCE_SKILL_VERSION,
+  applyFixes,
+  detectProject,
+  fileExists,
+  generateClaudeignore,
+  generateEnhanceSkill,
   log,
   printBanner,
   printScoreCard,
+  readFileOrNull,
   renderDoctorReport
-} from "./chunk-RJGXPH7P.js";
+} from "./chunk-S4WIADYE.js";
 
 // src/cli.ts
 import { Command as Command5 } from "commander";
-import { join as join12 } from "path";
+import { join as join9 } from "path";
 
 // src/commands/init/index.ts
 import { Command } from "commander";
 import { input, confirm, select } from "@inquirer/prompts";
-import { writeFile, mkdir, readFile as readFile2 } from "fs/promises";
+import { writeFile, mkdir, readFile } from "fs/promises";
 import { homedir } from "os";
-import { join as join2 } from "path";
-
-// src/lib/fs-utils.ts
-import { readFile, access } from "fs/promises";
-async function fileExists(path) {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readFileOrNull(path) {
-  try {
-    return await readFile(path, "utf-8");
-  } catch {
-    return null;
-  }
-}
-async function readJsonOrNull(path) {
-  try {
-    const content = await readFile(path, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-
-// src/lib/detect.ts
-import { join, basename } from "path";
-async function detectProject(root) {
-  const name = basename(root);
-  const [pkgJson, goMod, pyProject, gemfile, cargo, pubspec, composerJson, pomXml, buildGradleGroovy, buildGradleKts, packageSwift, mixExs, csproj, lockfiles] = await Promise.all([
-    readJsonOrNull(join(root, "package.json")),
-    fileExists(join(root, "go.mod")),
-    readFileOrNull(join(root, "pyproject.toml")),
-    fileExists(join(root, "Gemfile")),
-    fileExists(join(root, "Cargo.toml")),
-    fileExists(join(root, "pubspec.yaml")),
-    readJsonOrNull(join(root, "composer.json")),
-    fileExists(join(root, "pom.xml")),
-    fileExists(join(root, "build.gradle")),
-    fileExists(join(root, "build.gradle.kts")),
-    fileExists(join(root, "Package.swift")),
-    fileExists(join(root, "mix.exs")),
-    globExists(root, "*.csproj"),
-    detectLockfiles(root)
-  ]);
-  const buildGradle = buildGradleGroovy || buildGradleKts;
-  const manifests = {
-    pkgJson,
-    goMod,
-    pyProject,
-    gemfile,
-    cargo,
-    pubspec,
-    composerJson,
-    pomXml,
-    buildGradle,
-    packageSwift,
-    mixExs,
-    csproj
-  };
-  const language = detectLanguage(manifests);
-  const framework = detectFramework(manifests);
-  const packageManager = detectPackageManager(manifests, lockfiles);
-  const scripts = detectScripts({ pkgJson, pyProject, goMod, gemfile, composerJson, language });
-  return {
-    name,
-    language,
-    framework,
-    packageManager,
-    hasTests: scripts.testCommand !== null,
-    hasLinter: scripts.lintCommand !== null,
-    hasFormatter: scripts.formatCommand !== null,
-    ...scripts
-  };
-}
-function detectLanguage(m) {
-  if (m.pkgJson?.devDependencies?.typescript || m.pkgJson?.dependencies?.typescript) return "TypeScript";
-  if (m.pkgJson) return "JavaScript";
-  if (m.goMod) return "Go";
-  if (m.pyProject) return "Python";
-  if (m.gemfile) return "Ruby";
-  if (m.cargo) return "Rust";
-  if (m.pubspec) return "Dart";
-  if (m.composerJson) return "PHP";
-  if (m.buildGradle) return "Kotlin";
-  if (m.pomXml) return "Java";
-  if (m.packageSwift) return "Swift";
-  if (m.mixExs) return "Elixir";
-  if (m.csproj) return "C#";
-  return null;
-}
-function detectFramework(m) {
-  const deps = { ...m.pkgJson?.dependencies, ...m.pkgJson?.devDependencies };
-  if (deps.next) return "Next.js";
-  if (deps.nuxt) return "Nuxt";
-  if (deps.svelte || deps["@sveltejs/kit"]) return "SvelteKit";
-  if (deps.astro) return "Astro";
-  if (deps["@angular/core"]) return "Angular";
-  if (deps.remix || deps["@remix-run/react"]) return "Remix";
-  if (deps.vue) return "Vue";
-  if (deps.react && !deps.next) return "React";
-  if (deps.express) return "Express";
-  if (deps.fastify) return "Fastify";
-  if (deps.hono) return "Hono";
-  if (deps.nestjs || deps["@nestjs/core"]) return "NestJS";
-  if (m.pyProject) {
-    if (m.pyProject.includes("fastapi")) return "FastAPI";
-    if (m.pyProject.includes("django")) return "Django";
-    if (m.pyProject.includes("flask")) return "Flask";
-  }
-  if (m.composerJson) {
-    const phpDeps = { ...m.composerJson.require, ...m.composerJson["require-dev"] };
-    if (phpDeps["laravel/framework"]) return "Laravel";
-    if (phpDeps["symfony/framework-bundle"]) return "Symfony";
-  }
-  if (m.gemfile) return "Rails";
-  if (m.buildGradle) return "Gradle";
-  if (m.pomXml) return "Maven";
-  return null;
-}
-async function detectLockfiles(root) {
-  const [pnpmLock, yarnLock, bunLock, npmLock] = await Promise.all([
-    fileExists(join(root, "pnpm-lock.yaml")),
-    fileExists(join(root, "yarn.lock")),
-    fileExists(join(root, "bun.lockb")),
-    fileExists(join(root, "package-lock.json"))
-  ]);
-  return { pnpmLock, yarnLock, bunLock, npmLock };
-}
-function detectPackageManager(m, lockfiles) {
-  if (m.pkgJson) {
-    const pm = m.pkgJson.packageManager;
-    if (pm?.startsWith("pnpm")) return "pnpm";
-    if (pm?.startsWith("yarn")) return "yarn";
-    if (pm?.startsWith("bun")) return "bun";
-    if (pm?.startsWith("npm")) return "npm";
-    if (lockfiles.pnpmLock) return "pnpm";
-    if (lockfiles.yarnLock) return "yarn";
-    if (lockfiles.bunLock) return "bun";
-    if (lockfiles.npmLock) return "npm";
-    return "npm";
-  }
-  if (m.goMod) return "go modules";
-  if (m.pyProject) {
-    if (m.pyProject.includes("[tool.uv]")) return "uv";
-    if (m.pyProject.includes("[tool.poetry]")) return "poetry";
-    return "pip";
-  }
-  if (m.gemfile) return "bundler";
-  if (m.cargo) return "cargo";
-  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) {
-  if (m.pkgJson) {
-    const scripts = m.pkgJson.scripts ?? {};
-    const run = pmRun(m.pkgJson);
-    return {
-      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 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 && LANGUAGE_SCRIPTS[m.language]) {
-    return LANGUAGE_SCRIPTS[m.language];
-  }
-  return { devCommand: null, buildCommand: null, testCommand: null, lintCommand: null, formatCommand: null };
-}
-function pmRun(pkg) {
-  const pm = pkg.packageManager;
-  if (pm?.startsWith("pnpm")) return "pnpm";
-  if (pm?.startsWith("yarn")) return "yarn";
-  if (pm?.startsWith("bun")) return "bun";
-  return "npm run";
-}
-async function globExists(dir, pattern) {
-  const { readdir: readdir5 } = await import("fs/promises");
-  try {
-    const entries = await readdir5(dir);
-    return entries.some((e) => e.endsWith(pattern.replace("*", "")));
-  } catch {
-    return false;
-  }
-}
+import { join } from "path";
 
 // src/commands/init/generators/claude-md.ts
 function generateClaudeMd(options, detected) {
@@ -403,334 +200,6 @@ function buildFormatHook(detected) {
   };
 }
 
-// src/commands/init/generators/claudeignore.ts
-function generateClaudeignore(detected) {
-  const sections = ["# Generated by claude-launchpad"];
-  sections.push(`
-# Dependencies
-node_modules/
-.pnp/
-.yarn/
-
-# Build output
-dist/
-build/
-out/
-.next/
-.nuxt/
-.output/
-.svelte-kit/
-.vercel/
-.turbo/
-
-# Package manager
-pnpm-lock.yaml
-package-lock.json
-yarn.lock
-bun.lockb
-
-# IDE & OS
-.vscode/
-.idea/
-*.swp
-*.swo
-.DS_Store
-Thumbs.db
-
-# Test & coverage
-coverage/
-.nyc_output/
-__snapshots__/
-
-# Environment (should never be read)
-.env
-.env.*
-!.env.example`);
-  const lang = detected.language;
-  if (lang === "Python") {
-    sections.push(`
-# Python
-__pycache__/
-*.pyc
-*.pyo
-.venv/
-venv/
-.mypy_cache/
-.ruff_cache/
-.pytest_cache/
-*.egg-info/`);
-  }
-  if (lang === "Go") {
-    sections.push(`
-# Go
-bin/
-vendor/`);
-  }
-  if (lang === "Rust") {
-    sections.push(`
-# Rust
-target/
-Cargo.lock`);
-  }
-  if (lang === "Ruby") {
-    sections.push(`
-# Ruby
-vendor/bundle/
-.bundle/
-tmp/
-log/`);
-  }
-  if (lang === "Java" || lang === "Kotlin") {
-    sections.push(`
-# JVM
-target/
-build/
-.gradle/
-*.class
-*.jar`);
-  }
-  if (lang === "Dart") {
-    sections.push(`
-# Dart/Flutter
-.dart_tool/
-.packages
-build/`);
-  }
-  if (lang === "PHP") {
-    sections.push(`
-# PHP
-vendor/
-composer.lock`);
-  }
-  if (lang === "C#") {
-    sections.push(`
-# .NET
-bin/
-obj/
-*.dll`);
-  }
-  if (lang === "Elixir") {
-    sections.push(`
-# Elixir
-_build/
-deps/
-.elixir_ls/`);
-  }
-  if (lang === "Swift") {
-    sections.push(`
-# Swift
-.build/
-DerivedData/
-*.xcuserdata`);
-  }
-  return sections.join("\n") + "\n";
-}
-
-// src/commands/init/generators/skill-enhance.ts
-var ENHANCE_SKILL_VERSION = 5;
-function generateEnhanceSkill() {
-  return [
-    "---",
-    "name: lp-enhance",
-    "description: |",
-    "  AI-improve your CLAUDE.md based on codebase analysis. Fills in architecture, conventions, guardrails, and suggests hooks and MCP servers.",
-    '  TRIGGER when: user runs /lp-enhance, asks to "improve CLAUDE.md", "fill in architecture", or after major refactors.',
-    "  DO NOT TRIGGER when: user is editing CLAUDE.md manually, doing normal coding, or running doctor/eval.",
-    "allowed-tools: Read, Glob, Grep, Edit, Write",
-    "argument-hint: (no arguments needed)",
-    "---",
-    "",
-    `<!-- lp-enhance-version: ${ENHANCE_SKILL_VERSION} -->`,
-    "",
-    "# lp-enhance - AI-powered CLAUDE.md improver",
-    "",
-    "Read CLAUDE.md and the project's codebase, then update CLAUDE.md to fill in missing or incomplete sections.",
-    "",
-    "## Phase 1: Research",
-    "",
-    "1. Read CLAUDE.md (if it exists)",
-    "2. Read .claude/settings.json (hooks, permissions, MCP)",
-    "3. Read .claude/rules/*.md (existing rules)",
-    "4. Read .claudeignore (if it exists)",
-    "5. Scan src/ directory structure (top-level dirs, key files)",
-    "6. Read package.json / go.mod / pyproject.toml for stack detection",
-    "7. Check for monorepo indicators (workspaces, nx.json, lerna.json)",
-    "8. Check scenarios/ directory for existing eval scenarios",
-    "",
-    "**Done when:** you have a mental model of the stack, architecture, and existing config.",
-    "",
-    "## Phase 2: Plan",
-    "",
-    "Count current CLAUDE.md actionable lines. Budget is 200 lines max. Plan which sections to add or improve:",
-    "",
-    "1. **## Stack** - detect language, framework, package manager",
-    "2. **## Architecture** - 3-5 bullets describing codebase shape",
-    "3. **## Conventions** - max 8 key patterns. Overflow to .claude/rules/conventions.md",
-    "4. **## Off-Limits** - max 8 guardrails specific to this project",
-    "5. **## Memory** - ONLY if agentic-memory is configured in settings.json. Max 6 bullets.",
-    "6. **## Key Decisions** - only decisions that affect how Claude works in this codebase",
-    "",
-    "7. **Skill Authoring** - if .claude/rules/conventions.md lacks a Skill Authoring section, plan to add one",
-    "",
-    "If any section would exceed 8 bullets, plan a .claude/rules/ file for the overflow.",
-    "",
-    "**Done when:** you know exactly what to add/change and the line count stays under 200.",
-    "",
-    "## Phase 3: Execute",
-    "",
-    "Edit CLAUDE.md with the planned changes. Then:",
-    "",
-    "1. Create or update .claude/rules/ files for overflow content",
-    "2. Generate path-scoped rules if the project has distinct areas (see below)",
-    "3. Review .claudeignore and print suggestions (see below)",
-    "4. Generate 2-3 custom eval scenarios in scenarios/custom/ (see below)",
-    "5. Verify line count is under 200",
-    "",
-    "**Rules:**",
-    "- Don't remove existing content, only add or improve",
-    "- Be specific to THIS project, not generic advice",
-    "- Use bullet points, not paragraphs",
-    "",
-    "## Phase 4: Verify",
-    "",
-    "1. Run `claude-launchpad doctor` to check the score improved",
-    "2. Print suggested hooks (exact JSON) for .claude/settings.json but don't modify it",
-    "3. Print suggested MCP servers if external services detected (Postgres, Redis, Stripe, etc.)",
-    '4. If eval scenarios were generated, print: "Run this in your terminal (not inside Claude Code): `claude-launchpad eval --scenarios scenarios/ --runs 1`"',
-    "",
-    "**Done when:** doctor score is equal or higher, suggestions printed, eval scenarios created if applicable.",
-    "",
-    "## Path-scoped rules generation",
-    "",
-    "Scan the project structure and generate focused .claude/rules/ files with paths: frontmatter. These load ONLY when Claude works on matching files, saving context tokens.",
-    "",
-    "**How to detect areas:**",
-    "1. List top-level directories under src/ (or equivalent). Each distinct area (api, components, lib, tests) is a candidate.",
-    "2. Check for monorepo indicators: workspaces in package.json, pnpm-workspace.yaml, nx.json, lerna.json. Each workspace is a candidate.",
-    "3. Check for docs/, tests/, scripts/ as separate scopes.",
-    "",
-    "**For each detected area, create a rules file with this format:**",
-    "",
-    "---",
-    'paths: ["src/api/**"]',
-    "---",
-    "# API Rules",
-    "- Validate all request input with zod schemas",
-    "- Return typed error responses, never throw raw errors",
-    "- Keep route handlers under 30 lines",
-    "",
-    "**Stack-specific patterns to include:**",
-    `- Next.js app/: "Use Server Components by default, add 'use client' only when needed"`,
-    '- API routes / src/api/: "Validate input at boundaries, typed error responses"',
-    '- React components: "Colocate components near usage, props interface above component"',
-    '- Tests: "One assertion per test when possible, descriptive test names"',
-    '- Database / prisma/ / drizzle/: "Never write raw SQL, use the ORM, migrations required"',
-    '- Docs: "No em dashes, max 3 sentences per paragraph, code examples required"',
-    "",
-    "**When NOT to generate:**",
-    "- Small projects with < 5 source files (one conventions.md is enough)",
-    "- Projects where all code is in one flat directory",
-    "- If path-scoped rules already exist, don't overwrite them",
-    "",
-    "**Monorepo handling:**",
-    "- Each package gets its own rules file: .claude/rules/packages-<name>.md",
-    "- Suggest claudeMdExcludes in settings.json to skip irrelevant package CLAUDE.md files",
-    "",
-    "## Skill authoring conventions",
-    "",
-    "If .claude/rules/conventions.md exists but has no Skill Authoring section, add this:",
-    "",
-    "## Skill Authoring",
-    "",
-    "When creating Claude Code skills (.claude/skills/*/SKILL.md):",
-    "",
-    "- Add TRIGGER when / DO NOT TRIGGER when clauses in the description for auto-invocation",
-    "- Add allowed-tools in frontmatter to restrict tool access (e.g. Read, Glob, Grep for read-only skills)",
-    "- Add argument-hint in frontmatter showing the expected input format",
-    '- Structure as phases: Research, Plan, Execute, Verify with "Done when:" success criteria per phase',
-    "- Handle edge cases and preconditions before execution",
-    "",
-    "## Hook review",
-    "",
-    "Review .claude/settings.json hooks:",
-    "- If you see project-specific patterns that deserve hooks, suggest them",
-    "- If no PostCompact hook exists, suggest one that re-injects TASKS.md",
-    "- If no SessionStart hook exists, suggest one that injects TASKS.md",
-    "- DO NOT modify settings.json directly. Print exact JSON to add.",
-    "",
-    "## .claudeignore review",
-    "",
-    "Read .claudeignore and check if the patterns make sense for the detected stack:",
-    "",
-    "**Always flag:**",
-    "- Missing node_modules/ (JS/TS projects)",
-    "- Missing __pycache__/ or .venv/ (Python projects)",
-    "- Missing target/ (Rust/Java projects)",
-    "- Missing .env / .env.* patterns",
-    "- Missing lock files (pnpm-lock.yaml, package-lock.json, yarn.lock, etc.)",
-    "- Missing coverage/ directory",
-    "- Large generated files that waste context (*.min.js, *.map, migrations/)",
-    "",
-    "**Never flag:**",
-    "- Patterns the user clearly added intentionally",
-    "- Test fixtures or seed data (might be needed for context)",
-    "",
-    "If .claudeignore is missing entirely, create one with sensible defaults for the detected stack.",
-    "If it exists but has gaps, print suggested additions. Do NOT modify it directly.",
-    "",
-    "## Eval scenario generation",
-    "",
-    "After improving CLAUDE.md, generate 2-3 custom eval scenarios that test whether Claude follows the project's specific rules. Write them as YAML files in scenarios/ at the project root.",
-    "",
-    "**Scenario YAML format:**",
-    "```yaml",
-    "name: custom/scenario-name",
-    "description: What this scenario tests",
-    "setup:",
-    "  files:",
-    "    - path: src/example.ts",
-    "      content: |",
-    "        // Starter file that tempts Claude to break a rule",
-    "  instructions: |",
-    "    The specific rule from CLAUDE.md being tested.",
-    'prompt: "A task that would tempt Claude to break the rule"',
-    "checks:",
-    "  - type: grep",
-    '    pattern: "expected_pattern"',
-    "    target: src/example.ts",
-    "    expect: present",
-    "    points: 5",
-    "    label: What this check verifies",
-    "  - type: file-exists",
-    "    target: path/to/expected/file",
-    "    expect: present",
-    "    points: 5",
-    "    label: What this check verifies",
-    "passingScore: 7",
-    "runs: 3",
-    "```",
-    "",
-    "**How to choose scenarios:**",
-    "1. Pick the 2-3 most important rules from ## Off-Limits and ## Conventions",
-    "2. Design a task that naturally tempts Claude to break each rule",
-    "3. Write checks that verify compliance (grep for patterns, file-exists for structure)",
-    "",
-    "**Check types available:** `grep` (pattern in file), `file-exists` (present/absent), `max-lines` (file length)",
-    "",
-    "**Examples of good custom scenarios:**",
-    '- Off-limits says "never use any" \u2192 task asks to build types, check for no `any` keyword',
-    '- Convention says "max 400 lines per file" \u2192 task asks to generate a large module, check line count',
-    '- Off-limits says "no raw SQL" \u2192 task asks to add a query, check for ORM usage',
-    "",
-    "**Skip if:** scenarios/ already has 3+ YAML files, or CLAUDE.md has no project-specific rules worth testing.",
-    "",
-    "## Other advanced configuration",
-    "",
-    "- If the project uses external APIs, suggest sandbox.network.allowedDomains",
-    "- If you detect a monorepo, suggest claudeMdExcludes in settings.json"
-  ].join("\n");
-}
-
 // src/commands/init/generators/backlog.ts
 function generateBacklogMd(options) {
   return `# ${options.name} - Backlog
@@ -769,7 +238,7 @@ function createInitCommand() {
       message: "One-line description (optional):"
     });
     const options = { name: name.trim(), description: description.trim() };
-    const hasClaudeMd = await fileExists(join2(root, "CLAUDE.md"));
+    const hasClaudeMd = await fileExists(join(root, "CLAUDE.md"));
     if (hasClaudeMd && !opts.yes) {
       const overwrite = await confirm({
         message: "CLAUDE.md already exists. Overwrite?",
@@ -792,20 +261,20 @@ async function scaffold(root, options, detected, skipPrompts) {
   const backlogMd = generateBacklogMd(options);
   const settings = generateSettings(detected);
   const claudeignore = generateClaudeignore(detected);
-  await mkdir(join2(root, ".claude", "rules"), { recursive: true });
-  const settingsPath = join2(root, ".claude", "settings.json");
+  await mkdir(join(root, ".claude", "rules"), { recursive: true });
+  const settingsPath = join(root, ".claude", "settings.json");
   const mergedSettings = await mergeSettings(settingsPath, settings);
-  const backlogPath = join2(root, "BACKLOG.md");
+  const backlogPath = join(root, "BACKLOG.md");
   const hasBacklog = await fileExists(backlogPath);
-  const claudeignorePath = join2(root, ".claudeignore");
+  const claudeignorePath = join(root, ".claudeignore");
   const hasClaudeignore = await fileExists(claudeignorePath);
-  const claudeGitignorePath = join2(root, ".claude", ".gitignore");
+  const claudeGitignorePath = join(root, ".claude", ".gitignore");
   const hasClaudeGitignore = await fileExists(claudeGitignorePath);
-  const rulesPath = join2(root, ".claude", "rules", "conventions.md");
+  const rulesPath = join(root, ".claude", "rules", "conventions.md");
   const hasRules = await fileExists(rulesPath);
   const writes = [
-    writeFile(join2(root, "CLAUDE.md"), claudeMd),
-    writeFile(join2(root, "TASKS.md"), tasksMd),
+    writeFile(join(root, "CLAUDE.md"), claudeMd),
+    writeFile(join(root, "TASKS.md"), tasksMd),
     writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n")
   ];
   if (!hasBacklog) {
@@ -886,10 +355,10 @@ function generateStarterRules(detected) {
   return lines.join("\n");
 }
 async function createEnhanceSkillPrompt(root, skipPrompts) {
-  const projectPath = join2(root, ".claude", "skills", "lp-enhance", "SKILL.md");
-  const globalPath = join2(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
-  const legacyProject = join2(root, ".claude", "commands", "lp-enhance.md");
-  const legacyGlobal = join2(homedir(), ".claude", "commands", "lp-enhance.md");
+  const projectPath = join(root, ".claude", "skills", "lp-enhance", "SKILL.md");
+  const globalPath = join(homedir(), ".claude", "skills", "lp-enhance", "SKILL.md");
+  const legacyProject = join(root, ".claude", "commands", "lp-enhance.md");
+  const legacyGlobal = join(homedir(), ".claude", "commands", "lp-enhance.md");
   if (await fileExists(projectPath) || await fileExists(globalPath) || await fileExists(legacyProject) || await fileExists(legacyGlobal)) return;
   const scope = skipPrompts ? "project" : await select({
     message: "Install /lp-enhance skill (AI-powered CLAUDE.md improver):",
@@ -900,14 +369,14 @@ async function createEnhanceSkillPrompt(root, skipPrompts) {
     ]
   });
   if (scope === "skip") return;
-  const targetDir = scope === "global" ? join2(homedir(), ".claude", "skills", "lp-enhance") : join2(root, ".claude", "skills", "lp-enhance");
+  const targetDir = scope === "global" ? join(homedir(), ".claude", "skills", "lp-enhance") : join(root, ".claude", "skills", "lp-enhance");
   await mkdir(targetDir, { recursive: true });
-  await writeFile(join2(targetDir, "SKILL.md"), generateEnhanceSkill());
+  await writeFile(join(targetDir, "SKILL.md"), generateEnhanceSkill());
   log.success(`Generated /lp-enhance skill (${scope} scope)`);
 }
 async function mergeSettings(existingPath, generated) {
   try {
-    const existing = JSON.parse(await readFile2(existingPath, "utf-8"));
+    const existing = JSON.parse(await readFile(existingPath, "utf-8"));
     const existingHooks = existing.hooks ?? {};
     const generatedHooks = generated.hooks ?? {};
     const mergedHooks = { ...existingHooks };
@@ -931,8 +400,8 @@ import { Command as Command2 } from "commander";
 import chalk from "chalk";
 
 // src/lib/parser.ts
-import { readdir, access as access2 } from "fs/promises";
-import { join as join3, resolve } from "path";
+import { readdir, access } from "fs/promises";
+import { join as join2, resolve } from "path";
 var CLAUDE_MD = "CLAUDE.md";
 var CLAUDE_DIR = ".claude";
 var SETTINGS_FILE = "settings.json";
@@ -940,24 +409,24 @@ var SETTINGS_LOCAL_FILE = "settings.local.json";
 var RULES_DIR = "rules";
 async function parseClaudeConfig(projectRoot) {
   const root = resolve(projectRoot);
-  const claudeDir = join3(root, CLAUDE_DIR);
+  const claudeDir = join2(root, CLAUDE_DIR);
   const [claudeMd, localClaudeMd, settings, localSettings, hooks, rules, mcpServers, skills, claudeignore] = await Promise.all([
     readClaudeMd(root),
-    readFileOrNull(join3(claudeDir, CLAUDE_MD)),
+    readFileOrNull(join2(claudeDir, CLAUDE_MD)),
     readSettings(claudeDir),
     readSettingsFromFile(claudeDir, SETTINGS_LOCAL_FILE),
     readHooks(claudeDir),
     readRules(claudeDir),
     readMcpServers(claudeDir, root),
     readSkills(claudeDir),
-    readFileOrNull(join3(root, ".claudeignore"))
+    readFileOrNull(join2(root, ".claudeignore"))
   ]);
   const instructionCount = claudeMd ? countInstructions(claudeMd) : 0;
   return {
-    claudeMdPath: claudeMd !== null ? join3(root, CLAUDE_MD) : null,
+    claudeMdPath: claudeMd !== null ? join2(root, CLAUDE_MD) : null,
     claudeMdContent: claudeMd,
     claudeMdInstructionCount: instructionCount,
-    settingsPath: settings !== null ? join3(claudeDir, SETTINGS_FILE) : null,
+    settingsPath: settings !== null ? join2(claudeDir, SETTINGS_FILE) : null,
     settings,
     localClaudeMdContent: localClaudeMd,
     localSettings,
@@ -965,12 +434,12 @@ async function parseClaudeConfig(projectRoot) {
     rules,
     mcpServers,
     skills,
-    claudeignorePath: claudeignore !== null ? join3(root, ".claudeignore") : null,
+    claudeignorePath: claudeignore !== null ? join2(root, ".claudeignore") : null,
     claudeignoreContent: claudeignore
   };
 }
 async function readClaudeMd(root) {
-  return readFileOrNull(join3(root, CLAUDE_MD));
+  return readFileOrNull(join2(root, CLAUDE_MD));
 }
 function countInstructions(content) {
   const lines = content.split("\n");
@@ -989,7 +458,7 @@ async function readSettings(claudeDir) {
   return readSettingsFromFile(claudeDir, SETTINGS_FILE);
 }
 async function readSettingsFromFile(claudeDir, filename) {
-  const raw = await readFileOrNull(join3(claudeDir, filename));
+  const raw = await readFileOrNull(join2(claudeDir, filename));
   if (raw === null) return null;
   try {
     return JSON.parse(raw);
@@ -999,8 +468,8 @@ async function readSettingsFromFile(claudeDir, filename) {
 }
 async function readHooks(claudeDir) {
   const [shared, local] = await Promise.all([
-    readHooksFromFile(join3(claudeDir, SETTINGS_FILE)),
-    readHooksFromFile(join3(claudeDir, SETTINGS_LOCAL_FILE))
+    readHooksFromFile(join2(claudeDir, SETTINGS_FILE)),
+    readHooksFromFile(join2(claudeDir, SETTINGS_LOCAL_FILE))
   ]);
   return [...shared, ...local];
 }
@@ -1046,14 +515,14 @@ async function readHooksFromFile(settingsPath) {
   }
 }
 async function readRules(claudeDir) {
-  const rulesDir = join3(claudeDir, RULES_DIR);
+  const rulesDir = join2(claudeDir, RULES_DIR);
   return listFilesRecursive(rulesDir, ".md");
 }
 async function readMcpServers(claudeDir, projectRoot) {
   const [fromMcpJson, fromSettings, fromLocalSettings] = await Promise.all([
-    readMcpJsonFile(join3(projectRoot, ".mcp.json")),
-    readMcpServersFromSettings(join3(claudeDir, SETTINGS_FILE)),
-    readMcpServersFromSettings(join3(claudeDir, SETTINGS_LOCAL_FILE))
+    readMcpJsonFile(join2(projectRoot, ".mcp.json")),
+    readMcpServersFromSettings(join2(claudeDir, SETTINGS_FILE)),
+    readMcpServersFromSettings(join2(claudeDir, SETTINGS_LOCAL_FILE))
   ]);
   const seen = /* @__PURE__ */ new Set();
   const result = [];
@@ -1077,7 +546,7 @@ async function readMcpJsonFile(mcpJsonPath) {
       const c = config;
       result.push({
         name,
-        transport: c.transport ?? "stdio",
+        transport: c.transport ?? c.type ?? "stdio",
         command: c.command,
         url: c.url
       });
@@ -1099,7 +568,7 @@ async function readMcpServersFromSettings(settingsPath) {
       const c = config;
       result.push({
         name,
-        transport: c.transport ?? "stdio",
+        transport: c.transport ?? c.type ?? "stdio",
         command: c.command,
         url: c.url
       });
@@ -1110,8 +579,8 @@ async function readMcpServersFromSettings(settingsPath) {
   }
 }
 async function readSkills(claudeDir) {
-  const commandsDir = join3(claudeDir, "commands");
-  const skillsDir = join3(claudeDir, "skills");
+  const commandsDir = join2(claudeDir, "commands");
+  const skillsDir = join2(claudeDir, "skills");
   const [commands, skills] = await Promise.all([
     listFilesRecursive(commandsDir, ".md"),
     listFilesRecursive(skillsDir, ".md")
@@ -1120,14 +589,14 @@ async function readSkills(claudeDir) {
 }
 async function listFilesRecursive(dir, ext) {
   try {
-    await access2(dir);
+    await access(dir);
   } catch {
     return [];
   }
   const results = [];
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join3(dir, entry.name);
+    const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
       const nested = await listFilesRecursive(fullPath, ext);
       results.push(...nested);
@@ -1327,13 +796,13 @@ async function analyzeHooks(config) {
 }
 
 // src/commands/doctor/analyzers/rules.ts
-import { readFile as readFile3 } from "fs/promises";
-import { basename as basename2, join as join4, dirname } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { basename, join as join3, dirname } from "path";
 import { homedir as homedir2 } from "os";
 async function analyzeRules(config) {
   const issues = [];
   const projectRoot = config.claudeMdPath ? dirname(config.claudeMdPath) : process.cwd();
-  const hasBacklog = await fileExists(join4(projectRoot, "BACKLOG.md"));
+  const hasBacklog = await fileExists(join3(projectRoot, "BACKLOG.md"));
   if (!hasBacklog) {
     issues.push({
       analyzer: "Rules",
@@ -1342,7 +811,7 @@ async function analyzeRules(config) {
       fix: "Run `claude-launchpad init` or `doctor --fix` to generate one"
     });
   }
-  const hasClaudeignore = await fileExists(join4(projectRoot, ".claudeignore"));
+  const hasClaudeignore = await fileExists(join3(projectRoot, ".claudeignore"));
   if (!hasClaudeignore) {
     issues.push({
       analyzer: "Rules",
@@ -1352,9 +821,9 @@ async function analyzeRules(config) {
     });
   }
   const hasSkillInProject = config.skills.some(
-    (s) => basename2(s) === "SKILL.md" && s.includes("lp-enhance") || basename2(s) === "lp-enhance.md"
+    (s) => basename(s) === "SKILL.md" && s.includes("lp-enhance") || basename(s) === "lp-enhance.md"
   );
-  const hasSkillGlobal = await fileExists(join4(homedir2(), ".claude", "skills", "lp-enhance", "SKILL.md")) || await fileExists(join4(homedir2(), ".claude", "commands", "lp-enhance.md"));
+  const hasSkillGlobal = await fileExists(join3(homedir2(), ".claude", "skills", "lp-enhance", "SKILL.md")) || await fileExists(join3(homedir2(), ".claude", "commands", "lp-enhance.md"));
   if (!hasSkillInProject && !hasSkillGlobal) {
     issues.push({
       analyzer: "Rules",
@@ -1384,27 +853,27 @@ async function analyzeRules(config) {
   }
   for (const rulePath of config.rules) {
     try {
-      const content = await readFile3(rulePath, "utf-8");
+      const content = await readFile2(rulePath, "utf-8");
       const trimmed = content.trim();
       if (trimmed.length === 0) {
         issues.push({
           analyzer: "Rules",
           severity: "low",
-          message: `Empty rule file: ${basename2(rulePath)}`,
-          fix: `Add content to ${basename2(rulePath)} or delete it`
+          message: `Empty rule file: ${basename(rulePath)}`,
+          fix: `Add content to ${basename(rulePath)} or delete it`
         });
       } else if (trimmed.length < 20) {
         issues.push({
           analyzer: "Rules",
           severity: "info",
-          message: `Very short rule file (${trimmed.length} chars): ${basename2(rulePath)}`
+          message: `Very short rule file (${trimmed.length} chars): ${basename(rulePath)}`
         });
       }
     } catch {
       issues.push({
         analyzer: "Rules",
         severity: "low",
-        message: `Could not read rule file: ${basename2(rulePath)}`
+        message: `Could not read rule file: ${basename(rulePath)}`
       });
     }
   }
@@ -1413,12 +882,12 @@ async function analyzeRules(config) {
 }
 async function getSkillVersion(projectRoot) {
   const paths = [
-    join4(projectRoot, ".claude", "skills", "lp-enhance", "SKILL.md"),
-    join4(homedir2(), ".claude", "skills", "lp-enhance", "SKILL.md")
+    join3(projectRoot, ".claude", "skills", "lp-enhance", "SKILL.md"),
+    join3(homedir2(), ".claude", "skills", "lp-enhance", "SKILL.md")
   ];
   for (const p of paths) {
     try {
-      const content = await readFile3(p, "utf-8");
+      const content = await readFile2(p, "utf-8");
       const match = content.match(/<!-- lp-enhance-version: (\d+) -->/);
       if (match) return parseInt(match[1], 10);
       return 0;
@@ -1527,7 +996,7 @@ async function analyzePermissions(config) {
 }
 
 // src/commands/doctor/analyzers/mcp.ts
-import { access as access3 } from "fs/promises";
+import { access as access2 } from "fs/promises";
 async function analyzeMcp(config) {
   const issues = [];
   const servers = config.mcpServers;
@@ -1560,7 +1029,7 @@ async function analyzeMcp(config) {
       const executable = server.command.split(" ")[0];
       if (executable.startsWith("/") || executable.startsWith("./")) {
         try {
-          await access3(executable);
+          await access2(executable);
         } catch {
           issues.push({
             analyzer: "MCP",
@@ -1801,420 +1270,9 @@ async function analyzeQuality(config) {
   return { name: "CLAUDE.md Quality", issues, score };
 }
 
-// src/commands/doctor/fixer.ts
-import { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2, access as access4 } from "fs/promises";
-import { join as join6 } from "path";
-import { homedir as homedir3 } from "os";
-
-// src/commands/doctor/fixer-memory.ts
-import { readFile as readFile4 } from "fs/promises";
-import { join as join5 } from "path";
-async function addPlacementHook(root, placement, event, dedupKeyword, entry, prepend, successMsg) {
-  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
-  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
-  const settings = await read(root);
-  const hooks = settings.hooks ?? {};
-  const hookList = hooks[event] ?? [];
-  const alreadyHas = hookList.some((g) => {
-    const nested = g.hooks;
-    return nested?.some((h) => String(h.command ?? "").includes(dedupKeyword));
-  });
-  if (alreadyHas) return false;
-  hooks[event] = prepend ? [entry, ...hookList] : [...hookList, entry];
-  settings.hooks = hooks;
-  await write(root, settings);
-  log.success(successMsg);
-  return true;
-}
-async function disableAutoMemory(root, placement) {
-  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
-  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
-  const settings = await read(root);
-  if (settings.autoMemoryEnabled === false) return false;
-  settings.autoMemoryEnabled = false;
-  await write(root, settings);
-  const target = placement === "local" ? "settings.local.json" : "settings.json";
-  log.success(`Set autoMemoryEnabled: false in ${target}`);
-  return true;
-}
-async function addMemoryToolPermissions(root, placement) {
-  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
-  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
-  const settings = await read(root);
-  const permissions = settings.permissions ?? {};
-  const allow = permissions.allow ?? [];
-  const tools = [
-    "mcp__agentic-memory__memory_store",
-    "mcp__agentic-memory__memory_search",
-    "mcp__agentic-memory__memory_recent",
-    "mcp__agentic-memory__memory_forget",
-    "mcp__agentic-memory__memory_relate",
-    "mcp__agentic-memory__memory_stats",
-    "mcp__agentic-memory__memory_update"
-  ];
-  const missing = tools.filter((t) => !allow.includes(t));
-  if (missing.length === 0) return false;
-  settings.permissions = { ...permissions, allow: [...allow, ...missing] };
-  await write(root, settings);
-  const target = placement === "local" ? "settings.local.json" : "settings.json";
-  log.success(`Added agentic-memory MCP tool permissions to ${target}`);
-  return true;
-}
-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" }]
-  }, 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: "claude-launchpad memory push -y >/dev/null 2>&1 & exit 0" }]
-  }, false, `Added SessionEnd hook for memory sync to ${target}`);
-}
-async function removeStaleStopHook(root) {
-  const settings = await readSettingsJson(root);
-  const hooks = settings.hooks;
-  if (!hooks?.Stop) return false;
-  const stopHooks = hooks.Stop;
-  const filtered = stopHooks.filter((h) => {
-    const innerHooks = h.hooks;
-    return !innerHooks?.some(
-      (ih) => typeof ih.command === "string" && ih.command.includes("memory extract")
-    );
-  });
-  if (filtered.length === stopHooks.length) return false;
-  const updated = filtered.length === 0 ? (({ Stop: _, ...rest }) => rest)(hooks) : { ...hooks, Stop: filtered };
-  settings.hooks = updated;
-  await writeSettingsJson(root, settings);
-  log.success("Removed deprecated Stop hook (memory extract)");
-  return true;
-}
-async function addAllowedMcpServers(root, placement) {
-  const read = placement === "local" ? readSettingsLocalJson : readSettingsJson;
-  const write = placement === "local" ? writeSettingsLocalJson : writeSettingsJson;
-  const settings = await read(root);
-  if (settings.allowedMcpServers) return false;
-  const other = placement === "local" ? await readSettingsJson(root) : await readSettingsLocalJson(root);
-  if (other.allowedMcpServers) return false;
-  const serverNames = /* @__PURE__ */ new Set();
-  const settingsServers = settings.mcpServers;
-  if (settingsServers && typeof settingsServers === "object") {
-    for (const name of Object.keys(settingsServers)) serverNames.add(name);
-  }
-  const mcpJsonPath = join5(root, ".mcp.json");
-  try {
-    const mcpJson = JSON.parse(await readFile4(mcpJsonPath, "utf-8"));
-    const mcpServers = mcpJson.mcpServers;
-    if (mcpServers && typeof mcpServers === "object") {
-      for (const name of Object.keys(mcpServers)) serverNames.add(name);
-    }
-  } catch {
-  }
-  if (serverNames.size === 0) return false;
-  settings.allowedMcpServers = [...serverNames].map(
-    (name) => ({ serverName: name })
-  );
-  await write(root, settings);
-  const target = placement === "local" ? "settings.local.json" : "settings.json";
-  log.success(`Added allowedMcpServers from configured servers to ${target}`);
-  return true;
-}
-
-// src/commands/doctor/fixer.ts
-async function applyFixes(issues, projectRoot) {
-  const detected = await detectProject(projectRoot);
-  const hasMemoryIssues = issues.some((i) => i.analyzer === "Memory");
-  const placement = hasMemoryIssues ? await getMemoryPlacement(projectRoot) : "shared";
-  let fixed = 0;
-  let skipped = 0;
-  for (const issue of issues) {
-    const applied = await tryFix(issue, projectRoot, detected, placement);
-    if (applied) {
-      fixed++;
-    } else {
-      skipped++;
-    }
-  }
-  return { fixed, skipped };
-}
-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);
-    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", "<!-- TODO: Describe your codebase structure. Run `/lp-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", 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: "Quality", match: "Backlog", fix: (root) => addClaudeMdSection(root, "## Backlog", "- 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") },
-  { 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/", fix: (root) => createStarterRules(root) },
-  { analyzer: "Hooks", match: "PostCompact", fix: (root) => addPostCompactHook(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 not enabled", fix: (root) => addSandboxSettings(root) },
-  { analyzer: "Permissions", match: ".env is protected by hooks but not in .claudeignore", fix: (root) => addEnvToClaudeignore(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: "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: "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" ? join6(root, ".claude", "CLAUDE.md") : void 0;
-    return addClaudeMdSection(root, "## Memory", content, target);
-  } }
-];
-async function tryFix(issue, root, detected, placement) {
-  const entry = FIX_TABLE.find(
-    (e) => e.analyzer === issue.analyzer && issue.message.includes(e.match)
-  );
-  return entry ? entry.fix(root, detected, placement) : false;
-}
-async function addHook(root, event, dedupKeyword, entry, successMsg) {
-  const settings = await readSettingsJson(root);
-  const hooks = settings.hooks ?? {};
-  const hookList = hooks[event] ?? [];
-  const alreadyHas = hookList.some((g) => {
-    const nested = g.hooks;
-    return nested?.some((h) => String(h.command ?? "").includes(dedupKeyword));
-  });
-  if (alreadyHas) return false;
-  hookList.push(entry);
-  settings.hooks = { ...hooks, [event]: hookList };
-  await writeSettingsJson(root, settings);
-  log.success(successMsg);
-  return true;
-}
-async function addEnvProtectionHook(root) {
-  return addHook(root, "PreToolUse", ".env", {
-    matcher: "Read|Write|Edit",
-    hooks: [{
-      type: "command",
-      command: `echo "$TOOL_INPUT_FILE_PATH" | grep -qE '\\.(env|env\\..*)$' && ! echo "$TOOL_INPUT_FILE_PATH" | grep -q '.env.example' && echo 'BLOCKED: .env files contain secrets' && exit 1; exit 0`
-    }]
-  }, "Added .env file protection hook (PreToolUse)");
-}
-async function addAutoFormatHook(root, detected) {
-  if (!detected.language) return false;
-  const formatters = {
-    TypeScript: { extensions: ["ts", "tsx"], command: "npx prettier --write" },
-    JavaScript: { extensions: ["js", "jsx"], command: "npx prettier --write" },
-    Python: { extensions: ["py"], command: "ruff format" },
-    Go: { extensions: ["go"], command: "gofmt -w" },
-    Rust: { extensions: ["rs"], command: "rustfmt" },
-    Ruby: { extensions: ["rb"], command: "rubocop -A" },
-    PHP: { extensions: ["php"], command: "vendor/bin/pint" }
-  };
-  const config = formatters[detected.language];
-  if (!config) return false;
-  const extChecks = config.extensions.map((ext) => `[ "$ext" = "${ext}" ]`).join(" || ");
-  return addHook(root, "PostToolUse", "format", {
-    matcher: "Write|Edit",
-    hooks: [{
-      type: "command",
-      command: `ext=\${TOOL_INPUT_FILE_PATH##*.}; (${extChecks}) && ${config.command} "$TOOL_INPUT_FILE_PATH" 2>/dev/null; exit 0`
-    }]
-  }, `Added auto-format hook (PostToolUse \u2192 ${config.command})`);
-}
-async function addForcePushProtection(root) {
-  return addHook(root, "PreToolUse", "force", {
-    matcher: "Bash",
-    hooks: [{
-      type: "command",
-      command: `echo "$TOOL_INPUT_COMMAND" | grep -qE 'push.*--force|push.*-f' && echo 'WARNING: Force push detected \u2014 this can destroy remote history' && exit 1; exit 0`
-    }]
-  }, "Added force-push protection hook (PreToolUse \u2192 Bash)");
-}
-async function addPostCompactHook(root) {
-  return addHook(root, "PostCompact", "TASKS.md", {
-    matcher: "",
-    hooks: [{
-      type: "command",
-      command: "cat TASKS.md 2>/dev/null; exit 0"
-    }]
-  }, "Added PostCompact hook (re-injects TASKS.md after compaction)");
-}
-async function addSessionStartHook(root) {
-  return addHook(root, "SessionStart", "TASKS.md", {
-    matcher: "startup|resume",
-    hooks: [{
-      type: "command",
-      command: "cat TASKS.md 2>/dev/null; exit 0"
-    }]
-  }, "Added SessionStart hook (injects TASKS.md at startup)");
-}
-async function migrateAttribution(root) {
-  const settings = await readSettingsJson(root);
-  if (settings.includeCoAuthoredBy === void 0) return false;
-  const { includeCoAuthoredBy: _, ...rest } = settings;
-  const updated = { ...rest, attribution: { commit: "", pr: "" } };
-  await writeSettingsJson(root, updated);
-  log.success("Migrated includeCoAuthoredBy \u2192 attribution object");
-  return true;
-}
-async function addCredentialDenyRules(root) {
-  const settings = await readSettingsJson(root);
-  const permissions = settings.permissions ?? {};
-  const deny = permissions.deny ?? [];
-  const toAdd = ["Read(~/.ssh/*)", "Read(~/.aws/*)", "Read(~/.npmrc)"];
-  const missing = toAdd.filter((p) => !deny.includes(p));
-  if (missing.length === 0) return false;
-  settings.permissions = { ...permissions, deny: [...deny, ...missing] };
-  await writeSettingsJson(root, settings);
-  log.success("Added credential deny rules (SSH, AWS, npm)");
-  return true;
-}
-async function addBypassDisable(root) {
-  const settings = await readSettingsJson(root);
-  if (settings.disableBypassPermissionsMode === "disable") return false;
-  settings.disableBypassPermissionsMode = "disable";
-  await writeSettingsJson(root, settings);
-  log.success("Added disableBypassPermissionsMode: disable");
-  return true;
-}
-async function addSandboxSettings(root) {
-  const settings = await readSettingsJson(root);
-  const sandbox = settings.sandbox;
-  if (sandbox?.enabled === true) return false;
-  settings.sandbox = { enabled: true, failIfUnavailable: true };
-  await writeSettingsJson(root, settings);
-  log.success("Enabled sandbox with failIfUnavailable");
-  return true;
-}
-async function addEnvToClaudeignore(root) {
-  const ignorePath = join6(root, ".claudeignore");
-  let content;
-  try {
-    content = await readFile5(ignorePath, "utf-8");
-  } catch {
-    return false;
-  }
-  const lines = content.split("\n").map((l) => l.trim());
-  if (lines.some((l) => l === ".env" || l === ".env.*" || l === ".env*")) return false;
-  await writeFile2(ignorePath, content.trimEnd() + "\n.env\n.env.*\n");
-  log.success("Added .env to .claudeignore");
-  return true;
-}
-async function addClaudeMdSection(root, heading, content, targetPath) {
-  const claudeMdPath = targetPath ?? join6(root, "CLAUDE.md");
-  let existing;
-  try {
-    existing = await readFile5(claudeMdPath, "utf-8");
-  } catch {
-    if (!targetPath) return false;
-    await mkdir2(join6(root, ".claude"), { recursive: true });
-    existing = "# Local Claude Config\n";
-  }
-  if (existing.includes(heading)) return false;
-  const keyDecisionsIdx = existing.indexOf("## Key Decisions");
-  const insertAt = keyDecisionsIdx > -1 ? keyDecisionsIdx : existing.length;
-  const section = `
-${heading}
-${content}
-
-`;
-  const updated = existing.slice(0, insertAt) + section + existing.slice(insertAt);
-  await writeFile2(claudeMdPath, updated);
-  const label = targetPath ? ".claude/CLAUDE.md" : "CLAUDE.md";
-  log.success(`Added "${heading}" section to ${label}`);
-  return true;
-}
-async function createBacklogMd(root) {
-  const backlogPath = join6(root, "BACKLOG.md");
-  try {
-    await access4(backlogPath);
-    return false;
-  } catch {
-  }
-  const name = root.split("/").pop() ?? "Project";
-  await writeFile2(backlogPath, `# ${name} - Backlog
-
-> Features discussed but deferred. Pick up when relevant.
-> Priority: P0 = next sprint, P1 = soon, P2 = when relevant.
-`);
-  log.success("Generated BACKLOG.md");
-  return true;
-}
-async function createClaudeignore(root, detected) {
-  const ignorePath = join6(root, ".claudeignore");
-  try {
-    await access4(ignorePath);
-    return false;
-  } catch {
-  }
-  const content = generateClaudeignore(detected);
-  await writeFile2(ignorePath, content);
-  log.success("Generated .claudeignore with language-specific ignore patterns");
-  return true;
-}
-async function createStarterRules(root) {
-  const rulesDir = join6(root, ".claude", "rules");
-  try {
-    await access4(rulesDir);
-    return false;
-  } catch {
-  }
-  await mkdir2(rulesDir, { recursive: true });
-  await writeFile2(
-    join6(rulesDir, "conventions.md"),
-    `# Project Conventions
-
-- Use conventional commits (feat:, fix:, docs:, refactor:, test:, chore:)
-- Keep files under 400 lines, functions under 50 lines
-- Handle errors explicitly \u2014 no empty catch blocks
-- Validate input at system boundaries
-`
-  );
-  log.success("Created .claude/rules/conventions.md with starter rules");
-  return true;
-}
-async function createEnhanceSkill(root) {
-  const skillDir = join6(root, ".claude", "skills", "lp-enhance");
-  const skillPath = join6(skillDir, "SKILL.md");
-  const globalPath = join6(homedir3(), ".claude", "skills", "lp-enhance", "SKILL.md");
-  const legacyProject = join6(root, ".claude", "commands", "lp-enhance.md");
-  const legacyGlobal = join6(homedir3(), ".claude", "commands", "lp-enhance.md");
-  if (await fileExists(skillPath) || await fileExists(globalPath) || await fileExists(legacyProject) || await fileExists(legacyGlobal)) return false;
-  await mkdir2(skillDir, { recursive: true });
-  await writeFile2(skillPath, generateEnhanceSkill());
-  log.success("Generated /lp-enhance skill (.claude/skills/lp-enhance/)");
-  return true;
-}
-async function updateEnhanceSkill(root) {
-  const projectPath = join6(root, ".claude", "skills", "lp-enhance", "SKILL.md");
-  const globalPath = join6(homedir3(), ".claude", "skills", "lp-enhance", "SKILL.md");
-  const targetPath = await fileExists(projectPath) ? projectPath : await fileExists(globalPath) ? globalPath : null;
-  if (!targetPath) return false;
-  await writeFile2(targetPath, generateEnhanceSkill());
-  log.success("Updated /lp-enhance skill to latest version");
-  return true;
-}
-
 // src/commands/doctor/watcher.ts
 import { readdir as readdir2, stat } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join4 } from "path";
 async function watchConfig(projectRoot) {
   await runAndDisplay(projectRoot);
   log.blank();
@@ -2237,16 +1295,16 @@ async function watchConfig(projectRoot) {
 }
 async function getFileSnapshot(projectRoot) {
   const files = [
-    join7(projectRoot, "CLAUDE.md"),
-    join7(projectRoot, ".claudeignore")
+    join4(projectRoot, "CLAUDE.md"),
+    join4(projectRoot, ".claudeignore")
   ];
-  const claudeDir = join7(projectRoot, ".claude");
+  const claudeDir = join4(projectRoot, ".claude");
   try {
     const entries = await readdir2(claudeDir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile()) {
         const parentPath = entry.parentPath ?? claudeDir;
-        files.push(join7(parentPath, entry.name));
+        files.push(join4(parentPath, entry.name));
       }
     }
   } catch {
@@ -2390,12 +1448,12 @@ import { Command as Command3 } from "commander";
 import { select as select2 } from "@inquirer/prompts";
 import ora from "ora";
 import chalk2 from "chalk";
-import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import { join as join10 } from "path";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { join as join7 } from "path";
 
 // src/commands/eval/loader.ts
-import { readFile as readFile6, readdir as readdir3, access as access5 } from "fs/promises";
-import { join as join8, resolve as resolve2, dirname as dirname2 } from "path";
+import { readFile as readFile3, readdir as readdir3, access as access3 } from "fs/promises";
+import { join as join5, resolve as resolve2, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import { parse as parseYaml } from "yaml";
 
@@ -2509,7 +1567,7 @@ async function findScenariosDir() {
 }
 async function dirExists(path) {
   try {
-    await access5(path);
+    await access3(path);
     return true;
   } catch {
     return false;
@@ -2518,14 +1576,14 @@ async function dirExists(path) {
 async function loadScenarios(options) {
   const { suite, customPath } = options;
   const scenarioDir = customPath ? resolve2(customPath) : await findScenariosDir();
-  const dirs = suite ? [join8(scenarioDir, suite)] : await getSubdirectories(scenarioDir);
+  const dirs = suite ? [join5(scenarioDir, suite)] : await getSubdirectories(scenarioDir);
   const allDirs = [scenarioDir, ...dirs];
   const scenarios = [];
   for (const dir of allDirs) {
     const files = await listYamlFiles(dir);
     for (const file of files) {
       try {
-        const content = await readFile6(file, "utf-8");
+        const content = await readFile3(file, "utf-8");
         const raw = parseYaml(content);
         const scenario = validateScenario(raw, file);
         scenarios.push(scenario);
@@ -2540,7 +1598,7 @@ async function loadScenarios(options) {
 async function getSubdirectories(dir) {
   try {
     const entries = await readdir3(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).map((e) => join8(dir, e.name));
+    return entries.filter((e) => e.isDirectory()).map((e) => join5(dir, e.name));
   } catch {
     return [];
   }
@@ -2548,22 +1606,22 @@ async function getSubdirectories(dir) {
 async function listYamlFiles(dir) {
   try {
     const entries = await readdir3(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml"))).map((e) => join8(dir, e.name));
+    return entries.filter((e) => e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml"))).map((e) => join5(dir, e.name));
   } catch {
     return [];
   }
 }
 
 // src/commands/eval/runner.ts
-import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile7, readdir as readdir4, rm, cp } from "fs/promises";
-import { join as join9, dirname as dirname3 } from "path";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile4, readdir as readdir4, rm, cp } from "fs/promises";
+import { join as join6, dirname as dirname3 } from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var exec = promisify(execFile);
 async function runScenario(scenario, options) {
-  const sandboxDir = join9(tmpdir(), `claude-eval-${randomUUID()}`);
+  const sandboxDir = join6(tmpdir(), `claude-eval-${randomUUID()}`);
   try {
     await setupSandbox(sandboxDir, scenario, options.projectRoot);
     await runClaudeInSandbox(sandboxDir, scenario.prompt, options.timeout, options.model);
@@ -2587,16 +1645,16 @@ async function runScenarioWithRetries(scenario, options) {
   return sorted[Math.floor(sorted.length / 2)];
 }
 async function setupSandbox(sandboxDir, scenario, projectRoot) {
-  await mkdir3(sandboxDir, { recursive: true });
+  await mkdir2(sandboxDir, { recursive: true });
   for (const file of scenario.setup.files) {
-    const filePath = join9(sandboxDir, file.path);
-    await mkdir3(dirname3(filePath), { recursive: true });
-    await writeFile3(filePath, file.content);
+    const filePath = join6(sandboxDir, file.path);
+    await mkdir2(dirname3(filePath), { recursive: true });
+    await writeFile2(filePath, file.content);
   }
   await copyProjectConfig(sandboxDir, projectRoot);
   if (scenario.setup.instructions) {
-    await writeFile3(
-      join9(sandboxDir, "CLAUDE.md"),
+    await writeFile2(
+      join6(sandboxDir, "CLAUDE.md"),
       `# Eval Scenario
 
 ${scenario.setup.instructions}
@@ -2617,20 +1675,20 @@ ${scenario.setup.instructions}
   ], { cwd: sandboxDir });
 }
 async function copyProjectConfig(sandboxDir, projectRoot) {
-  const claudeDir = join9(projectRoot, ".claude");
-  const sandboxClaudeDir = join9(sandboxDir, ".claude");
-  const settingsPath = join9(claudeDir, "settings.json");
+  const claudeDir = join6(projectRoot, ".claude");
+  const sandboxClaudeDir = join6(sandboxDir, ".claude");
+  const settingsPath = join6(claudeDir, "settings.json");
   if (await fileExists(settingsPath)) {
-    await mkdir3(sandboxClaudeDir, { recursive: true });
-    await cp(settingsPath, join9(sandboxClaudeDir, "settings.json"));
+    await mkdir2(sandboxClaudeDir, { recursive: true });
+    await cp(settingsPath, join6(sandboxClaudeDir, "settings.json"));
   }
-  const rulesDir = join9(claudeDir, "rules");
+  const rulesDir = join6(claudeDir, "rules");
   if (await fileExists(rulesDir)) {
-    await cp(rulesDir, join9(sandboxClaudeDir, "rules"), { recursive: true });
+    await cp(rulesDir, join6(sandboxClaudeDir, "rules"), { recursive: true });
   }
-  const ignorePath = join9(projectRoot, ".claudeignore");
+  const ignorePath = join6(projectRoot, ".claudeignore");
   if (await fileExists(ignorePath)) {
-    await cp(ignorePath, join9(sandboxDir, ".claudeignore"));
+    await cp(ignorePath, join6(sandboxDir, ".claudeignore"));
   }
 }
 async function runClaudeInSandbox(cwd, prompt, timeout, model) {
@@ -2724,7 +1782,7 @@ async function evaluateSingleCheck(check, sandboxDir) {
 async function checkGrep(check, sandboxDir) {
   if (!check.pattern) return false;
   try {
-    const content = await readFile7(join9(sandboxDir, check.target), "utf-8");
+    const content = await readFile4(join6(sandboxDir, check.target), "utf-8");
     let found;
     try {
       found = new RegExp(check.pattern).test(content);
@@ -2738,7 +1796,7 @@ async function checkGrep(check, sandboxDir) {
 }
 async function checkFilePresence(check, sandboxDir) {
   try {
-    await readFile7(join9(sandboxDir, check.target));
+    await readFile4(join6(sandboxDir, check.target));
     return check.expect === "present";
   } catch {
     return check.expect === "absent";
@@ -2747,9 +1805,9 @@ async function checkFilePresence(check, sandboxDir) {
 async function checkMaxLines(check, sandboxDir) {
   const maxLines = parseInt(check.pattern ?? "800", 10);
   try {
-    const files = await listAllFiles(join9(sandboxDir, check.target));
+    const files = await listAllFiles(join6(sandboxDir, check.target));
     for (const file of files) {
-      const content = await readFile7(file, "utf-8");
+      const content = await readFile4(file, "utf-8");
       if (content.split("\n").length > maxLines) {
         return check.expect === "absent";
       }
@@ -2764,7 +1822,7 @@ async function listAllFiles(dir) {
   try {
     const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join9(dir, entry.name);
+      const fullPath = join6(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...await listAllFiles(fullPath));
       } else {
@@ -2950,10 +2008,10 @@ async function saveEvalReport(results, projectRoot, suite, model) {
       lines.push("");
     }
   }
-  const evalDir = join10(projectRoot, ".claude", "eval");
-  await mkdir4(evalDir, { recursive: true });
+  const evalDir = join7(projectRoot, ".claude", "eval");
+  await mkdir3(evalDir, { recursive: true });
   const filename = `eval-${suite ?? "all"}-${timestamp}.md`;
-  await writeFile4(join10(evalDir, filename), lines.join("\n"));
+  await writeFile3(join7(evalDir, filename), lines.join("\n"));
   log.success(`Report saved to .claude/eval/${filename}`);
 }
 async function checkClaudeCli() {
@@ -2970,12 +2028,12 @@ async function checkClaudeCli() {
 
 // src/commands/memory/index.ts
 import { readFileSync } from "fs";
-import { join as join11 } from "path";
+import { join as join8 } from "path";
 import { Command as Command4 } from "commander";
 import { confirm as confirm2 } from "@inquirer/prompts";
 function isMemoryInstalled() {
   const cwd = process.cwd();
-  return hasMemoryHook(join11(cwd, ".claude", "settings.json")) || hasMemoryHook(join11(cwd, ".claude", "settings.local.json"));
+  return hasMemoryHook(join8(cwd, ".claude", "settings.json")) || hasMemoryHook(join8(cwd, ".claude", "settings.local.json"));
 }
 function hasMemoryHook(path) {
   try {
@@ -2998,14 +2056,14 @@ function createMemoryCommand() {
         log.error("Knowledge base not set up yet. Run `claude-launchpad memory` first.");
         return;
       }
-      const { requireMemoryDeps } = await import("./require-deps-NKRCPVAO.js");
+      const { requireMemoryDeps } = await import("./require-deps-SUGLVBM2.js");
       await requireMemoryDeps();
-      const { startTui } = await import("./tui-XIYOOUP6.js");
+      const { startTui } = await import("./tui-DKWRY5PT.js");
       await startTui();
       return;
     }
     if (!isMemoryInstalled()) {
-      const { detectExistingSetup } = await import("./install-MVATZUXZ.js");
+      const { detectExistingSetup } = await import("./install-PFTFTNIF.js");
       const existing = detectExistingSetup(process.cwd());
       if (existing) {
         const location = existing === "local" ? ".claude/CLAUDE.md + settings.local.json" : "CLAUDE.md + settings.json";
@@ -3031,18 +2089,18 @@ function createMemoryCommand() {
         log.info("Skipped.");
         return;
       }
-      const { runInstall } = await import("./install-MVATZUXZ.js");
+      const { runInstall } = await import("./install-PFTFTNIF.js");
       await runInstall({});
     } else {
-      const { requireMemoryDeps } = await import("./require-deps-NKRCPVAO.js");
+      const { requireMemoryDeps } = await import("./require-deps-SUGLVBM2.js");
       await requireMemoryDeps();
-      const { runStats } = await import("./stats-QUBHHPV7.js");
+      const { runStats } = await import("./stats-7WFCVXBX.js");
       await runStats({});
     }
   });
   memory.addCommand(
     new Command4("context").description("Load session context (hook handler)").option("--json", "JSON output").action(async (opts) => {
-      const { runContext } = await import("./context-CWJUUTTU.js");
+      const { runContext } = await import("./context-53PKQOMI.js");
       await runContext(opts);
     }).helpCommand(false),
     { hidden: true }
@@ -3056,13 +2114,13 @@ function createMemoryCommand() {
   );
   memory.addCommand(
     new Command4("push").description("Push current project's memories to GitHub Gist").option("--all", "Push all projects").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {
-      const { runPush } = await import("./push-74XC5CUK.js");
+      const { runPush } = await import("./push-JOCEW3VG.js");
       await runPush(opts);
     })
   );
   memory.addCommand(
     new Command4("pull").description("Pull current project's memories from GitHub Gist").option("--all", "Pull all projects").action(async (opts) => {
-      const { runPull } = await import("./pull-YOESZ3UC.js");
+      const { runPull } = await import("./pull-4QTS57DQ.js");
       await runPull(opts);
     })
   );
@@ -3070,8 +2128,8 @@ function createMemoryCommand() {
 }
 
 // src/cli.ts
-var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.16.0", "-v, --version").action(async () => {
-  const hasConfig = await fileExists(join12(process.cwd(), "CLAUDE.md")) || await fileExists(join12(process.cwd(), ".claude", "settings.json"));
+var program = new Command5().name("claude-launchpad").description("CLI toolkit that makes Claude Code setups measurably good").version("0.16.1", "-v, --version").action(async () => {
+  const hasConfig = await fileExists(join9(process.cwd(), "CLAUDE.md")) || await fileExists(join9(process.cwd(), ".claude", "settings.json"));
   if (hasConfig) {
     await program.commands.find((c) => c.name() === "doctor")?.parseAsync([], { from: "user" });
   } else {