ai-dev-cli 2.0.0

package/README.md

@@ -0,0 +1,83 @@
+# ai-dev-cli
+
+Scaffold & audit tool for [Claude Code](https://docs.anthropic.com/en/docs/claude-code) projects.
+
+One command to set up CLAUDE.md, permissions, custom commands, hooks, MCP config, and coding standards.
+
+## Quick Start
+
+```bash
+npx ai-dev-cli init
+```
+
+## Init Levels
+
+| Level | What you get |
+|-------|-------------|
+| 0 — Minimal | `CLAUDE.md` + `.claude/settings.json` (permissions) |
+| 1 — Commands | + `/plan` `/review` `/commit` custom commands |
+| 2 — Quality | + Hook scripts (bash firewall, format guard, size guard, dep guard) |
+| 3 — Full | + MCP config, coding standards skill, approved-deps, ADR directory |
+
+Each level includes all lower levels.
+
+## Usage
+
+```bash
+# Interactive (prompts for project name, database, level)
+npx ai-dev-cli init
+
+# Non-interactive
+npx ai-dev-cli init --level 2 --name my-app --database prisma-sqlite
+
+# Compliance audit
+npx ai-dev-cli check
+npx ai-dev-cli check --fix
+
+# Takeover an existing project
+npx ai-dev-cli takeover
+```
+
+### Database Options
+
+| Option | Stack |
+|--------|-------|
+| `prisma-sqlite` | Prisma + SQLite |
+| `prisma-pg` | Prisma + PostgreSQL |
+| `supabase-cloud` | Supabase (Cloud) |
+| `supabase-cn` | Supabase (China, self-hosted) |
+
+## What It Generates
+
+```
+your-project/
+  CLAUDE.md              # AI assistant instructions
+  .claude/
+    settings.json        # Permissions + hooks config
+    commands/            # Custom slash commands
+      plan.md
+      review.md
+      commit.md
+      debug.md
+      doc.md
+    hooks/               # Automation hooks
+      pre-bash-firewall.sh
+      post-edit-format.sh
+      ...
+    skills/              # Coding standards skill
+      code-standards/
+        SKILL.md
+  .mcp.json              # MCP server config
+  docs/
+    approved-deps.md
+    adr/
+```
+
+## Requirements
+
+- Node.js >= 18
+- Git
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,752 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/commands/init.ts
+var import_node_fs4 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+
+// src/utils/logger.ts
+var isColorSupported = process.stdout.isTTY === true && process.env.CI !== "true";
+function colorize(code, text) {
+  return isColorSupported ? `\x1B[${code}m${text}\x1B[0m` : text;
+}
+var red = (s) => colorize(31, s);
+var green = (s) => colorize(32, s);
+var yellow = (s) => colorize(33, s);
+var blue = (s) => colorize(34, s);
+function info(msg) {
+  console.log(`${blue("[INFO]")} ${msg}`);
+}
+function ok(msg) {
+  console.log(`${green("[OK]")} ${msg}`);
+}
+function warn(msg) {
+  console.log(`${yellow("[WARN]")} ${msg}`);
+}
+function err(msg) {
+  console.error(`${red("[ERROR]")} ${msg}`);
+}
+function checkPass(msg) {
+  console.log(`${green("[PASS]")} ${msg}`);
+}
+function checkFail(msg) {
+  console.log(`${red("[FAIL]")} ${msg}`);
+}
+function checkWarn(msg) {
+  console.log(`${yellow("[WARN]")} ${msg}`);
+}
+
+// src/utils/file.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+function safeWrite(filepath, content) {
+  const dir = import_node_path.default.dirname(filepath);
+  import_node_fs.default.mkdirSync(dir, { recursive: true });
+  if (import_node_fs.default.existsSync(filepath)) {
+    warn(`Skipped (already exists): ${filepath}`);
+    return false;
+  }
+  import_node_fs.default.writeFileSync(filepath, content, "utf-8");
+  ok(`Created: ${filepath}`);
+  return true;
+}
+function safeWriteExecutable(filepath, content) {
+  const created = safeWrite(filepath, content);
+  if (created && process.platform !== "win32") {
+    import_node_fs.default.chmodSync(filepath, 493);
+  }
+  return created;
+}
+function appendGitignore(entry) {
+  const gitignore = ".gitignore";
+  if (!import_node_fs.default.existsSync(gitignore)) {
+    import_node_fs.default.writeFileSync(gitignore, "", "utf-8");
+  }
+  const content = import_node_fs.default.readFileSync(gitignore, "utf-8");
+  const lines = content.split("\n");
+  if (!lines.includes(entry)) {
+    import_node_fs.default.appendFileSync(gitignore, `${entry}
+`, "utf-8");
+    ok(`.gitignore += ${entry}`);
+  }
+}
+function readJsonFile(filepath) {
+  try {
+    const raw = import_node_fs.default.readFileSync(filepath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function mergeJsonFile(filepath, data) {
+  const existing = readJsonFile(filepath);
+  if (!existing) return;
+  const merged = deepMerge(existing, data);
+  import_node_fs.default.writeFileSync(filepath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  ok(`${filepath} updated`);
+}
+function deepMerge(target, source) {
+  const result2 = { ...target };
+  for (const key of Object.keys(source)) {
+    if (isObject(target[key]) && isObject(source[key])) {
+      result2[key] = deepMerge(
+        target[key],
+        source[key]
+      );
+    } else {
+      result2[key] = source[key];
+    }
+  }
+  return result2;
+}
+function isObject(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+
+// src/utils/template.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+function resolveTemplatesDir() {
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const candidate = import_node_path2.default.join(dir, "templates");
+    if (import_node_fs2.default.existsSync(candidate)) return candidate;
+    dir = import_node_path2.default.dirname(dir);
+  }
+  throw new Error(
+    "Could not find templates directory. Ensure it exists alongside the package."
+  );
+}
+var TEMPLATES_DIR = resolveTemplatesDir();
+function loadTemplate(name) {
+  const filepath = import_node_path2.default.join(TEMPLATES_DIR, name);
+  return import_node_fs2.default.readFileSync(filepath, "utf-8");
+}
+function renderTemplate(content, vars) {
+  return Object.entries(vars).reduce(
+    (result2, [key, value]) => result2.replaceAll(`{{${key}}}`, value),
+    content
+  );
+}
+function loadAndRender(name, vars) {
+  return renderTemplate(loadTemplate(name), vars);
+}
+
+// src/utils/detect.ts
+var import_node_fs3 = __toESM(require("fs"));
+function detectTechStack() {
+  const result2 = {
+    framework: "unknown",
+    language: "unknown",
+    runtime: "unknown",
+    database: "unknown"
+  };
+  const pkg = readJsonFile("package.json");
+  if (!pkg) return result2;
+  result2.runtime = "Node.js";
+  const deps = pkg.dependencies ?? {};
+  const devDeps = pkg.devDependencies ?? {};
+  if (import_node_fs3.default.existsSync("tsconfig.json") || devDeps["typescript"]) {
+    result2.language = "TypeScript";
+  } else {
+    result2.language = "JavaScript";
+  }
+  if (deps["next"]) result2.framework = "Next.js";
+  else if (deps["nuxt"]) result2.framework = "Nuxt";
+  else if (deps["react"]) result2.framework = "React";
+  else if (deps["vue"]) result2.framework = "Vue";
+  else if (deps["express"]) result2.framework = "Express";
+  if (deps["prisma"] || deps["@prisma/client"]) result2.database = "Prisma";
+  else if (deps["mongoose"]) result2.database = "MongoDB/Mongoose";
+  else if (deps["typeorm"]) result2.database = "TypeORM";
+  else if (deps["drizzle-orm"]) result2.database = "Drizzle";
+  else if (deps["sequelize"]) result2.database = "Sequelize";
+  return result2;
+}
+function extractNpmScripts() {
+  const pkg = readJsonFile("package.json");
+  if (!pkg || !pkg.scripts) return [];
+  const scripts = pkg.scripts;
+  return Object.keys(scripts).map((key) => `- \`npm run ${key}\` \u2014 ${key}`);
+}
+function extractDependencies() {
+  const pkg = readJsonFile("package.json");
+  if (!pkg) return [];
+  const deps = pkg.dependencies ?? {};
+  return Object.keys(deps).sort();
+}
+function detectDirectories() {
+  const candidates = [
+    "app",
+    "src",
+    "components",
+    "lib",
+    "services",
+    "pages",
+    "api",
+    "prisma",
+    "public",
+    "hooks",
+    "utils",
+    "types",
+    "middleware",
+    "routes",
+    "controllers",
+    "models",
+    "views"
+  ];
+  const found = [];
+  for (const d of candidates) {
+    if (import_node_fs3.default.existsSync(d) && import_node_fs3.default.statSync(d).isDirectory()) {
+      found.push(`/${d}`);
+    }
+    const srcPath = `src/${d}`;
+    if (import_node_fs3.default.existsSync(srcPath) && import_node_fs3.default.statSync(srcPath).isDirectory()) {
+      found.push(`/src/${d}`);
+    }
+  }
+  return found;
+}
+function commandExists(cmd) {
+  const { execSync: execSync2 } = require("child_process");
+  try {
+    execSync2(`command -v ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/prompt.ts
+var import_node_readline = __toESM(require("readline"));
+function ask(question, defaultValue) {
+  const rl = import_node_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const label = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+  return new Promise((resolve) => {
+    rl.question(label, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+function select(question, options, defaultIndex = 0) {
+  const rl = import_node_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  console.log("");
+  console.log(question);
+  options.forEach((opt, i) => {
+    const marker = i === defaultIndex ? "\u276F" : " ";
+    console.log(`  ${marker} ${i + 1}) ${opt}`);
+  });
+  console.log("");
+  return new Promise((resolve) => {
+    rl.question(`Select [1-${options.length}, default ${defaultIndex + 1}]: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      if (!trimmed) {
+        resolve(defaultIndex);
+        return;
+      }
+      const num = parseInt(trimmed, 10);
+      if (isNaN(num) || num < 1 || num > options.length) {
+        resolve(defaultIndex);
+        return;
+      }
+      resolve(num - 1);
+    });
+  });
+}
+
+// src/commands/init.ts
+var VERSION = "2.0.0";
+var DATABASE_OPTIONS = [
+  "prisma-sqlite",
+  "prisma-pg",
+  "supabase-cloud",
+  "supabase-cn"
+];
+var DATABASE_LABELS = {
+  "prisma-sqlite": "Prisma + SQLite      \u2014 zero-config local dev",
+  "prisma-pg": "Prisma + PostgreSQL  \u2014 traditional relational DB",
+  "supabase-cloud": "Supabase (Cloud)     \u2014 BaaS with auth/storage/realtime",
+  "supabase-cn": "Supabase (China)     \u2014 self-hosted for China region"
+};
+var DATABASE_CONFIGS = {
+  "prisma-sqlite": {
+    TECH_STACK: "Next.js 14 App Router + TypeScript + Prisma + SQLite + Tailwind CSS",
+    DB_COMMANDS: "- `npm run db:migrate` \u2014 Prisma migrate dev\n- `npm run db:studio` \u2014 Prisma Studio data browser",
+    DB_ARCHITECTURE: "`/prisma` \u2014 Schema definitions and migrations",
+    DB_DEPS: "prisma / @prisma/client / zod",
+    DB_BOUNDARY_RULE: "DB queries go through Service layer only \u2014 no Prisma in components/API Routes",
+    CALL_DIRECTION: "components \u2192 hooks \u2192 API \u2192 services \u2192 prisma"
+  },
+  "prisma-pg": {
+    TECH_STACK: "Next.js 14 App Router + TypeScript + Prisma + PostgreSQL + Tailwind CSS",
+    DB_COMMANDS: "- `npm run db:migrate` \u2014 Prisma migrate dev\n- `npm run db:studio` \u2014 Prisma Studio data browser",
+    DB_ARCHITECTURE: "`/prisma` \u2014 Schema definitions and migrations",
+    DB_DEPS: "prisma / @prisma/client / zod",
+    DB_BOUNDARY_RULE: "DB queries go through Service layer only \u2014 no Prisma in components/API Routes",
+    CALL_DIRECTION: "components \u2192 hooks \u2192 API \u2192 services \u2192 prisma"
+  },
+  "supabase-cloud": {
+    TECH_STACK: "Next.js 14 App Router + TypeScript + Supabase + Tailwind CSS",
+    DB_COMMANDS: "- `npx supabase start` \u2014 Local dev server\n- `npx supabase db push` \u2014 Push schema changes",
+    DB_ARCHITECTURE: "`/supabase` \u2014 Migrations and edge functions",
+    DB_DEPS: "@supabase/supabase-js / @supabase/ssr / zod",
+    DB_BOUNDARY_RULE: "Supabase client calls go through Service layer only \u2014 no direct supabase calls in components",
+    CALL_DIRECTION: "components \u2192 hooks \u2192 API \u2192 services \u2192 supabase"
+  },
+  "supabase-cn": {
+    TECH_STACK: "Next.js 14 App Router + TypeScript + Supabase (self-hosted) + Tailwind CSS",
+    DB_COMMANDS: "- `npx supabase start` \u2014 Local dev server\n- `npx supabase db push` \u2014 Push schema changes",
+    DB_ARCHITECTURE: "`/supabase` \u2014 Migrations and edge functions",
+    DB_DEPS: "@supabase/supabase-js / @supabase/ssr / zod",
+    DB_BOUNDARY_RULE: "Supabase client calls go through Service layer only \u2014 no direct supabase calls in components",
+    CALL_DIRECTION: "components \u2192 hooks \u2192 API \u2192 services \u2192 supabase"
+  }
+};
+function resolveDatabaseOption(input) {
+  if (DATABASE_OPTIONS.includes(input)) {
+    return input;
+  }
+  err(`Invalid database option: ${input}`);
+  err(`Valid options: ${DATABASE_OPTIONS.join(", ")}`);
+  process.exit(1);
+}
+async function runInit(options) {
+  console.log("");
+  console.log("======================================");
+  console.log(`  AI Dev Lifecycle Init v${VERSION}`);
+  console.log("======================================");
+  console.log("");
+  checkPrerequisites();
+  const defaultName = import_node_path3.default.basename(process.cwd());
+  const projectName = options.name || await ask("Project name", defaultName);
+  let dbOption;
+  if (options.database) {
+    dbOption = resolveDatabaseOption(options.database);
+  } else {
+    const labels = DATABASE_OPTIONS.map((key) => DATABASE_LABELS[key]);
+    const idx = await select("Select database solution:", labels, 0);
+    dbOption = DATABASE_OPTIONS[idx];
+  }
+  const dbConfig = DATABASE_CONFIGS[dbOption];
+  let level;
+  if (options.level !== void 0) {
+    level = parseInt(options.level, 10);
+  } else {
+    console.log("");
+    console.log("Select initialization level:");
+    console.log("  0) Minimal    \u2014 CLAUDE.md + basic permissions");
+    console.log("  1) Commands   \u2014 + /plan /review /commit");
+    console.log("  2) Quality    \u2014 + Hooks automation");
+    console.log("  3) Full       \u2014 + MCP + Skills + docs");
+    console.log("");
+    const input = await ask("Level [0-3]", "1");
+    level = parseInt(input, 10);
+  }
+  if (isNaN(level) || level < 0 || level > 3) {
+    err(`Invalid level: ${options.level}`);
+    process.exit(1);
+  }
+  console.log("");
+  info(`Database: ${dbOption}`);
+  info(`Starting Level ${level} initialization ...`);
+  console.log("");
+  const vars = {
+    PROJECT_NAME: projectName,
+    ...dbConfig
+  };
+  initLevel0(vars);
+  if (level >= 1) initLevel1();
+  if (level >= 2) initLevel2();
+  if (level >= 3) initLevel3(vars);
+  console.log("");
+  console.log("======================================");
+  ok(`Initialization complete! (Level ${level})`);
+  console.log("======================================");
+  console.log("");
+  console.log("Next steps:");
+  console.log("  1. Edit CLAUDE.md \u2014 fill in project description and actual commands");
+  console.log("  2. Run 'claude' to start Claude Code");
+  if (level < 3) {
+    console.log(`  3. Want more? Re-run: npx ai-dev-cli init --level 3`);
+  }
+  if (level >= 2) {
+    console.log(`  3. Test hooks: echo '{"tool_input":{"command":"sudo rm"}}' | .claude/hooks/pre-bash-firewall.sh`);
+  }
+  console.log("");
+}
+function checkPrerequisites() {
+  const missing = [];
+  if (!commandExists("git")) missing.push("git");
+  if (!commandExists("node")) missing.push("node");
+  if (missing.length > 0) {
+    err(`Missing required tools: ${missing.join(", ")}`);
+    err("Please install them before running this script.");
+    process.exit(1);
+  }
+  if (!commandExists("claude")) {
+    warn("Claude Code CLI not detected. Config files will still be generated.");
+  }
+  ok("Prerequisites check passed");
+}
+function initLevel0(vars) {
+  info("=== Level 0: Minimal Setup ===");
+  const claudeContent = loadAndRender("level-0/CLAUDE.md.tpl", vars);
+  safeWrite("CLAUDE.md", claudeContent);
+  const settingsContent = loadTemplate("level-0/settings.json.tpl");
+  safeWrite(".claude/settings.json", settingsContent);
+  appendGitignore("CLAUDE.local.md");
+  appendGitignore(".claude/settings.local.json");
+  appendGitignore(".claude/memory.jsonl");
+}
+function initLevel1() {
+  info("=== Level 1: Core Commands ===");
+  safeWrite(".claude/commands/plan.md", loadTemplate("level-1/plan.md"));
+  safeWrite(".claude/commands/review.md", loadTemplate("level-1/review.md"));
+  safeWrite(".claude/commands/commit.md", loadTemplate("level-1/commit.md"));
+}
+function initLevel2() {
+  info("=== Level 2: Quality Gates (Hooks) ===");
+  const hooks = [
+    "pre-bash-firewall.sh",
+    "post-edit-format.sh",
+    "pre-compact-preserve.sh",
+    "post-write-size-guard.sh",
+    "pre-bash-dep-guard.sh"
+  ];
+  for (const hook of hooks) {
+    safeWriteExecutable(
+      `.claude/hooks/${hook}`,
+      loadTemplate(`level-2/${hook}`)
+    );
+  }
+  const settingsPath = ".claude/settings.json";
+  if (import_node_fs4.default.existsSync(settingsPath)) {
+    const existing = readJsonFile(settingsPath);
+    if (existing && !existing["hooks"]) {
+      const hooksConfig = JSON.parse(loadTemplate("level-2/hooks-config.json"));
+      mergeJsonFile(settingsPath, hooksConfig);
+    } else {
+      warn("settings.json already has hooks config \u2014 skipped");
+    }
+  }
+}
+function initLevel3(vars) {
+  info("=== Level 3: Full System ===");
+  safeWrite(".mcp.json", loadTemplate("level-3/mcp.json"));
+  safeWrite(".claude/commands/debug.md", loadTemplate("level-3/debug.md"));
+  safeWrite(".claude/commands/doc.md", loadTemplate("level-3/doc.md"));
+  safeWrite(
+    ".claude/skills/code-standards/SKILL.md",
+    loadTemplate("level-3/code-standards.md")
+  );
+  safeWrite("docs/approved-deps.md", loadAndRender("level-3/approved-deps.md", vars));
+  const adrKeep = "docs/adr/.gitkeep";
+  if (!import_node_fs4.default.existsSync(adrKeep)) {
+    import_node_fs4.default.mkdirSync("docs/adr", { recursive: true });
+    import_node_fs4.default.writeFileSync(adrKeep, "");
+    ok("Created: docs/adr/.gitkeep");
+  }
+}
+
+// src/commands/check.ts
+var import_node_fs5 = __toESM(require("fs"));
+var import_node_path4 = __toESM(require("path"));
+var import_node_child_process = require("child_process");
+var result = { pass: 0, fail: 0, warn: 0 };
+function pass(msg) {
+  checkPass(msg);
+  result.pass++;
+}
+function fail(msg) {
+  checkFail(msg);
+  result.fail++;
+}
+function warning(msg) {
+  checkWarn(msg);
+  result.warn++;
+}
+async function runCheck(options) {
+  result.pass = 0;
+  result.fail = 0;
+  result.warn = 0;
+  console.log("");
+  console.log("====== AI Dev Lifecycle Check ======");
+  console.log("");
+  checkClaudeMd(options.fix);
+  checkSettingsJson(options.fix);
+  checkHookPermissions(options.fix);
+  checkGitignore(options.fix);
+  checkEnvSafety();
+  checkLongFiles();
+  checkBannedDeps();
+  checkEnvFilesTracked();
+  console.log("");
+  console.log(
+    `====== Results: ${result.pass} passed, ${result.fail} failed, ${result.warn} warnings ======`
+  );
+  if (options.ci && result.fail > 0) {
+    process.exit(1);
+  }
+}
+function checkClaudeMd(fix) {
+  if (import_node_fs5.default.existsSync("CLAUDE.md")) {
+    pass("CLAUDE.md exists");
+  } else {
+    fail("CLAUDE.md does not exist");
+    if (fix) {
+      info("Auto-fix: Run `npx ai-dev-cli init --level 0` to create CLAUDE.md");
+    }
+  }
+}
+function checkSettingsJson(fix) {
+  const settingsPath = ".claude/settings.json";
+  if (!import_node_fs5.default.existsSync(settingsPath)) {
+    fail(".claude/settings.json does not exist");
+    if (fix) {
+      info("Auto-fix: Run `npx ai-dev-cli init --level 0` to create settings.json");
+    }
+    return;
+  }
+  const data = readJsonFile(settingsPath);
+  if (data) {
+    pass(".claude/settings.json format is valid");
+  } else {
+    fail(".claude/settings.json has invalid JSON format");
+    return;
+  }
+  const permissions = data["permissions"];
+  const deny = permissions?.["deny"];
+  if (deny && deny.length > 0) {
+    pass("deny rules configured");
+  } else {
+    warning("settings.json has no deny rules");
+  }
+}
+function checkHookPermissions(fix) {
+  const hooksDir = ".claude/hooks";
+  if (!import_node_fs5.default.existsSync(hooksDir)) return;
+  const files = import_node_fs5.default.readdirSync(hooksDir).filter((f) => f.endsWith(".sh"));
+  for (const file of files) {
+    const hookPath = import_node_path4.default.join(hooksDir, file);
+    try {
+      import_node_fs5.default.accessSync(hookPath, import_node_fs5.default.constants.X_OK);
+      pass(`Hook executable: ${file}`);
+    } catch {
+      fail(`Hook missing execute permission: ${hookPath}`);
+      if (fix && process.platform !== "win32") {
+        import_node_fs5.default.chmodSync(hookPath, 493);
+        info(`Auto-fix: chmod +x ${hookPath}`);
+      }
+    }
+  }
+}
+function checkGitignore(fix) {
+  const entries = [
+    "CLAUDE.local.md",
+    ".claude/settings.local.json",
+    ".claude/memory.jsonl"
+  ];
+  for (const entry of entries) {
+    if (import_node_fs5.default.existsSync(".gitignore") && import_node_fs5.default.readFileSync(".gitignore", "utf-8").split("\n").includes(entry)) {
+      pass(`.gitignore contains ${entry}`);
+    } else {
+      warning(`.gitignore missing ${entry}`);
+      if (fix) {
+        appendGitignore(entry);
+      }
+    }
+  }
+}
+function checkEnvSafety() {
+  if (!import_node_fs5.default.existsSync(".env")) {
+    pass("No .env file present (or not tracked)");
+    return;
+  }
+  try {
+    (0, import_node_child_process.execSync)("git ls-files --error-unmatch .env", { stdio: "ignore" });
+    fail(".env file is tracked by git (security risk!)");
+  } catch {
+    pass(".env exists but is not tracked by git");
+  }
+}
+function checkLongFiles() {
+  const longFiles = [];
+  walkDir(".", (filepath) => {
+    if (!filepath.match(/\.(ts|tsx)$/) || filepath.includes("node_modules") || filepath.includes(".next") || filepath.includes("dist")) {
+      return;
+    }
+    const content = import_node_fs5.default.readFileSync(filepath, "utf-8");
+    const lines = content.split("\n").length;
+    if (lines > 300) {
+      longFiles.push(`${filepath} (${lines} lines)`);
+    }
+  });
+  if (longFiles.length > 0) {
+    warning(`Files exceeding 300 lines:
+${longFiles.map((f) => `       - ${f}`).join("\n")}`);
+  } else {
+    pass("All .ts/.tsx files are within 300 lines");
+  }
+}
+function checkBannedDeps() {
+  const pkg = readJsonFile("package.json");
+  if (!pkg) return;
+  const deps = pkg["dependencies"] ?? {};
+  const devDeps = pkg["devDependencies"] ?? {};
+  let foundBanned = false;
+  for (const dep of ["moment", "jquery"]) {
+    if (deps[dep] || devDeps[dep]) {
+      fail(`Banned dependency found: ${dep}`);
+      foundBanned = true;
+    }
+  }
+  if (deps["lodash"]) {
+    warning("Using full lodash package \u2014 consider lodash-es with submodule imports");
+  }
+  if (!foundBanned) {
+    pass("No banned dependencies");
+  }
+}
+function checkEnvFilesTracked() {
+  if (!import_node_fs5.default.existsSync(".")) return;
+  const envFiles = import_node_fs5.default.readdirSync(".").filter(
+    (f) => f.startsWith(".env.") && f !== ".env.example" && f !== ".env.sample"
+  );
+  for (const envFile of envFiles) {
+    try {
+      (0, import_node_child_process.execSync)(`git ls-files --error-unmatch ${envFile}`, { stdio: "ignore" });
+      fail(`${envFile} is tracked by git`);
+    } catch {
+    }
+  }
+}
+function walkDir(dir, callback) {
+  if (!import_node_fs5.default.existsSync(dir)) return;
+  const entries = import_node_fs5.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = import_node_path4.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (["node_modules", ".next", "dist", ".git", ".claude"].includes(entry.name)) continue;
+      walkDir(fullPath, callback);
+    } else {
+      callback(fullPath);
+    }
+  }
+}
+
+// src/commands/takeover.ts
+var import_node_fs6 = __toESM(require("fs"));
+var import_node_path5 = __toESM(require("path"));
+var VERSION2 = "2.0.0";
+async function runTakeover() {
+  console.log("");
+  console.log("======================================");
+  console.log(`  AI Dev Lifecycle Takeover v${VERSION2}`);
+  console.log("======================================");
+  console.log("");
+  const missing = [];
+  if (!commandExists("git")) missing.push("git");
+  if (!commandExists("node")) missing.push("node");
+  if (missing.length > 0) {
+    console.error(`Missing required tools: ${missing.join(", ")}`);
+    process.exit(1);
+  }
+  info("=== Analyzing existing project ===");
+  console.log("");
+  const projectName = import_node_path5.default.basename(process.cwd()).replace(/[^a-zA-Z0-9._-]/g, "");
+  const tech = detectTechStack();
+  ok(`Tech stack: ${tech.framework} + ${tech.language} + ${tech.runtime} + ${tech.database}`);
+  const scripts = extractNpmScripts();
+  const scriptsSection = scripts.length > 0 ? scripts.join("\n") : "[TODO: Fill in development commands]";
+  const dirs = detectDirectories();
+  const dirsSection = dirs.length > 0 ? dirs.map((d) => `- \`${d}\``).join("\n") : "[TODO: Fill in directory structure]";
+  let techLine = tech.framework;
+  if (tech.language !== "unknown") techLine += ` + ${tech.language}`;
+  if (tech.database !== "unknown") techLine += ` + ${tech.database}`;
+  const claudeContent = loadAndRender("takeover/CLAUDE.md.tpl", {
+    PROJECT_NAME: projectName,
+    TECH_LINE: techLine,
+    SCRIPTS_SECTION: scriptsSection,
+    DIRS_SECTION: dirsSection
+  });
+  if (safeWrite("CLAUDE.md", claudeContent)) {
+    ok("Created: CLAUDE.md (DRAFT \u2014 review required)");
+  }
+  const deps = extractDependencies();
+  if (deps.length > 0 && !import_node_fs6.default.existsSync("docs/approved-deps.md")) {
+    import_node_fs6.default.mkdirSync("docs", { recursive: true });
+    const content = [
+      "# Approved Dependencies (auto-generated from package.json)",
+      "",
+      "Review and mark banned items.",
+      "",
+      "## Current Dependencies",
+      ...deps.map((d) => `- ${d}`),
+      "",
+      "## Banned",
+      "[TODO: Add based on project conventions]",
+      ""
+    ].join("\n");
+    import_node_fs6.default.writeFileSync("docs/approved-deps.md", content, "utf-8");
+    ok("Created: docs/approved-deps.md (DRAFT \u2014 review required)");
+  }
+  safeWrite(".claude/settings.json", loadTemplate("level-0/settings.json.tpl"));
+  appendGitignore("CLAUDE.local.md");
+  appendGitignore(".claude/settings.local.json");
+  appendGitignore(".claude/memory.jsonl");
+  console.log("");
+  console.log("======================================");
+  ok("Takeover drafts generated");
+  console.log("======================================");
+  console.log("");
+  warn("All generated files are DRAFTS. You MUST review and refine:");
+  console.log("  1. CLAUDE.md \u2014 add project description, business context, coding rules");
+  console.log("  2. docs/approved-deps.md \u2014 mark banned dependencies");
+  console.log("  3. After running 'claude', use this prompt to let AI help refine:");
+  console.log("");
+  console.log('     "Read the entire codebase, understand the architecture and module');
+  console.log("      relationships, then help me refine CLAUDE.md with architecture");
+  console.log('      descriptions and key rules."');
+  console.log("");
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("ai-dev-cli").description("AI Dev Lifecycle \u2014 scaffold & audit tool for Claude Code projects").version("2.0.0");
+program.command("init").description("Initialize AI dev system (Level 0-3)").option("-l, --level <0-3>", "initialization level").option("-n, --name <name>", "project name").option("-d, --database <option>", "database: prisma-sqlite|prisma-pg|supabase-cloud|supabase-cn").action(runInit);
+program.command("check").description("Compliance audit").option("--fix", "auto-fix issues").option("--ci", "CI mode \u2014 exit non-zero on failure").action(runCheck);
+program.command("takeover").description("Analyze and scaffold existing project").action(runTakeover);
+program.parse();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "ai-dev-cli",
+  "version": "2.0.0",
+  "description": "AI Dev Lifecycle — scaffold & audit tool for Claude Code projects",
+  "bin": {
+    "ai-dev-cli": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wh759705-creator/ai-dev-lifecycle.git",
+    "directory": "cli"
+  },
+  "homepage": "https://github.com/wh759705-creator/ai-dev-lifecycle#readme",
+  "keywords": [
+    "claude-code",
+    "ai-dev",
+    "scaffold",
+    "cli",
+    "claude",
+    "ai-coding"
+  ]
+}

