claude-code-starter 0.16.0 → 0.17.0

package/dist/cli.js

@@ -2,8 +2,9 @@
 
 // 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 pc2 from "picocolors";
@@ -33,9 +34,9 @@ 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(files, packageJson);
   const hasDocker = files.includes("Dockerfile") || files.includes("docker-compose.yml") || files.includes("docker-compose.yaml");
@@ -275,7 +276,7 @@ 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 = getAllDeps(packageJson);
     if (allDeps.vitest) return "vitest";
@@ -290,7 +291,14 @@ function detectTestingFramework(packageJson, files) {
   if (files.includes("go.mod")) return "go-test";
   if (files.includes("Cargo.toml")) return "rust-test";
   if (files.includes(".rspec")) return "rspec";
-  if (files.includes("Gemfile") && files.includes("spec")) 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) {
@@ -309,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"
   )) {
@@ -322,7 +330,19 @@ function detectFormatter(packageJson, files) {
     if (allDeps["@biomejs/biome"]) return "biome";
   }
   if (files.includes("ruff.toml") || files.includes(".ruff.toml")) return "ruff";
-  if (files.includes("pyproject.toml")) return "black";
+  if (files.includes("pyproject.toml")) {
+    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;
 }
 function detectBundler(packageJson, files) {
@@ -723,13 +743,19 @@ function checkHookStatus(rootDir) {
   };
   if (fs2.existsSync(projectScriptPath)) {
     result.projectInstalled = true;
-    const content = fs2.readFileSync(projectScriptPath, "utf-8");
-    result.projectMatchesOurs = content.trim() === HOOK_SCRIPT.trim();
+    try {
+      const content = fs2.readFileSync(projectScriptPath, "utf-8");
+      result.projectMatchesOurs = content.trim() === HOOK_SCRIPT.trim();
+    } catch {
+    }
   }
   if (fs2.existsSync(globalScriptPath)) {
     result.globalInstalled = true;
-    const content = fs2.readFileSync(globalScriptPath, "utf-8");
-    result.globalMatchesOurs = content.trim() === HOOK_SCRIPT.trim();
+    try {
+      const content = fs2.readFileSync(globalScriptPath, "utf-8");
+      result.globalMatchesOurs = content.trim() === HOOK_SCRIPT.trim();
+    } catch {
+    }
   }
   return result;
 }
@@ -925,6 +951,133 @@ function installStatuslineGlobal() {
     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")) : {};
@@ -959,6 +1112,16 @@ var EXTRAS = [
     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) {
@@ -1086,19 +1249,446 @@ function generateSettings(stack) {
     content: JSON.stringify(settings, null, 2)
   };
 }
-function writeSettings(rootDir, stack) {
+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;
+}
+function loadTemplate(templatePath) {
+  try {
+    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;
+  }
+}
+function findProjectTemplate(projectDir) {
+  const templatePath = path5.join(projectDir, ".claude-template.json");
+  if (fs5.existsSync(templatePath)) return templatePath;
+  return null;
+}
+function readFileOrNull(filePath) {
+  try {
+    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");
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+
 // src/prompt.ts
 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}
@@ -1107,7 +1697,7 @@ ${AGENTS_PROMPT}
 
 ${RULES_PROMPT}
 
-${COMMANDS_PROMPT}
+${COMMANDS_PROMPT}${memorySection}
 
 ---
 
@@ -1134,11 +1724,12 @@ ${options.claudeMdMode === "keep" ? `3. Skip CLAUDE.md generation \u2014 the exi
 4. Execute Phase 3 - verify quality before writing
 ${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.`;
@@ -1588,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.
@@ -1650,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\`
 
@@ -1710,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
@@ -1775,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
@@ -1803,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]*?)```/);
@@ -1867,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 = [];
@@ -1897,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);
     }
@@ -1922,15 +2776,15 @@ 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++;
       try {
@@ -1939,7 +2793,7 @@ function validateArtifacts(rootDir) {
           result.filesModified++;
           result.duplicationsRemoved += changes.length;
           for (const change of changes) {
-            change.file = path4.relative(rootDir, filePath);
+            change.file = path6.relative(rootDir, filePath);
           }
           result.changes.push(...changes);
         }
@@ -1953,22 +2807,72 @@ 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(`
 ${pc2.cyan("Claude Code Starter")} v${VERSION}
@@ -1979,11 +2883,19 @@ ${pc2.bold("USAGE")}
   npx claude-code-starter [OPTIONS]
 
 ${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
+  -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
@@ -2452,6 +3364,11 @@ function runClaudeAnalysis(projectDir, projectInfo, options = { claudeMdMode: "r
         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();
@@ -2494,6 +3411,8 @@ function runClaudeAnalysis(projectDir, projectInfo, options = { claudeMdMode: "r
       resolve(false);
     });
     child.on("close", (code) => {
+      process.off("SIGINT", cleanup);
+      process.off("SIGTERM", cleanup);
       if (code === 0) {
         spinner.succeed("Claude analysis complete!");
         resolve(true);
@@ -2508,17 +3427,17 @@ function runClaudeAnalysis(projectDir, projectInfo, options = { claudeMdMode: "r
   });
 }
 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));
       }
     }
   }
@@ -2536,11 +3455,132 @@ async function main() {
     process.exit(0);
   }
   showBanner();
+  checkForUpdate();
   const projectDir = process.cwd();
+  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);
@@ -2570,9 +3610,9 @@ async function main() {
   }
   let claudeMdMode = "replace";
   let existingClaudeMd = null;
-  const claudeMdPath = path5.join(projectDir, ".claude", "CLAUDE.md");
-  if (fs5.existsSync(claudeMdPath)) {
-    existingClaudeMd = fs5.readFileSync(claudeMdPath, "utf-8");
+  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) {
@@ -2604,14 +3644,15 @@ async function main() {
   }
   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(pc2.green("Created:"));
   console.log(pc2.green("  + .claude/settings.json"));
   console.log();
   const success = await runClaudeAnalysis(projectDir, projectInfo, {
     claudeMdMode,
-    existingClaudeMd: claudeMdMode === "improve" ? existingClaudeMd : null
+    existingClaudeMd: claudeMdMode === "improve" ? existingClaudeMd : null,
+    noMemory: args.noMemory
   });
   if (!success) {
     console.error(pc2.red("Claude analysis failed. Please try again."));
@@ -2639,12 +3680,12 @@ async function main() {
   }
   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) {
@@ -2668,7 +3709,7 @@ async function main() {
   );
 }
 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(pc2.red("Error:"), err.message);
@@ -2682,9 +3723,11 @@ try {
 }
 export {
   checkClaudeCli,
+  checkForUpdate,
   formatFramework,
   formatLanguage,
   getVersion,
+  isNewerVersion,
   mapFormatter,
   parseArgs,
   promptNewProject,