claude-code-starter 0.15.0 → 0.17.0

package/dist/cli.js

@@ -2,19 +2,20 @@
 
 // src/cli.ts
 import { execSync, spawn } from "child_process";
-import fs5 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import os2 from "os";
+import path7 from "path";
 import { fileURLToPath } from "url";
 import ora from "ora";
-import pc from "picocolors";
-import prompts from "prompts";
+import pc2 from "picocolors";
+import prompts2 from "prompts";
 
 // src/analyzer.ts
 import fs from "fs";
 import path from "path";
 function analyzeRepository(rootDir) {
   const techStack = detectTechStack(rootDir);
-  const fileCount = countSourceFiles(rootDir, techStack.languages);
+  const fileCount = countSourceFiles(rootDir);
   const packageJson = readPackageJson(rootDir);
   return {
     isExisting: fileCount > 0,
@@ -33,11 +34,11 @@ function detectTechStack(rootDir) {
   const frameworks = detectFrameworks(packageJson, files, rootDir);
   const primaryFramework = frameworks[0] || null;
   const packageManager = detectPackageManager(files);
-  const testingFramework = detectTestingFramework(packageJson, files);
+  const testingFramework = detectTestingFramework(packageJson, files, rootDir);
   const linter = detectLinter(packageJson, files);
-  const formatter = detectFormatter(packageJson, files);
+  const formatter = detectFormatter(packageJson, files, rootDir);
   const bundler = detectBundler(packageJson, files);
-  const isMonorepo = detectMonorepo(rootDir, files, packageJson);
+  const isMonorepo = detectMonorepo(files, packageJson);
   const hasDocker = files.includes("Dockerfile") || files.includes("docker-compose.yml") || files.includes("docker-compose.yaml");
   const { hasCICD, cicdPlatform } = detectCICD(rootDir, files);
   const { hasClaudeConfig, existingClaudeFiles } = detectExistingClaudeConfig(rootDir);
@@ -59,6 +60,12 @@ function detectTechStack(rootDir) {
     existingClaudeFiles
   };
 }
+function getAllDeps(packageJson) {
+  return {
+    ...packageJson.dependencies || {},
+    ...packageJson.devDependencies || {}
+  };
+}
 function readPackageJson(rootDir) {
   const packageJsonPath = path.join(rootDir, "package.json");
   if (!fs.existsSync(packageJsonPath)) return null;
@@ -269,12 +276,9 @@ function detectPackageManager(files) {
   if (files.includes("build.gradle") || files.includes("build.gradle.kts")) return "gradle";
   return null;
 }
-function detectTestingFramework(packageJson, files) {
+function detectTestingFramework(packageJson, files, rootDir) {
   if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies || {},
-      ...packageJson.devDependencies || {}
-    };
+    const allDeps = getAllDeps(packageJson);
     if (allDeps.vitest) return "vitest";
     if (allDeps.jest) return "jest";
     if (allDeps.mocha) return "mocha";
@@ -286,7 +290,15 @@ function detectTestingFramework(packageJson, files) {
   if (files.includes("pytest.ini") || files.includes("conftest.py")) return "pytest";
   if (files.includes("go.mod")) return "go-test";
   if (files.includes("Cargo.toml")) return "rust-test";
-  if (files.includes("Gemfile")) return "rspec";
+  if (files.includes(".rspec")) return "rspec";
+  if (files.includes("Gemfile")) {
+    if (files.includes("spec")) return "rspec";
+    try {
+      const gemfile = fs.readFileSync(path.join(rootDir, "Gemfile"), "utf-8").toLowerCase();
+      if (gemfile.includes("rspec")) return "rspec";
+    } catch {
+    }
+  }
   return null;
 }
 function detectLinter(packageJson, files) {
@@ -297,10 +309,7 @@ function detectLinter(packageJson, files) {
   }
   if (files.includes("biome.json") || files.includes("biome.jsonc")) return "biome";
   if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies || {},
-      ...packageJson.devDependencies || {}
-    };
+    const allDeps = getAllDeps(packageJson);
     if (allDeps.eslint) return "eslint";
     if (allDeps["@biomejs/biome"]) return "biome";
   }
@@ -308,7 +317,7 @@ function detectLinter(packageJson, files) {
   if (files.includes(".flake8") || files.includes("setup.cfg")) return "flake8";
   return null;
 }
-function detectFormatter(packageJson, files) {
+function detectFormatter(packageJson, files, rootDir) {
   if (files.some(
     (f) => f.startsWith(".prettierrc") || f === "prettier.config.js" || f === "prettier.config.mjs"
   )) {
@@ -316,15 +325,23 @@ function detectFormatter(packageJson, files) {
   }
   if (files.includes("biome.json") || files.includes("biome.jsonc")) return "biome";
   if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies || {},
-      ...packageJson.devDependencies || {}
-    };
+    const allDeps = getAllDeps(packageJson);
     if (allDeps.prettier) return "prettier";
     if (allDeps["@biomejs/biome"]) return "biome";
   }
+  if (files.includes("ruff.toml") || files.includes(".ruff.toml")) return "ruff";
   if (files.includes("pyproject.toml")) {
-    return "black";
+    try {
+      const pyproject = fs.readFileSync(path.join(rootDir, "pyproject.toml"), "utf-8");
+      if (pyproject.includes("[tool.ruff.format]") || pyproject.includes("[tool.ruff]")) {
+        return "ruff";
+      }
+      if (pyproject.includes("[tool.black]") || pyproject.includes("black")) {
+        return "black";
+      }
+    } catch {
+    }
+    return null;
   }
   return null;
 }
@@ -335,10 +352,7 @@ function detectBundler(packageJson, files) {
   if (files.some((f) => f.startsWith("rollup.config"))) return "rollup";
   if (files.some((f) => f.startsWith("esbuild"))) return "esbuild";
   if (packageJson) {
-    const allDeps = {
-      ...packageJson.dependencies || {},
-      ...packageJson.devDependencies || {}
-    };
+    const allDeps = getAllDeps(packageJson);
     if (allDeps.vite) return "vite";
     if (allDeps.webpack) return "webpack";
     if (allDeps.tsup) return "tsup";
@@ -350,16 +364,12 @@ function detectBundler(packageJson, files) {
   }
   return null;
 }
-function detectMonorepo(rootDir, files, packageJson) {
+function detectMonorepo(files, packageJson) {
   if (files.includes("pnpm-workspace.yaml")) return true;
   if (files.includes("lerna.json")) return true;
   if (files.includes("nx.json")) return true;
   if (files.includes("turbo.json")) return true;
   if (packageJson?.workspaces) return true;
-  const packagesDir = path.join(rootDir, "packages");
-  const appsDir = path.join(rootDir, "apps");
-  if (fs.existsSync(packagesDir) && fs.statSync(packagesDir).isDirectory()) return true;
-  if (fs.existsSync(appsDir) && fs.statSync(appsDir).isDirectory()) return true;
   return false;
 }
 function detectCICD(rootDir, files) {
@@ -435,7 +445,7 @@ function listSourceFilesShallow(rootDir, extensions) {
   scan(rootDir, 0);
   return files;
 }
-function countSourceFiles(rootDir, _languages) {
+function countSourceFiles(rootDir) {
   const extensions = [
     // JavaScript/TypeScript
     ".js",
@@ -512,96 +522,13 @@ function countSourceFiles(rootDir, _languages) {
   return count;
 }
 
-// src/generator.ts
-import fs2 from "fs";
-import path2 from "path";
-function ensureDirectories(rootDir) {
-  const dirs = [".claude", ".claude/skills", ".claude/agents", ".claude/rules", ".claude/commands"];
-  for (const dir of dirs) {
-    fs2.mkdirSync(path2.join(rootDir, dir), { recursive: true });
-  }
-}
-function generateSettings(stack) {
-  const permissions = ["Read(**)", "Edit(**)", "Write(.claude/**)", "Bash(git:*)"];
-  const pkgManagers = ["npm", "yarn", "pnpm", "bun", "npx"];
-  for (const pm of pkgManagers) {
-    permissions.push(`Bash(${pm}:*)`);
-  }
-  if (stack.languages.includes("typescript") || stack.languages.includes("javascript")) {
-    permissions.push("Bash(node:*)", "Bash(tsc:*)");
-  }
-  if (stack.languages.includes("python")) {
-    permissions.push(
-      "Bash(python:*)",
-      "Bash(pip:*)",
-      "Bash(poetry:*)",
-      "Bash(pytest:*)",
-      "Bash(uvicorn:*)"
-    );
-  }
-  if (stack.languages.includes("go")) {
-    permissions.push("Bash(go:*)");
-  }
-  if (stack.languages.includes("rust")) {
-    permissions.push("Bash(cargo:*)", "Bash(rustc:*)");
-  }
-  if (stack.languages.includes("ruby")) {
-    permissions.push("Bash(ruby:*)", "Bash(bundle:*)", "Bash(rails:*)", "Bash(rake:*)");
-  }
-  if (stack.testingFramework) {
-    const testCommands = {
-      jest: ["jest:*"],
-      vitest: ["vitest:*"],
-      playwright: ["playwright:*"],
-      cypress: ["cypress:*"],
-      pytest: ["pytest:*"],
-      rspec: ["rspec:*"]
-    };
-    const cmds = testCommands[stack.testingFramework];
-    if (cmds) {
-      permissions.push(...cmds.map((c) => `Bash(${c})`));
-    }
-  }
-  if (stack.linter) {
-    permissions.push(`Bash(${stack.linter}:*)`);
-  }
-  if (stack.formatter) {
-    permissions.push(`Bash(${stack.formatter}:*)`);
-  }
-  permissions.push(
-    "Bash(ls:*)",
-    "Bash(mkdir:*)",
-    "Bash(cat:*)",
-    "Bash(echo:*)",
-    "Bash(grep:*)",
-    "Bash(find:*)"
-  );
-  if (stack.hasDocker) {
-    permissions.push("Bash(docker:*)", "Bash(docker-compose:*)");
-  }
-  const settings = {
-    $schema: "https://json.schemastore.org/claude-code-settings.json",
-    permissions: {
-      allow: [...new Set(permissions)]
-      // Deduplicate
-    }
-  };
-  return {
-    path: ".claude/settings.json",
-    content: JSON.stringify(settings, null, 2)
-  };
-}
-function writeSettings(rootDir, stack) {
-  const { path: settingsPath, content } = generateSettings(stack);
-  const fullPath = path2.join(rootDir, settingsPath);
-  const dir = path2.dirname(fullPath);
-  fs2.mkdirSync(dir, { recursive: true });
-  fs2.writeFileSync(fullPath, content);
-}
+// src/extras.ts
+import pc from "picocolors";
+import prompts from "prompts";
 
 // src/hooks.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path2 from "path";
 var HOOK_SCRIPT = String.raw`#!/usr/bin/env node
 /**
  * Block Dangerous Commands - PreToolUse Hook for Bash
@@ -765,77 +692,1003 @@ function checkCommand(cmd, safetyLevel) {
       return { blocked: true, pattern: p };
     }
   }
-  return { blocked: false, pattern: null };
+  return { blocked: false, pattern: null };
+}
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  try {
+    const data = JSON.parse(input);
+    const { tool_name, tool_input, session_id, cwd, permission_mode } = data;
+    if (tool_name !== 'Bash') return console.log('{}');
+
+    const cmd = tool_input?.command || '';
+    const result = checkCommand(cmd);
+
+    if (result.blocked) {
+      const p = result.pattern;
+      log({ level: 'BLOCKED', id: p.id, priority: p.level, cmd, session_id, cwd, permission_mode });
+      return console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason: EMOJIS[p.level] + ' [' + p.id + '] ' + p.reason
+        }
+      }));
+    }
+    console.log('{}');
+  } catch (e) {
+    log({ level: 'ERROR', error: e.message });
+    console.log('{}');
+  }
+}
+
+if (require.main === module) {
+  main();
+} else {
+  module.exports = { PATTERNS, LEVELS, SAFETY_LEVEL, checkCommand };
+}
+`;
+function checkHookStatus(rootDir) {
+  const homeDir = process.env.HOME || "";
+  const projectScriptPath = path2.join(rootDir, ".claude", "hooks", "block-dangerous-commands.js");
+  const globalScriptPath = path2.join(homeDir, ".claude", "hooks", "block-dangerous-commands.js");
+  const result = {
+    projectInstalled: false,
+    globalInstalled: false,
+    projectMatchesOurs: false,
+    globalMatchesOurs: false
+  };
+  if (fs2.existsSync(projectScriptPath)) {
+    result.projectInstalled = true;
+    try {
+      const content = fs2.readFileSync(projectScriptPath, "utf-8");
+      result.projectMatchesOurs = content.trim() === HOOK_SCRIPT.trim();
+    } catch {
+    }
+  }
+  if (fs2.existsSync(globalScriptPath)) {
+    result.globalInstalled = true;
+    try {
+      const content = fs2.readFileSync(globalScriptPath, "utf-8");
+      result.globalMatchesOurs = content.trim() === HOOK_SCRIPT.trim();
+    } catch {
+    }
+  }
+  return result;
+}
+function installHook(rootDir) {
+  const hooksDir = path2.join(rootDir, ".claude", "hooks");
+  const hookPath = path2.join(hooksDir, "block-dangerous-commands.js");
+  const settingsPath = path2.join(rootDir, ".claude", "settings.json");
+  fs2.mkdirSync(hooksDir, { recursive: true });
+  fs2.writeFileSync(hookPath, HOOK_SCRIPT);
+  fs2.chmodSync(hookPath, 493);
+  try {
+    const existing = fs2.existsSync(settingsPath) ? JSON.parse(fs2.readFileSync(settingsPath, "utf-8")) : {};
+    const newEntry = {
+      matcher: "Bash",
+      hooks: [
+        {
+          type: "command",
+          command: "node .claude/hooks/block-dangerous-commands.js"
+        }
+      ]
+    };
+    const existingPreToolUse = Array.isArray(existing.hooks?.PreToolUse) ? existing.hooks.PreToolUse : [];
+    const alreadyInstalled = existingPreToolUse.some(
+      (e) => Array.isArray(e.hooks) && e.hooks.some((h) => h.command?.includes("block-dangerous-commands.js"))
+    );
+    existing.hooks = {
+      ...existing.hooks,
+      PreToolUse: alreadyInstalled ? existingPreToolUse : [...existingPreToolUse, newEntry]
+    };
+    fs2.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    console.error(`  Warning: could not patch settings.json (${msg}) \u2014 add hook config manually`);
+  }
+}
+function installHookGlobal() {
+  const homeDir = process.env.HOME || "";
+  const hooksDir = path2.join(homeDir, ".claude", "hooks");
+  const hookPath = path2.join(hooksDir, "block-dangerous-commands.js");
+  const settingsPath = path2.join(homeDir, ".claude", "settings.json");
+  fs2.mkdirSync(hooksDir, { recursive: true });
+  fs2.writeFileSync(hookPath, HOOK_SCRIPT);
+  fs2.chmodSync(hookPath, 493);
+  try {
+    const existing = fs2.existsSync(settingsPath) ? JSON.parse(fs2.readFileSync(settingsPath, "utf-8")) : {};
+    const newEntry = {
+      matcher: "Bash",
+      hooks: [{ type: "command", command: "node ~/.claude/hooks/block-dangerous-commands.js" }]
+    };
+    const existingPreToolUse = Array.isArray(existing.hooks?.PreToolUse) ? existing.hooks.PreToolUse : [];
+    const alreadyInstalled = existingPreToolUse.some(
+      (e) => Array.isArray(e.hooks) && e.hooks.some((h) => h.command?.includes("block-dangerous-commands.js"))
+    );
+    existing.hooks = {
+      ...existing.hooks,
+      PreToolUse: alreadyInstalled ? existingPreToolUse : [...existingPreToolUse, newEntry]
+    };
+    fs2.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    console.error(`  Warning: could not patch settings.json (${msg}) \u2014 add hook config manually`);
+  }
+}
+var STATUSLINE_SCRIPT = [
+  "#!/usr/bin/env bash",
+  "# Claude Code statusline \u2014 portable, no runtime dependency beyond jq",
+  "",
+  "set -euo pipefail",
+  "",
+  "# Colors (using $'...' so escapes resolve at assignment, not at output time)",
+  "RST=$'\\033[0m'",
+  "CYAN=$'\\033[36m'",
+  "MAGENTA=$'\\033[35m'",
+  "BLUE=$'\\033[34m'",
+  "GREEN=$'\\033[32m'",
+  "YELLOW=$'\\033[33m'",
+  "RED=$'\\033[31m'",
+  "",
+  "# Read JSON from stdin (Claude Code pipes session data)",
+  'INPUT="$(cat)"',
+  "",
+  "# Parse fields with jq",
+  `CWD="$(echo "$INPUT" | jq -r '.workspace.current_dir // .cwd // ""')"`,
+  'PROJECT="$(basename "$CWD")"',
+  `SESSION_ID="$(echo "$INPUT" | jq -r '.session_id // empty')"`,
+  `SESSION_NAME="$(echo "$INPUT" | jq -r '.session_name // empty')"`,
+  `REMAINING="$(echo "$INPUT" | jq -r '.context_window.remaining_percentage // empty')"`,
+  `MODEL="$(echo "$INPUT" | jq -r '.model.display_name // empty')"`,
+  "",
+  "# Line 1: [user] project [on branch]",
+  'LINE1=""',
+  'if [[ -n "${SSH_CONNECTION:-}" ]]; then',
+  '    LINE1+="${BLUE}$(whoami)${RST} "',
+  "fi",
+  'LINE1+="${CYAN}${PROJECT}${RST}"',
+  "",
+  'BRANCH="$(git branch --show-current 2>/dev/null || git rev-parse --short HEAD 2>/dev/null || true)"',
+  'if [[ -n "$BRANCH" ]]; then',
+  '    LINE1+=" on ${MAGENTA}\u{1F331} ${BRANCH}${RST}"',
+  "fi",
+  "",
+  "# Line 2: session + context + model",
+  'PARTS=""',
+  'if [[ -n "$SESSION_ID" ]]; then',
+  '    if [[ -n "$SESSION_NAME" ]]; then',
+  '        PARTS+="${MAGENTA}${SESSION_NAME} \xB7 sid: ${SESSION_ID}${RST}"',
+  "    else",
+  '        PARTS+="${MAGENTA}sid: ${SESSION_ID}${RST}"',
+  "    fi",
+  "fi",
+  "",
+  'if [[ -n "$REMAINING" ]]; then',
+  '    RND="${REMAINING%%.*}"',
+  "    if (( RND < 20 )); then",
+  '        CTX_COLOR="$RED"',
+  "    elif (( RND < 50 )); then",
+  '        CTX_COLOR="$YELLOW"',
+  "    else",
+  '        CTX_COLOR="$GREEN"',
+  "    fi",
+  '    [[ -n "$PARTS" ]] && PARTS+=" "',
+  '    PARTS+="${CTX_COLOR}[ctx: ${RND}%]${RST}"',
+  "fi",
+  "",
+  'if [[ -n "$MODEL" ]]; then',
+  '    [[ -n "$PARTS" ]] && PARTS+=" "',
+  '    PARTS+="[${CYAN}${MODEL}${RST}]"',
+  "fi",
+  "",
+  'echo "$LINE1"',
+  'echo "$PARTS"'
+].join("\n");
+function checkStatuslineStatus(rootDir) {
+  const homeDir = process.env.HOME || "";
+  const projectScriptPath = path2.join(rootDir, ".claude", "config", "statusline-command.sh");
+  const globalScriptPath = path2.join(homeDir, ".claude", "config", "statusline-command.sh");
+  const projectSettingsPath = path2.join(rootDir, ".claude", "settings.json");
+  const globalSettingsPath = path2.join(homeDir, ".claude", "settings.json");
+  const result = {
+    projectInstalled: false,
+    globalInstalled: false,
+    projectMatchesOurs: false,
+    globalMatchesOurs: false
+  };
+  try {
+    if (fs2.existsSync(projectSettingsPath)) {
+      const settings = JSON.parse(fs2.readFileSync(projectSettingsPath, "utf-8"));
+      if (settings.statusLine?.command) {
+        result.projectInstalled = true;
+        if (fs2.existsSync(projectScriptPath)) {
+          const content = fs2.readFileSync(projectScriptPath, "utf-8");
+          result.projectMatchesOurs = content.trim() === STATUSLINE_SCRIPT.trim();
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    if (fs2.existsSync(globalSettingsPath)) {
+      const settings = JSON.parse(fs2.readFileSync(globalSettingsPath, "utf-8"));
+      if (settings.statusLine?.command) {
+        result.globalInstalled = true;
+        if (fs2.existsSync(globalScriptPath)) {
+          const content = fs2.readFileSync(globalScriptPath, "utf-8");
+          result.globalMatchesOurs = content.trim() === STATUSLINE_SCRIPT.trim();
+        }
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function installStatusline(rootDir) {
+  const configDir = path2.join(rootDir, ".claude", "config");
+  const scriptPath = path2.join(configDir, "statusline-command.sh");
+  const settingsPath = path2.join(rootDir, ".claude", "settings.json");
+  fs2.mkdirSync(configDir, { recursive: true });
+  fs2.writeFileSync(scriptPath, STATUSLINE_SCRIPT);
+  fs2.chmodSync(scriptPath, 493);
+  patchSettings(settingsPath, {
+    statusLine: { type: "command", command: "bash .claude/config/statusline-command.sh" }
+  });
+}
+function installStatuslineGlobal() {
+  const homeDir = process.env.HOME || "";
+  const configDir = path2.join(homeDir, ".claude", "config");
+  const scriptPath = path2.join(configDir, "statusline-command.sh");
+  const settingsPath = path2.join(homeDir, ".claude", "settings.json");
+  fs2.mkdirSync(configDir, { recursive: true });
+  fs2.writeFileSync(scriptPath, STATUSLINE_SCRIPT);
+  fs2.chmodSync(scriptPath, 493);
+  patchSettings(settingsPath, {
+    statusLine: { type: "command", command: "bash ~/.claude/config/statusline-command.sh" }
+  });
+}
+var SENSITIVE_FILES_HOOK = String.raw`#!/usr/bin/env node
+/**
+ * Protect Sensitive Files - PreToolUse Hook for Write/Edit
+ * Warns before modifying sensitive files (migrations, env, credentials, lock files).
+ */
+
+const path = require('path');
+
+const SENSITIVE_PATTERNS = [
+  { pattern: /\/migrations?\//i, reason: 'migration file — changes may affect database schema' },
+  { pattern: /\.env(\.\w+)?$/, reason: 'environment file — may contain secrets' },
+  { pattern: /\/secrets?\//i, reason: 'secrets directory — may contain credentials' },
+  { pattern: /\/credentials?\//i, reason: 'credentials directory' },
+  { pattern: /\.(pem|key|cert|crt)$/, reason: 'certificate/key file' },
+  { pattern: /package-lock\.json$/, reason: 'lock file — should be managed by package manager' },
+  { pattern: /yarn\.lock$/, reason: 'lock file — should be managed by package manager' },
+  { pattern: /pnpm-lock\.yaml$/, reason: 'lock file — should be managed by package manager' },
+  { pattern: /bun\.lock$/, reason: 'lock file — should be managed by package manager' },
+  { pattern: /Cargo\.lock$/, reason: 'lock file — should be managed by cargo' },
+  { pattern: /poetry\.lock$/, reason: 'lock file — should be managed by poetry' },
+];
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  try {
+    const data = JSON.parse(input);
+    const { tool_name, tool_input } = data;
+
+    if (tool_name !== 'Write' && tool_name !== 'Edit') {
+      return console.log('{}');
+    }
+
+    const filePath = tool_input?.file_path || tool_input?.path || '';
+    const normalized = filePath.replace(/\\/g, '/');
+
+    for (const { pattern, reason } of SENSITIVE_PATTERNS) {
+      if (pattern.test(normalized)) {
+        return console.log(JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'ask',
+            permissionDecisionReason: '\u26A0\uFE0F Sensitive file: ' + reason + ' (' + path.basename(filePath) + ')'
+          }
+        }));
+      }
+    }
+
+    console.log('{}');
+  } catch {
+    console.log('{}');
+  }
+}
+
+if (require.main === module) main();
+`;
+function checkSensitiveHookStatus(rootDir) {
+  const homeDir = process.env.HOME || "";
+  const projectPath = path2.join(rootDir, ".claude", "hooks", "protect-sensitive-files.js");
+  const globalPath = path2.join(homeDir, ".claude", "hooks", "protect-sensitive-files.js");
+  const result = {
+    projectInstalled: false,
+    globalInstalled: false,
+    projectMatchesOurs: false,
+    globalMatchesOurs: false
+  };
+  if (fs2.existsSync(projectPath)) {
+    result.projectInstalled = true;
+    try {
+      result.projectMatchesOurs = fs2.readFileSync(projectPath, "utf-8").trim() === SENSITIVE_FILES_HOOK.trim();
+    } catch {
+    }
+  }
+  if (fs2.existsSync(globalPath)) {
+    result.globalInstalled = true;
+    try {
+      result.globalMatchesOurs = fs2.readFileSync(globalPath, "utf-8").trim() === SENSITIVE_FILES_HOOK.trim();
+    } catch {
+    }
+  }
+  return result;
+}
+function installSensitiveHook(rootDir) {
+  const hooksDir = path2.join(rootDir, ".claude", "hooks");
+  const hookPath = path2.join(hooksDir, "protect-sensitive-files.js");
+  const settingsPath = path2.join(rootDir, ".claude", "settings.json");
+  fs2.mkdirSync(hooksDir, { recursive: true });
+  fs2.writeFileSync(hookPath, SENSITIVE_FILES_HOOK);
+  fs2.chmodSync(hookPath, 493);
+  patchHook(settingsPath, "Write", "node .claude/hooks/protect-sensitive-files.js");
+  patchHook(settingsPath, "Edit", "node .claude/hooks/protect-sensitive-files.js");
+}
+function installSensitiveHookGlobal() {
+  const homeDir = process.env.HOME || "";
+  const hooksDir = path2.join(homeDir, ".claude", "hooks");
+  const hookPath = path2.join(hooksDir, "protect-sensitive-files.js");
+  const settingsPath = path2.join(homeDir, ".claude", "settings.json");
+  fs2.mkdirSync(hooksDir, { recursive: true });
+  fs2.writeFileSync(hookPath, SENSITIVE_FILES_HOOK);
+  fs2.chmodSync(hookPath, 493);
+  patchHook(settingsPath, "Write", "node ~/.claude/hooks/protect-sensitive-files.js");
+  patchHook(settingsPath, "Edit", "node ~/.claude/hooks/protect-sensitive-files.js");
+}
+function patchHook(settingsPath, matcher, command) {
+  try {
+    const existing = fs2.existsSync(settingsPath) ? JSON.parse(fs2.readFileSync(settingsPath, "utf-8")) : {};
+    const newEntry = {
+      matcher,
+      hooks: [{ type: "command", command }]
+    };
+    const existingPreToolUse = Array.isArray(existing.hooks?.PreToolUse) ? existing.hooks.PreToolUse : [];
+    const alreadyInstalled = existingPreToolUse.some(
+      (e) => e.matcher === matcher && Array.isArray(e.hooks) && e.hooks.some((h) => h.command === command)
+    );
+    if (!alreadyInstalled) {
+      existing.hooks = {
+        ...existing.hooks,
+        PreToolUse: [...existingPreToolUse, newEntry]
+      };
+      fs2.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    console.error(`  Warning: could not patch settings.json (${msg}) \u2014 add hook config manually`);
+  }
+}
+function patchSettings(settingsPath, patch) {
+  try {
+    const existing = fs2.existsSync(settingsPath) ? JSON.parse(fs2.readFileSync(settingsPath, "utf-8")) : {};
+    Object.assign(existing, patch);
+    fs2.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    console.error(
+      `  Warning: could not patch settings.json (${msg}) \u2014 add statusLine config manually`
+    );
+  }
+}
+
+// src/extras.ts
+var EXTRAS = [
+  {
+    id: "safety-hook",
+    name: "Safety hook",
+    description: "Block dangerous commands (git push, rm -rf, etc.)",
+    checkStatus: checkHookStatus,
+    installProject: installHook,
+    installGlobal: installHookGlobal,
+    projectPath: ".claude/hooks/block-dangerous-commands.js",
+    globalPath: "~/.claude/hooks/block-dangerous-commands.js"
+  },
+  {
+    id: "statusline",
+    name: "Custom statusline",
+    description: "Shows project, branch, context, model",
+    checkStatus: checkStatuslineStatus,
+    installProject: installStatusline,
+    installGlobal: installStatuslineGlobal,
+    projectPath: ".claude/config/statusline-command.sh",
+    globalPath: "~/.claude/config/statusline-command.sh"
+  },
+  {
+    id: "sensitive-files",
+    name: "Sensitive file protection",
+    description: "Warns before editing migrations, env, lock files, credentials",
+    checkStatus: checkSensitiveHookStatus,
+    installProject: installSensitiveHook,
+    installGlobal: installSensitiveHookGlobal,
+    projectPath: ".claude/hooks/protect-sensitive-files.js",
+    globalPath: "~/.claude/hooks/protect-sensitive-files.js"
+  }
+];
+async function promptExtras(projectDir) {
+  for (const extra of EXTRAS) {
+    const status = extra.checkStatus(projectDir);
+    if (status.projectMatchesOurs || status.globalMatchesOurs) {
+      continue;
+    }
+    if (status.projectInstalled || status.globalInstalled) {
+      const where = status.globalInstalled ? "globally" : "in this project";
+      const { action } = await prompts({
+        type: "select",
+        name: "action",
+        message: `A different ${extra.name.toLowerCase()} is already configured ${where}. Replace it?`,
+        choices: [
+          { title: "Install for this project only", value: "project" },
+          { title: "Install globally (all projects)", value: "global" },
+          { title: "Skip \u2014 keep existing", value: "skip" }
+        ],
+        initial: 2
+      });
+      applyAction(action, extra, projectDir);
+    } else {
+      const { action } = await prompts({
+        type: "select",
+        name: "action",
+        message: `Add ${extra.name.toLowerCase()}? (${extra.description})`,
+        choices: [
+          { title: "Install for this project only", value: "project" },
+          { title: "Install globally (all projects)", value: "global" },
+          { title: "Skip", value: "skip" }
+        ],
+        initial: 0
+      });
+      applyAction(action, extra, projectDir);
+    }
+  }
+}
+function applyAction(action, extra, projectDir) {
+  if (action === "project") {
+    extra.installProject(projectDir);
+    console.log(pc.green(`  + ${extra.projectPath}`));
+  } else if (action === "global") {
+    extra.installGlobal();
+    console.log(pc.green(`  + ${extra.globalPath} (global)`));
+  }
+}
+
+// src/generator.ts
+import fs3 from "fs";
+import path3 from "path";
+function ensureDirectories(rootDir) {
+  const dirs = [".claude", ".claude/skills", ".claude/agents", ".claude/rules", ".claude/commands"];
+  for (const dir of dirs) {
+    fs3.mkdirSync(path3.join(rootDir, dir), { recursive: true });
+  }
+}
+function generateSettings(stack) {
+  const permissions = ["Read(**)", "Edit(**)", "Write(.claude/**)", "Bash(git:*)"];
+  const pkgManagers = ["npm", "yarn", "pnpm", "bun", "npx"];
+  for (const pm of pkgManagers) {
+    permissions.push(`Bash(${pm}:*)`);
+  }
+  if (stack.languages.includes("typescript") || stack.languages.includes("javascript")) {
+    permissions.push("Bash(node:*)", "Bash(tsc:*)");
+  }
+  if (stack.languages.includes("python")) {
+    permissions.push(
+      "Bash(python:*)",
+      "Bash(pip:*)",
+      "Bash(poetry:*)",
+      "Bash(pytest:*)",
+      "Bash(uvicorn:*)"
+    );
+  }
+  if (stack.languages.includes("go")) {
+    permissions.push("Bash(go:*)");
+  }
+  if (stack.languages.includes("rust")) {
+    permissions.push("Bash(cargo:*)", "Bash(rustc:*)");
+  }
+  if (stack.languages.includes("ruby")) {
+    permissions.push("Bash(ruby:*)", "Bash(bundle:*)", "Bash(rails:*)", "Bash(rake:*)");
+  }
+  if (stack.testingFramework) {
+    const testCommands = {
+      jest: ["jest:*"],
+      vitest: ["vitest:*"],
+      playwright: ["playwright:*"],
+      cypress: ["cypress:*"],
+      pytest: ["pytest:*"],
+      rspec: ["rspec:*"]
+    };
+    const cmds = testCommands[stack.testingFramework];
+    if (cmds) {
+      permissions.push(...cmds.map((c) => `Bash(${c})`));
+    }
+  }
+  if (stack.linter) {
+    permissions.push(`Bash(${stack.linter}:*)`);
+  }
+  if (stack.formatter) {
+    permissions.push(`Bash(${stack.formatter}:*)`);
+  }
+  permissions.push(
+    "Bash(ls:*)",
+    "Bash(mkdir:*)",
+    "Bash(cat:*)",
+    "Bash(echo:*)",
+    "Bash(grep:*)",
+    "Bash(find:*)"
+  );
+  if (stack.hasDocker) {
+    permissions.push("Bash(docker:*)", "Bash(docker-compose:*)");
+  }
+  const settings = {
+    $schema: "https://json.schemastore.org/claude-code-settings.json",
+    permissions: {
+      allow: [...new Set(permissions)]
+      // Deduplicate
+    }
+  };
+  return {
+    path: ".claude/settings.json",
+    content: JSON.stringify(settings, null, 2)
+  };
+}
+function writeSettings(rootDir, stack, force = false) {
+  const { path: settingsPath, content } = generateSettings(stack);
+  const fullPath = path3.join(rootDir, settingsPath);
+  const dir = path3.dirname(fullPath);
+  fs3.mkdirSync(dir, { recursive: true });
+  if (!force && fs3.existsSync(fullPath)) {
+    try {
+      const existing = JSON.parse(fs3.readFileSync(fullPath, "utf-8"));
+      const generated = JSON.parse(content);
+      const existingAllow = existing.permissions?.allow || [];
+      const generatedAllow = generated.permissions?.allow || [];
+      const mergedAllow = [.../* @__PURE__ */ new Set([...existingAllow, ...generatedAllow])];
+      const merged = {
+        ...existing,
+        $schema: generated.$schema,
+        permissions: {
+          ...existing.permissions,
+          allow: mergedAllow
+        }
+      };
+      fs3.writeFileSync(fullPath, JSON.stringify(merged, null, 2));
+      return;
+    } catch {
+    }
+  }
+  fs3.writeFileSync(fullPath, content);
+}
+
+// src/health.ts
+import fs4 from "fs";
+import os from "os";
+import path4 from "path";
+function checkHealth(projectDir) {
+  const items = [];
+  items.push(checkClaudeMdExists(projectDir));
+  items.push(checkClaudeMdLength(projectDir));
+  items.push(checkClaudeMdReferences(projectDir));
+  items.push(checkSettingsExists(projectDir));
+  items.push(checkAgentsExist(projectDir));
+  items.push(checkSkillsExist(projectDir));
+  items.push(checkRulesHaveFilters(projectDir));
+  items.push(checkCommandsExist(projectDir));
+  items.push(checkSafetyHook(projectDir));
+  items.push(checkNoDuplication(projectDir));
+  const score = items.reduce((sum, item) => sum + item.score, 0);
+  const maxScore = items.reduce((sum, item) => sum + item.maxScore, 0);
+  return { score, maxScore, items };
+}
+function checkClaudeMdExists(projectDir) {
+  const exists = fs4.existsSync(path4.join(projectDir, ".claude", "CLAUDE.md"));
+  return {
+    name: "CLAUDE.md exists",
+    passed: exists,
+    score: exists ? 10 : 0,
+    maxScore: 10,
+    message: exists ? "CLAUDE.md found" : "Missing .claude/CLAUDE.md \u2014 run claude-code-starter to generate"
+  };
+}
+function checkClaudeMdLength(projectDir) {
+  const claudeMdPath = path4.join(projectDir, ".claude", "CLAUDE.md");
+  if (!fs4.existsSync(claudeMdPath)) {
+    return {
+      name: "CLAUDE.md length",
+      passed: false,
+      score: 0,
+      maxScore: 5,
+      message: "CLAUDE.md not found"
+    };
+  }
+  const lines = fs4.readFileSync(claudeMdPath, "utf-8").split("\n").length;
+  const ok = lines <= 120;
+  return {
+    name: "CLAUDE.md length",
+    passed: ok,
+    score: ok ? 5 : 2,
+    maxScore: 5,
+    message: ok ? `${lines} lines (within 120-line cap)` : `${lines} lines \u2014 exceeds 120-line cap, consider trimming`
+  };
+}
+function checkClaudeMdReferences(projectDir) {
+  const claudeMdPath = path4.join(projectDir, ".claude", "CLAUDE.md");
+  if (!fs4.existsSync(claudeMdPath)) {
+    return {
+      name: "CLAUDE.md file references",
+      passed: false,
+      score: 0,
+      maxScore: 10,
+      message: "CLAUDE.md not found"
+    };
+  }
+  const content = fs4.readFileSync(claudeMdPath, "utf-8");
+  const fileRefs = content.match(/`([^`]+\.\w{1,5})`/g) || [];
+  const uniqueRefs = [...new Set(fileRefs.map((r) => r.replace(/`/g, "").split(" ")[0]))];
+  let valid = 0;
+  let invalid = 0;
+  const brokenRefs = [];
+  for (const ref of uniqueRefs) {
+    if (ref.includes("*") || ref.includes("://") || ref.startsWith("$") || ref.startsWith(".env"))
+      continue;
+    const filePart = ref.split("(")[0].trim();
+    if (filePart.length === 0) continue;
+    const fullPath = path4.join(projectDir, filePart);
+    if (fs4.existsSync(fullPath)) {
+      valid++;
+    } else {
+      invalid++;
+      brokenRefs.push(filePart);
+    }
+  }
+  const total = valid + invalid;
+  if (total === 0) {
+    return {
+      name: "CLAUDE.md file references",
+      passed: true,
+      score: 10,
+      maxScore: 10,
+      message: "No file references to validate"
+    };
+  }
+  const passed = invalid === 0;
+  const score = total > 0 ? Math.round(valid / total * 10) : 10;
+  const message = passed ? `All ${valid} file references are valid` : `${invalid}/${total} file references are broken: ${brokenRefs.slice(0, 3).join(", ")}${brokenRefs.length > 3 ? "..." : ""}`;
+  return { name: "CLAUDE.md file references", passed, score, maxScore: 10, message };
+}
+function checkSettingsExists(projectDir) {
+  const settingsPath = path4.join(projectDir, ".claude", "settings.json");
+  if (!fs4.existsSync(settingsPath)) {
+    return {
+      name: "settings.json",
+      passed: false,
+      score: 0,
+      maxScore: 5,
+      message: "Missing .claude/settings.json"
+    };
+  }
+  try {
+    const settings = JSON.parse(fs4.readFileSync(settingsPath, "utf-8"));
+    const hasPermissions = Array.isArray(settings.permissions?.allow) && settings.permissions.allow.length > 0;
+    return {
+      name: "settings.json",
+      passed: hasPermissions,
+      score: hasPermissions ? 5 : 3,
+      maxScore: 5,
+      message: hasPermissions ? `${settings.permissions.allow.length} permissions configured` : "settings.json exists but no permissions configured"
+    };
+  } catch {
+    return {
+      name: "settings.json",
+      passed: false,
+      score: 1,
+      maxScore: 5,
+      message: "settings.json exists but is malformed"
+    };
+  }
+}
+function checkAgentsExist(projectDir) {
+  const agentsDir = path4.join(projectDir, ".claude", "agents");
+  const agents = listMdFiles(agentsDir);
+  const passed = agents.length >= 2;
+  return {
+    name: "Agents",
+    passed,
+    score: Math.min(agents.length * 2, 10),
+    maxScore: 10,
+    message: agents.length > 0 ? `${agents.length} agents: ${agents.map((a) => path4.basename(a, ".md")).join(", ")}` : "No agents found \u2014 run claude-code-starter to generate"
+  };
+}
+function checkSkillsExist(projectDir) {
+  const skillsDir = path4.join(projectDir, ".claude", "skills");
+  const skills = listMdFiles(skillsDir);
+  const passed = skills.length >= 4;
+  return {
+    name: "Skills",
+    passed,
+    score: Math.min(skills.length, 5),
+    maxScore: 5,
+    message: skills.length > 0 ? `${skills.length} skills found` : "No skills found \u2014 run claude-code-starter to generate"
+  };
+}
+function checkRulesHaveFilters(projectDir) {
+  const rulesDir = path4.join(projectDir, ".claude", "rules");
+  const rules = listMdFiles(rulesDir);
+  if (rules.length === 0) {
+    return {
+      name: "Rules have paths filters",
+      passed: true,
+      score: 5,
+      maxScore: 5,
+      message: "No rules to check"
+    };
+  }
+  let withFilter = 0;
+  let withoutFilter = 0;
+  for (const rule of rules) {
+    try {
+      const content = fs4.readFileSync(rule, "utf-8");
+      if (content.includes("paths:")) {
+        withFilter++;
+      } else {
+        withoutFilter++;
+      }
+    } catch {
+      withoutFilter++;
+    }
+  }
+  const passed = withoutFilter === 0;
+  return {
+    name: "Rules have paths filters",
+    passed,
+    score: passed ? 5 : Math.round(withFilter / rules.length * 5),
+    maxScore: 5,
+    message: passed ? `All ${withFilter} rules have paths: filters` : `${withoutFilter}/${rules.length} rules missing paths: filter \u2014 they load every session`
+  };
+}
+function checkCommandsExist(projectDir) {
+  const commandsDir = path4.join(projectDir, ".claude", "commands");
+  const commands = listMdFiles(commandsDir);
+  const passed = commands.length >= 2;
+  return {
+    name: "Commands",
+    passed,
+    score: Math.min(commands.length * 2, 5),
+    maxScore: 5,
+    message: commands.length > 0 ? `${commands.length} commands: ${commands.map((c) => `/${path4.basename(c, ".md")}`).join(", ")}` : "No commands found"
+  };
+}
+function checkSafetyHook(projectDir) {
+  const hookPath = path4.join(projectDir, ".claude", "hooks", "block-dangerous-commands.js");
+  const globalHookPath = path4.join(
+    process.env.HOME || os.homedir(),
+    ".claude",
+    "hooks",
+    "block-dangerous-commands.js"
+  );
+  const installed = fs4.existsSync(hookPath) || fs4.existsSync(globalHookPath);
+  return {
+    name: "Safety hook",
+    passed: installed,
+    score: installed ? 5 : 0,
+    maxScore: 5,
+    message: installed ? "Safety hook installed" : "No safety hook \u2014 consider installing via --refresh"
+  };
+}
+function checkNoDuplication(projectDir) {
+  const claudeMdPath = path4.join(projectDir, ".claude", "CLAUDE.md");
+  if (!fs4.existsSync(claudeMdPath)) {
+    return {
+      name: "No duplication",
+      passed: true,
+      score: 10,
+      maxScore: 10,
+      message: "CLAUDE.md not found \u2014 nothing to check"
+    };
+  }
+  const claudeMd = fs4.readFileSync(claudeMdPath, "utf-8");
+  const conventionSection = claudeMd.indexOf("## Code Conventions");
+  if (conventionSection === -1) {
+    return {
+      name: "No duplication",
+      passed: true,
+      score: 10,
+      maxScore: 10,
+      message: "No conventions section to check"
+    };
+  }
+  const keywords = ["camelCase", "PascalCase", "named export", "default export", "import type"];
+  const claudeDir = path4.join(projectDir, ".claude");
+  const files = walkMdFiles(claudeDir).filter((f) => !f.endsWith("CLAUDE.md"));
+  let duplications = 0;
+  for (const file of files) {
+    try {
+      const content = fs4.readFileSync(file, "utf-8");
+      for (const kw of keywords) {
+        if (claudeMd.includes(kw) && content.includes(kw)) {
+          duplications++;
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  const passed = duplications === 0;
+  return {
+    name: "No duplication",
+    passed,
+    score: passed ? 10 : Math.max(0, 10 - duplications * 2),
+    maxScore: 10,
+    message: passed ? "No convention duplication detected" : `${duplications} files duplicate conventions from CLAUDE.md \u2014 run validation`
+  };
+}
+function listMdFiles(dir) {
+  if (!fs4.existsSync(dir)) return [];
+  try {
+    return fs4.readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => path4.join(dir, f));
+  } catch {
+    return [];
+  }
+}
+function walkMdFiles(dir) {
+  const files = [];
+  if (!fs4.existsSync(dir)) return files;
+  try {
+    for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...walkMdFiles(fullPath));
+      } else if (entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+
+// src/portability.ts
+import fs5 from "fs";
+import path5 from "path";
+function exportConfig(projectDir, outputPath) {
+  const claudeDir = path5.join(projectDir, ".claude");
+  const config = {
+    version: "1.0",
+    exportDate: (/* @__PURE__ */ new Date()).toISOString(),
+    projectName: path5.basename(projectDir),
+    techStack: {},
+    claudeMd: readFileOrNull(path5.join(claudeDir, "CLAUDE.md")),
+    settings: readJsonOrNull(path5.join(claudeDir, "settings.json")),
+    skills: readDirFiles(path5.join(claudeDir, "skills")),
+    agents: readDirFiles(path5.join(claudeDir, "agents")),
+    rules: readDirFiles(path5.join(claudeDir, "rules")),
+    commands: readDirFiles(path5.join(claudeDir, "commands")),
+    hooks: readDirFiles(path5.join(claudeDir, "hooks"))
+  };
+  fs5.writeFileSync(outputPath, JSON.stringify(config, null, 2));
+  return config;
+}
+function importConfig(inputPath, projectDir, force = false) {
+  let config;
+  try {
+    const content = fs5.readFileSync(inputPath, "utf-8");
+    config = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  const written = [];
+  const claudeDir = path5.join(projectDir, ".claude");
+  if (config.claudeMd) {
+    const dest = path5.join(claudeDir, "CLAUDE.md");
+    if (force || !fs5.existsSync(dest)) {
+      fs5.mkdirSync(claudeDir, { recursive: true });
+      fs5.writeFileSync(dest, config.claudeMd);
+      written.push(".claude/CLAUDE.md");
+    }
+  }
+  if (config.settings) {
+    const dest = path5.join(claudeDir, "settings.json");
+    if (force || !fs5.existsSync(dest)) {
+      fs5.mkdirSync(claudeDir, { recursive: true });
+      fs5.writeFileSync(dest, JSON.stringify(config.settings, null, 2));
+      written.push(".claude/settings.json");
+    }
+  }
+  const dirs = [
+    ["skills", config.skills],
+    ["agents", config.agents],
+    ["rules", config.rules],
+    ["commands", config.commands],
+    ["hooks", config.hooks]
+  ];
+  for (const [dirName, files] of dirs) {
+    if (!files || Object.keys(files).length === 0) continue;
+    const dirPath = path5.join(claudeDir, dirName);
+    fs5.mkdirSync(dirPath, { recursive: true });
+    for (const [fileName, fileContent] of Object.entries(files)) {
+      const dest = path5.resolve(dirPath, fileName);
+      if (!dest.startsWith(dirPath + path5.sep) && dest !== dirPath) continue;
+      if (force || !fs5.existsSync(dest)) {
+        fs5.writeFileSync(dest, fileContent);
+        written.push(`.claude/${dirName}/${fileName}`);
+      }
+    }
+  }
+  return written;
 }
-
-async function main() {
-  let input = '';
-  for await (const chunk of process.stdin) input += chunk;
-
+function loadTemplate(templatePath) {
   try {
-    const data = JSON.parse(input);
-    const { tool_name, tool_input, session_id, cwd, permission_mode } = data;
-    if (tool_name !== 'Bash') return console.log('{}');
-
-    const cmd = tool_input?.command || '';
-    const result = checkCommand(cmd);
-
-    if (result.blocked) {
-      const p = result.pattern;
-      log({ level: 'BLOCKED', id: p.id, priority: p.level, cmd, session_id, cwd, permission_mode });
-      return console.log(JSON.stringify({
-        hookSpecificOutput: {
-          hookEventName: 'PreToolUse',
-          permissionDecision: 'deny',
-          permissionDecisionReason: EMOJIS[p.level] + ' [' + p.id + '] ' + p.reason
-        }
-      }));
-    }
-    console.log('{}');
-  } catch (e) {
-    log({ level: 'ERROR', error: e.message });
-    console.log('{}');
+    if (!fs5.existsSync(templatePath)) return null;
+    const content = fs5.readFileSync(templatePath, "utf-8");
+    const config = JSON.parse(content);
+    if (!config.version || typeof config.skills !== "object") return null;
+    return config;
+  } catch {
+    return null;
   }
 }
-
-if (require.main === module) {
-  main();
-} else {
-  module.exports = { PATTERNS, LEVELS, SAFETY_LEVEL, checkCommand };
+function findProjectTemplate(projectDir) {
+  const templatePath = path5.join(projectDir, ".claude-template.json");
+  if (fs5.existsSync(templatePath)) return templatePath;
+  return null;
 }
-`;
-function installHook(rootDir) {
-  const hooksDir = path3.join(rootDir, ".claude", "hooks");
-  const hookPath = path3.join(hooksDir, "block-dangerous-commands.js");
-  const settingsPath = path3.join(rootDir, ".claude", "settings.json");
-  fs3.mkdirSync(hooksDir, { recursive: true });
-  fs3.writeFileSync(hookPath, HOOK_SCRIPT);
-  fs3.chmodSync(hookPath, 493);
+function readFileOrNull(filePath) {
   try {
-    const existing = fs3.existsSync(settingsPath) ? JSON.parse(fs3.readFileSync(settingsPath, "utf-8")) : {};
-    existing.hooks = {
-      ...existing.hooks,
-      PreToolUse: [
-        {
-          matcher: "Bash",
-          hooks: [
-            {
-              type: "command",
-              command: "node .claude/hooks/block-dangerous-commands.js"
-            }
-          ]
+    return fs5.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function readJsonOrNull(filePath) {
+  try {
+    return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readDirFiles(dirPath) {
+  const result = {};
+  if (!fs5.existsSync(dirPath)) return result;
+  try {
+    for (const entry of fs5.readdirSync(dirPath)) {
+      try {
+        const fullPath = path5.join(dirPath, entry);
+        if (fs5.statSync(fullPath).isFile()) {
+          result[entry] = fs5.readFileSync(fullPath, "utf-8");
         }
-      ]
-    };
-    fs3.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+      } catch {
+      }
+    }
   } catch {
   }
+  return result;
 }
 
 // src/prompt.ts
-function getAnalysisPrompt(projectInfo) {
+function getAnalysisPrompt(projectInfo, options = { claudeMdMode: "replace", existingClaudeMd: null }) {
   const context = buildContextSection(projectInfo);
   const templateVars = buildTemplateVariables(projectInfo);
+  const claudeMdInstructions = buildClaudeMdInstructions(options);
+  const memorySection = options.noMemory ? "" : `
+
+${MEMORY_PROMPT}`;
   return `${ANALYSIS_PROMPT}
 
 ${SKILLS_PROMPT}
@@ -844,7 +1697,7 @@ ${AGENTS_PROMPT}
 
 ${RULES_PROMPT}
 
-${COMMANDS_PROMPT}
+${COMMANDS_PROMPT}${memorySection}
 
 ---
 
@@ -859,25 +1712,63 @@ ${context}
 
 ${templateVars}
 
+${claudeMdInstructions}
+
 ---
 
 ## Execute Now
 
 1. Read this entire prompt to understand all phases
 2. Execute Phase 1 completely - read files, analyze code, gather all data
-3. Execute Phase 2 - generate the CLAUDE.md (max 120 lines) using only discovered information
+${options.claudeMdMode === "keep" ? `3. Skip CLAUDE.md generation \u2014 the existing file is being kept as-is` : options.claudeMdMode === "improve" ? `3. Execute Phase 2 \u2014 IMPROVE the existing CLAUDE.md (see Improvement Mode instructions above)` : `3. Execute Phase 2 - generate the CLAUDE.md (max 120 lines) using only discovered information`}
 4. Execute Phase 3 - verify quality before writing
-5. Use the Write tool to create \`.claude/CLAUDE.md\` with the final content
+${options.claudeMdMode === "keep" ? `5. Skip writing CLAUDE.md \u2014 it is being preserved` : `5. Use the Write tool to create \`.claude/CLAUDE.md\` with the final content`}
 6. Execute Phase 4 - generate ALL skill files (4 core + framework-specific if detected)
-7. Execute Phase 5 - generate agent files
+7. Execute Phase 5 - generate ALL agent files (6 agents)
 8. Execute Phase 6 - generate rule files
-9. Execute Phase 7 - generate command files (2 commands: analyze, code-review)
-10. Run the Anti-Redundancy Enforcement checks one final time across ALL generated files \u2014 if any convention is restated, any command is duplicated, or any rule lacks a \`paths:\` filter, fix it before proceeding
-11. Output a brief summary of what was generated and any gaps found
+9. Execute Phase 7 - generate ALL command files (6 commands)
+${options.noMemory ? `10. Skip memory seeding (--no-memory flag)` : `10. Execute Phase 8 - seed initial memory files`}
+11. Run the Anti-Redundancy Enforcement checks one final time across ALL generated files \u2014 if any convention is restated, any command is duplicated, or any rule lacks a \`paths:\` filter, fix it before proceeding
+12. Output a brief summary of what was generated and any gaps found
 
 Do NOT output file contents to stdout. Write all files to disk using the Write tool.
 Generate ALL files in a single pass \u2014 do not stop after CLAUDE.md.`;
 }
+function buildClaudeMdInstructions(options) {
+  if (options.claudeMdMode === "keep") {
+    return `---
+
+## CLAUDE.md Mode: KEEP
+
+The user chose to keep their existing CLAUDE.md unchanged.
+**Do NOT read, modify, or overwrite \`.claude/CLAUDE.md\`.**
+Generate all other files (skills, agents, rules, commands) normally.
+Use the existing CLAUDE.md as the source of truth for cross-references.`;
+  }
+  if (options.claudeMdMode === "improve" && options.existingClaudeMd) {
+    return `---
+
+## CLAUDE.md Mode: IMPROVE
+
+The user has an existing CLAUDE.md and wants it improved, not replaced.
+Here is the current content:
+
+\`\`\`markdown
+${options.existingClaudeMd}
+\`\`\`
+
+### Improvement Rules
+
+1. **Preserve all manually-added content** \u2014 sections, notes, and custom rules the user wrote
+2. **Enhance with discovered information** \u2014 fill gaps, add missing sections, improve specificity
+3. **Fix generic content** \u2014 replace boilerplate with project-specific details found during Phase 1
+4. **Update stale references** \u2014 fix file paths, commands, or patterns that no longer match the codebase
+5. **Respect the 120-line cap** \u2014 if the file is already near the limit, prioritize density over additions
+6. **Keep the user's structure** \u2014 if they organized sections differently from the template, keep their layout
+7. **Do NOT remove content you don't understand** \u2014 if a section seems custom or domain-specific, preserve it`;
+  }
+  return "";
+}
 function buildContextSection(projectInfo) {
   const { name, description, techStack, fileCount } = projectInfo;
   const lines = [];
@@ -1288,7 +2179,7 @@ var SKILLS_PROMPT = `---
 ## Phase 4: Generate Skills
 
 Write each skill file to \`.claude/skills/\` using the Write tool. Every skill must have
-YAML frontmatter with \`name\`, \`description\`, and optionally \`globs\` for file matching.
+YAML frontmatter with \`name\`, \`description\`, and \`globs\` for auto-triggering when relevant files are open.
 
 **Tailor ALL skills to this specific project** \u2014 use the actual file patterns and
 conventions discovered during Phase 1.
@@ -1350,12 +2241,34 @@ Generate the matching skill ONLY if the framework was detected in the tech stack
 
 - **Rails detected** \u2192 Write \`.claude/skills/rails-patterns.md\` \u2014 MVC, ActiveRecord, concerns, service objects, jobs, mailers, strong parameters.
 
-- **Spring detected** \u2192 Write \`.claude/skills/spring-patterns.md\` \u2014 Beans, controllers, services, repositories, AOP, dependency injection, configuration properties.`;
+- **Spring detected** \u2192 Write \`.claude/skills/spring-patterns.md\` \u2014 Beans, controllers, services, repositories, AOP, dependency injection, configuration properties.
+
+### 4.3 Project-Specific Skills (ONLY if detected)
+
+Generate additional skills based on detected infrastructure:
+
+- **Database/ORM detected** (Prisma, Drizzle, TypeORM, SQLAlchemy, Mongoose) \u2192 Write \`.claude/skills/database-patterns.md\` with globs targeting migration/schema files. Content: migration workflow, schema change process, query optimization patterns for the detected ORM, seed data conventions.
+
+- **Docker detected** \u2192 Write \`.claude/skills/docker-patterns.md\` with globs: \`["**/Dockerfile*", "**/docker-compose*", "**/.dockerignore"]\`. Content: multi-stage build patterns, compose service definitions, volume mounting, health checks, image optimization.
+
+- **Monorepo detected** \u2192 Write \`.claude/skills/monorepo-patterns.md\` with globs targeting workspace configs. Content: cross-package changes, shared dependency management, workspace protocol, package publishing order.
+
+- **CI/CD detected** \u2192 Write \`.claude/skills/cicd-patterns.md\` with globs targeting workflow files. Content: workflow modification guidelines, secret handling, deployment patterns, caching strategies for the detected CI platform.
+
+### 4.4 Skill Globs Reference
+
+Every skill MUST include a \`globs\` field in its frontmatter for auto-triggering:
+
+- \`iterative-development.md\` \u2192 omit globs (methodology, invoked manually)
+- \`code-deduplication.md\` \u2192 omit globs (methodology, invoked manually)
+- \`security.md\` \u2192 \`globs: ["**/.env*", "**/secrets/**", "**/auth/**", "**/middleware/**"]\`
+- \`testing-methodology.md\` \u2192 \`globs: ["**/*.test.*", "**/*.spec.*", "**/tests/**", "**/test/**"]\`
+- Framework skills \u2192 framework-specific globs (e.g., Next.js: \`["**/app/**", "**/pages/**", "next.config.*"]\`)`;
 var AGENTS_PROMPT = `---
 
 ## Phase 5: Generate Agents
 
-Write 2 agent files to \`.claude/agents/\`.
+Write 6 agent files to \`.claude/agents/\`.
 
 ### \`.claude/agents/code-reviewer.md\`
 
@@ -1410,7 +2323,121 @@ Body content \u2014 instructions for the test writer agent:
 - Include edge cases: empty inputs, nulls, errors, boundaries
 - Mock external dependencies following project patterns
 - Run tests after writing to verify they pass
-- Do NOT duplicate the testing-methodology skill content. The skill covers test design (what to test, edge cases, organization); this agent covers writing and running tests (framework syntax, assertions, execution).`;
+- Do NOT duplicate the testing-methodology skill content. The skill covers test design (what to test, edge cases, organization); this agent covers writing and running tests (framework syntax, assertions, execution).
+
+### \`.claude/agents/code-simplifier.md\`
+
+YAML frontmatter:
+\`\`\`yaml
+---
+name: code-simplifier
+description: Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality
+tools:
+  - Read
+  - Grep
+  - Glob
+  - Write
+  - Edit
+  - "Bash({lint_command})"
+  - "Bash({test_command})"
+model: sonnet
+---
+\`\`\`
+
+Body content \u2014 instructions for the code simplifier agent:
+- Focus on recently modified code (use \`git diff --name-only\` to identify changed files)
+- Look for: duplicated logic, overly complex conditionals, dead code, inconsistent patterns
+- Simplify without changing behavior \u2014 preserve ALL existing functionality
+- Follow conventions in CLAUDE.md
+- Specific simplifications: extract repeated code into helpers, flatten nested conditionals, remove unused variables/imports, replace verbose patterns with idiomatic equivalents
+- Run the linter after modifications
+- Run tests after modifications to verify nothing breaks
+- Do NOT add features, refactor beyond the changed area, or make "improvements" beyond simplification
+
+### \`.claude/agents/explore.md\`
+
+YAML frontmatter:
+\`\`\`yaml
+---
+name: explore
+description: Fast codebase exploration \u2014 find files, search code, answer architecture questions
+tools:
+  - Read
+  - Grep
+  - Glob
+disallowed_tools:
+  - Write
+  - Edit
+  - Bash
+model: haiku
+---
+\`\`\`
+
+Body content \u2014 instructions for the explore agent:
+- Use Glob for file pattern matching, Grep for content search, Read for file contents
+- Answer questions about: where things are defined, how modules connect, what patterns are used
+- Report findings in a structured format: file paths, relevant code snippets, relationships
+- When asked "how does X work?": trace the code path from entry point to implementation
+- When asked "where is X?": search broadly first (Glob for files, Grep for content), then narrow
+- Never modify files \u2014 this agent is strictly read-only
+- Be thorough but fast \u2014 use targeted searches, not exhaustive reads
+
+### \`.claude/agents/plan.md\`
+
+YAML frontmatter:
+\`\`\`yaml
+---
+name: plan
+description: Designs implementation plans with step-by-step approach and trade-off analysis
+tools:
+  - Read
+  - Grep
+  - Glob
+disallowed_tools:
+  - Write
+  - Edit
+  - Bash
+model: sonnet
+---
+\`\`\`
+
+Body content \u2014 instructions for the plan agent:
+- Read relevant source files to understand current architecture
+- Identify affected files, dependencies, and potential risks
+- Produce a step-by-step plan with: files to create/modify, approach for each, testing strategy
+- Consider trade-offs: complexity vs simplicity, performance vs readability
+- Flag breaking changes or migration requirements
+- Follow conventions in CLAUDE.md
+- Output format: numbered steps, each with file path, action (create/modify/delete), and description
+- Include a "Risks & Considerations" section at the end
+
+### \`.claude/agents/docs-writer.md\`
+
+YAML frontmatter:
+\`\`\`yaml
+---
+name: docs-writer
+description: Generates and updates documentation from code analysis
+tools:
+  - Read
+  - Grep
+  - Glob
+  - Write
+  - Edit
+disallowed_tools:
+  - Bash
+model: sonnet
+---
+\`\`\`
+
+Body content \u2014 instructions for the docs writer agent:
+- Analyze code changes (specified files or recent changes)
+- Update relevant documentation: README, API docs, architecture docs, changelogs
+- Generate JSDoc/docstrings for new public functions, classes, and interfaces
+- Maintain consistency with existing documentation style
+- Never fabricate information \u2014 only document what is verifiable from the code
+- When updating existing docs, preserve the author's structure and voice
+- For new documentation, follow the project's existing documentation patterns`;
 var RULES_PROMPT = `---
 
 ## Phase 6: Generate Rules
@@ -1475,7 +2502,7 @@ var COMMANDS_PROMPT = `---
 
 ## Phase 7: Generate Commands
 
-Write 2 command files to \`.claude/commands/\`. Each needs YAML frontmatter with
+Write 6 command files to \`.claude/commands/\`. Each needs YAML frontmatter with
 \`allowed-tools\`, \`description\`, and optionally \`argument-hint\`.
 
 Do NOT generate task management commands (\`task.md\`, \`status.md\`, \`done.md\`) \u2014
@@ -1503,11 +2530,138 @@ Body: This command delegates to the code-reviewer agent for thorough review.
 1. Run \`git diff\` and \`git diff --cached\` to identify staged and unstaged changes
 2. Spawn the \`code-reviewer\` agent to perform the full review
 3. If the agent is unavailable, perform a lightweight review: run the linter and check for obvious issues
-Do NOT duplicate the code-reviewer agent's checklist here \u2014 the agent has the full review criteria.`;
+Do NOT duplicate the code-reviewer agent's checklist here \u2014 the agent has the full review criteria.
+
+### \`.claude/commands/commit.md\`
+\`\`\`yaml
+---
+allowed-tools: ["Read", "Grep", "Glob", "Bash(git status)", "Bash(git diff)", "Bash(git diff --cached)", "Bash(git log --oneline -10)"]
+description: "Generate a conventional commit message from staged changes"
+---
+\`\`\`
+Body:
+1. Run \`git diff --cached\` to see staged changes (if nothing staged, run \`git diff\` and suggest what to stage)
+2. Run \`git log --oneline -10\` to match existing commit style
+3. Analyze the nature of changes: feat, fix, refactor, chore, docs, test, style, perf, ci, build
+4. Determine scope from the files changed (e.g., \`cli\`, \`analyzer\`, \`hooks\`)
+5. Generate a conventional commit message: \`type(scope): subject\`
+6. Include a body if changes are substantial (>50 lines changed)
+7. Follow commit conventions in CLAUDE.md
+8. Present the message for user review \u2014 do NOT run git commit
+
+### \`.claude/commands/fix.md\`
+\`\`\`yaml
+---
+allowed-tools: ["Read", "Grep", "Glob", "Write", "Edit", "Bash({test_command})", "Bash({lint_command})"]
+description: "Diagnose and fix a failing test or error"
+argument-hint: "<error message or test name>"
+---
+\`\`\`
+Body:
+1. If argument is a test name: run that specific test to reproduce the failure
+2. If argument is an error message: search codebase for related code
+3. Follow 4-phase debugging methodology:
+   - **Reproduce**: Run the failing test/command to see the exact error
+   - **Locate**: Trace the error from the failure point to the source
+   - **Diagnose**: Understand WHY the code fails (not just WHERE)
+   - **Fix**: Apply the minimal fix that resolves the root cause
+4. Re-run the failing test to verify the fix
+5. Run the full test suite to check for regressions (see Common Commands in CLAUDE.md)
+
+### \`.claude/commands/explain.md\`
+\`\`\`yaml
+---
+allowed-tools: ["Read", "Grep", "Glob"]
+description: "Deep explanation of a file, module, or concept"
+argument-hint: "<file path, module name, or concept>"
+---
+\`\`\`
+Body:
+1. Read the specified file or search for the module/concept
+2. Trace dependencies (what it imports) and dependents (what imports it)
+3. Explain in a structured format:
+   - **Purpose**: What this code does and why it exists
+   - **How It Works**: Step-by-step walkthrough of the logic
+   - **Dependencies**: What it relies on (internal and external)
+   - **Public API**: Exported functions, classes, types with brief descriptions
+   - **Gotchas**: Non-obvious behavior, edge cases, known limitations
+4. Use actual code references with file paths
+5. Tailor the explanation depth to the complexity of the code
+
+### \`.claude/commands/refactor.md\`
+\`\`\`yaml
+---
+allowed-tools: ["Read", "Grep", "Glob", "Write", "Edit", "Bash({test_command})", "Bash({lint_command})"]
+description: "Targeted refactoring of a specific area"
+argument-hint: "<file path or description of what to refactor>"
+---
+\`\`\`
+Body:
+1. Read the target code and understand its current structure
+2. Search for ALL references to affected functions/variables/types (Grep the entire project)
+3. Plan the refactoring: what changes, what stays, what tests cover it
+4. Apply changes incrementally:
+   - Make the structural change
+   - Update all references (imports, usages, tests, docs)
+   - Run linter
+   - Run tests
+5. Verify no stale references remain (Grep for old names)
+6. Follow conventions in CLAUDE.md`;
+var MEMORY_PROMPT = `---
+
+## Phase 8: Seed Initial Memory
+
+Claude Code has a persistent memory system at \`.claude/memory/\`. Seed it with
+factual information discovered during Phase 1 that would be useful in future conversations.
+
+**Only write memories that cannot be easily derived from reading the code or CLAUDE.md.**
+
+### Memory File Format
+
+Each memory file uses this frontmatter format:
+\`\`\`markdown
+---
+name: {memory name}
+description: {one-line description}
+type: {project | reference}
+---
+
+{memory content}
+\`\`\`
+
+### What to Seed
+
+1. **Project memory** (type: \`project\`) \u2014 Write 1-2 files for:
+   - Architecture pattern and rationale (e.g., "Clean Architecture with feature-based modules \u2014 chosen for testability and team scaling")
+   - Primary domain and business context (e.g., "E-commerce platform for B2B wholesale \u2014 domain entities are Company, Order, Product, PriceList")
+
+2. **Reference memory** (type: \`reference\`) \u2014 Write 1-2 files for:
+   - CI/CD platform and deployment patterns (e.g., "GitHub Actions deploys to Vercel on push to main, preview deploys on PRs")
+   - External system pointers found in README or config (e.g., "API docs at /docs/api.md, issue tracker is GitHub Issues")
+
+### What NOT to Seed
+
+- Anything already in CLAUDE.md (commands, conventions, file structure)
+- Anything derivable from config files (package.json, tsconfig, etc.)
+- Generic information (e.g., "this is a TypeScript project")
+- Ephemeral state (current bugs, in-progress work)
+
+### Where to Write
+
+Write memory files to \`.claude/memory/\`:
+- \`.claude/memory/architecture.md\`
+- \`.claude/memory/domain.md\`
+- \`.claude/memory/deployment.md\`
+- \`.claude/memory/references.md\`
+
+Only write files for which you have genuine, project-specific information.
+Write a \`.claude/memory/MEMORY.md\` index file with one-line pointers to each memory file.
+
+Skip this phase entirely if the project is too new or simple to have meaningful memory seeds.`;
 
 // src/validator.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path6 from "path";
 function extractCommands(claudeMd) {
   const commands = [];
   const match = claudeMd.match(/## Common Commands[\s\S]*?```(?:bash)?\n([\s\S]*?)```/);
@@ -1567,7 +2721,7 @@ function separateFrontmatter(content) {
   };
 }
 function processFile(filePath, commands, fingerprints) {
-  const content = fs4.readFileSync(filePath, "utf-8");
+  const content = fs6.readFileSync(filePath, "utf-8");
   const { frontmatter, body } = separateFrontmatter(content);
   const lines = body.split("\n");
   const changes = [];
@@ -1597,18 +2751,18 @@ function processFile(filePath, commands, fingerprints) {
     newLines.push(line);
   }
   if (changes.length > 0) {
-    fs4.writeFileSync(filePath, frontmatter + newLines.join("\n"));
+    fs6.writeFileSync(filePath, frontmatter + newLines.join("\n"));
   }
   return changes;
 }
-function walkMdFiles(dir) {
+function walkMdFiles2(dir) {
   const files = [];
-  if (!fs4.existsSync(dir)) return files;
-  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  if (!fs6.existsSync(dir)) return files;
+  const entries = fs6.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path4.join(dir, entry.name);
+    const fullPath = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
-      files.push(...walkMdFiles(fullPath));
+      files.push(...walkMdFiles2(fullPath));
     } else if (entry.name.endsWith(".md")) {
       files.push(fullPath);
     }
@@ -1622,25 +2776,28 @@ function validateArtifacts(rootDir) {
     duplicationsRemoved: 0,
     changes: []
   };
-  const claudeMdPath = path4.join(rootDir, ".claude", "CLAUDE.md");
-  if (!fs4.existsSync(claudeMdPath)) return result;
+  const claudeMdPath = path6.join(rootDir, ".claude", "CLAUDE.md");
+  if (!fs6.existsSync(claudeMdPath)) return result;
   try {
-    const claudeMd = fs4.readFileSync(claudeMdPath, "utf-8");
+    const claudeMd = fs6.readFileSync(claudeMdPath, "utf-8");
     const commands = extractCommands(claudeMd);
     const fingerprints = extractConventionFingerprints(claudeMd);
     if (commands.length === 0 && fingerprints.length === 0) return result;
-    const claudeDir = path4.join(rootDir, ".claude");
-    const files = walkMdFiles(claudeDir).filter((f) => !f.endsWith("CLAUDE.md"));
+    const claudeDir = path6.join(rootDir, ".claude");
+    const files = walkMdFiles2(claudeDir).filter((f) => !f.endsWith("CLAUDE.md"));
     for (const filePath of files) {
       result.filesChecked++;
-      const changes = processFile(filePath, commands, fingerprints);
-      if (changes.length > 0) {
-        result.filesModified++;
-        result.duplicationsRemoved += changes.length;
-        for (const change of changes) {
-          change.file = path4.relative(rootDir, filePath);
+      try {
+        const changes = processFile(filePath, commands, fingerprints);
+        if (changes.length > 0) {
+          result.filesModified++;
+          result.duplicationsRemoved += changes.length;
+          for (const change of changes) {
+            change.file = path6.relative(rootDir, filePath);
+          }
+          result.changes.push(...changes);
         }
-        result.changes.push(...changes);
+      } catch {
       }
     }
   } catch {
@@ -1650,39 +2807,97 @@ function validateArtifacts(rootDir) {
 }
 
 // src/cli.ts
-var __dirname2 = path5.dirname(fileURLToPath(import.meta.url));
-var VERSION = JSON.parse(
-  fs5.readFileSync(path5.join(__dirname2, "..", "package.json"), "utf-8")
-).version;
+var VERSION;
+if (true) {
+  VERSION = "0.17.0";
+} else {
+  try {
+    const __dirname2 = path7.dirname(fileURLToPath(import.meta.url));
+    VERSION = JSON.parse(
+      fs7.readFileSync(path7.join(__dirname2, "..", "package.json"), "utf-8")
+    ).version;
+  } catch {
+    VERSION = "unknown";
+  }
+}
 function parseArgs(args) {
+  const findValue = (flag) => {
+    const idx = args.indexOf(flag);
+    if (idx !== -1 && idx + 1 < args.length) return args[idx + 1];
+    return null;
+  };
+  const profileValue = findValue("--profile");
+  const validProfiles = ["solo", "team", "ci"];
+  const profile = profileValue && validProfiles.includes(profileValue) ? profileValue : null;
+  let interactive = !args.includes("--no-interactive") && !args.includes("-y");
+  if (profile === "ci") interactive = false;
   return {
     help: args.includes("-h") || args.includes("--help"),
     version: args.includes("-v") || args.includes("--version"),
     force: args.includes("-f") || args.includes("--force"),
-    interactive: !args.includes("--no-interactive") && !args.includes("-y"),
-    verbose: args.includes("--verbose") || args.includes("-V")
+    interactive,
+    verbose: args.includes("--verbose") || args.includes("-V"),
+    refresh: args.includes("--refresh"),
+    tune: args.includes("--tune"),
+    check: args.includes("--check"),
+    noMemory: args.includes("--no-memory") || profile === "ci",
+    exportPath: findValue("--export"),
+    importPath: findValue("--import"),
+    template: findValue("--template"),
+    profile
   };
 }
 function getVersion() {
   return VERSION;
 }
+function isNewerVersion(current, latest) {
+  const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
+  const [cMajor, cMinor, cPatch] = parse(current);
+  const [lMajor, lMinor, lPatch] = parse(latest);
+  if (lMajor !== cMajor) return lMajor > cMajor;
+  if (lMinor !== cMinor) return lMinor > cMinor;
+  return lPatch > cPatch;
+}
+function checkForUpdate() {
+  try {
+    const latest = execSync("npm view claude-code-starter version", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (latest && isNewerVersion(VERSION, latest)) {
+      console.log(pc2.yellow(`  Update available: ${VERSION} \u2192 ${latest}`));
+      console.log(pc2.yellow("  Run: npm install -g claude-code-starter@latest"));
+      console.log();
+    }
+  } catch {
+  }
+}
 function showHelp() {
   console.log(`
-${pc.cyan("Claude Code Starter")} v${VERSION}
+${pc2.cyan("Claude Code Starter")} v${VERSION}
 
 Bootstrap intelligent Claude Code configurations for any repository.
 
-${pc.bold("USAGE")}
+${pc2.bold("USAGE")}
   npx claude-code-starter [OPTIONS]
 
-${pc.bold("OPTIONS")}
-  -h, --help          Show this help message
-  -v, --version       Show version number
-  -f, --force         Force overwrite existing .claude files
-  -y, --no-interactive  Skip interactive prompts (use defaults)
-  -V, --verbose       Show detailed output
-
-${pc.bold("WHAT IT DOES")}
+${pc2.bold("OPTIONS")}
+  -h, --help             Show this help message
+  -v, --version          Show version number
+  -f, --force            Force overwrite existing .claude files
+  -y, --no-interactive   Skip interactive prompts (use defaults)
+  -V, --verbose          Show detailed output
+  --refresh              Refresh settings.json, hooks, and statusline without re-running Claude analysis
+  --tune                 Re-analyze existing .claude/ setup and show health report
+  --check                Audit .claude/ directory and exit with score (CI-friendly)
+  --no-memory            Skip memory seeding during analysis
+  --export <path>        Export .claude/ config as portable JSON archive
+  --import <path>        Import a config archive into .claude/
+  --template <path>      Bootstrap from a template file
+  --profile <name>       Generation profile: solo, team, or ci
+
+${pc2.bold("WHAT IT DOES")}
   1. Analyzes your repository's tech stack
   2. Launches Claude CLI to deeply analyze your codebase
   3. Generates all .claude/ configuration files:
@@ -1692,53 +2907,53 @@ ${pc.bold("WHAT IT DOES")}
      - Rules matching your code style
      - Commands for analysis and code review
 
-${pc.bold("REQUIREMENTS")}
+${pc2.bold("REQUIREMENTS")}
   Claude CLI must be installed: https://claude.ai/download
 
-${pc.bold("MORE INFO")}
+${pc2.bold("MORE INFO")}
   https://github.com/cassmtnr/claude-code-starter
 `);
 }
 function showBanner() {
   console.log();
-  console.log(pc.bold("Claude Code Starter") + pc.gray(` v${VERSION}`));
-  console.log(pc.gray("Intelligent AI-Assisted Development Setup"));
+  console.log(pc2.bold("Claude Code Starter") + pc2.gray(` v${VERSION}`));
+  console.log(pc2.gray("Intelligent AI-Assisted Development Setup"));
   console.log();
 }
 function showTechStack(projectInfo, verbose) {
   const { techStack } = projectInfo;
-  console.log(pc.bold("Tech Stack"));
+  console.log(pc2.bold("Tech Stack"));
   console.log();
   if (techStack.primaryLanguage) {
-    console.log(`  ${pc.bold("Language:")} ${formatLanguage(techStack.primaryLanguage)}`);
+    console.log(`  ${pc2.bold("Language:")} ${formatLanguage(techStack.primaryLanguage)}`);
   }
   if (techStack.primaryFramework) {
-    console.log(`  ${pc.bold("Framework:")} ${formatFramework(techStack.primaryFramework)}`);
+    console.log(`  ${pc2.bold("Framework:")} ${formatFramework(techStack.primaryFramework)}`);
   }
   if (techStack.packageManager) {
-    console.log(`  ${pc.bold("Package Manager:")} ${techStack.packageManager}`);
+    console.log(`  ${pc2.bold("Package Manager:")} ${techStack.packageManager}`);
   }
   if (techStack.testingFramework) {
-    console.log(`  ${pc.bold("Testing:")} ${techStack.testingFramework}`);
+    console.log(`  ${pc2.bold("Testing:")} ${techStack.testingFramework}`);
   }
   if (verbose) {
     if (techStack.linter) {
-      console.log(`  ${pc.bold("Linter:")} ${techStack.linter}`);
+      console.log(`  ${pc2.bold("Linter:")} ${techStack.linter}`);
     }
     if (techStack.formatter) {
-      console.log(`  ${pc.bold("Formatter:")} ${techStack.formatter}`);
+      console.log(`  ${pc2.bold("Formatter:")} ${techStack.formatter}`);
     }
     if (techStack.bundler) {
-      console.log(`  ${pc.bold("Bundler:")} ${techStack.bundler}`);
+      console.log(`  ${pc2.bold("Bundler:")} ${techStack.bundler}`);
     }
     if (techStack.isMonorepo) {
-      console.log(`  ${pc.bold("Monorepo:")} yes`);
+      console.log(`  ${pc2.bold("Monorepo:")} yes`);
     }
     if (techStack.hasDocker) {
-      console.log(`  ${pc.bold("Docker:")} yes`);
+      console.log(`  ${pc2.bold("Docker:")} yes`);
     }
     if (techStack.hasCICD) {
-      console.log(`  ${pc.bold("CI/CD:")} ${techStack.cicdPlatform}`);
+      console.log(`  ${pc2.bold("CI/CD:")} ${techStack.cicdPlatform}`);
     }
   }
   console.log();
@@ -1814,9 +3029,9 @@ async function promptNewProject(args) {
   if (!args.interactive) {
     return null;
   }
-  console.log(pc.yellow("New project detected - let's set it up!"));
+  console.log(pc2.yellow("New project detected - let's set it up!"));
   console.log();
-  const descResponse = await prompts({
+  const descResponse = await prompts2({
     type: "text",
     name: "description",
     message: "What are you building?",
@@ -1825,7 +3040,7 @@ async function promptNewProject(args) {
   if (!descResponse.description) {
     return null;
   }
-  const langResponse = await prompts({
+  const langResponse = await prompts2({
     type: "select",
     name: "primaryLanguage",
     message: "Primary language?",
@@ -1846,34 +3061,34 @@ async function promptNewProject(args) {
   });
   const lang = langResponse.primaryLanguage || "typescript";
   const fwChoices = frameworkChoices[lang] || defaultFrameworkChoices;
-  const fwResponse = await prompts({
+  const fwResponse = await prompts2({
     type: "select",
     name: "framework",
     message: "Framework?",
     choices: fwChoices
   });
   const pmChoices = getPackageManagerChoices(lang);
-  const pmResponse = await prompts({
+  const pmResponse = await prompts2({
     type: "select",
     name: "packageManager",
     message: "Package manager?",
     choices: pmChoices
   });
   const testChoices = getTestingFrameworkChoices(lang);
-  const testResponse = await prompts({
+  const testResponse = await prompts2({
     type: "select",
     name: "testingFramework",
     message: "Testing framework?",
     choices: testChoices
   });
   const lintChoices = getLinterFormatterChoices(lang);
-  const lintResponse = await prompts({
+  const lintResponse = await prompts2({
     type: "select",
     name: "linter",
     message: "Linter/Formatter?",
     choices: lintChoices
   });
-  const typeResponse = await prompts({
+  const typeResponse = await prompts2({
     type: "select",
     name: "projectType",
     message: "Project type?",
@@ -1981,7 +3196,6 @@ function getLinterFormatterChoices(lang) {
     return [
       { title: "Biome", value: "biome" },
       { title: "ESLint + Prettier", value: "eslint" },
-      { title: "ESLint", value: "eslint" },
       { title: "None", value: null }
     ];
   }
@@ -2112,12 +3326,12 @@ function checkClaudeCli() {
     return false;
   }
 }
-function runClaudeAnalysis(projectDir, projectInfo) {
+function runClaudeAnalysis(projectDir, projectInfo, options = { claudeMdMode: "replace", existingClaudeMd: null }) {
   return new Promise((resolve) => {
-    const prompt = getAnalysisPrompt(projectInfo);
-    console.log(pc.cyan("Launching Claude for deep project analysis..."));
+    const prompt = getAnalysisPrompt(projectInfo, options);
+    console.log(pc2.cyan("Launching Claude for deep project analysis..."));
     console.log(
-      pc.gray("Claude will read your codebase and generate all .claude/ configuration files")
+      pc2.gray("Claude will read your codebase and generate all .claude/ configuration files")
     );
     console.log();
     const spinner = ora({
@@ -2132,6 +3346,8 @@ function runClaudeAnalysis(projectDir, projectInfo) {
       "claude",
       [
         "-p",
+        "--verbose",
+        "--output-format=stream-json",
         "--allowedTools",
         "Read",
         "--allowedTools",
@@ -2148,35 +3364,80 @@ function runClaudeAnalysis(projectDir, projectInfo) {
         stdio: ["pipe", "pipe", "pipe"]
       }
     );
+    const cleanup = () => {
+      child.kill("SIGTERM");
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    let stdoutBuffer = "";
+    child.stdout.on("data", (chunk) => {
+      stdoutBuffer += chunk.toString();
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+            for (const block of event.message.content) {
+              if (block.type === "tool_use" && block.name && block.input) {
+                const toolName = block.name;
+                const toolInput = block.input;
+                const filePath = toolInput.file_path || toolInput.path || toolInput.pattern || "";
+                const shortPath = filePath.split("/").slice(-2).join("/");
+                const action = toolName === "Write" || toolName === "Edit" ? "Writing" : "Reading";
+                if (shortPath) {
+                  spinner.text = `${action} ${shortPath}...`;
+                } else {
+                  spinner.text = `Using ${toolName}...`;
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    child.stdin.on("error", () => {
+    });
     child.stdin.write(prompt);
     child.stdin.end();
+    let stderrOutput = "";
+    child.stderr.on("data", (chunk) => {
+      stderrOutput += chunk.toString();
+    });
     child.on("error", (err) => {
       spinner.fail(`Failed to launch Claude CLI: ${err.message}`);
       resolve(false);
     });
     child.on("close", (code) => {
+      process.off("SIGINT", cleanup);
+      process.off("SIGTERM", cleanup);
       if (code === 0) {
         spinner.succeed("Claude analysis complete!");
         resolve(true);
       } else {
         spinner.fail(`Claude exited with code ${code}`);
+        if (stderrOutput.trim()) {
+          console.error(pc2.gray(stderrOutput.trim()));
+        }
         resolve(false);
       }
     });
   });
 }
 function getGeneratedFiles(projectDir) {
-  const claudeDir = path5.join(projectDir, ".claude");
+  const claudeDir = path7.join(projectDir, ".claude");
   const files = [];
   function walk(dir) {
-    if (!fs5.existsSync(dir)) return;
-    const entries = fs5.readdirSync(dir, { withFileTypes: true });
+    if (!fs7.existsSync(dir)) return;
+    const entries = fs7.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path5.join(dir, entry.name);
+      const fullPath = path7.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else {
-        files.push(path5.relative(projectDir, fullPath));
+        files.push(path7.relative(projectDir, fullPath));
       }
     }
   }
@@ -2194,11 +3455,132 @@ async function main() {
     process.exit(0);
   }
   showBanner();
+  checkForUpdate();
   const projectDir = process.cwd();
-  console.log(pc.gray("Analyzing repository..."));
+  if (args.check) {
+    const claudeDir = path7.join(projectDir, ".claude");
+    if (!fs7.existsSync(claudeDir)) {
+      console.error(pc2.red("No .claude/ directory found. Run claude-code-starter first."));
+      process.exit(1);
+    }
+    const result = checkHealth(projectDir);
+    console.log(pc2.bold("Health Check"));
+    console.log();
+    for (const item of result.items) {
+      const icon = item.passed ? pc2.green("PASS") : pc2.red("FAIL");
+      console.log(`  ${icon} ${item.name} (${item.score}/${item.maxScore})`);
+      console.log(pc2.gray(`       ${item.message}`));
+    }
+    console.log();
+    const pct = Math.round(result.score / result.maxScore * 100);
+    const scoreColor = pct >= 70 ? pc2.green : pct >= 40 ? pc2.yellow : pc2.red;
+    console.log(scoreColor(`Score: ${result.score}/${result.maxScore} (${pct}%)`));
+    process.exit(pct >= 60 ? 0 : 1);
+  }
+  if (args.tune) {
+    const claudeDir = path7.join(projectDir, ".claude");
+    if (!fs7.existsSync(claudeDir)) {
+      console.error(pc2.red("No .claude/ directory found. Run claude-code-starter first."));
+      process.exit(1);
+    }
+    console.log(pc2.gray("Analyzing existing .claude/ configuration..."));
+    console.log();
+    const projectInfo2 = analyzeRepository(projectDir);
+    showTechStack(projectInfo2, args.verbose);
+    const result = checkHealth(projectDir);
+    console.log(pc2.bold("Configuration Health"));
+    console.log();
+    for (const item of result.items) {
+      const icon = item.passed ? pc2.green("PASS") : pc2.yellow("WARN");
+      console.log(`  ${icon} ${item.name} (${item.score}/${item.maxScore})`);
+      console.log(pc2.gray(`       ${item.message}`));
+    }
+    console.log();
+    const pct = Math.round(result.score / result.maxScore * 100);
+    const scoreColor = pct >= 70 ? pc2.green : pct >= 40 ? pc2.yellow : pc2.red;
+    console.log(scoreColor(`Score: ${result.score}/${result.maxScore} (${pct}%)`));
+    const failing = result.items.filter((i) => !i.passed);
+    if (failing.length > 0) {
+      console.log();
+      console.log(pc2.bold("Suggestions:"));
+      for (const item of failing) {
+        console.log(`  - ${item.message}`);
+      }
+      console.log();
+      console.log(
+        pc2.gray("Run claude-code-starter again to regenerate, or --refresh for settings only")
+      );
+    }
+    return;
+  }
+  if (args.exportPath) {
+    const claudeDir = path7.join(projectDir, ".claude");
+    if (!fs7.existsSync(claudeDir)) {
+      console.error(pc2.red("No .claude/ directory found. Nothing to export."));
+      process.exit(1);
+    }
+    const config = exportConfig(projectDir, args.exportPath);
+    const fileCount = Object.keys(config.skills).length + Object.keys(config.agents).length + Object.keys(config.rules).length + Object.keys(config.commands).length + Object.keys(config.hooks).length + (config.claudeMd ? 1 : 0) + (config.settings ? 1 : 0);
+    console.log(pc2.green(`Exported ${fileCount} files to ${args.exportPath}`));
+    return;
+  }
+  if (args.importPath) {
+    if (!fs7.existsSync(args.importPath)) {
+      console.error(pc2.red(`File not found: ${args.importPath}`));
+      process.exit(1);
+    }
+    const written = importConfig(args.importPath, projectDir, args.force);
+    if (written.length === 0) {
+      console.log(pc2.yellow("No files written (all already exist). Use -f to overwrite."));
+    } else {
+      console.log(pc2.green(`Imported ${written.length} files:`));
+      for (const file of written) {
+        console.log(pc2.green(`  + ${file}`));
+      }
+    }
+    return;
+  }
+  const templatePath = args.template || findProjectTemplate(projectDir);
+  if (templatePath) {
+    const template = loadTemplate(templatePath);
+    if (!template) {
+      console.error(pc2.red(`Invalid or missing template: ${templatePath}`));
+      process.exit(1);
+    }
+    const tmpPath = path7.join(os2.tmpdir(), `.claude-template-import-${Date.now()}.json`);
+    try {
+      fs7.writeFileSync(tmpPath, JSON.stringify(template, null, 2));
+      const written = importConfig(tmpPath, projectDir, args.force);
+      console.log(pc2.green(`Applied template: ${written.length} files written`));
+      for (const file of written) {
+        console.log(pc2.green(`  + ${file}`));
+      }
+    } finally {
+      try {
+        fs7.unlinkSync(tmpPath);
+      } catch {
+      }
+    }
+    return;
+  }
+  console.log(pc2.gray("Analyzing repository..."));
   console.log();
   const projectInfo = analyzeRepository(projectDir);
   showTechStack(projectInfo, args.verbose);
+  if (args.refresh) {
+    console.log(pc2.gray("Setting up .claude/ directory structure..."));
+    console.log();
+    writeSettings(projectDir, projectInfo.techStack);
+    ensureDirectories(projectDir);
+    console.log(pc2.green("Updated:"));
+    console.log(pc2.green("  + .claude/settings.json"));
+    console.log();
+    await promptExtras(projectDir);
+    console.log();
+    console.log(pc2.green("Done!"));
+    console.log();
+    return;
+  }
   let preferences = null;
   if (!projectInfo.isExisting) {
     preferences = await promptNewProject(args);
@@ -2223,71 +3605,87 @@ async function main() {
       projectInfo.description = preferences.description;
     }
   } else {
-    console.log(pc.gray(`Existing project with ${projectInfo.fileCount} source files`));
+    console.log(pc2.gray(`Existing project with ${projectInfo.fileCount} source files`));
     console.log();
   }
-  if (projectInfo.techStack.hasClaudeConfig && !args.force) {
-    console.log(pc.yellow("Existing .claude/ configuration detected"));
-    console.log();
-    if (args.interactive) {
-      const { proceed } = await prompts({
-        type: "confirm",
-        name: "proceed",
-        message: "Update existing configuration?",
-        initial: true
+  let claudeMdMode = "replace";
+  let existingClaudeMd = null;
+  const claudeMdPath = path7.join(projectDir, ".claude", "CLAUDE.md");
+  if (fs7.existsSync(claudeMdPath)) {
+    existingClaudeMd = fs7.readFileSync(claudeMdPath, "utf-8");
+    if (args.force) {
+      claudeMdMode = "replace";
+    } else if (args.interactive) {
+      console.log(pc2.yellow("Existing CLAUDE.md detected"));
+      console.log();
+      const { mode } = await prompts2({
+        type: "select",
+        name: "mode",
+        message: "How should we handle the existing CLAUDE.md?",
+        choices: [
+          { title: "Improve \u2014 scan and enhance the existing file", value: "improve" },
+          { title: "Replace \u2014 generate a new one from scratch", value: "replace" },
+          { title: "Keep \u2014 leave CLAUDE.md as-is, regenerate other files", value: "keep" }
+        ],
+        initial: 0
       });
-      if (!proceed) {
-        console.log(pc.gray("Cancelled. Use --force to overwrite."));
+      if (mode === void 0) {
+        console.log(pc2.gray("Cancelled."));
         process.exit(0);
       }
+      claudeMdMode = mode;
     }
     console.log();
   }
   if (!checkClaudeCli()) {
-    console.error(pc.red("Claude CLI is required but not found."));
-    console.error(pc.gray("Install it from: https://claude.ai/download"));
+    console.error(pc2.red("Claude CLI is required but not found."));
+    console.error(pc2.gray("Install it from: https://claude.ai/download"));
     process.exit(1);
   }
-  console.log(pc.gray("Setting up .claude/ directory structure..."));
+  console.log(pc2.gray("Setting up .claude/ directory structure..."));
   console.log();
-  writeSettings(projectDir, projectInfo.techStack);
+  writeSettings(projectDir, projectInfo.techStack, args.force);
   ensureDirectories(projectDir);
-  console.log(pc.green("Created:"));
-  console.log(pc.green("  + .claude/settings.json"));
+  console.log(pc2.green("Created:"));
+  console.log(pc2.green("  + .claude/settings.json"));
   console.log();
-  const success = await runClaudeAnalysis(projectDir, projectInfo);
+  const success = await runClaudeAnalysis(projectDir, projectInfo, {
+    claudeMdMode,
+    existingClaudeMd: claudeMdMode === "improve" ? existingClaudeMd : null,
+    noMemory: args.noMemory
+  });
   if (!success) {
-    console.error(pc.red("Claude analysis failed. Please try again."));
+    console.error(pc2.red("Claude analysis failed. Please try again."));
     process.exit(1);
   }
   const validation = validateArtifacts(projectDir);
   if (validation.duplicationsRemoved > 0) {
     console.log(
-      pc.gray(
+      pc2.gray(
         `  Deduplication: removed ${validation.duplicationsRemoved} redundancies from ${validation.filesModified} files`
       )
     );
   }
   const generatedFiles = getGeneratedFiles(projectDir);
   console.log();
-  console.log(pc.green(`Done! (${generatedFiles.length} files)`));
+  console.log(pc2.green(`Done! (${generatedFiles.length} files)`));
   console.log();
-  console.log(pc.bold("Generated for your stack:"));
+  console.log(pc2.bold("Generated for your stack:"));
   const skills = generatedFiles.filter((f) => f.includes("/skills/"));
   const agents = generatedFiles.filter((f) => f.includes("/agents/"));
   const rules = generatedFiles.filter((f) => f.includes("/rules/"));
   const commands = generatedFiles.filter((f) => f.includes("/commands/"));
   if (generatedFiles.some((f) => f.endsWith("CLAUDE.md"))) {
-    console.log(pc.cyan("  CLAUDE.md (deep analysis by Claude)"));
+    console.log(pc2.cyan("  CLAUDE.md (deep analysis by Claude)"));
   }
   if (skills.length > 0) {
     console.log(
-      `  ${skills.length} skills (${skills.map((s) => path5.basename(s, ".md")).join(", ")})`
+      `  ${skills.length} skills (${skills.map((s) => path7.basename(s, ".md")).join(", ")})`
     );
   }
   if (agents.length > 0) {
     console.log(
-      `  ${agents.length} agents (${agents.map((a) => path5.basename(a, ".md")).join(", ")})`
+      `  ${agents.length} agents (${agents.map((a) => path7.basename(a, ".md")).join(", ")})`
     );
   }
   if (rules.length > 0) {
@@ -2299,32 +3697,22 @@ async function main() {
   console.log();
   if (args.interactive) {
     console.log();
-    const { installSafetyHook } = await prompts({
-      type: "confirm",
-      name: "installSafetyHook",
-      message: "Add a safety hook to block dangerous commands? (git push, rm -rf, etc.)",
-      initial: true
-    });
-    if (installSafetyHook) {
-      installHook(projectDir);
-      console.log(pc.green("  + .claude/hooks/block-dangerous-commands.js"));
-      console.log(pc.gray("    Blocks destructive Bash commands before execution"));
-    }
+    await promptExtras(projectDir);
   }
   console.log();
-  console.log(`${pc.cyan("Next step:")} Run ${pc.bold("claude")} to start working!`);
+  console.log(`${pc2.cyan("Next step:")} Run ${pc2.bold("claude")} to start working!`);
   console.log();
   console.log(
-    pc.gray(
+    pc2.gray(
       "Your .claude/ files were generated by deep analysis - review them with: ls -la .claude/"
     )
   );
 }
 try {
-  const isMain = process.argv[1] && fs5.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  const isMain = process.argv[1] && fs7.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
   if (isMain) {
     main().catch((err) => {
-      console.error(pc.red("Error:"), err.message);
+      console.error(pc2.red("Error:"), err.message);
       if (process.env.DEBUG) {
         console.error(err.stack);
       }
@@ -2335,9 +3723,11 @@ try {
 }
 export {
   checkClaudeCli,
+  checkForUpdate,
   formatFramework,
   formatLanguage,
   getVersion,
+  isNewerVersion,
   mapFormatter,
   parseArgs,
   promptNewProject,