package/templates/level-0/CLAUDE.md.tpl

@@ -0,0 +1,71 @@
+# Project: {{PROJECT_NAME}}
+
+[One-line project description].
+Tech stack: {{TECH_STACK}}.
+
+## Commands
+
+- `npm run dev` — Dev server (port 3000)
+- `npm run build` — Production build
+- `npm run test` — Run Vitest unit tests
+- `npm run test:e2e` — Run Playwright E2E tests
+- `npm run lint` — ESLint check
+{{DB_COMMANDS}}
+
+## Architecture
+
+- `/app` — Page routes and layouts (App Router)
+- `/app/api` — API Route Handlers
+- `/components` — React components
+- `/components/ui` — Base UI components (shadcn/ui)
+- `/lib` — Utilities, client instances, auth helpers
+- `/services` — Business logic layer
+- {{DB_ARCHITECTURE}}
+- `/types` — Shared TypeScript type definitions
+- `/hooks` — Custom React Hooks
+- `/__tests__` — Test files
+
+## Key Rules
+
+- NEVER commit .env files or any files containing secrets
+- NEVER use `any` type — TypeScript strict mode
+- NEVER rewrite entire modules at once — small steps, verify each
+- MUST use named exports, no default export
+- MUST validate all API inputs with zod
+- MUST use unified AppError class for error handling
+- MUST run related tests after code changes
+- File naming: kebab-case; Component naming: PascalCase
+- Single file must not exceed 300 lines — split if exceeded
+- {{DB_BOUNDARY_RULE}}
+
+## Work Mode
+
+- Produce a plan before coding (list files to modify and change points), wait for approval
+- When modifying shared types/interfaces, search all references first, list impact scope
+- Read the full content of any file BEFORE modifying it
+- Search for existing similar functionality BEFORE implementing new features
+- Verify that any referenced types/functions actually exist in the project (no fabrication)
+- Commit at each working state — don't wait until everything is done
+
+## Module Boundaries
+
+- Components (/components) never call the database directly
+- API Routes only parse requests and format responses — business logic lives in Service layer
+- Service layer is the sole home of business logic
+- Call direction (one-way): {{CALL_DIRECTION}}
+
+## Project Glossary
+
+<!-- Project-specific terms to prevent AI misunderstanding. Format: term — meaning in this project -->
+
+## Dependency Policy
+
+Check docs/approved-deps.md before introducing new dependencies. Unlisted deps require justification.
+
+## Common Pitfalls (update when AI makes mistakes)
+
+<!-- Format: - Describe the issue and correct approach (date) -->
+
+## Compact Preservation
+
+Preserve: modified file paths, current task progress, test commands, architecture decisions, failed attempts and reasons

package/templates/level-0/settings.json.tpl

@@ -0,0 +1,33 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run lint)",
+      "Bash(npm run test:*)",
+      "Bash(npm run build)",
+      "Bash(npx prettier:*)",
+      "Bash(npx tsc:*)",
+      "Bash(git log:*)",
+      "Bash(git diff:*)",
+      "Bash(git status)",
+      "Bash(git branch:*)",
+      "Bash(git checkout:*)",
+      "Bash(git stash:*)"
+    ],
+    "deny": [
+      "Bash(sudo:*)",
+      "Bash(curl:*|*sh)",
+      "Bash(wget:*|*sh)",
+      "Bash(rm -rf /)",
+      "Bash(git push:*--force*)",
+      "Bash(git reset --hard)",
+      "Bash(chmod 777:*)",
+      "Read(.env)",
+      "Read(.env.*)",
+      "Read(**/*.key)",
+      "Read(**/*.pem)"
+    ]
+  },
+  "env": {
+    "BASH_DEFAULT_TIMEOUT_MS": "30000"
+  }
+}

package/templates/level-1/commit.md

@@ -0,0 +1,17 @@
+---
+description: "Smart commit — generate semantic commit message and execute"
+allowed-tools: Bash, Read
+---
+
+Execute a smart commit:
+
+1. Run `git status` and `git diff --staged` to see changes
+2. If no staged files, `git add` relevant files individually (never use `git add .`)
+3. Analyze changes and generate Conventional Commits format message:
+   feat|fix|refactor|docs|test|chore(scope): description
+
+Rules:
+- scope = module name or key part of file path
+- Description in English, under 50 chars, explain WHY not WHAT
+- Never commit .env or key files
+- If changes span more than 10 files, suggest splitting into multiple commits

package/templates/level-1/plan.md

@@ -0,0 +1,16 @@
+---
+description: "Requirements analysis and plan design — produce a plan, wait for approval before coding"
+allowed-tools: Read, Grep, Glob, Bash
+---
+
+Analyze requirement "$ARGUMENTS" and design an implementation plan:
+
+1. Use AskUserQuestion to confirm requirement details and boundaries
+2. Search the codebase for existing similar features or reusable modules
+3. Output the implementation plan:
+   - Overview (one sentence)
+   - Impact scope (new files, modified files, dependency changes)
+   - Implementation steps (specific to file and function level)
+   - Risk points and mitigations
+
+IMPORTANT: After outputting the plan, you MUST wait for user confirmation. Do NOT start implementation on your own.

package/templates/level-1/review.md

@@ -0,0 +1,19 @@
+---
+description: "Code review — focus on correctness, security, and edge cases"
+allowed-tools: Read, Grep, Glob, Bash
+---
+
+Review recent git changes:
+
+1. Run `git diff HEAD` to see changes
+2. Review dimensions:
+   - Correctness: logic, edge cases, null defense, async error handling
+   - Security: injection risks, input validation, sensitive info exposure
+   - Performance: unnecessary re-renders, N+1 queries, large list pagination
+   - Standards: compliance with CLAUDE.md rules
+
+3. Output format — categorize by severity:
+   - **Must fix**: security vulnerabilities, logic errors, data loss risk
+   - **Suggested improvement**: code smells, missing error handling, perf issues
+   - **Minor suggestion**: naming optimization, style consistency
+   Each item includes: filename:line, problem description, fix suggestion

package/templates/level-2/hooks-config.json

@@ -0,0 +1,24 @@
+{
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "Bash",
+      "hooks": [
+        {"type": "command", "command": ".claude/hooks/pre-bash-firewall.sh"},
+        {"type": "command", "command": ".claude/hooks/pre-bash-dep-guard.sh"}
+      ]
+    }],
+    "PostToolUse": [{
+      "matcher": "Write|Edit",
+      "hooks": [
+        {"type": "command", "command": ".claude/hooks/post-edit-format.sh"},
+        {"type": "command", "command": ".claude/hooks/post-write-size-guard.sh"}
+      ]
+    }],
+    "PreCompact": [{
+      "matcher": "auto",
+      "hooks": [
+        {"type": "command", "command": ".claude/hooks/pre-compact-preserve.sh"}
+      ]
+    }]
+  }
+}

package/templates/level-2/post-edit-format.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+input=$(cat)
+file_path=$(echo "$input" | jq -r '.tool_input.file_path // ""')
+
+# Only format project source files
+case "$file_path" in
+  *.ts|*.tsx|*.js|*.jsx|*.json)
+    if command -v npx &>/dev/null; then
+      npx prettier --write "$file_path" 2>/dev/null || true
+    fi
+    ;;
+esac
+
+exit 0

package/templates/level-2/post-write-size-guard.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+input=$(cat)
+file_path=$(echo "$input" | jq -r '.tool_input.file_path // ""')
+
+# Only check TS/TSX files
+case "$file_path" in
+  *.ts|*.tsx)
+    if [ -f "$file_path" ]; then
+      lines=$(wc -l < "$file_path")
+      if [ "$lines" -gt 300 ]; then
+        echo "WARNING: $file_path has ${lines} lines, exceeding the 300-line limit. Consider splitting." >&2
+        exit 1
+      fi
+    fi
+    ;;
+esac
+exit 0

package/templates/level-2/pre-bash-dep-guard.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -euo pipefail
+input=$(cat)
+cmd=$(echo "$input" | jq -r '.tool_input.command // ""')
+
+# Only intercept package install commands
+if ! echo "$cmd" | grep -qE '(npm install|npm add|yarn add|pnpm add)'; then
+  exit 0
+fi
+
+# Extract all package names (strip flags and versions)
+pkgs=$(echo "$cmd" | sed -E 's/^(npm install|npm add|yarn add|pnpm add)[[:space:]]+//' | tr ' ' '\n' | grep -v '^-')
+
+if [ -z "$pkgs" ]; then
+  exit 0
+fi
+
+# Pass 1: Check all packages against banned list (blocking)
+banned=("moment" "jquery" "lodash")
+for pkg in $pkgs; do
+  pkg=$(echo "$pkg" | sed 's/@.*//')
+  [ -z "$pkg" ] && continue
+  for b in "${banned[@]}"; do
+    if [ "$pkg" = "$b" ]; then
+      echo "BLOCKED: $pkg is in the banned dependency list. See docs/approved-deps.md for alternatives." >&2
+      exit 2
+    fi
+  done
+done
+
+# Pass 2: Check allowlist (non-blocking warning)
+if [ -f "docs/approved-deps.md" ]; then
+  for pkg in $pkgs; do
+    pkg=$(echo "$pkg" | sed 's/@.*//')
+    [ -z "$pkg" ] && continue
+    if ! grep -q "$pkg" docs/approved-deps.md; then
+      echo "WARNING: $pkg is not in the approved dependency list. Evaluate before adding to docs/approved-deps.md." >&2
+      exit 1
+    fi
+  done
+fi
+
+exit 0

package/templates/level-2/pre-bash-firewall.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Read tool input from stdin
+input=$(cat)
+cmd=$(echo "$input" | jq -r '.tool_input.command // ""')
+
+# Dangerous command patterns
+dangerous_patterns=(
+  'rm -rf /'
+  'git reset --hard'
+  'git push.*--force'
+  'git clean -f'
+  'sudo '
+  'chmod 777'
+  'curl.*|.*sh'
+  'wget.*|.*sh'
+)
+
+for pattern in "${dangerous_patterns[@]}"; do
+  if echo "$cmd" | grep -qE "$pattern"; then
+    echo "BLOCKED: Dangerous command pattern detected '$pattern'" >&2
+    echo "Command: $cmd" >&2
+    exit 2
+  fi
+done
+
+exit 0

package/templates/level-2/pre-compact-preserve.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+cat <<'EOF'
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreCompact",
+    "additionalContext": "MUST preserve during compaction: 1. All modified file paths 2. Current task progress and next steps 3. Test commands and results 4. Architecture decisions 5. Failed attempts and reasons"
+  }
+}
+EOF
+exit 0

package/templates/level-3/approved-deps.md

@@ -0,0 +1,24 @@
+# Approved Dependencies
+
+Check this list before introducing new dependencies. Unlisted deps require evaluation.
+
+## Core Framework
+- next / react / react-dom / typescript
+
+## Database
+- {{DB_DEPS}}
+
+## UI
+- tailwindcss / @radix-ui/* / lucide-react
+
+## Utilities
+- date-fns (moment.js is BANNED)
+- clsx / tailwind-merge
+
+## Testing
+- vitest / @playwright/test / @testing-library/react
+
+## Banned
+- moment.js — use date-fns instead
+- lodash (full package) — use native methods or lodash-es submodule imports
+- jquery

package/templates/level-3/code-standards.md

@@ -0,0 +1,37 @@
+---
+name: code-standards
+description: >
+  Coding standards guard. Automatically referenced during code generation.
+  Ensures TypeScript type safety, API input validation, unified error handling, and naming conventions.
+---
+
+# Coding Standards
+
+Check these rules before generating code:
+
+## TypeScript
+- All functions must have complete type annotations — no `any`
+- Use named exports — no default export
+- Interface names without `I` prefix (use `User` not `IUser`)
+
+## API Route
+- All inputs validated with zod schema
+- Unified response format: `{ data, error, meta }`
+- Errors use AppError class with error code
+
+## React Components
+- Functional components + hooks
+- Props defined as a separate type (ComponentNameProps)
+- State management priority: useState → useReducer → Zustand → Server State
+
+## Files
+- Single file ≤ 300 lines
+- File naming: kebab-case; Component naming: PascalCase
+- Test files colocated with source or in __tests__ directory
+
+## Template Reference
+| Scenario | Reference |
+|----------|-----------|
+| API Route | See existing implementations under /app/api/ |
+| Service | See existing implementations under /services/ |
+| Component | See existing implementations under /components/ |

package/templates/level-3/debug.md

@@ -0,0 +1,15 @@
+---
+description: "Bug diagnosis — systematically locate root cause"
+allowed-tools: Read, Grep, Glob, Bash, Edit
+---
+
+Diagnose the problem: "$ARGUMENTS"
+
+Steps:
+1. Collect info: read error logs, find related source code
+2. Check recent git changes: `git log --oneline -10`
+3. Trace the call chain upward from the error point
+4. Rank possible root causes by probability
+5. Output: root cause analysis + fix plan + verification method
+
+IMPORTANT: If unsure about the root cause, say so explicitly. Do NOT speculatively modify code.

package/templates/level-3/doc.md

@@ -0,0 +1,15 @@
+---
+description: "Check and update project documentation to stay in sync with code"
+allowed-tools: Read, Write, Edit, Glob, Bash
+---
+
+Check which docs need updating after code changes:
+
+1. `git diff --name-only` to see changed files
+2. Check:
+   - New module → update CLAUDE.md "Architecture" section
+   - New command → update CLAUDE.md "Commands" section
+   - New dependency → update docs/approved-deps.md
+   - Major decision → suggest creating an ADR in docs/adr/
+3. Execute necessary updates
+4. If no updates needed, say so explicitly

package/templates/level-3/mcp.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp@latest"]
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"]
+    }
+  }
+}

package/templates/takeover/CLAUDE.md.tpl

@@ -0,0 +1,25 @@
+# Project: {{PROJECT_NAME}}
+
+[TODO: One-line project description].
+Tech stack: {{TECH_LINE}} (verify and adjust as needed).
+
+## Commands
+
+{{SCRIPTS_SECTION}}
+
+## Architecture
+
+{{DIRS_SECTION}}
+
+## Key Rules
+
+- NEVER commit .env files
+- MUST run related tests after code changes
+- Produce a plan before coding, wait for approval
+[TODO: Add project-specific rules]
+
+## Common Pitfalls (update when AI makes mistakes)
+
+## Compact Preservation
+
+Preserve: modified file paths, current task progress, test commands, architecture decisions