ai-spec-dev 0.1.0 → 0.14.1

package/dist/index.mjs

@@ -2,6 +2,7 @@
 import { GoogleGenerativeAI } from "@google/generative-ai";
 import Anthropic from "@anthropic-ai/sdk";
 import OpenAI from "openai";
+import axios from "axios";
 import { ProxyAgent } from "undici";
 
 // prompts/spec.prompt.ts
@@ -116,12 +117,21 @@ function geminiRequestOptions() {
 }
 var PROVIDER_CATALOG = {
   // ── International ──────────────────────────────────────────────────────────
+  mimo: {
+    displayName: "MiMo (Xiaomi)",
+    description: "\u5C0F\u7C73 MiMo \u2014 mimo-v2-pro (Anthropic-compatible API)",
+    models: ["mimo-v2-pro"],
+    envKey: "MIMO_API_KEY"
+    // baseURL not used — MiMo has a dedicated provider class
+  },
   gemini: {
     displayName: "Google Gemini",
-    description: "Google AI Studio \u2014 Gemini 2.5 / 1.5 series",
+    description: "Google AI Studio \u2014 Gemini 2.5 / 2.0 series",
     models: [
-      "gemini-2.5-flash",
       "gemini-2.5-pro",
+      "gemini-2.5-flash",
+      "gemini-2.0-flash",
+      "gemini-2.0-flash-lite",
       "gemini-1.5-pro",
       "gemini-1.5-flash"
     ],
@@ -129,61 +139,103 @@ var PROVIDER_CATALOG = {
   },
   claude: {
     displayName: "Anthropic Claude",
-    description: "Anthropic \u2014 Claude 4.x series",
+    description: "Anthropic \u2014 Claude 4.x / 3.7 series",
     models: [
-      "claude-sonnet-4-6",
       "claude-opus-4-6",
-      "claude-haiku-4-5"
+      "claude-sonnet-4-6",
+      "claude-haiku-4-5",
+      "claude-3-7-sonnet-20250219"
     ],
     envKey: "ANTHROPIC_API_KEY"
   },
   openai: {
     displayName: "OpenAI",
-    description: "OpenAI \u2014 GPT-4o / o1 series",
-    models: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "o1-mini"],
+    description: "OpenAI \u2014 o3 / GPT-4o series",
+    models: [
+      "o3",
+      "o3-mini",
+      "o1",
+      "o1-mini",
+      "gpt-4o",
+      "gpt-4o-mini"
+    ],
     envKey: "OPENAI_API_KEY",
     baseURL: "https://api.openai.com/v1"
   },
+  deepseek: {
+    displayName: "DeepSeek",
+    description: "DeepSeek \u2014 V3 (chat) / R1 (reasoning)",
+    models: [
+      "deepseek-chat",
+      // DeepSeek-V3
+      "deepseek-reasoner"
+      // DeepSeek-R1
+    ],
+    envKey: "DEEPSEEK_API_KEY",
+    baseURL: "https://api.deepseek.com/v1"
+  },
   // ── Chinese Models (OpenAI-compatible) ────────────────────────────────────
   qwen: {
     displayName: "\u901A\u4E49\u5343\u95EE (Qwen)",
-    description: "\u963F\u91CC\u4E91\u767E\u70BC DashScope \u2014 qwen-max / plus / turbo",
+    description: "\u963F\u91CC\u4E91\u767E\u70BC \u2014 Qwen3 / Qwen2.5 series",
     models: [
+      "qwen3-235b-a22b",
+      // Qwen3 MoE flagship (supports thinking mode)
+      "qwen3-72b",
+      "qwen3-32b",
+      "qwen3-8b",
       "qwen-max",
       "qwen-max-latest",
       "qwen-plus",
-      "qwen-plus-latest",
-      "qwen-turbo",
       "qwen-long"
     ],
     envKey: "DASHSCOPE_API_KEY",
-    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
+    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    // Qwen3 models enable thinking (CoT) by default, which pollutes structured outputs.
+    // Disable it so JSON/Markdown responses stay clean.
+    extraBody: { enable_thinking: false }
+  },
+  glm: {
+    displayName: "\u667A\u8C31 GLM (Zhipu AI)",
+    description: "\u667A\u8C31 AI \u2014 GLM-5 / GLM-4 series + Z1 reasoning",
+    models: [
+      "glm-5",
+      // GLM-5 flagship (如不可用请确认最新 model ID)
+      "glm-5-flash",
+      "glm-z1",
+      // GLM-Z1 reasoning model
+      "glm-z1-flash",
+      "glm-4-plus",
+      "glm-4-flash",
+      "glm-4-long"
+    ],
+    envKey: "ZHIPU_API_KEY",
+    baseURL: "https://open.bigmodel.cn/api/paas/v4/"
   },
   minimax: {
     displayName: "MiniMax",
-    description: "MiniMax AI \u2014 MiniMax-Text-01 / abab series",
+    description: "MiniMax AI \u2014 MiniMax-Text-2.7 / Text-01 series",
     models: [
+      "MiniMax-Text-2.7",
+      // MiniMax 最新旗舰 (如不可用请确认最新 model ID)
       "MiniMax-Text-01",
-      "abab6.5s-chat",
-      "abab6.5g-chat",
-      "abab5.5-chat"
+      "abab6.5s-chat"
     ],
     envKey: "MINIMAX_API_KEY",
     baseURL: "https://api.minimax.chat/v1"
   },
-  glm: {
-    displayName: "\u667A\u8C31 GLM (Zhipu AI)",
-    description: "\u667A\u8C31 AI \u2014 GLM-4 plus / flash / air series",
+  doubao: {
+    displayName: "\u8C46\u5305 Doubao (ByteDance)",
+    description: "\u706B\u5C71\u5F15\u64CE Ark \u2014 Doubao Pro/Lite series",
     models: [
-      "glm-4-plus",
-      "glm-4",
-      "glm-4-flash",
-      "glm-4-air",
-      "glm-4-airx",
-      "glm-4-long"
+      "doubao-pro-256k",
+      "doubao-pro-128k",
+      "doubao-pro-32k",
+      "doubao-lite-128k",
+      "doubao-lite-32k"
     ],
-    envKey: "ZHIPU_API_KEY",
-    baseURL: "https://open.bigmodel.cn/api/paas/v4/"
+    envKey: "ARK_API_KEY",
+    baseURL: "https://ark.cn-beijing.volces.com/api/v3"
   }
 };
 var SUPPORTED_PROVIDERS = Object.keys(PROVIDER_CATALOG);
@@ -234,9 +286,13 @@ var OpenAICompatibleProvider = class {
   client;
   providerName;
   modelName;
-  constructor(providerName, apiKey, modelName, baseURL) {
+  systemRole;
+  extraBody;
+  constructor(providerName, apiKey, modelName, baseURL, systemRole = "system", extraBody) {
     this.providerName = providerName;
     this.modelName = modelName;
+    this.systemRole = systemRole;
+    this.extraBody = extraBody;
     this.client = new OpenAI({
       apiKey,
       ...baseURL ? { baseURL } : {}
@@ -245,16 +301,57 @@ var OpenAICompatibleProvider = class {
   async generate(prompt, systemInstruction) {
     const messages = [];
     if (systemInstruction) {
-      messages.push({ role: "system", content: systemInstruction });
+      const isOSeries = /^o[13]/.test(this.modelName);
+      const role = isOSeries ? "developer" : this.systemRole;
+      messages.push({ role, content: systemInstruction });
     }
     messages.push({ role: "user", content: prompt });
     const completion = await this.client.chat.completions.create({
       model: this.modelName,
-      messages
+      messages,
+      ...this.extraBody ? { extra_body: this.extraBody } : {}
     });
     return completion.choices[0].message.content ?? "";
   }
 };
+var MiMoProvider = class {
+  providerName = "mimo";
+  modelName;
+  apiKey;
+  baseUrl = "https://api.xiaomimimo.com/anthropic/v1/messages";
+  constructor(apiKey, modelName = PROVIDER_CATALOG.mimo.models[0]) {
+    this.apiKey = apiKey;
+    this.modelName = modelName;
+  }
+  async generate(prompt, systemInstruction) {
+    const body = {
+      model: this.modelName,
+      max_tokens: 16384,
+      messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
+      top_p: 0.95,
+      stream: false,
+      temperature: 1,
+      stop_sequences: null
+    };
+    if (systemInstruction) {
+      body.system = systemInstruction;
+    }
+    const response = await axios.post(this.baseUrl, body, {
+      headers: {
+        "api-key": this.apiKey,
+        "Content-Type": "application/json"
+      }
+    });
+    const data = response.data;
+    const blocks = data?.content ?? [];
+    const textBlock = blocks.find((b) => b.type === "text");
+    if (textBlock?.text) return textBlock.text;
+    if (data?.stop_reason === "max_tokens") {
+      throw new Error(`MiMo response truncated (max_tokens reached). The prompt may be too long. Try a shorter spec or switch to a model with larger context.`);
+    }
+    throw new Error(`Unexpected MiMo response: ${JSON.stringify(response.data).slice(0, 200)}`);
+  }
+};
 function createProvider(providerName, apiKey, modelName) {
   const meta = PROVIDER_CATALOG[providerName];
   if (!meta) {
@@ -268,9 +365,18 @@ function createProvider(providerName, apiKey, modelName) {
       return new GeminiProvider(apiKey, model);
     case "claude":
       return new ClaudeProvider(apiKey, model);
-    // All OpenAI-compatible providers (openai, qwen, minimax, glm)
+    case "mimo":
+      return new MiMoProvider(apiKey, model);
+    // All OpenAI-compatible providers: openai, deepseek, qwen, glm, minimax, doubao
     default:
-      return new OpenAICompatibleProvider(providerName, apiKey, model, meta.baseURL);
+      return new OpenAICompatibleProvider(
+        providerName,
+        apiKey,
+        model,
+        meta.baseURL,
+        meta.systemRole ?? "system",
+        meta.extraBody
+      );
   }
 }
 var SpecGenerator = class {
@@ -320,8 +426,8 @@ ${context.schema.slice(0, 3e3)}`);
 };
 
 // core/context-loader.ts
-import * as fs2 from "fs-extra";
-import * as path from "path";
+import * as fs3 from "fs-extra";
+import * as path2 from "path";
 
 // node_modules/glob/dist/esm/index.min.js
 import { fileURLToPath as Wi } from "url";
@@ -3307,7 +3413,48 @@ var Ui = Object.assign(ts, { stream: Bt, iterate: Ut });
 var Ze = Object.assign(Je, { glob: Je, globSync: ts, sync: Ui, globStream: Qe, stream: Ii, globStreamSync: Bt, streamSync: ji, globIterate: es, iterate: Bi, globIterateSync: Ut, iterateSync: zi, Glob: I, hasMagic: le, escape: tt, unescape: W });
 Ze.glob = Ze;
 
+// core/global-constitution.ts
+import * as fs2 from "fs-extra";
+import * as path from "path";
+import * as os2 from "os";
+var GLOBAL_CONSTITUTION_FILE = ".ai-spec-global-constitution.md";
+var SEARCH_ROOTS = [
+  // Workspace root is injected at runtime — see loadGlobalConstitution()
+  os2.homedir()
+];
+async function loadGlobalConstitution(extraRoots = []) {
+  const roots = [...extraRoots, ...SEARCH_ROOTS];
+  for (const root of roots) {
+    const filePath = path.join(root, GLOBAL_CONSTITUTION_FILE);
+    if (await fs2.pathExists(filePath)) {
+      const content = await fs2.readFile(filePath, "utf-8");
+      return { content, source: filePath };
+    }
+  }
+  return null;
+}
+function mergeConstitutions(globalContent, projectContent) {
+  const parts = [
+    "<!-- BEGIN GLOBAL CONSTITUTION (team baseline \u2014 lower priority) -->",
+    globalContent.trim(),
+    "<!-- END GLOBAL CONSTITUTION -->"
+  ];
+  if (projectContent && projectContent.trim()) {
+    parts.push(
+      "",
+      "<!-- BEGIN PROJECT CONSTITUTION (project-specific \u2014 HIGHER priority, overrides global) -->",
+      projectContent.trim(),
+      "<!-- END PROJECT CONSTITUTION -->"
+    );
+  }
+  return parts.join("\n");
+}
+
 // core/context-loader.ts
+var FRONTEND_FRAMEWORKS = ["react", "vue", "next", "nuxt", "react-native", "expo", "svelte", "solid-js", "qwik"];
+function isFrontendDeps(deps) {
+  return deps.some((d) => FRONTEND_FRAMEWORKS.includes(d));
+}
 var STACK_MAP = {
   react: "React",
   vue: "Vue",
@@ -3341,21 +3488,150 @@ var ContextLoader = class {
       apiStructure: []
     };
     try {
-      await this.loadPackageJson(context);
-      await this.loadPrismaSchema(context);
+      const isPhp = await fs3.pathExists(path2.join(this.projectRoot, "composer.json"));
+      const isJava = await fs3.pathExists(path2.join(this.projectRoot, "pom.xml")) || await fs3.pathExists(path2.join(this.projectRoot, "build.gradle")) || await fs3.pathExists(path2.join(this.projectRoot, "build.gradle.kts"));
+      if (isPhp) {
+        await this.loadComposerJson(context);
+        await this.loadPhpRoutes(context);
+      } else if (isJava) {
+        await this.loadMavenOrGradle(context);
+        await this.loadJavaApiStructure(context);
+      } else {
+        await this.loadPackageJson(context);
+        await this.loadPrismaSchema(context);
+      }
       await this.loadFileStructure(context);
       await this.loadApiStructure(context);
       await this.loadConstitution(context);
       await this.loadErrorPatterns(context);
+      await this.loadSharedConfigFiles(context);
     } catch (e) {
       console.warn("Warning: Could not load full project context.", e);
     }
     return context;
   }
+  /** Load PHP project context from composer.json */
+  async loadComposerJson(context) {
+    const composerPath = path2.join(this.projectRoot, "composer.json");
+    let composer = {};
+    try {
+      composer = await fs3.readJson(composerPath);
+    } catch {
+      return;
+    }
+    const require2 = composer.require ?? {};
+    const requireDev = composer["require-dev"] ?? {};
+    context.dependencies = [...Object.keys(require2), ...Object.keys(requireDev)];
+    const stack = /* @__PURE__ */ new Set();
+    stack.add("PHP");
+    if (require2["laravel/lumen-framework"]) stack.add("Lumen");
+    if (require2["laravel/framework"]) stack.add("Laravel");
+    if (require2["symfony/framework-bundle"]) stack.add("Symfony");
+    if (require2["slim/slim"]) stack.add("Slim");
+    if (require2["illuminate/database"] || require2["laravel/lumen-framework"]) stack.add("Eloquent ORM");
+    if (require2["doctrine/orm"]) stack.add("Doctrine ORM");
+    if (require2["tymon/jwt-auth"]) stack.add("JWT Auth");
+    if (require2["league/fractal"] || require2["spatie/laravel-fractal"]) stack.add("Fractal (Transformers)");
+    const phpVersion = require2["php"];
+    if (phpVersion) stack.add(`PHP ${phpVersion}`);
+    context.techStack = Array.from(stack);
+  }
+  /**
+   * Load PHP route files (routes/api.php, routes/web.php) as routeSummary.
+   * Lumen uses these files to register API endpoints.
+   */
+  async loadPhpRoutes(context) {
+    const routeFiles = ["routes/api.php", "routes/web.php"];
+    const parts = [];
+    for (const rel of routeFiles) {
+      const fullPath = path2.join(this.projectRoot, rel);
+      if (!await fs3.pathExists(fullPath)) continue;
+      try {
+        const content = await fs3.readFile(fullPath, "utf-8");
+        parts.push(`// ${rel}
+${content.slice(0, 1500)}`);
+      } catch {
+      }
+    }
+    if (parts.length > 0) {
+      context.routeSummary = parts.join("\n\n");
+    }
+    const controllerFiles = await Ze("app/Http/Controllers/**/*.php", {
+      cwd: this.projectRoot,
+      ignore: ["vendor/**"]
+    });
+    context.apiStructure = controllerFiles.slice(0, 20);
+  }
+  /** Load Java project context from pom.xml or build.gradle */
+  async loadMavenOrGradle(context) {
+    const pomPath = path2.join(this.projectRoot, "pom.xml");
+    const gradlePath = path2.join(this.projectRoot, "build.gradle");
+    const gradleKtsPath = path2.join(this.projectRoot, "build.gradle.kts");
+    const stack = /* @__PURE__ */ new Set(["Java"]);
+    const deps = [];
+    if (await fs3.pathExists(pomPath)) {
+      try {
+        const xml = await fs3.readFile(pomPath, "utf-8");
+        const artifactIds = [...xml.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)].map((m) => m[1].trim()).filter((id, i) => i > 0);
+        deps.push(...artifactIds);
+        const javaVerMatch = xml.match(/<maven\.compiler\.source>(\d+)<\/maven\.compiler\.source>/);
+        if (javaVerMatch) stack.add(`Java ${javaVerMatch[1]}`);
+        if (deps.some((d) => d.includes("spring-boot"))) stack.add("Spring Boot");
+        if (deps.some((d) => d.includes("spring-web") || d.includes("spring-webmvc"))) stack.add("Spring MVC");
+        if (deps.some((d) => d.includes("mybatis"))) stack.add("MyBatis");
+        if (deps.some((d) => d.includes("hibernate") || d.includes("spring-data-jpa"))) stack.add("JPA/Hibernate");
+        if (deps.some((d) => d.includes("dubbo"))) stack.add("Dubbo");
+        if (deps.some((d) => d.includes("rocketmq"))) stack.add("RocketMQ");
+        if (deps.some((d) => d.includes("kafka"))) stack.add("Kafka");
+        if (deps.some((d) => d.includes("redis"))) stack.add("Redis");
+        if (deps.some((d) => d.includes("lombok"))) stack.add("Lombok");
+        if (deps.some((d) => d.includes("feign") || d.includes("openfeign"))) stack.add("OpenFeign");
+        if (deps.some((d) => d.includes("nacos"))) stack.add("Nacos");
+        if (deps.some((d) => d.includes("sentinel"))) stack.add("Sentinel");
+      } catch {
+      }
+    } else {
+      const gradleFile = await fs3.pathExists(gradleKtsPath) ? gradleKtsPath : gradlePath;
+      try {
+        const content = await fs3.readFile(gradleFile, "utf-8");
+        const depMatches = [...content.matchAll(/['"]([a-zA-Z0-9._-]+):([a-zA-Z0-9._-]+):[^'"]+['"]/g)];
+        deps.push(...depMatches.map((m) => m[2]));
+        if (deps.some((d) => d.includes("spring-boot"))) stack.add("Spring Boot");
+        if (deps.some((d) => d.includes("mybatis"))) stack.add("MyBatis");
+      } catch {
+      }
+    }
+    context.techStack = Array.from(stack);
+    context.dependencies = [...new Set(deps)];
+  }
+  /** Scan Java controller files for API structure */
+  async loadJavaApiStructure(context) {
+    const controllerFiles = await Ze("**/src/main/java/**/*Controller.java", {
+      cwd: this.projectRoot,
+      ignore: ["**/target/**"]
+    });
+    context.apiStructure = controllerFiles.slice(0, 30);
+    const propFiles = await Ze("**/src/main/resources/application.{properties,yml,yaml}", {
+      cwd: this.projectRoot,
+      ignore: ["**/target/**"]
+    });
+    if (propFiles.length > 0 && !context.routeSummary) {
+      const parts = [];
+      for (const f of propFiles.slice(0, 2)) {
+        try {
+          const content = await fs3.readFile(path2.join(this.projectRoot, f), "utf-8");
+          parts.push(`// ${f}
+${content.slice(0, 800)}`);
+        } catch {
+        }
+      }
+      if (parts.length > 0) context.routeSummary = parts.join("\n\n");
+    }
+  }
   async loadPackageJson(context) {
-    const pkgPath = path.join(this.projectRoot, "package.json");
-    if (!await fs2.pathExists(pkgPath)) return;
-    const pkg = await fs2.readJson(pkgPath);
+    const pkgPath = path2.join(this.projectRoot, "package.json");
+    if (!await fs3.pathExists(pkgPath)) return;
+    const pkg = await fs3.readJson(pkgPath);
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     context.dependencies = Object.keys(allDeps);
     const detectedStack = /* @__PURE__ */ new Set();
@@ -3367,9 +3643,9 @@ var ContextLoader = class {
     context.techStack = Array.from(detectedStack);
   }
   async loadPrismaSchema(context) {
-    const schemaPath = path.join(this.projectRoot, "prisma", "schema.prisma");
-    if (await fs2.pathExists(schemaPath)) {
-      context.schema = await fs2.readFile(schemaPath, "utf-8");
+    const schemaPath = path2.join(this.projectRoot, "prisma", "schema.prisma");
+    if (await fs3.pathExists(schemaPath)) {
+      context.schema = await fs3.readFile(schemaPath, "utf-8");
     }
   }
   async loadFileStructure(context) {
@@ -3377,21 +3653,30 @@ var ContextLoader = class {
       cwd: this.projectRoot,
       ignore: [
         "node_modules/**",
+        "vendor/**",
         "dist/**",
+        "build/**",
         ".git/**",
         "coverage/**",
         "*.lock",
-        ".DS_Store"
+        ".DS_Store",
+        "**/*.min.js",
+        "**/*.map"
       ],
       nodir: false,
-      maxDepth: 3
+      maxDepth: 5
     });
-    context.fileStructure = files.slice(0, 60);
+    context.fileStructure = files.slice(0, 120);
   }
   async loadConstitution(context) {
-    const filePath = path.join(this.projectRoot, ".ai-spec-constitution.md");
-    if (await fs2.pathExists(filePath)) {
-      context.constitution = await fs2.readFile(filePath, "utf-8");
+    const projectFile = path2.join(this.projectRoot, ".ai-spec-constitution.md");
+    const projectConstitution = await fs3.pathExists(projectFile) ? await fs3.readFile(projectFile, "utf-8") : void 0;
+    const workspaceRoot = path2.dirname(this.projectRoot);
+    const globalResult = await loadGlobalConstitution([workspaceRoot]);
+    if (globalResult) {
+      context.constitution = mergeConstitutions(globalResult.content, projectConstitution);
+    } else if (projectConstitution) {
+      context.constitution = projectConstitution;
     }
   }
   async loadErrorPatterns(context) {
@@ -3402,12 +3687,16 @@ var ContextLoader = class {
     const middlewareErrors = await Ze("src/**/middleware/**/{error,notFound}.{ts,js}", {
       cwd: this.projectRoot
     });
-    const allErrorFiles = [.../* @__PURE__ */ new Set([...errorFiles, ...middlewareErrors])].slice(0, 3);
+    const phpErrorFiles = await Ze(
+      "app/Exceptions/{Handler,ErrorHandler}.php",
+      { cwd: this.projectRoot, ignore: ["vendor/**"] }
+    );
+    const allErrorFiles = [.../* @__PURE__ */ new Set([...errorFiles, ...middlewareErrors, ...phpErrorFiles])].slice(0, 3);
     if (allErrorFiles.length === 0) return;
     const parts = [];
     for (const f of allErrorFiles) {
       try {
-        const content = await fs2.readFile(path.join(this.projectRoot, f), "utf-8");
+        const content = await fs3.readFile(path2.join(this.projectRoot, f), "utf-8");
         parts.push(`// ${f}
 ${content.slice(0, 800)}`);
       } catch {
@@ -3417,6 +3706,70 @@ ${content.slice(0, 800)}`);
       context.errorPatterns = parts.join("\n\n");
     }
   }
+  /**
+   * Scan for "singleton" config files that should never be duplicated.
+   * These are append-only files: i18n bundles, constants, enums, config indices.
+   */
+  async loadSharedConfigFiles(context) {
+    const patterns = [
+      // i18n / locales
+      { glob: "src/locales/**/*.{json,ts,js}", category: "i18n" },
+      { glob: "src/i18n/**/*.{json,ts,js}", category: "i18n" },
+      { glob: "locales/**/*.{json,ts,js}", category: "i18n" },
+      { glob: "public/locales/**/*.{json,ts,js}", category: "i18n" },
+      // constants / enums
+      { glob: "src/constants/**/*.{ts,js}", category: "constants" },
+      { glob: "src/enums/**/*.{ts,js}", category: "enums" },
+      { glob: "src/**/constants.{ts,js}", category: "constants" },
+      { glob: "src/**/enums.{ts,js}", category: "enums" },
+      // config
+      { glob: "src/config/**/*.{ts,js}", category: "config" },
+      // ── Route registration files ────────────────────────────────────────────
+      // Node.js / Express
+      { glob: "src/routes/**/index.{ts,js}", category: "route-index" },
+      { glob: "src/routes/index.{ts,js}", category: "route-index" },
+      // Vue Router — root index and modules pattern
+      { glob: "src/router/index.{ts,js}", category: "route-index" },
+      { glob: "src/router/routes.{ts,js}", category: "route-index" },
+      { glob: "src/router/modules/**/*.{ts,js}", category: "route-index" },
+      // React Router — standalone routes file or App entry
+      { glob: "src/routes.{ts,tsx,js,jsx}", category: "route-index" },
+      { glob: "src/router.{ts,tsx,js,jsx}", category: "route-index" },
+      // PHP (Lumen / Laravel)
+      { glob: "routes/api.php", category: "route-index" },
+      { glob: "routes/web.php", category: "route-index" },
+      // ── Store registration files ────────────────────────────────────────────
+      // Pinia / Vuex index
+      { glob: "src/stores/index.{ts,js}", category: "store-index" },
+      { glob: "src/store/index.{ts,js}", category: "store-index" },
+      { glob: "src/store/modules/index.{ts,js}", category: "store-index" },
+      // Redux root reducer / store setup
+      { glob: "src/store/rootReducer.{ts,js}", category: "store-index" },
+      { glob: "src/store/store.{ts,js}", category: "store-index" },
+      { glob: "src/app/store.{ts,js}", category: "store-index" }
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const { glob: pattern, category } of patterns) {
+      const files = await Ze(pattern, {
+        cwd: this.projectRoot,
+        ignore: ["node_modules/**", "dist/**", "**/*.test.*", "**/*.spec.*"]
+      });
+      for (const filePath of files) {
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        try {
+          const content = await fs3.readFile(path2.join(this.projectRoot, filePath), "utf-8");
+          const preview = content.split("\n").slice(0, 120).join("\n");
+          results.push({ path: filePath, preview, category });
+        } catch {
+        }
+      }
+    }
+    if (results.length > 0) {
+      context.sharedConfigFiles = results;
+    }
+  }
   async loadApiStructure(context) {
     const apiFiles = await Ze(
       "src/**/{routes,controllers,api,router,middleware}/**/*.{ts,js}",
@@ -3432,9 +3785,9 @@ ${content.slice(0, 800)}`);
     if (context.apiStructure.length > 0) {
       const summaryParts = [];
       for (const filePath of context.apiStructure.slice(0, 8)) {
-        const fullPath = path.join(this.projectRoot, filePath);
+        const fullPath = path2.join(this.projectRoot, filePath);
         try {
-          const content = await fs2.readFile(fullPath, "utf-8");
+          const content = await fs3.readFile(fullPath, "utf-8");
           const preview = content.split("\n").slice(0, 60).join("\n");
           summaryParts.push(`\`\`\`
 // ${filePath}
@@ -3452,7 +3805,99 @@ ${preview}
 
 // core/spec-refiner.ts
 import { editor, confirm, select } from "@inquirer/prompts";
+import chalk2 from "chalk";
+
+// core/spec-versioning.ts
 import chalk from "chalk";
+import * as fs4 from "fs-extra";
+function computeDiff(oldText, newText) {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const m = oldLines.length;
+  const n7 = newLines.length;
+  const MAX = 800;
+  if (m > MAX || n7 > MAX) {
+    return computeSimpleDiff(oldLines, newLines);
+  }
+  const dp = Array.from({ length: m + 1 }, () => new Array(n7 + 1).fill(0));
+  for (let i2 = m - 1; i2 >= 0; i2--) {
+    for (let j3 = n7 - 1; j3 >= 0; j3--) {
+      if (oldLines[i2] === newLines[j3]) {
+        dp[i2][j3] = dp[i2 + 1][j3 + 1] + 1;
+      } else {
+        dp[i2][j3] = Math.max(dp[i2 + 1][j3], dp[i2][j3 + 1]);
+      }
+    }
+  }
+  const lines = [];
+  let i = 0, j2 = 0, lineNo = 1;
+  while (i < m || j2 < n7) {
+    if (i < m && j2 < n7 && oldLines[i] === newLines[j2]) {
+      lines.push({ type: "unchanged", content: oldLines[i], lineNo: lineNo++ });
+      i++;
+      j2++;
+    } else if (j2 < n7 && (i >= m || dp[i + 1][j2] <= dp[i][j2 + 1])) {
+      lines.push({ type: "added", content: newLines[j2], lineNo: lineNo++ });
+      j2++;
+    } else {
+      lines.push({ type: "removed", content: oldLines[i], lineNo });
+      i++;
+    }
+  }
+  const added = lines.filter((l) => l.type === "added").length;
+  const removed = lines.filter((l) => l.type === "removed").length;
+  const unchanged = lines.filter((l) => l.type === "unchanged").length;
+  return { added, removed, unchanged, lines };
+}
+function computeSimpleDiff(oldLines, newLines) {
+  const lines = [
+    ...oldLines.map((c, i) => ({ type: "removed", content: c, lineNo: i + 1 })),
+    ...newLines.map((c, i) => ({ type: "added", content: c, lineNo: i + 1 }))
+  ];
+  return { added: newLines.length, removed: oldLines.length, unchanged: 0, lines };
+}
+var CONTEXT_LINES = 3;
+function printDiff(diff) {
+  if (diff.added === 0 && diff.removed === 0) {
+    console.log(chalk.gray("  (no changes)"));
+    return;
+  }
+  const { lines } = diff;
+  const changedIdxs = new Set(
+    lines.map((l, i) => l.type !== "unchanged" ? i : -1).filter((i) => i !== -1)
+  );
+  const toShow = /* @__PURE__ */ new Set();
+  for (const idx of changedIdxs) {
+    for (let k2 = Math.max(0, idx - CONTEXT_LINES); k2 <= Math.min(lines.length - 1, idx + CONTEXT_LINES); k2++) {
+      toShow.add(k2);
+    }
+  }
+  const sorted = [...toShow].sort((a, b) => a - b);
+  let prevIdx = -2;
+  for (const idx of sorted) {
+    if (idx > prevIdx + 1 && prevIdx !== -2) {
+      console.log(chalk.cyan("  @@"));
+    }
+    const l = lines[idx];
+    if (l.type === "added") {
+      console.log(chalk.green(`  + ${l.content}`));
+    } else if (l.type === "removed") {
+      console.log(chalk.red(`  - ${l.content}`));
+    } else {
+      console.log(chalk.gray(`    ${l.content}`));
+    }
+    prevIdx = idx;
+  }
+}
+function printDiffSummary(diff, label) {
+  const parts = [];
+  if (diff.added > 0) parts.push(chalk.green(`+${diff.added}`));
+  if (diff.removed > 0) parts.push(chalk.red(`-${diff.removed}`));
+  if (parts.length === 0) parts.push(chalk.gray("no change"));
+  console.log(chalk.bold(`  ${label}: `) + parts.join("  ") + chalk.gray(` lines`));
+}
+
+// core/spec-refiner.ts
 var SpecRefiner = class {
   constructor(provider) {
     this.provider = provider;
@@ -3461,16 +3906,16 @@ var SpecRefiner = class {
     let currentSpec = initialSpec;
     let round = 1;
     while (true) {
-      console.log(chalk.cyan(`
+      console.log(chalk2.cyan(`
 \u2500\u2500\u2500 Spec Review (Round ${round}) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
-      console.log(chalk.gray("  Opening spec in editor. Save and close to continue."));
+      console.log(chalk2.gray("  Opening spec in editor. Save and close to continue."));
       currentSpec = await editor({
         message: "Review and edit the spec:",
         default: currentSpec,
         postfix: ".md",
         waitForUserInput: false
       });
-      console.log(chalk.green("  \u2714 Spec saved."));
+      console.log(chalk2.green("  \u2714 Spec saved."));
       const action = await select({
         message: "What would you like to do?",
         choices: [
@@ -3483,7 +3928,7 @@ var SpecRefiner = class {
         break;
       }
       if (action === "ai") {
-        console.log(chalk.blue(`  AI (${this.provider.providerName}/${this.provider.modelName}) is polishing the spec...`));
+        console.log(chalk2.blue(`  AI (${this.provider.providerName}/${this.provider.modelName}) is polishing the spec...`));
         try {
           const improved = await this.provider.generate(
             `Review the following feature spec and improve it for clarity, completeness, and technical feasibility.
@@ -3493,25 +3938,30 @@ Output ONLY the improved markdown spec, nothing else.
 ${currentSpec}`,
             "You are a Senior Tech Lead doing a spec review. Output only the improved Markdown."
           );
-          console.log(chalk.yellow("\n  AI has suggested improvements. Opening diff in editor..."));
+          console.log(chalk2.yellow("\n  AI has suggested improvements. Opening diff in editor..."));
           const acceptImproved = await confirm({
             message: "Accept AI improvements? (opens editor so you can review first)",
             default: true
           });
           if (acceptImproved) {
+            const diff = computeDiff(currentSpec, improved);
+            console.log(chalk2.cyan("\n  \u2500\u2500 AI Changes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+            printDiffSummary(diff, "AI edits");
+            printDiff(diff);
+            console.log(chalk2.cyan("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
             currentSpec = await editor({
               message: "Review AI-improved spec (edit if needed, then save):",
               default: improved,
               postfix: ".md",
               waitForUserInput: false
             });
-            console.log(chalk.green("  \u2714 AI-improved spec accepted."));
+            console.log(chalk2.green("  \u2714 AI-improved spec accepted."));
           } else {
-            console.log(chalk.gray("  AI improvements discarded. Keeping your version."));
+            console.log(chalk2.gray("  AI improvements discarded. Keeping your version."));
           }
         } catch (err) {
-          console.error(chalk.red("  AI improvement failed:"), err);
-          console.log(chalk.gray("  Continuing with current spec."));
+          console.error(chalk2.red("  AI improvement failed:"), err);
+          console.log(chalk2.gray("  Continuing with current spec."));
         }
       }
       round++;
@@ -3521,10 +3971,10 @@ ${currentSpec}`,
 };
 
 // core/code-generator.ts
-import chalk3 from "chalk";
+import chalk6 from "chalk";
 import { execSync } from "child_process";
-import * as path3 from "path";
-import * as fs4 from "fs-extra";
+import * as path6 from "path";
+import * as fs8 from "fs-extra";
 
 // prompts/codegen.prompt.ts
 var codeGenSystemPrompt = `You are a Senior Full-Stack Developer implementing features based on provided specifications.
@@ -3535,30 +3985,217 @@ Rules:
 3. Include proper error handling, input validation, and logging
 4. Output ONLY raw code content \u2014 NO markdown fences, NO explanations, NO comments outside the code
 5. Match the imports, exports, and module patterns visible in the existing codebase
-6. Do not add unnecessary dependencies \u2014 reuse what is already in the project
-7. If modifying an existing file, preserve all unchanged code exactly`;
-var reviewSystemPrompt = `You are a Senior Software Architect conducting a thorough code review. Your review should be structured, constructive, and specific.
+6. If modifying an existing file, preserve all unchanged code exactly \u2014 return the FULL file content with only the new additions merged in
+
+CRITICAL \u2014 Dependency Hallucination Prevention (MUST follow):
+7. You will be given an "=== Installed Packages ===" section listing ALL packages available in this project.
+   NEVER import or use ANY package, library, or module that does not appear in that list.
+   This includes (but is not limited to): i18n libraries, UI component libraries, utility libraries, state management libraries.
+   If a feature would normally need a missing library, implement the equivalent functionality using only what IS installed.
+   Violating this rule will break the project and is unacceptable.
+
+CRITICAL \u2014 File Reuse Rules:
+8. NEVER create a new file if an existing file serves the same purpose. Check the shared config file list before planning any new file.
+9. i18n / locale files: ONLY add translation keys if an i18n file already exists in the project. If no i18n/locale files are listed in "Installed Packages" or shared config files, do NOT add any i18n code.
+10. constants / enums files: ALWAYS add new values to the EXISTING constants or enums file. Never create a new parallel file.
+11. When in doubt: prefer "modify existing" over "create new".
+
+CRITICAL \u2014 Component Reuse (MUST follow):
+12. Before writing any UI component or element: check the "Existing reusable components" list in the context.
+    If a component serving the same purpose already exists in src/components/, import and use it \u2014 do NOT create a duplicate.
+13. Check the "Existing page examples" for how the project's UI library components (e.g. antd, element-plus, arco-design) are actually used.
+    Copy those exact component names and import patterns. Do NOT use generic HTML elements where the UI library already provides a component.
+
+CRITICAL \u2014 Frontend Architecture Layer Separation (MUST follow):
+14. State management stores (Pinia, Vuex, Redux, Zustand) MUST NOT make HTTP requests directly.
+    Stores call functions from the API layer (src/api/ or src/apis/). The API layer makes HTTP requests.
+    If the existing store patterns in the context show no HTTP calls, do not add any.
+13. API files import the HTTP client using ONLY the exact import line shown in "HTTP client import" in the context.
+    NEVER invent a different import path (e.g., '@/utils/request', '@/utils/http') unless that exact path appears in the provided context.
+
+CRITICAL \u2014 Learn conventions from examples, do not invent them:
+15. The "=== Existing Shared Config Files ===" section below shows real files from the project.
+    Study them carefully and match their exact structure, naming conventions, and patterns.
+    - Router files: replicate the exact same file structure, path naming, and registration approach you see.
+    - Store files: replicate the exact module pattern shown.
+    - Do NOT apply generic framework defaults (e.g., Vue Router docs examples) if the project shows a different convention.
+    - If you see a modules/ directory pattern in the examples, follow it. If you see a flat file pattern, follow that instead.
+    The examples are ground truth. Your prior knowledge about "typical" project layouts is secondary.
+
+CRITICAL \u2014 Route/Store index registration (MUST follow):
+16. When creating a new route module file (e.g., src/router/routes/taskManagement.ts), you MUST ALSO update
+    the corresponding index file (src/router/routes/index.ts) to import the new module and add it to the export array.
+    This is non-negotiable. A route module that is not registered in the index will never be loaded.
+    Pattern: add "import taskManagement from './taskManagement'" at the top and "taskManagement" inside the "export default [...]".
+
+CRITICAL \u2014 Cross-file function name consistency (MUST follow):
+17. When you see an "=== Files Already Generated in This Run ===" section, those file contents are the AUTHORITATIVE source
+    of truth for exported function/variable names.
+    NEVER rename, guess, or substitute alternative names. If the file exports "getTaskList", import "getTaskList" \u2014 not "getTasks".
+    If no such section is present, derive function names strictly from the DSL endpoint IDs shown in the spec.`;
+var codeGenGoSystemPrompt = `You are a Senior Go Developer implementing features based on provided specifications.
+
+Rules:
+1. Follow standard Go project layout (cmd/, internal/, pkg/, api/). Match whatever layout already exists in the project.
+2. Write idiomatic Go \u2014 use named return errors, defer for cleanup, context propagation, structured logging (slog or zap if present).
+3. Write complete, production-ready code \u2014 no placeholders, no TODOs, no stub implementations.
+4. Output ONLY raw Go code \u2014 NO markdown fences, NO explanations.
+5. Use Go modules (go.mod already exists). Never add a dependency without checking go.mod first.
+6. Error handling: always return errors up the call stack. Never ignore errors with _.
+7. If modifying an existing file, preserve all unchanged code exactly \u2014 return the FULL file content.
+8. HTTP handlers: match the existing router pattern (net/http ServeMux, gorilla/mux, chi, gin, echo \u2014 use whatever is in go.mod).
+9. Tests: use the standard testing package + testify/assert if already in go.mod.
+
+CRITICAL \u2014 File Reuse Rules:
+10. NEVER create a parallel package if an existing one serves the purpose.
+11. Register routes/handlers in the EXISTING router setup file.
+12. Add new model structs to the EXISTING models file if one exists.`;
+var codeGenPythonSystemPrompt = `You are a Senior Python Developer implementing features based on provided specifications.
+
+Rules:
+1. Follow PEP 8 and PEP 20. Match the code style visible in the existing codebase.
+2. Detect and match the existing framework: FastAPI, Flask, Django, or plain scripts.
+3. Write complete, production-ready code \u2014 no placeholders, no TODOs, no stub implementations.
+4. Output ONLY raw Python code \u2014 NO markdown fences, NO explanations.
+5. Use type annotations (Python 3.10+ style). Use Pydantic models if FastAPI is detected.
+6. Error handling: raise HTTPException (FastAPI/Flask) or domain exceptions \u2014 never swallow errors.
+7. If modifying an existing file, preserve all unchanged code exactly \u2014 return the FULL file content.
+8. Dependency management: only use packages already in requirements.txt / pyproject.toml.
+9. FastAPI: use APIRouter for new endpoints and include it in the main app router.
+10. Django: follow MVT pattern, register URLs in urls.py.
+
+CRITICAL \u2014 File Reuse Rules:
+11. NEVER create a parallel module if an existing one serves the purpose.
+12. Register new routes/views in the EXISTING urls.py / router.py.
+13. Add new models to the EXISTING models.py if it exists \u2014 do not create a parallel models file.`;
+var codeGenJavaSystemPrompt = `You are a Senior Java Developer implementing features based on provided specifications.
+
+Rules:
+1. Detect and match the existing framework: Spring Boot, Micronaut, or Quarkus.
+2. Follow standard layered architecture: Controller \u2192 Service \u2192 Repository. Match existing package names.
+3. Write complete, production-ready code \u2014 no placeholders, no TODOs.
+4. Output ONLY raw Java code \u2014 NO markdown fences, NO explanations.
+5. Use constructor injection (@Autowired on constructor, not field injection).
+6. Exception handling: use @ControllerAdvice / @ExceptionHandler if already present. Never swallow exceptions.
+7. If modifying an existing file, preserve all unchanged code exactly \u2014 return the FULL file content.
+8. Use Lombok if already in pom.xml / build.gradle (@Data, @Builder, etc.).
+
+CRITICAL \u2014 File Reuse Rules:
+9. Register new endpoints in the EXISTING Controller class if one covers the same resource.
+10. Add new repository methods to the EXISTING Repository interface \u2014 never create a parallel one.`;
+var codeGenRustSystemPrompt = `You are a Senior Rust Developer implementing features based on provided specifications.
+
+Rules:
+1. Detect and match the existing web framework: Axum, Actix-web, Warp, or Rocket.
+2. Write idiomatic Rust \u2014 use Result<T,E> everywhere, no unwrap() in production paths, use ? operator.
+3. Write complete, production-ready code \u2014 no placeholders, no TODOs.
+4. Output ONLY raw Rust code \u2014 NO markdown fences, NO explanations.
+5. Follow existing module structure (mod declarations in lib.rs / main.rs).
+6. Use existing crates from Cargo.toml only \u2014 do not add new dependencies.
+7. If modifying an existing file, preserve all unchanged code exactly \u2014 return the FULL file content.
+8. Async: use tokio if already in Cargo.toml. Match existing async patterns.
+
+CRITICAL \u2014 File Reuse Rules:
+9. Register new routes in the EXISTING router setup (match pattern in main.rs or router.rs).
+10. Add new model structs to the EXISTING models.rs / types.rs \u2014 never create a parallel file.`;
+var codeGenPhpSystemPrompt = `You are a Senior PHP Developer implementing features based on provided specifications.
+
+Rules:
+1. Detect and match the existing framework: Lumen, Laravel, or plain PHP. Follow its directory conventions (app/Http/Controllers, app/Models, routes/web.php / routes/api.php).
+2. Write clean, PSR-12 compliant PHP 8.x code. Use typed properties, constructor promotion, named arguments, and match expressions where appropriate.
+3. Write complete, production-ready code \u2014 no placeholders, no TODOs, no stub implementations.
+4. Output ONLY raw PHP code \u2014 NO markdown fences, NO explanations.
+5. Use Eloquent ORM if already present. Never introduce raw SQL when Eloquent is available.
+6. Lumen: register routes in routes/web.php or routes/api.php. Laravel: use resource controllers and Route::apiResource where suitable.
+7. Error handling: throw proper HTTP exceptions (e.g. Illuminate\\Http\\Exceptions\\HttpResponseException) and return JSON responses consistently.
+8. If modifying an existing file, preserve all unchanged code exactly \u2014 return the FULL file content.
+9. Only use Composer packages already listed in composer.json \u2014 never add new dependencies.
+
+CRITICAL \u2014 File Reuse Rules:
+10. Register new routes in the EXISTING routes/api.php (or routes/web.php) \u2014 never create a parallel routes file.
+11. Add new Eloquent model methods to the EXISTING Model class \u2014 never create a parallel model file.
+12. Add new service methods to the EXISTING service class if one already covers the same resource.`;
+function getCodeGenSystemPrompt(repoType) {
+  switch (repoType) {
+    case "go":
+      return codeGenGoSystemPrompt;
+    case "python":
+      return codeGenPythonSystemPrompt;
+    case "java":
+      return codeGenJavaSystemPrompt;
+    case "rust":
+      return codeGenRustSystemPrompt;
+    case "php":
+      return codeGenPhpSystemPrompt;
+    default:
+      return codeGenSystemPrompt;
+  }
+}
+var reviewArchitectureSystemPrompt = `You are a Senior Software Architect reviewing the HIGH-LEVEL design of a code change.
+
+Focus ONLY on:
+1. **Spec compliance** \u2014 Does the implementation match the spec? Are there missing or extra endpoints/components?
+2. **Layer separation** \u2014 Does each layer have the right responsibilities? (e.g., no business logic in controllers, no HTTP in stores)
+3. **API contract** \u2014 Are request/response shapes correct? Are all error codes from the spec implemented?
+4. **Data model integrity** \u2014 Are constraints, unique fields, and relationships correct?
+5. **Security posture** \u2014 Are auth checks applied to the right endpoints? Any obvious missing auth?
+
+DO NOT comment on:
+- Code style, naming conventions, formatting
+- Minor implementation details (variable names, inline comments)
+- Performance micro-optimizations
 
-Always format your review with these exact sections:
+Format:
+
+## \u{1F3D7} \u67B6\u6784\u5408\u89C4\u6027 (Spec Compliance)
+Does the implementation match the spec? List any missing or wrong endpoints/components.
+
+## \u{1F500} \u5C42\u804C\u8D23\u5206\u79BB (Layer Separation)
+Any layer boundary violations?
+
+## \u{1F512} \u5B89\u5168\u4E0E\u6743\u9650 (Security & Auth)
+Any missing auth checks, exposed data, or privilege issues?
+
+## \u{1F4CB} \u67B6\u6784\u8BC4\u5206 (Architecture Score)
+Score: X/10 \u2014 One short paragraph.
+
+Be specific. Reference file names or endpoint paths.`;
+var reviewImplementationSystemPrompt = `You are a Senior Engineer reviewing the IMPLEMENTATION DETAILS of a code change.
+
+An architecture review has already been completed (provided as context). Do NOT repeat its findings.
+
+Focus ONLY on:
+1. **Input validation** \u2014 Are all inputs validated before use? Missing length/format/type checks?
+2. **Error handling** \u2014 Are all error paths handled? Any unhandled promise rejections or uncaught exceptions?
+3. **Edge cases** \u2014 Null/undefined handling, empty arrays, boundary conditions?
+4. **Code patterns** \u2014 DRY violations, overly complex logic that could be simplified, missing abstractions?
+5. **Past issue recurrence** \u2014 Does the code repeat any known patterns flagged in previous reviews (provided as history context)?
+
+DO NOT repeat architecture-level findings already covered in the architecture review.
+
+Format:
 
 ## \u2705 \u4F18\u70B9 (What's Good)
-List specific things done well.
+Specific implementation strengths.
 
 ## \u26A0\uFE0F \u95EE\u9898 (Issues Found)
-List bugs, security issues, or spec deviations with line references.
+Bugs, missing validation, error handling gaps \u2014 with file:line references where possible.
+
+## \u{1F501} \u5386\u53F2\u95EE\u9898\u590D\u73B0 (Recurring Issues)
+Any issues that appeared in past reviews and are still present? (Only if history context is provided)
 
 ## \u{1F4A1} \u6539\u8FDB\u5EFA\u8BAE (Suggestions)
-Actionable improvements that would elevate code quality.
+Actionable, concrete improvements.
 
-## \u{1F4CA} \u603B\u4F53\u8BC4\u4EF7 (Overall Assessment)
-Score: X/10 \u2014 One-paragraph summary.
+## \u{1F4CA} \u7EFC\u5408\u8BC4\u5206 (Final Score)
+Score: X/10 \u2014 Combined architecture + implementation assessment in one paragraph.
 
 Be specific. Reference actual code, not vague principles.`;
 
 // core/task-generator.ts
-import chalk2 from "chalk";
-import * as fs3 from "fs-extra";
-import * as path2 from "path";
+import chalk3 from "chalk";
+import * as fs5 from "fs-extra";
+import * as path3 from "path";
 
 // prompts/tasks.prompt.ts
 var tasksSystemPrompt = `You are a Senior Software Architect. Decompose the provided Feature Spec into an ordered list of discrete implementation tasks.
@@ -3571,7 +4208,7 @@ Each task object must have these exact fields:
   "title": "...",             // short action phrase, e.g. "Add UserFavorite Prisma model"
   "description": "...",       // 1-2 sentences, specific and actionable
   "layer": "data|service|api|test|infra",  // implementation layer
-  "filesToTouch": ["..."],    // specific file paths relative to project root
+  "filesToTouch": ["..."],    // VERIFIED paths only \u2014 see rules below
   "acceptanceCriteria": ["..."],  // verifiable completion conditions
   "dependencies": ["TASK-001"],  // task ids that must complete first (empty array if none)
   "priority": "high|medium|low"
@@ -3584,14 +4221,64 @@ Layer ordering guidance (implement in this order):
 4. "api"     \u2014 controllers, routes, middleware, validators
 5. "test"    \u2014 unit tests, integration tests
 
-Rules:
-- Be specific about filesToTouch \u2014 use exact paths from the project context
+CRITICAL \u2014 filesToTouch Rules (hallucination prevention):
+- ONLY use paths that appear in the "Verified File Inventory" section of the prompt.
+- For NEW files that don't exist yet, derive the path by following the naming pattern of sibling files already in the inventory (same directory, same extension, same casing).
+- For EXISTING singleton files (i18n, constants, enums, route index), you MUST use the exact path from the inventory. NEVER invent a sub-path or nested variant.
+- If you are unsure of the exact path for a new file, leave it as "TBD:<description>" rather than guessing.
+- Cross-check: after writing all tasks, verify every path in filesToTouch exists in the inventory or is a logical new sibling. If it doesn't pass this check, fix it.
+
+Other rules:
 - acceptanceCriteria must be verifiable (not vague like "works correctly")
 - dependencies must reflect real implementation order
 - Aim for 4-10 tasks total \u2014 not too granular, not too coarse
 - Each task should be completable in one focused coding session`;
 
 // core/task-generator.ts
+function buildVerifiedInventory(context) {
+  const lines = ["=== Verified File Inventory (filesToTouch MUST use paths from here) ===\n"];
+  if (context.sharedConfigFiles && context.sharedConfigFiles.length > 0) {
+    lines.push("-- Shared Config Files (APPEND-ONLY \u2014 never create a parallel file) --");
+    for (const f of context.sharedConfigFiles) {
+      lines.push(`  [${f.category}] ${f.path}`);
+    }
+    lines.push("");
+  }
+  if (context.apiStructure.length > 0) {
+    lines.push("-- API / Route / Controller Files --");
+    for (const f of context.apiStructure.slice(0, 20)) {
+      lines.push(`  ${f}`);
+    }
+    lines.push("");
+  }
+  if (context.fileStructure.length > 0) {
+    lines.push("-- Project File Tree (first 60 entries) --");
+    for (const f of context.fileStructure.slice(0, 60)) {
+      lines.push(`  ${f}`);
+    }
+    lines.push("");
+  }
+  lines.push(
+    "REMINDER: If a needed file does not appear above and is NOT a new file, verify its path.\nFor i18n/locale files, constants, enums, or route indexes \u2014 use EXACTLY the path shown above.\n"
+  );
+  return lines.join("\n");
+}
+function buildTaskPrompt(spec, context) {
+  if (!context) return spec;
+  const parts = [spec];
+  if (context.constitution) {
+    parts.push(`
+=== Project Constitution (rules to follow) ===
+${context.constitution.slice(0, 1500)}`);
+  }
+  if (context.techStack.length > 0) {
+    parts.push(`
+=== Tech Stack ===
+${context.techStack.join(", ")}`);
+  }
+  parts.push("\n" + buildVerifiedInventory(context));
+  return parts.join("\n");
+}
 var LAYER_ORDER = {
   data: 0,
   infra: 1,
@@ -3604,20 +4291,15 @@ var TaskGenerator = class {
     this.provider = provider;
   }
   async generateTasks(spec, context) {
-    const contextSummary = context ? `
-=== Project Context ===
-Tech: ${context.techStack.join(", ")}
-Files: ${context.fileStructure.slice(0, 20).join(", ")}
-` : "";
-    const prompt = `${spec}${contextSummary}`;
+    const prompt = buildTaskPrompt(spec, context);
     const raw = await this.provider.generate(prompt, tasksSystemPrompt);
     return parseTasks(raw);
   }
   async saveTasks(tasks, specFilePath) {
-    const dir = path2.dirname(specFilePath);
-    const base = path2.basename(specFilePath, ".md");
-    const tasksFile = path2.join(dir, `${base}-tasks.json`);
-    await fs3.writeJson(tasksFile, tasks, { spaces: 2 });
+    const dir = path3.dirname(specFilePath);
+    const base = path3.basename(specFilePath, ".md");
+    const tasksFile = path3.join(dir, `${base}-tasks.json`);
+    await fs5.writeJson(tasksFile, tasks, { spaces: 2 });
     return tasksFile;
   }
   sortByLayer(tasks) {
@@ -3640,103 +4322,986 @@ function parseTasks(raw) {
 }
 function printTasks(tasks) {
   const layerColors = {
-    data: chalk2.magenta,
-    infra: chalk2.gray,
-    service: chalk2.blue,
-    api: chalk2.cyan,
-    test: chalk2.green
+    data: chalk3.magenta,
+    infra: chalk3.gray,
+    service: chalk3.blue,
+    api: chalk3.cyan,
+    test: chalk3.green
   };
-  console.log(chalk2.bold(`
+  console.log(chalk3.bold(`
   Tasks (${tasks.length}):`));
   for (const task of tasks) {
-    const color = layerColors[task.layer] ?? chalk2.white;
+    const color = layerColors[task.layer] ?? chalk3.white;
     const badge = color(`[${task.layer}]`);
-    const prio = task.priority === "high" ? chalk2.red("\u25CF") : task.priority === "medium" ? chalk2.yellow("\u25CF") : chalk2.gray("\u25CF");
-    console.log(`  ${prio} ${chalk2.bold(task.id)} ${badge} ${task.title}`);
+    const prio = task.priority === "high" ? chalk3.red("\u25CF") : task.priority === "medium" ? chalk3.yellow("\u25CF") : chalk3.gray("\u25CF");
+    console.log(`  ${prio} ${chalk3.bold(task.id)} ${badge} ${task.title}`);
   }
 }
 async function loadTasksForSpec(specFilePath) {
-  const base = path2.basename(specFilePath, ".md");
-  const dir = path2.dirname(specFilePath);
-  const tasksFile = path2.join(dir, `${base}-tasks.json`);
-  if (await fs3.pathExists(tasksFile)) {
-    return fs3.readJson(tasksFile);
+  const base = path3.basename(specFilePath, ".md");
+  const dir = path3.dirname(specFilePath);
+  const tasksFile = path3.join(dir, `${base}-tasks.json`);
+  if (await fs5.pathExists(tasksFile)) {
+    return fs5.readJson(tasksFile);
   }
   return null;
 }
+async function updateTaskStatus(specFilePath, taskId, status) {
+  const tasks = await loadTasksForSpec(specFilePath);
+  if (!tasks) return;
+  const task = tasks.find((t) => t.id === taskId);
+  if (!task) return;
+  task.status = status;
+  const base = path3.basename(specFilePath, ".md");
+  const dir = path3.dirname(specFilePath);
+  await fs5.writeJson(path3.join(dir, `${base}-tasks.json`), tasks, { spaces: 2 });
+}
 
-// core/code-generator.ts
-function isRtkAvailable() {
-  try {
-    execSync("rtk --version", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
+// core/dsl-extractor.ts
+import chalk5 from "chalk";
+import * as fs6 from "fs-extra";
+import * as path4 from "path";
+import { select as select2 } from "@inquirer/prompts";
+
+// core/dsl-validator.ts
+import chalk4 from "chalk";
+var VALID_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+var MAX_MODELS = 50;
+var MAX_FIELDS_PER_MODEL = 100;
+var MAX_ENDPOINTS = 100;
+var MAX_BEHAVIORS = 50;
+var MAX_ERRORS_PER_ENDPOINT = 20;
+function validateDsl(raw) {
+  const errors = [];
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return {
+      valid: false,
+      errors: [{ path: "root", message: "DSL must be a JSON object, got: " + typeLabel(raw) }]
+    };
   }
-}
-function stripCodeFences(output) {
-  const fenced = output.match(/^```(?:\w+)?\n([\s\S]*?)```\s*$/m);
-  if (fenced) return fenced[1].trim();
-  const lines = output.split("\n");
-  if (lines[0].startsWith("```")) lines.shift();
-  if (lines[lines.length - 1].trim() === "```") lines.pop();
-  return lines.join("\n").trim();
-}
-function parseJsonArray(text) {
-  const fenced = text.match(/```(?:json)?\n(\[[\s\S]*?\])\n```/);
-  const raw = fenced ? fenced[1] : text.match(/\[[\s\S]*?\]/)?.[0] ?? "";
-  try {
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed)) return parsed;
-  } catch {
+  const obj = raw;
+  if (obj["version"] !== "1.0") {
+    errors.push({
+      path: "version",
+      message: `Must be "1.0", got: ${JSON.stringify(obj["version"])}`
+    });
   }
-  return [];
-}
-var CodeGenerator = class {
-  constructor(provider, mode = "claude-code") {
-    this.provider = provider;
-    this.mode = mode;
+  validateFeature(obj["feature"], "feature", errors);
+  if (!Array.isArray(obj["models"])) {
+    errors.push({ path: "models", message: `Must be an array, got: ${typeLabel(obj["models"])}` });
+  } else {
+    const models = obj["models"];
+    if (models.length > MAX_MODELS) {
+      errors.push({ path: "models", message: `Too many models (${models.length} > ${MAX_MODELS})` });
+    }
+    for (let i = 0; i < Math.min(models.length, MAX_MODELS); i++) {
+      validateModel(models[i], `models[${i}]`, errors);
+    }
   }
-  async generateCode(specFilePath, workingDir, context, options = {}) {
-    let effectiveMode = this.mode;
-    if (effectiveMode === "claude-code" && this.provider.providerName !== "claude") {
-      console.log(
-        chalk3.yellow(
-          `
-  \u26A0  codegen \u6A21\u5F0F "claude-code" \u9700\u8981 Claude\uFF0C\u4F46\u5F53\u524D provider \u662F "${this.provider.providerName}"\u3002`
-        )
-      );
-      console.log(chalk3.gray(`  \u81EA\u52A8\u5207\u6362\u5230 "api" \u6A21\u5F0F\uFF08\u4F7F\u7528 ${this.provider.providerName}/${this.provider.modelName} \u751F\u6210\u4EE3\u7801\uFF09\u3002`));
-      console.log(chalk3.gray(`  \u63D0\u793A\uFF1A\u8FD0\u884C \`ai-spec config --codegen api\` \u53EF\u56FA\u5316\u6B64\u8BBE\u7F6E\u3002
-`));
-      effectiveMode = "api";
+  if (!Array.isArray(obj["endpoints"])) {
+    errors.push({ path: "endpoints", message: `Must be an array, got: ${typeLabel(obj["endpoints"])}` });
+  } else {
+    const eps = obj["endpoints"];
+    if (eps.length > MAX_ENDPOINTS) {
+      errors.push({ path: "endpoints", message: `Too many endpoints (${eps.length} > ${MAX_ENDPOINTS})` });
     }
-    switch (effectiveMode) {
-      case "claude-code":
-        return this.runClaudeCode(specFilePath, workingDir, options);
-      case "api":
-        return this.runApiMode(specFilePath, workingDir, context);
-      case "plan":
-        return this.runPlanMode(specFilePath);
+    for (let i = 0; i < Math.min(eps.length, MAX_ENDPOINTS); i++) {
+      validateEndpoint(eps[i], `endpoints[${i}]`, errors);
     }
   }
-  // ── Mode: claude-code ──────────────────────────────────────────────────────
-  isClaudeCLIAvailable() {
-    try {
-      execSync("claude --version", { stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
+  if (obj["behaviors"] !== void 0) {
+    if (!Array.isArray(obj["behaviors"])) {
+      errors.push({ path: "behaviors", message: `Must be an array if present, got: ${typeLabel(obj["behaviors"])}` });
+    } else {
+      const behaviors = obj["behaviors"];
+      if (behaviors.length > MAX_BEHAVIORS) {
+        errors.push({ path: "behaviors", message: `Too many behaviors (${behaviors.length} > ${MAX_BEHAVIORS})` });
+      }
+      for (let i = 0; i < Math.min(behaviors.length, MAX_BEHAVIORS); i++) {
+        validateBehavior(behaviors[i], `behaviors[${i}]`, errors);
+      }
     }
   }
-  async runClaudeCode(specFilePath, workingDir, options = {}) {
-    console.log(chalk3.blue("\n\u2500\u2500\u2500 Code Generation: Claude Code CLI \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    if (!this.isClaudeCLIAvailable()) {
-      console.log(chalk3.yellow("  \u26A0\uFE0F  Claude Code CLI not found. Falling back to plan mode."));
-      console.log(chalk3.gray("  Install: npm install -g @anthropic-ai/claude-code"));
+  if (obj["components"] !== void 0) {
+    if (!Array.isArray(obj["components"])) {
+      errors.push({ path: "components", message: `Must be an array if present, got: ${typeLabel(obj["components"])}` });
+    } else {
+      const components = obj["components"];
+      for (let i = 0; i < Math.min(components.length, 50); i++) {
+        validateComponent(components[i], `components[${i}]`, errors);
+      }
+    }
+  }
+  if (errors.length > 0) {
+    return { valid: false, errors };
+  }
+  return { valid: true, dsl: raw };
+}
+function validateFeature(raw, path10, errors) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    return;
+  }
+  const f = raw;
+  requireNonEmptyString(f["id"], `${path10}.id`, errors);
+  requireNonEmptyString(f["title"], `${path10}.title`, errors);
+  requireNonEmptyString(f["description"], `${path10}.description`, errors);
+}
+function validateModel(raw, path10, errors) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    return;
+  }
+  const m = raw;
+  requireNonEmptyString(m["name"], `${path10}.name`, errors);
+  if (!Array.isArray(m["fields"])) {
+    errors.push({ path: `${path10}.fields`, message: `Must be an array, got: ${typeLabel(m["fields"])}` });
+  } else {
+    const fields = m["fields"];
+    if (fields.length > MAX_FIELDS_PER_MODEL) {
+      errors.push({ path: `${path10}.fields`, message: `Too many fields (${fields.length} > ${MAX_FIELDS_PER_MODEL})` });
+    }
+    for (let j2 = 0; j2 < Math.min(fields.length, MAX_FIELDS_PER_MODEL); j2++) {
+      validateModelField(fields[j2], `${path10}.fields[${j2}]`, errors);
+    }
+  }
+  if (m["relations"] !== void 0) {
+    if (!Array.isArray(m["relations"])) {
+      errors.push({ path: `${path10}.relations`, message: "Must be an array of strings if present" });
+    } else {
+      const rels = m["relations"];
+      for (let j2 = 0; j2 < rels.length; j2++) {
+        if (typeof rels[j2] !== "string") {
+          errors.push({ path: `${path10}.relations[${j2}]`, message: "Must be a string" });
+        }
+      }
+    }
+  }
+}
+function validateModelField(raw, path10, errors) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    return;
+  }
+  const f = raw;
+  requireNonEmptyString(f["name"], `${path10}.name`, errors);
+  requireNonEmptyString(f["type"], `${path10}.type`, errors);
+  if (typeof f["required"] !== "boolean") {
+    errors.push({ path: `${path10}.required`, message: `Must be boolean, got: ${typeLabel(f["required"])}` });
+  }
+}
+function validateEndpoint(raw, path10, errors) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    return;
+  }
+  const e = raw;
+  requireNonEmptyString(e["id"], `${path10}.id`, errors);
+  requireNonEmptyString(e["description"], `${path10}.description`, errors);
+  if (!VALID_METHODS.includes(e["method"])) {
+    errors.push({
+      path: `${path10}.method`,
+      message: `Must be one of ${VALID_METHODS.join("|")}, got: ${JSON.stringify(e["method"])}`
+    });
+  }
+  if (typeof e["path"] !== "string" || !e["path"].startsWith("/")) {
+    errors.push({
+      path: `${path10}.path`,
+      message: `Must be a string starting with "/", got: ${JSON.stringify(e["path"])}`
+    });
+  }
+  if (typeof e["auth"] !== "boolean") {
+    errors.push({ path: `${path10}.auth`, message: `Must be boolean, got: ${typeLabel(e["auth"])}` });
+  }
+  if (typeof e["successStatus"] !== "number" || e["successStatus"] < 100 || e["successStatus"] > 599) {
+    errors.push({
+      path: `${path10}.successStatus`,
+      message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["successStatus"])}`
+    });
+  }
+  requireNonEmptyString(e["successDescription"], `${path10}.successDescription`, errors);
+  if (e["request"] !== void 0) {
+    validateRequestSchema(e["request"], `${path10}.request`, errors);
+  }
+  if (e["errors"] !== void 0) {
+    if (!Array.isArray(e["errors"])) {
+      errors.push({ path: `${path10}.errors`, message: "Must be an array if present" });
+    } else {
+      const errs = e["errors"];
+      if (errs.length > MAX_ERRORS_PER_ENDPOINT) {
+        errors.push({ path: `${path10}.errors`, message: `Too many error entries (${errs.length} > ${MAX_ERRORS_PER_ENDPOINT})` });
+      }
+      for (let j2 = 0; j2 < Math.min(errs.length, MAX_ERRORS_PER_ENDPOINT); j2++) {
+        validateResponseError(errs[j2], `${path10}.errors[${j2}]`, errors);
+      }
+    }
+  }
+}
+function validateRequestSchema(raw, path10, errors) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    return;
+  }
+  const r = raw;
+  for (const key of ["body", "query", "params"]) {
+    if (r[key] !== void 0) {
+      validateFieldMap(r[key], `${path10}.${key}`, errors);
+    }
+  }
+}
+function validateFieldMap(raw, path10, errors) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push({ path: path10, message: `Must be a flat object (FieldMap), got: ${typeLabel(raw)}` });
+    return;
+  }
+  const map = raw;
+  for (const [k2, v2] of Object.entries(map)) {
+    if (typeof v2 !== "string") {
+      errors.push({ path: `${path10}.${k2}`, message: `Value must be a type-description string, got: ${typeLabel(v2)}` });
+    }
+  }
+}
+function validateResponseError(raw, path10, errors) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    return;
+  }
+  const e = raw;
+  if (typeof e["status"] !== "number" || e["status"] < 100 || e["status"] > 599) {
+    errors.push({ path: `${path10}.status`, message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["status"])}` });
+  }
+  requireNonEmptyString(e["code"], `${path10}.code`, errors);
+  requireNonEmptyString(e["description"], `${path10}.description`, errors);
+}
+function validateBehavior(raw, path10, errors) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    return;
+  }
+  const b = raw;
+  requireNonEmptyString(b["id"], `${path10}.id`, errors);
+  requireNonEmptyString(b["description"], `${path10}.description`, errors);
+  if (b["constraints"] !== void 0) {
+    if (!Array.isArray(b["constraints"])) {
+      errors.push({ path: `${path10}.constraints`, message: "Must be an array of strings if present" });
+    } else {
+      const cs2 = b["constraints"];
+      for (let j2 = 0; j2 < cs2.length; j2++) {
+        if (typeof cs2[j2] !== "string") {
+          errors.push({ path: `${path10}.constraints[${j2}]`, message: "Must be a string" });
+        }
+      }
+    }
+  }
+}
+function validateComponent(raw, path10, errors) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    return;
+  }
+  const c = raw;
+  requireNonEmptyString(c["id"], `${path10}.id`, errors);
+  requireNonEmptyString(c["name"], `${path10}.name`, errors);
+  requireNonEmptyString(c["description"], `${path10}.description`, errors);
+  if (c["props"] !== void 0) {
+    if (!Array.isArray(c["props"])) {
+      errors.push({ path: `${path10}.props`, message: "Must be an array if present" });
+    } else {
+      const props = c["props"];
+      for (let j2 = 0; j2 < props.length; j2++) {
+        const p = props[j2];
+        if (typeof p !== "object" || p === null) {
+          errors.push({ path: `${path10}.props[${j2}]`, message: "Must be an object" });
+          continue;
+        }
+        requireNonEmptyString(p["name"], `${path10}.props[${j2}].name`, errors);
+        requireNonEmptyString(p["type"], `${path10}.props[${j2}].type`, errors);
+        if (typeof p["required"] !== "boolean") {
+          errors.push({ path: `${path10}.props[${j2}].required`, message: "Must be boolean" });
+        }
+      }
+    }
+  }
+  if (c["events"] !== void 0) {
+    if (!Array.isArray(c["events"])) {
+      errors.push({ path: `${path10}.events`, message: "Must be an array if present" });
+    } else {
+      const events = c["events"];
+      for (let j2 = 0; j2 < events.length; j2++) {
+        const e = events[j2];
+        if (typeof e !== "object" || e === null) {
+          errors.push({ path: `${path10}.events[${j2}]`, message: "Must be an object" });
+          continue;
+        }
+        requireNonEmptyString(e["name"], `${path10}.events[${j2}].name`, errors);
+      }
+    }
+  }
+  if (c["state"] !== void 0) {
+    if (typeof c["state"] !== "object" || Array.isArray(c["state"]) || c["state"] === null) {
+      errors.push({ path: `${path10}.state`, message: "Must be a flat object (Record<string, string>) if present" });
+    }
+  }
+  if (c["apiCalls"] !== void 0) {
+    if (!Array.isArray(c["apiCalls"])) {
+      errors.push({ path: `${path10}.apiCalls`, message: "Must be an array of strings if present" });
+    }
+  }
+}
+function requireNonEmptyString(v2, path10, errors) {
+  if (typeof v2 !== "string" || v2.trim().length === 0) {
+    errors.push({
+      path: path10,
+      message: `Must be a non-empty string, got: ${typeLabel(v2)}`
+    });
+  }
+}
+function typeLabel(v2) {
+  if (v2 === null) return "null";
+  if (Array.isArray(v2)) return "array";
+  return typeof v2;
+}
+
+// core/dsl-extractor.ts
+function dslFilePath(specFilePath) {
+  const dir = path4.dirname(specFilePath);
+  const base = path4.basename(specFilePath, ".md");
+  return path4.join(dir, `${base}.dsl.json`);
+}
+function buildDslContextSection(dsl) {
+  const lines = [
+    "=== Feature DSL (structured summary \u2014 use for implementation guidance) ==="
+  ];
+  if (dsl.models.length > 0) {
+    lines.push("\n-- Data Models --");
+    for (const model of dsl.models) {
+      lines.push(`${model.name}:`);
+      for (const field of model.fields) {
+        const flags = [];
+        if (field.required) flags.push("required");
+        if (field.unique) flags.push("unique");
+        lines.push(`  ${field.name}: ${field.type}${flags.length ? ` (${flags.join(", ")})` : ""}`);
+      }
+      if (model.relations && model.relations.length > 0) {
+        lines.push(`  relations: ${model.relations.join("; ")}`);
+      }
+    }
+  }
+  if (dsl.endpoints.length > 0) {
+    lines.push("\n-- API Endpoints --");
+    for (const ep of dsl.endpoints) {
+      lines.push(`${ep.id}: ${ep.method} ${ep.path}  [auth: ${ep.auth}]  \u2192 ${ep.successStatus}`);
+      lines.push(`  ${ep.description}`);
+      if (ep.request?.body) {
+        const fields = Object.entries(ep.request.body).map(([k2, v2]) => `${k2}: ${v2}`).join(", ");
+        lines.push(`  body: { ${fields} }`);
+      }
+      if (ep.errors && ep.errors.length > 0) {
+        lines.push(`  errors: ${ep.errors.map((e) => `${e.status} ${e.code}`).join(", ")}`);
+      }
+    }
+  }
+  if (dsl.behaviors.length > 0) {
+    lines.push("\n-- Business Behaviors --");
+    for (const b of dsl.behaviors) {
+      lines.push(`${b.id}: ${b.description}`);
+      if (b.trigger) lines.push(`  trigger: ${b.trigger}`);
+      if (b.constraints && b.constraints.length > 0) {
+        lines.push(`  rules: ${b.constraints.join("; ")}`);
+      }
+    }
+  }
+  if (dsl.components && dsl.components.length > 0) {
+    lines.push("\n-- UI Components --");
+    for (const cmp of dsl.components) {
+      lines.push(`${cmp.id}: ${cmp.name} \u2014 ${cmp.description}`);
+      if (cmp.props.length > 0) {
+        lines.push(`  props: ${cmp.props.map((p) => `${p.name}${p.required ? "" : "?"}:${p.type}`).join(", ")}`);
+      }
+      if (cmp.events.length > 0) {
+        lines.push(`  events: ${cmp.events.map((e) => `${e.name}(${e.payload ?? ""})`).join(", ")}`);
+      }
+      if (Object.keys(cmp.state).length > 0) {
+        lines.push(`  state: ${Object.entries(cmp.state).map(([k2, v2]) => `${k2}:${v2}`).join(", ")}`);
+      }
+      if (cmp.apiCalls.length > 0) {
+        lines.push(`  calls: ${cmp.apiCalls.join(", ")}`);
+      }
+    }
+  }
+  lines.push("\n=== End of DSL ===");
+  return lines.join("\n");
+}
+async function loadDslForSpec(specFilePath) {
+  const dslPath = dslFilePath(specFilePath);
+  if (!await fs6.pathExists(dslPath)) return null;
+  try {
+    const raw = await fs6.readJson(dslPath);
+    const result = validateDsl(raw);
+    return result.valid ? result.dsl : null;
+  } catch {
+    return null;
+  }
+}
+
+// core/frontend-context-loader.ts
+import * as fs7 from "fs-extra";
+import * as path5 from "path";
+var STATE_MANAGEMENT_LIBS = [
+  "zustand",
+  "redux",
+  "@reduxjs/toolkit",
+  "jotai",
+  "recoil",
+  "mobx",
+  "mobx-react",
+  "valtio",
+  "pinia",
+  "vuex"
+];
+var HTTP_CLIENT_LIBS = [
+  ["swr", "swr"],
+  ["@tanstack/react-query", "react-query"],
+  ["react-query", "react-query"],
+  ["axios", "axios"],
+  ["ky", "ky"]
+];
+var UI_LIBRARY_LIBS = [
+  ["antd", "antd"],
+  ["@ant-design/pro-components", "antd-pro"],
+  ["@mui/material", "mui"],
+  ["@chakra-ui/react", "chakra-ui"],
+  ["shadcn-ui", "shadcn"],
+  ["@radix-ui/react-primitive", "radix-ui"],
+  ["element-plus", "element-plus"],
+  ["vant", "vant"],
+  ["tailwindcss", "tailwind"],
+  ["@tailwindcss/vite", "tailwind"],
+  ["react-native-paper", "react-native-paper"]
+];
+var ROUTING_LIBS = [
+  ["react-router-dom", "react-router"],
+  ["react-router", "react-router"],
+  ["@tanstack/react-router", "tanstack-router"],
+  ["react-navigation", "react-navigation"],
+  ["expo-router", "expo-router"],
+  ["vue-router", "vue-router"]
+];
+async function loadFrontendContext(projectRoot) {
+  const ctx = {
+    framework: "unknown",
+    stateManagement: [],
+    httpClient: "fetch",
+    uiLibrary: "unknown",
+    routingPattern: "unknown",
+    testFramework: "unknown",
+    existingApiFiles: [],
+    apiWrapperContent: [],
+    hookFiles: [],
+    hookPatterns: [],
+    storeFiles: [],
+    storePatterns: [],
+    reusableComponents: [],
+    pageExamples: [],
+    componentPatterns: []
+  };
+  try {
+    const pkgPath = path5.join(projectRoot, "package.json");
+    if (!await fs7.pathExists(pkgPath)) return ctx;
+    const pkg = await fs7.readJson(pkgPath);
+    const allDeps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+    const depKeys = Object.keys(allDeps);
+    const has = (name) => depKeys.includes(name);
+    if (has("react-native") || has("expo")) {
+      ctx.framework = "react-native";
+    } else if (has("next")) {
+      ctx.framework = "next";
+    } else if (has("react")) {
+      ctx.framework = "react";
+    } else if (has("vue")) {
+      ctx.framework = "vue";
+    }
+    ctx.stateManagement = STATE_MANAGEMENT_LIBS.filter((lib) => has(lib));
+    for (const [lib, label] of HTTP_CLIENT_LIBS) {
+      if (has(lib)) {
+        ctx.httpClient = label;
+        break;
+      }
+    }
+    for (const [lib, label] of UI_LIBRARY_LIBS) {
+      if (has(lib)) {
+        ctx.uiLibrary = label;
+        break;
+      }
+    }
+    if (ctx.uiLibrary === "unknown") {
+      ctx.uiLibrary = "none";
+    }
+    if (ctx.framework === "next") {
+      const hasAppDir = await fs7.pathExists(path5.join(projectRoot, "app"));
+      ctx.routingPattern = hasAppDir ? "next-app-router" : "next-pages-router";
+    } else {
+      for (const [lib, label] of ROUTING_LIBS) {
+        if (has(lib)) {
+          ctx.routingPattern = label;
+          break;
+        }
+      }
+    }
+    if (depKeys.includes("@testing-library/react") || depKeys.includes("@testing-library/vue")) {
+      ctx.testFramework = "rtl";
+    } else if (depKeys.includes("cypress")) {
+      ctx.testFramework = "cypress";
+    } else if (depKeys.includes("vitest")) {
+      ctx.testFramework = "vitest";
+    } else if (depKeys.includes("jest") || depKeys.includes("@jest/core")) {
+      ctx.testFramework = "jest";
+    }
+    const apiFilePatterns = [
+      "src/api/**/*.{ts,js}",
+      "src/apis/**/*.{ts,js}",
+      "src/services/**/*.{ts,js}",
+      "src/lib/api/**/*.{ts,js}",
+      "src/utils/api/**/*.{ts,js}",
+      "api/**/*.{ts,js}",
+      "services/**/*.{ts,js}"
+    ];
+    for (const pattern of apiFilePatterns) {
+      const files = await Ze(pattern, {
+        cwd: projectRoot,
+        ignore: ["**/*.test.*", "**/*.spec.*", "node_modules/**"]
+      });
+      ctx.existingApiFiles.push(...files);
+    }
+    ctx.existingApiFiles = [...new Set(ctx.existingApiFiles)].slice(0, 20);
+    for (const relPath of ctx.existingApiFiles.slice(0, 2)) {
+      try {
+        const content = await fs7.readFile(path5.join(projectRoot, relPath), "utf-8");
+        const preview = content.split("\n").slice(0, 60).join("\n");
+        ctx.apiWrapperContent.push(`// ${relPath}
+${preview}`);
+      } catch {
+      }
+    }
+    const hookPatterns = [
+      "src/hooks/use*.{ts,tsx}",
+      "src/**/hooks/use*.{ts,tsx}",
+      "hooks/use*.{ts,tsx}"
+    ];
+    for (const pattern of hookPatterns) {
+      const files = await Ze(pattern, {
+        cwd: projectRoot,
+        ignore: ["**/*.test.*", "**/*.spec.*", "node_modules/**"]
+      });
+      ctx.hookFiles.push(...files);
+    }
+    ctx.hookFiles = [...new Set(ctx.hookFiles)].slice(0, 15);
+    for (const relPath of ctx.hookFiles.slice(0, 2)) {
+      try {
+        const content = await fs7.readFile(path5.join(projectRoot, relPath), "utf-8");
+        const preview = content.split("\n").slice(0, 30).join("\n");
+        ctx.hookPatterns.push(`// ${relPath}
+${preview}`);
+      } catch {
+      }
+    }
+    const storeFilePatterns = [
+      "src/store/**/*.{ts,js}",
+      "src/stores/**/*.{ts,js}",
+      "src/**/slice*.{ts,js}",
+      "src/**/*slice.{ts,js}",
+      "src/**/*store.{ts,js}",
+      "src/**/*Store.{ts,js}",
+      "store/**/*.{ts,js}",
+      "stores/**/*.{ts,js}"
+    ];
+    for (const pattern of storeFilePatterns) {
+      const files = await Ze(pattern, {
+        cwd: projectRoot,
+        ignore: ["**/*.test.*", "**/*.spec.*", "node_modules/**"]
+      });
+      ctx.storeFiles.push(...files);
+    }
+    ctx.storeFiles = [...new Set(ctx.storeFiles)].slice(0, 10);
+    for (const relPath of ctx.storeFiles.slice(0, 2)) {
+      try {
+        const content = await fs7.readFile(path5.join(projectRoot, relPath), "utf-8");
+        const preview = content.split("\n").slice(0, 60).join("\n");
+        ctx.storePatterns.push(`// ${relPath}
+${preview}`);
+      } catch {
+      }
+    }
+    const httpImportRegex = /^import\s+(?:\w+|\{[^}]+\})\s+from\s+['"](@\/[^'"]+|axios|ky)['"]/m;
+    for (const relPath of ctx.existingApiFiles.slice(0, 5)) {
+      try {
+        const content = await fs7.readFile(path5.join(projectRoot, relPath), "utf-8");
+        const match = content.match(httpImportRegex);
+        if (match) {
+          ctx.httpClientImport = match[0].trim();
+          break;
+        }
+      } catch {
+      }
+    }
+    const paginationFieldNames = ["pageIndex", "pageSize", "pageNum", "current", "page", "size", "offset", "limit"];
+    const paginationInterfaceRegex = new RegExp(
+      `(?:interface|type)\\s+(\\w*(?:Params|Query|Request|Filter|Page)\\w*)\\s*\\{[^}]*\\b(?:${paginationFieldNames.join("|")})\\b[^}]*\\}`,
+      "s"
+    );
+    const apiExportFnRegex = /export\s+(?:async\s+)?function\s+\w+\s*\([^)]*\)[^{]*\{[\s\S]*?\n\}/g;
+    for (const relPath of ctx.existingApiFiles) {
+      if (/types?\.ts$|index\.ts$/.test(relPath)) continue;
+      try {
+        const content = await fs7.readFile(path5.join(projectRoot, relPath), "utf-8");
+        if (!paginationFieldNames.some((f) => content.includes(f))) continue;
+        const interfaceMatch = content.match(paginationInterfaceRegex);
+        if (!interfaceMatch) continue;
+        const interfaceName = interfaceMatch[1];
+        const fnRegex = new RegExp(
+          `export\\s+(?:async\\s+)?function\\s+\\w+\\s*\\(\\s*\\w+\\s*:\\s*${interfaceName}[^)]*\\)[\\s\\S]*?\\n\\}`,
+          ""
+        );
+        const fnMatch = content.match(fnRegex);
+        if (fnMatch) {
+          ctx.paginationExample = `// From ${relPath}
+${interfaceMatch[0]}
+
+${fnMatch[0]}`;
+          break;
+        }
+      } catch {
+      }
+    }
+    const sharedComponentDirs = ["src/components", "components"];
+    for (const dir of sharedComponentDirs) {
+      const absDir = path5.join(projectRoot, dir);
+      if (!await fs7.pathExists(absDir)) continue;
+      const files = await Ze("**/*.{vue,tsx,jsx}", {
+        cwd: absDir,
+        ignore: ["**/*.test.*", "**/*.spec.*", "node_modules/**"],
+        maxDepth: 4
+      });
+      ctx.reusableComponents.push(...files.map((f) => path5.join(dir, f)));
+    }
+    ctx.reusableComponents = [...new Set(ctx.reusableComponents)].slice(0, 40);
+    const viewDirs = ["src/views", "src/pages", "views", "pages"];
+    const viewFiles = [];
+    for (const dir of viewDirs) {
+      const absDir = path5.join(projectRoot, dir);
+      if (!await fs7.pathExists(absDir)) continue;
+      const files = await Ze("**/*.{vue,tsx,jsx}", {
+        cwd: absDir,
+        ignore: ["**/*.test.*", "**/*.spec.*", "node_modules/**"],
+        maxDepth: 3
+      });
+      viewFiles.push(...files.map((f) => path5.join(dir, f)));
+      if (viewFiles.length >= 6) break;
+    }
+    for (const relPath of viewFiles.slice(0, 2)) {
+      try {
+        const content = await fs7.readFile(path5.join(projectRoot, relPath), "utf-8");
+        const preview = content.split("\n").slice(0, 80).join("\n");
+        ctx.pageExamples.push(`// ${relPath}
+${preview}`);
+      } catch {
+      }
+    }
+    const componentFiles = [];
+    for (const dir of sharedComponentDirs) {
+      const absDir = path5.join(projectRoot, dir);
+      if (!await fs7.pathExists(absDir)) continue;
+      const files = await Ze("**/*.{tsx,vue,jsx}", {
+        cwd: absDir,
+        ignore: ["**/*.test.*", "**/*.spec.*", "node_modules/**"],
+        maxDepth: 2
+      });
+      componentFiles.push(...files.map((f) => path5.join(dir, f)));
+      if (componentFiles.length >= 5) break;
+    }
+    for (const relPath of componentFiles.slice(0, 3)) {
+      try {
+        const content = await fs7.readFile(path5.join(projectRoot, relPath), "utf-8");
+        const preview = content.split("\n").slice(0, 40).join("\n");
+        ctx.componentPatterns.push(`// ${relPath}
+${preview}`);
+      } catch {
+      }
+    }
+    await extractRouteModuleContext(projectRoot, ctx);
+  } catch {
+  }
+  return ctx;
+}
+async function extractRouteModuleContext(projectRoot, ctx) {
+  const modulePatterns = [
+    "src/router/modules/**/*.{ts,js}",
+    "src/routes/modules/**/*.{ts,js}",
+    "src/router/**/*.{ts,js}"
+  ];
+  const moduleFiles = [];
+  for (const pattern of modulePatterns) {
+    const files = await Ze(pattern, {
+      cwd: projectRoot,
+      ignore: ["**/index.{ts,js}", "node_modules/**", "**/*.test.*"]
+    });
+    moduleFiles.push(...files);
+  }
+  if (moduleFiles.length === 0) return;
+  const layoutImportRegex = /^(?:const\s+Layout\s*=.*import\(['"][^'"]+['"]\)|import\s+Layout\s+from\s+['"][^'"]+['"])/m;
+  for (const relPath of moduleFiles) {
+    try {
+      const content = await fs7.readFile(path5.join(projectRoot, relPath), "utf-8");
+      const match = content.match(layoutImportRegex);
+      if (match) {
+        ctx.layoutImport = match[0].trim();
+        const preview = content.split("\n").slice(0, 100).join("\n");
+        ctx.routeModuleExample = { path: relPath, content: preview };
+        break;
+      }
+    } catch {
+    }
+  }
+}
+function buildFrontendContextSection(ctx) {
+  const lines = [
+    "=== Frontend Project Context ===",
+    `Framework        : ${ctx.framework}`,
+    `State Management : ${ctx.stateManagement.join(", ") || "none detected"}`,
+    `HTTP Client      : ${ctx.httpClient}`,
+    `UI Library       : ${ctx.uiLibrary}`,
+    `Routing          : ${ctx.routingPattern}`,
+    `Test Framework   : ${ctx.testFramework}`
+  ];
+  if (ctx.layoutImport) {
+    lines.push(
+      `
+Layout component import (COPY THIS EXACTLY in every new route module \u2014 do NOT invent a different path):`,
+      `  ${ctx.layoutImport}`
+    );
+  }
+  if (ctx.routeModuleExample) {
+    lines.push(
+      `
+Existing route module template (${ctx.routeModuleExample.path}) \u2014 use this as the structural template for new route modules:`,
+      "```",
+      ctx.routeModuleExample.content,
+      "```"
+    );
+  }
+  if (ctx.existingApiFiles.length > 0) {
+    lines.push(`
+Existing API/service files (${ctx.existingApiFiles.length}):`);
+    ctx.existingApiFiles.slice(0, 10).forEach((f) => lines.push(`  - ${f}`));
+  }
+  if (ctx.httpClientImport) {
+    lines.push(
+      `
+HTTP client import (COPY THIS EXACTLY in every new API file \u2014 do NOT import from any other path):`,
+      `  ${ctx.httpClientImport}`
+    );
+  }
+  if (ctx.paginationExample) {
+    lines.push(
+      `
+Pagination pattern (COPY THIS EXACTLY for all paginated list APIs \u2014 use IDENTICAL parameter names, HTTP method, and call style):`,
+      "```typescript",
+      ctx.paginationExample,
+      "```"
+    );
+  }
+  if (ctx.apiWrapperContent.length > 0) {
+    lines.push(`
+API file patterns (new API functions must follow this exact structure):`);
+    ctx.apiWrapperContent.forEach((p) => {
+      lines.push("```");
+      lines.push(p);
+      lines.push("```");
+    });
+  }
+  if (ctx.hookFiles.length > 0) {
+    lines.push(`
+Existing custom hooks (${ctx.hookFiles.length}):`);
+    ctx.hookFiles.slice(0, 8).forEach((f) => lines.push(`  - ${f}`));
+  }
+  if (ctx.hookPatterns.length > 0) {
+    lines.push(`
+Hook patterns (follow same structure):`);
+    ctx.hookPatterns.forEach((p) => {
+      lines.push("```");
+      lines.push(p);
+      lines.push("```");
+    });
+  }
+  if (ctx.storeFiles.length > 0) {
+    lines.push(`
+State store files (${ctx.storeFiles.length}):`);
+    ctx.storeFiles.slice(0, 8).forEach((f) => lines.push(`  - ${f}`));
+  }
+  if (ctx.storePatterns.length > 0) {
+    lines.push(
+      `
+Existing store patterns (CRITICAL \u2014 stores in this project call API layer functions, they do NOT make HTTP requests directly):`,
+      `Follow this exact structure for new stores:`
+    );
+    ctx.storePatterns.forEach((p) => {
+      lines.push("```");
+      lines.push(p);
+      lines.push("```");
+    });
+  }
+  if (ctx.reusableComponents.length > 0) {
+    lines.push(
+      `
+Existing reusable components in src/components/ (${ctx.reusableComponents.length} files):`,
+      `ALWAYS check this list before creating a new component. Import and reuse existing ones instead of reinventing.`
+    );
+    ctx.reusableComponents.forEach((f) => lines.push(`  - ${f}`));
+  }
+  if (ctx.pageExamples.length > 0) {
+    lines.push(
+      `
+Existing page examples (shows which UI library components and shared components are used \u2014 follow the same import and usage patterns):`
+    );
+    ctx.pageExamples.forEach((p) => {
+      lines.push("```");
+      lines.push(p);
+      lines.push("```");
+    });
+  }
+  if (ctx.componentPatterns.length > 0) {
+    lines.push(`
+Shared component structure patterns:`);
+    ctx.componentPatterns.forEach((p) => {
+      lines.push("```");
+      lines.push(p.slice(0, 500));
+      lines.push("```");
+    });
+  }
+  lines.push("=== End of Frontend Context ===");
+  return lines.join("\n");
+}
+
+// core/code-generator.ts
+function buildSharedConfigSection(context) {
+  if (!context?.sharedConfigFiles || context.sharedConfigFiles.length === 0) return "";
+  const lines = [
+    "\n=== Existing Shared Config Files (study these to learn project conventions) ===",
+    "These are real files from the project. Use them as ground truth for naming, structure, and registration patterns.",
+    "Modify them in-place when adding new entries. Do NOT create parallel files for the same purpose.\n"
+  ];
+  for (const f of context.sharedConfigFiles) {
+    lines.push(`--- File: ${f.path}  [${f.category}] ---`);
+    lines.push(f.preview);
+    lines.push("");
+  }
+  return lines.join("\n") + "\n";
+}
+function buildInstalledPackagesSection(context) {
+  if (!context?.dependencies || context.dependencies.length === 0) return "";
+  return `
+=== Installed Packages (ONLY use packages from this list \u2014 NEVER import anything not listed here) ===
+${context.dependencies.join(", ")}
+`;
+}
+function buildGeneratedFilesSection(cache) {
+  if (cache.size === 0) return "";
+  const lines = [
+    "\n=== Files Already Generated in This Run \u2014 USE EXACT EXPORTS (do not rename or invent alternatives) ==="
+  ];
+  for (const [filePath, content] of cache) {
+    lines.push(`
+--- ${filePath} ---`);
+    lines.push(content.slice(0, 800));
+    if (content.length > 800) lines.push("... (truncated)");
+  }
+  return lines.join("\n") + "\n";
+}
+function isRtkAvailable() {
+  try {
+    execSync("rtk --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stripCodeFences(output) {
+  const fenced = output.match(/^```(?:\w+)?\n([\s\S]*?)```\s*$/m);
+  if (fenced) return fenced[1].trim();
+  const lines = output.split("\n");
+  if (lines[0].startsWith("```")) lines.shift();
+  if (lines[lines.length - 1].trim() === "```") lines.pop();
+  return lines.join("\n").trim();
+}
+function parseJsonArray(text) {
+  const fenced = text.match(/```(?:json)?\n(\[[\s\S]*?\])\n```/);
+  const raw = fenced ? fenced[1] : text.match(/\[[\s\S]*?\]/)?.[0] ?? "";
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed;
+  } catch {
+  }
+  return [];
+}
+var CodeGenerator = class {
+  constructor(provider, mode = "claude-code") {
+    this.provider = provider;
+    this.mode = mode;
+  }
+  /** Returns the list of file paths written to disk (useful for api-mode review). */
+  async generateCode(specFilePath, workingDir, context, options = {}) {
+    let effectiveMode = this.mode;
+    if (effectiveMode === "claude-code" && this.provider.providerName !== "claude") {
+      console.log(
+        chalk6.yellow(
+          `
+  \u26A0  codegen \u6A21\u5F0F "claude-code" \u9700\u8981 Claude\uFF0C\u4F46\u5F53\u524D provider \u662F "${this.provider.providerName}"\u3002`
+        )
+      );
+      console.log(chalk6.gray(`  \u81EA\u52A8\u5207\u6362\u5230 "api" \u6A21\u5F0F\uFF08\u4F7F\u7528 ${this.provider.providerName}/${this.provider.modelName} \u751F\u6210\u4EE3\u7801\uFF09\u3002`));
+      console.log(chalk6.gray(`  \u63D0\u793A\uFF1A\u8FD0\u884C \`ai-spec config --codegen api\` \u53EF\u56FA\u5316\u6B64\u8BBE\u7F6E\u3002
+`));
+      effectiveMode = "api";
+    }
+    switch (effectiveMode) {
+      case "claude-code":
+        await this.runClaudeCode(specFilePath, workingDir, options);
+        return [];
+      case "api":
+        return this.runApiMode(specFilePath, workingDir, context, options);
+      case "plan":
+        await this.runPlanMode(specFilePath);
+        return [];
+    }
+  }
+  // ── Mode: claude-code ──────────────────────────────────────────────────────
+  isClaudeCLIAvailable() {
+    try {
+      execSync("claude --version", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async runClaudeCode(specFilePath, workingDir, options = {}) {
+    console.log(chalk6.blue("\n\u2500\u2500\u2500 Code Generation: Claude Code CLI \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    if (!this.isClaudeCLIAvailable()) {
+      console.log(chalk6.yellow("  \u26A0\uFE0F  Claude Code CLI not found. Falling back to plan mode."));
+      console.log(chalk6.gray("  Install: npm install -g @anthropic-ai/claude-code"));
       return this.runPlanMode(specFilePath);
     }
+    const rtkAvailable = isRtkAvailable();
+    const claudeCmd = rtkAvailable ? "rtk claude" : "claude";
+    if (rtkAvailable) {
+      console.log(chalk6.green("  \u2713 RTK detected \u2014 using rtk claude for token savings"));
+    }
     const tasks = await loadTasksForSpec(specFilePath);
+    if (options.auto && tasks && tasks.length > 0) {
+      return this.runClaudeCodeIncremental(tasks, specFilePath, workingDir, claudeCmd, options);
+    }
     const taskSection = tasks && tasks.length > 0 ? `
 
 == Implementation Tasks (implement in order) ==
@@ -3744,64 +5309,139 @@ ${tasks.map((t) => `${t.id} [${t.layer}] ${t.title}
   Files: ${t.filesToTouch.join(", ")}
   Criteria: ${t.acceptanceCriteria.join("; ")}`).join("\n")}` : "";
     const promptContent = `Please read the spec file at ${specFilePath} and implement all the requirements. Create or modify files as necessary.${taskSection}`;
-    const promptFile = path3.join(workingDir, ".claude-prompt.txt");
-    await fs4.writeFile(promptFile, promptContent, "utf-8");
-    const rtkAvailable = isRtkAvailable();
-    const claudeCmd = rtkAvailable ? "rtk claude" : "claude";
-    if (rtkAvailable) {
-      console.log(chalk3.green("  \u2713 RTK detected \u2014 using rtk claude for token savings"));
-    }
+    const promptFile = path6.join(workingDir, ".claude-prompt.txt");
+    await fs8.writeFile(promptFile, promptContent, "utf-8");
     if (options.auto) {
-      console.log(chalk3.cyan(`  \u{1F916} Auto mode: running claude -p (non-interactive)...`));
-      console.log(chalk3.gray(`  Spec: ${specFilePath}`));
-      if (tasks) console.log(chalk3.gray(`  Tasks: ${tasks.length} tasks loaded`));
+      console.log(chalk6.cyan(`  \u{1F916} Auto mode: running claude -p (non-interactive)...`));
+      console.log(chalk6.gray(`  Spec: ${specFilePath}`));
       try {
         execSync(`${claudeCmd} -p "${promptContent.replace(/"/g, '\\"')}"`, {
           cwd: workingDir,
           stdio: "inherit"
         });
-        console.log(chalk3.green("\n  \u2714 Claude Code completed."));
+        console.log(chalk6.green("\n  \u2714 Claude Code completed."));
       } catch {
-        console.log(chalk3.yellow("\n  Claude Code exited. Check output above."));
+        console.log(chalk6.yellow("\n  Claude Code exited. Check output above."));
       }
     } else {
-      console.log(chalk3.cyan(`  \u{1F680} Launching ${claudeCmd} in: ${workingDir}`));
-      console.log(chalk3.gray(`  Spec: ${specFilePath}`));
-      if (tasks) console.log(chalk3.gray(`  Tasks: ${tasks.length} tasks loaded into .claude-prompt.txt`));
-      console.log(chalk3.gray("  Prompt pre-loaded in .claude-prompt.txt\n"));
+      console.log(chalk6.cyan(`  \u{1F680} Launching ${claudeCmd} in: ${workingDir}`));
+      console.log(chalk6.gray(`  Spec: ${specFilePath}`));
+      if (tasks) console.log(chalk6.gray(`  Tasks: ${tasks.length} tasks loaded into .claude-prompt.txt`));
+      console.log(chalk6.gray("  Prompt pre-loaded in .claude-prompt.txt\n"));
       try {
         execSync(claudeCmd, { cwd: workingDir, stdio: "inherit" });
-        console.log(chalk3.green("\n  \u2714 Claude Code session completed."));
+        console.log(chalk6.green("\n  \u2714 Claude Code session completed."));
       } catch {
-        console.log(chalk3.yellow("\n  Claude Code session ended. Continuing workflow."));
+        console.log(chalk6.yellow("\n  Claude Code session ended. Continuing workflow."));
       }
     }
   }
+  /**
+   * Incremental claude-code execution: one `claude -p` call per task.
+   * Tasks marked as "done" are skipped (resume support).
+   * Progress is shown as a percentage bar.
+   */
+  async runClaudeCodeIncremental(tasks, specFilePath, workingDir, claudeCmd, options) {
+    const pending = tasks.filter((t) => t.status !== "done");
+    const doneCount = tasks.length - pending.length;
+    if (options.resume && doneCount > 0) {
+      console.log(chalk6.cyan(`
+  Resuming: ${doneCount}/${tasks.length} tasks already done \u2014 skipping.`));
+    } else {
+      console.log(chalk6.cyan(`
+  Incremental mode: ${tasks.length} tasks`));
+    }
+    let completed = doneCount;
+    for (const task of tasks) {
+      if (task.status === "done") {
+        printTaskProgress(completed, tasks.length, task, "skip");
+        continue;
+      }
+      printTaskProgress(completed, tasks.length, task, "run");
+      const taskPrompt = `Task: ${task.id} \u2014 ${task.title}
+Layer: ${task.layer}
+Description: ${task.description}
+Files to touch: ${task.filesToTouch.join(", ") || "as needed"}
+Acceptance criteria:
+${task.acceptanceCriteria.map((c) => `  - ${c}`).join("\n")}
+
+Full spec is at: ${specFilePath}
+Implement ONLY this task. Do not implement other tasks.`;
+      let taskStatus = "done";
+      try {
+        execSync(`${claudeCmd} -p "${taskPrompt.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`, {
+          cwd: workingDir,
+          stdio: "inherit"
+        });
+        completed++;
+      } catch {
+        taskStatus = "failed";
+        console.log(chalk6.yellow(`
+  \u26A0 Task ${task.id} exited with error \u2014 marked as failed. Re-run with --resume to retry.`));
+      }
+      await updateTaskStatus(specFilePath, task.id, taskStatus);
+    }
+    const successCount = tasks.filter((t) => t.status === "done").length + (completed - doneCount);
+    console.log(
+      chalk6.bold(
+        `
+  ${successCount === tasks.length ? chalk6.green("\u2714") : chalk6.yellow("!")} Incremental build: ${completed}/${tasks.length} tasks completed.`
+      )
+    );
+  }
   // ── Mode: api ─────────────────────────────────────────────────────────────
-  async runApiMode(specFilePath, workingDir, context) {
+  async runApiMode(specFilePath, workingDir, context, options = {}) {
     console.log(
-      chalk3.blue(
+      chalk6.blue(
         `
 \u2500\u2500\u2500 Code Generation: API (${this.provider.providerName}/${this.provider.modelName}) \u2500\u2500\u2500`
       )
     );
-    const spec = await fs4.readFile(specFilePath, "utf-8");
+    const systemPrompt = getCodeGenSystemPrompt(options.repoType);
+    if (options.repoType && options.repoType !== "node-express" && options.repoType !== "node-koa" && options.repoType !== "unknown") {
+      console.log(chalk6.gray(`  Language: ${options.repoType} (using language-specific codegen prompt)`));
+    }
+    const spec = await fs8.readFile(specFilePath, "utf-8");
     const constitutionSection = context?.constitution ? `
 === Project Constitution (MUST follow) ===
 ${context.constitution.slice(0, 2e3)}
 ` : "";
     const contextSummary = context ? `Tech Stack: ${context.techStack.join(", ")}
 Existing files: ${context.fileStructure.slice(0, 20).join(", ")}` : "";
+    const installedPackagesSection = buildInstalledPackagesSection(context);
+    const sharedConfigSection = buildSharedConfigSection(context);
+    const dsl = await loadDslForSpec(specFilePath);
+    const dslSection = dsl ? `
+${buildDslContextSection(dsl)}
+` : "";
+    if (dsl) {
+      const cmpCount = dsl.components?.length ?? 0;
+      const cmpSuffix = cmpCount > 0 ? `, ${cmpCount} components` : "";
+      console.log(chalk6.green(`  \u2713 DSL loaded \u2014 ${dsl.endpoints.length} endpoints, ${dsl.models.length} models${cmpSuffix}`));
+    }
+    const isFrontend = isFrontendDeps(context?.dependencies ?? []);
+    let frontendSection = "";
+    if (isFrontend) {
+      const fctx = await loadFrontendContext(workingDir);
+      frontendSection = `
+${buildFrontendContextSection(fctx)}
+`;
+      console.log(chalk6.gray(`  Frontend context: ${fctx.framework} / ${fctx.httpClient} | hooks:${fctx.hookFiles.length} stores:${fctx.storeFiles.length}`));
+    }
     const tasks = await loadTasksForSpec(specFilePath);
     if (tasks && tasks.length > 0) {
-      return this.runApiModeWithTasks(spec, tasks, workingDir, constitutionSection);
+      return this.runApiModeWithTasks(spec, tasks, specFilePath, workingDir, constitutionSection + dslSection + installedPackagesSection, frontendSection, sharedConfigSection, options, systemPrompt, context);
     }
-    console.log(chalk3.gray("  [1/2] Planning implementation files..."));
+    console.log(chalk6.gray("  [1/2] Planning implementation files..."));
     const planPrompt = `Based on the feature spec and project context below, list ALL files that need to be created or modified.
 
+IMPORTANT: Check the "Existing Shared Config Files" section below FIRST. For any file listed there,
+use action "modify" (never "create") even if you are only adding new entries.
+IMPORTANT: Check the "Frontend Project Context" section below. Extend existing hooks/services/stores \u2014 do NOT create new parallel utilities.
+
 === Feature Spec ===
 ${spec}
-${constitutionSection}
+${constitutionSection}${dslSection}${frontendSection}${installedPackagesSection}${sharedConfigSection}
 === Project Context ===
 ${contextSummary}
 
@@ -3812,71 +5452,195 @@ Output ONLY a valid JSON array:
 ]`;
     let filePlan = [];
     try {
-      const planResponse = await this.provider.generate(planPrompt, codeGenSystemPrompt);
+      const planResponse = await this.provider.generate(planPrompt, systemPrompt);
       filePlan = parseJsonArray(planResponse);
     } catch (err) {
-      console.error(chalk3.red("  Failed to generate file plan:"), err);
+      console.error(chalk6.red("  Failed to generate file plan:"), err);
     }
     if (filePlan.length === 0) {
-      console.log(chalk3.yellow("  Could not determine file plan. Falling back to plan mode."));
-      return this.runPlanMode(specFilePath);
+      console.log(chalk6.yellow("  Could not determine file plan. Falling back to plan mode."));
+      await this.runPlanMode(specFilePath);
+      return [];
     }
-    console.log(chalk3.cyan(`
+    console.log(chalk6.cyan(`
   Plan: ${filePlan.length} file(s) to process`));
     filePlan.forEach((item) => {
-      const icon = item.action === "create" ? chalk3.green("+") : chalk3.yellow("~");
-      console.log(`  ${icon} ${item.file}: ${chalk3.gray(item.description)}`);
+      const icon = item.action === "create" ? chalk6.green("+") : chalk6.yellow("~");
+      console.log(`  ${icon} ${item.file}: ${chalk6.gray(item.description)}`);
     });
-    await this.generateFiles(filePlan, spec, workingDir, constitutionSection);
-  }
-  async runApiModeWithTasks(spec, tasks, workingDir, constitutionSection) {
-    console.log(chalk3.cyan(`
+    const { files } = await this.generateFiles(filePlan, spec, workingDir, constitutionSection + dslSection + frontendSection + installedPackagesSection, systemPrompt);
+    return files;
+  }
+  async runApiModeWithTasks(spec, tasks, specFilePath, workingDir, constitutionSection, frontendSection = "", sharedConfigSection = "", options = {}, systemPrompt = getCodeGenSystemPrompt(), context) {
+    const pendingTasks = tasks.filter((t) => t.status !== "done");
+    const doneCount = tasks.length - pendingTasks.length;
+    if (options.resume && doneCount > 0) {
+      console.log(chalk6.cyan(`
+  Task-based generation (resume): ${tasks.length} tasks (${chalk6.green(doneCount + " already done")}, skipping)`));
+    } else if (doneCount > 0) {
+      console.log(chalk6.cyan(`
+  Task-based generation: ${tasks.length} tasks (${chalk6.green(doneCount + " already done")}, resuming from checkpoint)`));
+    } else {
+      console.log(chalk6.cyan(`
   Task-based generation: ${tasks.length} tasks`));
+    }
+    const sharedConfigPaths = new Set(
+      (context?.sharedConfigFiles ?? []).map((f) => f.path)
+    );
+    const processedSharedConfigs = /* @__PURE__ */ new Set();
+    const generatedFileCache = /* @__PURE__ */ new Map();
     let totalSuccess = 0;
     let totalFiles = 0;
+    let completedTasks = doneCount;
+    const allGeneratedFiles = [];
     for (const task of tasks) {
-      console.log(chalk3.bold(`
-  \u2192 ${task.id} [${task.layer}] ${task.title}`));
-      if (task.filesToTouch.length === 0) {
-        console.log(chalk3.gray("    No files specified, skipping."));
-        continue;
+      if (task.status === "done") {
+        printTaskProgress(completedTasks++, tasks.length, task, "skip");
+      }
+    }
+    const LAYER_ORDER2 = ["data", "infra", "service", "api", "test"];
+    const layerGroups = [];
+    for (const layer of LAYER_ORDER2) {
+      const group = pendingTasks.filter((t) => t.layer === layer);
+      if (group.length > 0) layerGroups.push({ layer, tasks: group });
+    }
+    const unknownTasks = pendingTasks.filter((t) => !LAYER_ORDER2.includes(t.layer));
+    if (unknownTasks.length > 0) layerGroups.push({ layer: "other", tasks: unknownTasks });
+    for (const { layer, tasks: layerTasks } of layerGroups) {
+      const isParallel = layerTasks.length > 1;
+      const layerIcon = LAYER_ICONS[layer] ?? "  ";
+      if (isParallel) {
+        const pct = Math.round(completedTasks / tasks.length * 100);
+        const barWidth = 20;
+        const filled = Math.round(pct / 100 * barWidth);
+        const bar = chalk6.green("\u2588".repeat(filled)) + chalk6.gray("\u2591".repeat(barWidth - filled));
+        console.log(
+          chalk6.bold(`
+  [${bar}] ${pct}% \u26A1 Layer [${layer}] ${layerIcon} \u2014 ${layerTasks.length} tasks running in parallel`)
+        );
+      } else {
+        printTaskProgress(completedTasks, tasks.length, layerTasks[0], "run");
       }
-      const filePlan = task.filesToTouch.map((f) => ({
-        file: f,
-        action: "create",
-        description: task.description
-      }));
-      const taskContext = `Task: ${task.id} \u2014 ${task.title}
+      const generatedFilesSection = buildGeneratedFilesSection(generatedFileCache);
+      const taskResultPromises = layerTasks.map(async (task) => {
+        if (task.filesToTouch.length === 0) {
+          if (!isParallel) console.log(chalk6.gray("    No files specified, skipping."));
+          return { task, files: [], createdFiles: [], success: 0, total: 0, impliesRegistration: false };
+        }
+        const filePlan = await Promise.all(
+          task.filesToTouch.filter((f) => !sharedConfigPaths.has(f)).map(async (f) => {
+            const exists = await fs8.pathExists(path6.join(workingDir, f));
+            return {
+              file: f,
+              action: exists ? "modify" : "create",
+              description: task.description
+            };
+          })
+        );
+        const createsNewFiles = filePlan.some((f) => f.action === "create");
+        const taskText = `${task.title} ${task.description}`.toLowerCase();
+        const impliesRegistration = createsNewFiles && (taskText.includes("route") || taskText.includes("router") || taskText.includes("page") || taskText.includes("view") || taskText.includes("store") || taskText.includes("service") || taskText.includes("component") || taskText.includes("menu") || taskText.includes("navigation") || taskText.includes("\u6A21\u5757") || taskText.includes("\u9875\u9762") || taskText.includes("\u8DEF\u7531") || taskText.includes("\u6CE8\u518C"));
+        if (filePlan.length === 0) {
+          return { task, files: [], createdFiles: [], success: 0, total: 0, impliesRegistration };
+        }
+        const taskContext = `Task: ${task.id} \u2014 ${task.title}
 ${task.description}
 Acceptance: ${task.acceptanceCriteria.join("; ")}`;
-      const { success, total } = await this.generateFiles(
-        filePlan,
-        `${spec}
+        const { success, total, files } = await this.generateFiles(
+          filePlan,
+          `${spec}
 
 === Current Task ===
 ${taskContext}`,
-        workingDir,
-        constitutionSection
-      );
-      totalSuccess += success;
-      totalFiles += total;
+          workingDir,
+          constitutionSection + frontendSection + sharedConfigSection + generatedFilesSection,
+          systemPrompt,
+          isParallel ? task.id : void 0
+          // prefix output lines with task ID in parallel mode
+        );
+        const createdFiles = filePlan.filter((fp) => fp.action === "create").map((fp) => fp.file);
+        return { task, files, createdFiles, success, total, impliesRegistration };
+      });
+      const layerResults = await Promise.all(taskResultPromises);
+      if (isParallel) {
+        console.log("");
+      }
+      for (const result of layerResults) {
+        totalSuccess += result.success;
+        totalFiles += result.total;
+        allGeneratedFiles.push(...result.files);
+        if (isParallel) {
+          const icon = result.success === result.total ? chalk6.green("\u2714") : chalk6.yellow("!");
+          const layerTaskIcon = LAYER_ICONS[result.task.layer] ?? "  ";
+          console.log(`  ${icon} ${result.task.id} ${layerTaskIcon} ${result.task.title} \u2014 ${result.success}/${result.total} files`);
+        }
+        const taskStatus = result.success === result.total ? "done" : "failed";
+        await updateTaskStatus(specFilePath, result.task.id, taskStatus);
+        if (taskStatus === "failed") {
+          console.log(chalk6.yellow(`  \u26A0 ${result.task.id} marked as failed \u2014 re-run with --resume to retry`));
+        }
+      }
+      completedTasks += layerTasks.length;
+      for (const result of layerResults) {
+        for (const writtenFile of result.files) {
+          if (/src[\\/](api[s]?|services?|stores?|composables?)[\\/]/.test(writtenFile)) {
+            try {
+              const content = await fs8.readFile(path6.join(workingDir, writtenFile), "utf-8");
+              generatedFileCache.set(writtenFile, content);
+            } catch {
+            }
+          }
+        }
+      }
+      const anyImpliesRegistration = layerResults.some((r) => r.impliesRegistration);
+      if (anyImpliesRegistration && sharedConfigPaths.size > 0 && context?.sharedConfigFiles) {
+        const allCreatedInLayer = layerResults.flatMap((r) => r.createdFiles);
+        for (const sharedFile of context.sharedConfigFiles) {
+          if (processedSharedConfigs.has(sharedFile.path)) continue;
+          const newModuleNames = allCreatedInLayer.filter((f) => f !== sharedFile.path).map((f) => path6.basename(f).replace(/\.[jt]sx?$/, ""));
+          if (newModuleNames.length === 0 && sharedFile.category !== "route-index" && sharedFile.category !== "store-index") continue;
+          let purpose = `Register/update ${sharedFile.category} entries for the new feature`;
+          if ((sharedFile.category === "route-index" || sharedFile.category === "store-index") && newModuleNames.length > 0) {
+            purpose = `Add to this file: import ${newModuleNames.join(", ")} from their respective paths and register them in the export/default array. Do NOT remove any existing imports.`;
+          }
+          console.log(chalk6.gray(`
+    + updating shared config: ${sharedFile.path} [${sharedFile.category}]`));
+          const updatedGeneratedFilesSection = buildGeneratedFilesSection(generatedFileCache);
+          await this.generateFiles(
+            [{ file: sharedFile.path, action: "modify", description: purpose }],
+            `${spec}
+
+=== Context ===
+Updating shared registration after layer [${layer}] completed. New modules: ${newModuleNames.join(", ")}.`,
+            workingDir,
+            constitutionSection + frontendSection + sharedConfigSection + updatedGeneratedFilesSection,
+            systemPrompt
+          );
+          processedSharedConfigs.add(sharedFile.path);
+        }
+      }
     }
     console.log(
-      chalk3.bold(
+      chalk6.bold(
         `
-  ${totalSuccess === totalFiles ? chalk3.green("\u2714") : chalk3.yellow("!")} Task-based generation: ${totalSuccess}/${totalFiles} files written across ${tasks.length} tasks.`
+  ${totalSuccess === totalFiles ? chalk6.green("\u2714") : chalk6.yellow("!")} Task-based generation: ${totalSuccess}/${totalFiles} files written across ${pendingTasks.length} tasks.`
       )
     );
+    return allGeneratedFiles;
   }
-  async generateFiles(filePlan, spec, workingDir, constitutionSection) {
-    console.log(chalk3.gray(`
+  async generateFiles(filePlan, spec, workingDir, constitutionSection, systemPrompt = getCodeGenSystemPrompt(), taskLabel) {
+    const prefix = taskLabel ? `  [${chalk6.cyan(taskLabel)}] ` : "  ";
+    if (!taskLabel) {
+      console.log(chalk6.gray(`
   Generating ${filePlan.length} file(s)...`));
+    }
     let successCount = 0;
+    const writtenFiles = [];
     for (const item of filePlan) {
-      const fullPath = path3.join(workingDir, item.file);
+      const fullPath = path6.join(workingDir, item.file);
       let existingContent = "";
-      if (await fs4.pathExists(fullPath)) {
-        existingContent = await fs4.readFile(fullPath, "utf-8");
+      if (await fs8.pathExists(fullPath)) {
+        existingContent = await fs8.readFile(fullPath, "utf-8");
       }
       const codePrompt = `Implement this file.
 
@@ -3888,30 +5652,31 @@ ${spec}
 ${constitutionSection}
 === ${existingContent ? "Existing content (modify and return the complete file)" : "Create this file from scratch"} ===
 ${existingContent || "Output only the complete file content."}`;
-      process.stdout.write(`  ${existingContent ? chalk3.yellow("~") : chalk3.green("+")} ${chalk3.bold(item.file)}... `);
       try {
-        const raw = await this.provider.generate(codePrompt, codeGenSystemPrompt);
+        const raw = await this.provider.generate(codePrompt, systemPrompt);
         const fileContent = stripCodeFences(raw);
-        await fs4.ensureDir(path3.dirname(fullPath));
-        await fs4.writeFile(fullPath, fileContent, "utf-8");
-        console.log(chalk3.green("\u2714"));
+        await fs8.ensureDir(path6.dirname(fullPath));
+        await fs8.writeFile(fullPath, fileContent, "utf-8");
+        console.log(`${prefix}${existingContent ? chalk6.yellow("~") : chalk6.green("+")} ${chalk6.bold(item.file)} ${chalk6.green("\u2714")}`);
         successCount++;
+        writtenFiles.push(item.file);
       } catch (err) {
-        console.log(chalk3.red("\u2718"));
-        console.error(chalk3.red(`    Error: ${err.message}`));
+        console.log(`${prefix}${chalk6.red("\u2718")} ${chalk6.bold(item.file)} \u2014 ${chalk6.red(err.message)}`);
       }
     }
-    console.log(
-      chalk3.bold(
-        `  ${successCount === filePlan.length ? chalk3.green("\u2714") : chalk3.yellow("!")} ${successCount}/${filePlan.length} files written.`
-      )
-    );
-    return { success: successCount, total: filePlan.length };
+    if (!taskLabel) {
+      console.log(
+        chalk6.bold(
+          `  ${successCount === filePlan.length ? chalk6.green("\u2714") : chalk6.yellow("!")} ${successCount}/${filePlan.length} files written.`
+        )
+      );
+    }
+    return { success: successCount, total: filePlan.length, files: writtenFiles };
   }
   // ── Mode: plan ─────────────────────────────────────────────────────────────
   async runPlanMode(specFilePath) {
-    console.log(chalk3.blue("\n\u2500\u2500\u2500 Implementation Plan \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    const spec = await fs4.readFile(specFilePath, "utf-8");
+    console.log(chalk6.blue("\n\u2500\u2500\u2500 Implementation Plan \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    const spec = await fs8.readFile(specFilePath, "utf-8");
     const plan = await this.provider.generate(
       `Create a detailed, step-by-step implementation plan for the following feature spec.
 Be specific about:
@@ -3923,22 +5688,95 @@ Be specific about:
 ${spec}`,
       "You are a senior developer creating an actionable implementation guide."
     );
-    console.log(chalk3.cyan("\n") + plan);
+    console.log(chalk6.cyan("\n") + plan);
   }
 };
+var LAYER_ICONS = {
+  data: "\u{1F4BE}",
+  infra: "\u2699\uFE0F ",
+  service: "\u{1F527}",
+  api: "\u{1F310}",
+  test: "\u{1F9EA}"
+};
+function printTaskProgress(completed, total, task, mode) {
+  const pct = total > 0 ? Math.round(completed / total * 100) : 0;
+  const barWidth = 20;
+  const filled = Math.round(pct / 100 * barWidth);
+  const bar = chalk6.green("\u2588".repeat(filled)) + chalk6.gray("\u2591".repeat(barWidth - filled));
+  const icon = LAYER_ICONS[task.layer] ?? "  ";
+  if (mode === "skip") {
+    console.log(
+      chalk6.gray(`
+  [${bar}] ${pct}% \u2713 ${task.id} ${icon} ${task.title} \u2014 already done`)
+    );
+  } else {
+    console.log(
+      chalk6.bold(`
+  [${bar}] ${pct}% \u2192 ${task.id} ${icon} ${task.title}`)
+    );
+  }
+}
 
 // core/reviewer.ts
-import chalk4 from "chalk";
+import chalk7 from "chalk";
 import { execSync as execSync2 } from "child_process";
+import * as path7 from "path";
+import * as fs9 from "fs-extra";
+var REVIEW_HISTORY_FILE = ".ai-spec-reviews.json";
+async function loadReviewHistory(projectRoot) {
+  const historyPath = path7.join(projectRoot, REVIEW_HISTORY_FILE);
+  try {
+    if (await fs9.pathExists(historyPath)) {
+      return await fs9.readJson(historyPath);
+    }
+  } catch {
+  }
+  return [];
+}
+async function appendReviewHistory(projectRoot, entry) {
+  const historyPath = path7.join(projectRoot, REVIEW_HISTORY_FILE);
+  const existing = await loadReviewHistory(projectRoot);
+  const updated = [...existing, entry].slice(-20);
+  try {
+    await fs9.writeJson(historyPath, updated, { spaces: 2 });
+  } catch {
+  }
+}
+function extractScore(reviewText) {
+  const match = reviewText.match(/Score:\s*(\d+(?:\.\d+)?)\s*\/\s*10/i);
+  return match ? parseFloat(match[1]) : 0;
+}
+function extractTopIssues(reviewText) {
+  const issuesSection = reviewText.match(/##.*?问题.*?\n([\s\S]*?)(?=##|$)/i)?.[1] ?? "";
+  return issuesSection.split("\n").filter((l) => /^[-·•*]/.test(l.trim())).map((l) => l.replace(/^[-·•*]\s*/, "").trim()).filter(Boolean).slice(0, 3);
+}
+function buildHistoryContext(history) {
+  if (history.length === 0) return "";
+  const recent = history.slice(-5);
+  const lines = ["\n=== \u5386\u53F2\u5BA1\u67E5\u95EE\u9898 (Past Review Issues \u2014 check if any recur) ==="];
+  for (const entry of recent) {
+    lines.push(`
+[${entry.date}] ${path7.basename(entry.specFile)} \u2014 Score: ${entry.score}/10`);
+    entry.topIssues.forEach((issue) => lines.push(`  \xB7 ${issue}`));
+  }
+  return lines.join("\n") + "\n";
+}
 var CodeReviewer = class {
-  constructor(provider) {
+  constructor(provider, projectRoot = process.cwd()) {
     this.provider = provider;
+    this.projectRoot = projectRoot;
   }
   getGitDiff() {
+    const silent = { encoding: "utf-8", stdio: "pipe" };
+    try {
+      execSync2("git rev-parse --is-inside-work-tree", silent);
+    } catch {
+      return "";
+    }
     try {
-      let diff = execSync2("git diff --cached", { encoding: "utf-8" });
-      if (!diff.trim()) diff = execSync2("git diff HEAD", { encoding: "utf-8" });
-      if (!diff.trim()) diff = execSync2("git diff", { encoding: "utf-8" });
+      let diff = execSync2("git diff --cached", silent);
+      if (!diff.trim()) diff = execSync2("git diff HEAD", silent);
+      if (!diff.trim()) diff = execSync2("git diff", silent);
       return diff;
     } catch {
       return "";
@@ -3952,42 +5790,135 @@ var CodeReviewer = class {
       removed: lines.filter((l) => l.startsWith("-") && !l.startsWith("---")).length
     };
   }
-  async reviewCode(specContent) {
-    console.log(chalk4.cyan("\n\u2500\u2500\u2500 Automated Code Review \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  /**
+   * Two-pass review:
+   *   Pass 1 — architecture (spec compliance, layer separation, auth)
+   *   Pass 2 — implementation details (validation, error handling, edge cases)
+   *             + historical issue recurrence check
+   *
+   * Falls back to single-pass if the two-pass flag is not set.
+   */
+  async runTwoPassReview(specContent, codeContext, specFile) {
+    console.log(chalk7.gray("  Pass 1/2: Architecture review..."));
+    const archPrompt = `Review the architecture of this change.
+
+=== Feature Spec ===
+${specContent || "(No spec \u2014 review for general code quality)"}
+
+=== Code ===
+${codeContext}`;
+    const archReview = await this.provider.generate(archPrompt, reviewArchitectureSystemPrompt);
+    console.log(chalk7.gray("  Pass 2/2: Implementation review..."));
+    const history = await loadReviewHistory(this.projectRoot);
+    const historyContext = buildHistoryContext(history);
+    const implPrompt = `Review the implementation details of this change.
+
+=== Feature Spec ===
+${specContent || "(No spec \u2014 review for general code quality)"}
+
+=== Code ===
+${codeContext}
+
+=== Architecture Review (Pass 1 \u2014 do NOT repeat these findings) ===
+${archReview}
+${historyContext}`;
+    const implReview = await this.provider.generate(implPrompt, reviewImplementationSystemPrompt);
+    const combined = `${archReview}
+
+${"\u2500".repeat(52)}
+
+${implReview}`;
+    const score = extractScore(implReview) || extractScore(archReview);
+    const topIssues = extractTopIssues(implReview);
+    if (score > 0 && specFile) {
+      await appendReviewHistory(this.projectRoot, {
+        date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+        specFile: path7.relative(this.projectRoot, specFile),
+        score,
+        topIssues
+      });
+    }
+    return combined;
+  }
+  async reviewCode(specContent, specFile) {
+    console.log(chalk7.cyan("\n\u2500\u2500\u2500 Automated Code Review \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     const diff = this.getGitDiff();
     if (!diff.trim()) {
       console.log(
-        chalk4.yellow("  No git diff found. Stage or commit changes first, then run review.")
+        chalk7.yellow("  No git diff found. Stage or commit changes first, then run review.")
       );
-      console.log(chalk4.gray("  Tip: run `git add .` then `ai-spec review` to review your work."));
+      console.log(chalk7.gray("  Tip: run `git add .` then `ai-spec review` to review your work."));
       return "No changes";
     }
     const { files, added, removed } = this.getDiffStats(diff);
     console.log(
-      chalk4.gray(`  Diff: ${files} file(s), ${chalk4.green("+" + added)} ${chalk4.red("-" + removed)}`)
+      chalk7.gray(`  Diff: ${files} file(s), ${chalk7.green("+" + added)} ${chalk7.red("-" + removed)}`)
+    );
+    console.log(
+      chalk7.blue(`  Reviewing with ${this.provider.providerName}/${this.provider.modelName}...`)
     );
+    const codeContext = diff.slice(0, 1e4);
+    const reviewResult = await this.runTwoPassReview(specContent, codeContext, specFile);
+    console.log(chalk7.cyan("\n\u2500\u2500\u2500 Review Result \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(reviewResult);
+    console.log(chalk7.cyan("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
+    return reviewResult;
+  }
+  /**
+   * Review directly from generated file contents (for api mode where git diff is empty).
+   */
+  async reviewFiles(specContent, filePaths, workingDir, specFile) {
+    console.log(chalk7.cyan("\n\u2500\u2500\u2500 Automated Code Review (file-based) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk7.gray(`  Reviewing ${filePaths.length} generated file(s)...`));
     console.log(
-      chalk4.blue(`  Reviewing with ${this.provider.providerName}/${this.provider.modelName}...`)
+      chalk7.blue(`  Reviewing with ${this.provider.providerName}/${this.provider.modelName}...`)
     );
-    const prompt = `Conduct a code review for the following change.
+    let filesSection = "";
+    for (const filePath of filePaths) {
+      const fullPath = path7.join(workingDir, filePath);
+      try {
+        const content = await fs9.readFile(fullPath, "utf-8");
+        filesSection += `
 
-=== Feature Spec (what should be implemented) ===
-${specContent || "(No spec provided \u2014 review for general code quality, patterns, and correctness)"}
+=== ${filePath} ===
+${content.slice(0, 3e3)}`;
+        if (content.length > 3e3) filesSection += `
+... (truncated, ${content.length} chars total)`;
+      } catch {
+        filesSection += `
 
-=== Git Diff (what was actually implemented) ===
-${diff.slice(0, 1e4)}`;
-    const reviewResult = await this.provider.generate(prompt, reviewSystemPrompt);
-    console.log(chalk4.cyan("\n\u2500\u2500\u2500 Review Result \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+=== ${filePath} ===
+(file not found)`;
+      }
+    }
+    const reviewResult = await this.runTwoPassReview(specContent, filesSection, specFile);
+    console.log(chalk7.cyan("\n\u2500\u2500\u2500 Review Result \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     console.log(reviewResult);
-    console.log(chalk4.cyan("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
+    console.log(chalk7.cyan("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
     return reviewResult;
   }
+  /** Print score trend from history (last N reviews) */
+  async printScoreTrend(limit = 5) {
+    const history = await loadReviewHistory(this.projectRoot);
+    if (history.length === 0) {
+      console.log(chalk7.gray("  No review history yet."));
+      return;
+    }
+    const recent = history.slice(-limit);
+    console.log(chalk7.cyan("\n\u2500\u2500\u2500 Review Score Trend \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    for (const entry of recent) {
+      const bar = "\u2588".repeat(entry.score) + "\u2591".repeat(10 - entry.score);
+      const color = entry.score >= 8 ? chalk7.green : entry.score >= 6 ? chalk7.yellow : chalk7.red;
+      console.log(`  ${entry.date}  [${color(bar)}] ${color(entry.score + "/10")}  ${path7.basename(entry.specFile)}`);
+    }
+    console.log(chalk7.cyan("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  }
 };
 
 // core/constitution-generator.ts
-import chalk5 from "chalk";
-import * as fs5 from "fs-extra";
-import * as path4 from "path";
+import chalk8 from "chalk";
+import * as fs10 from "fs-extra";
+import * as path8 from "path";
 
 // prompts/constitution.prompt.ts
 var constitutionSystemPrompt = `You are a Senior Software Architect. Analyze the provided project codebase context and generate a concise "Project Constitution" \u2014 a living document that captures the architectural rules, conventions, and red lines that ALL future feature specs and code generation MUST follow.
@@ -4035,9 +5966,24 @@ Output a Markdown document with EXACTLY these sections. Be specific and derive r
 - \u5FC5\u987B\u8986\u76D6\u7684\u6D4B\u8BD5\u573A\u666F\u7C7B\u578B
 - \u6D4B\u8BD5\u6846\u67B6\u548C\u5DE5\u5177
 
+## 8. \u5171\u4EAB\u914D\u7F6E\u6587\u4EF6\u6E05\u5355 (Shared Config Files \u2014 Append-Only)
+
+CRITICAL: The following files are **singleton config files** that already exist in the project.
+When any feature needs to add entries (translations, constants, routes, enums, etc.), they MUST be
+appended/merged into these existing files. **NEVER create a new parallel file.**
+
+For each discovered file, list it as:
+- \`<relative-path>\` \u2014 <category> \u2014 **MODIFY ONLY, never recreate**
+
+If the project context includes i18n/locale files: list ALL of them with their paths.
+If the project context includes constants/enums files: list ALL of them.
+If the project context includes route index files: list ALL of them.
+If none are provided in the context, write: "(No shared config files detected \u2014 will be populated on first run)"
+
 ---
 
-Be concise. Each rule must be specific enough to enforce, not a vague principle.`;
+Be concise. Each rule must be specific enough to enforce, not a vague principle.
+**Section 8 is the most important section for preventing file duplication bugs.**`;
 
 // core/constitution-generator.ts
 var CONSTITUTION_FILE = ".ai-spec-constitution.md";
@@ -4052,8 +5998,8 @@ var ConstitutionGenerator = class {
     return this.provider.generate(prompt, constitutionSystemPrompt);
   }
   async saveConstitution(projectRoot, content) {
-    const filePath = path4.join(projectRoot, CONSTITUTION_FILE);
-    await fs5.writeFile(filePath, content, "utf-8");
+    const filePath = path8.join(projectRoot, CONSTITUTION_FILE);
+    await fs10.writeFile(filePath, content, "utf-8");
     return filePath;
   }
 };
@@ -4085,32 +6031,88 @@ ${context.schema.slice(0, 4e3)}
   if (context.errorPatterns) {
     parts.push(`=== Error Handling Patterns ===
 ${context.errorPatterns}
+`);
+  }
+  if (context.sharedConfigFiles && context.sharedConfigFiles.length > 0) {
+    const grouped = context.sharedConfigFiles.reduce(
+      (acc, f) => {
+        (acc[f.category] ??= []).push(f);
+        return acc;
+      },
+      {}
+    );
+    const sections = [];
+    for (const [category, files] of Object.entries(grouped)) {
+      sections.push(`--- ${category} ---`);
+      for (const f of files) {
+        sections.push(`File: ${f.path}
+${f.preview.slice(0, 600)}
+`);
+      }
+    }
+    parts.push(`=== Existing Shared Config Files (Append-Only \u2014 NEVER Recreate) ===
+${sections.join("\n")}
 `);
   }
   return parts.join("\n");
 }
 async function loadConstitution(projectRoot) {
-  const filePath = path4.join(projectRoot, CONSTITUTION_FILE);
-  if (await fs5.pathExists(filePath)) {
-    return fs5.readFile(filePath, "utf-8");
+  const filePath = path8.join(projectRoot, CONSTITUTION_FILE);
+  if (await fs10.pathExists(filePath)) {
+    return fs10.readFile(filePath, "utf-8");
   }
   return void 0;
 }
 function printConstitutionHint(exists) {
   if (!exists) {
     console.log(
-      chalk5.yellow(
+      chalk8.yellow(
         "  \u26A1 Tip: Run `ai-spec init` to generate a Project Constitution for better spec quality."
       )
     );
   }
 }
 
+// core/combined-generator.ts
+var TASKS_SEPARATOR = "---TASKS_JSON---";
+var tasksInstruction = `
+
+---
+After outputting the complete spec above, append EXACTLY this line on its own (no extra text before or after it):
+${TASKS_SEPARATOR}
+Then output a valid JSON array of implementation tasks. Each element must have these exact fields:
+{"id":"TASK-001","title":"...","description":"1-2 sentences, specific","layer":"data|infra|service|api|test","filesToTouch":["src/..."],"acceptanceCriteria":["verifiable condition"],"dependencies":[],"priority":"high|medium|low"}
+Layer order: data \u2192 infra \u2192 service \u2192 api \u2192 test. 4-10 tasks total. filesToTouch must use real paths from the project context.`;
+async function generateSpecWithTasks(provider, idea, context) {
+  const contextBlock = buildTaskPrompt("", context).trim();
+  const fullPrompt = [idea, contextBlock].filter(Boolean).join("\n\n");
+  const combinedSystemPrompt = specPrompt + tasksInstruction;
+  const raw = await provider.generate(fullPrompt, combinedSystemPrompt);
+  return parseSpecAndTasks(raw);
+}
+function parseSpecAndTasks(raw) {
+  const sepIdx = raw.indexOf(TASKS_SEPARATOR);
+  if (sepIdx === -1) {
+    return { spec: raw.trim(), tasks: [] };
+  }
+  const spec = raw.slice(0, sepIdx).trim();
+  const tasksRaw = raw.slice(sepIdx + TASKS_SEPARATOR.length).trim();
+  let tasks = [];
+  try {
+    const jsonMatch = tasksRaw.match(/\[[\s\S]*\]/);
+    if (jsonMatch) {
+      tasks = JSON.parse(jsonMatch[0]);
+    }
+  } catch {
+  }
+  return { spec, tasks };
+}
+
 // git/worktree.ts
 import { execSync as execSync3 } from "child_process";
-import * as path5 from "path";
-import * as fs6 from "fs-extra";
-import chalk6 from "chalk";
+import * as path9 from "path";
+import * as fs11 from "fs-extra";
+import chalk9 from "chalk";
 var GitWorktreeManager = class {
   constructor(baseDir) {
     this.baseDir = baseDir;
@@ -4126,38 +6128,73 @@ var GitWorktreeManager = class {
   sanitizeFeatureName(idea) {
     return idea.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").substring(0, 30) || `feature-${Date.now()}`;
   }
+  /**
+   * Symlink dependency directories from the base repo into the worktree so that
+   * tools like `vite`, `tsc`, etc. are available without re-installing.
+   *
+   * Handles: node_modules (npm/yarn/pnpm), vendor (PHP Composer)
+   */
+  async linkDependencies(worktreePath) {
+    const candidates = ["node_modules", "vendor"];
+    for (const dir of candidates) {
+      const src = path9.join(this.baseDir, dir);
+      const dest = path9.join(worktreePath, dir);
+      if (!await fs11.pathExists(src)) continue;
+      if (await fs11.pathExists(dest)) continue;
+      try {
+        await fs11.ensureSymlink(src, dest, "dir");
+        console.log(chalk9.gray(`  Symlinked ${dir}/ from base repo \u2192 worktree`));
+      } catch (err) {
+        console.log(chalk9.yellow(`  \u26A0 Could not symlink ${dir}/: ${err.message}`));
+        console.log(chalk9.yellow(`    Run \`npm install\` inside the worktree manually.`));
+      }
+    }
+  }
   async createWorktree(idea) {
     if (!this.isGitRepo()) {
-      console.log(chalk6.yellow("\u26A0\uFE0F Not a git repository. Skipping worktree creation."));
+      console.log(chalk9.yellow("\u26A0\uFE0F Not a git repository. Skipping worktree creation."));
       return null;
     }
     const featureName = this.sanitizeFeatureName(idea);
     const branchName = `feature/${featureName}`;
-    const repoName = path5.basename(this.baseDir);
-    const worktreePath = path5.resolve(this.baseDir, "..", `${repoName}-${featureName}`);
-    console.log(chalk6.cyan(`
+    const repoName = path9.basename(this.baseDir);
+    const worktreePath = path9.resolve(this.baseDir, "..", `${repoName}-${featureName}`);
+    console.log(chalk9.cyan(`
 --- Setting up Git Worktree ---`));
-    if (await fs6.pathExists(worktreePath)) {
-      console.log(chalk6.yellow(`\u26A0\uFE0F Worktree directory already exists at: ${worktreePath}`));
+    if (await fs11.pathExists(worktreePath)) {
+      console.log(chalk9.yellow(`\u26A0\uFE0F Worktree directory already exists at: ${worktreePath}`));
+      await this.linkDependencies(worktreePath);
       return worktreePath;
     }
     try {
       let branchExists = false;
       try {
-        execSync3(`git show-ref --verify refs/heads/${branchName}`, { cwd: this.baseDir, stdio: "ignore" });
+        execSync3(`git show-ref --verify refs/heads/${branchName}`, {
+          cwd: this.baseDir,
+          stdio: "ignore"
+        });
         branchExists = true;
       } catch {
       }
-      console.log(chalk6.gray(`Creating worktree at: ${worktreePath}`));
+      console.log(chalk9.gray(`Creating worktree at: ${worktreePath}`));
       if (branchExists) {
-        execSync3(`git worktree add "${worktreePath}" ${branchName}`, { cwd: this.baseDir, stdio: "inherit" });
+        execSync3(`git worktree add "${worktreePath}" ${branchName}`, {
+          cwd: this.baseDir,
+          stdio: "inherit"
+        });
       } else {
-        execSync3(`git worktree add -b ${branchName} "${worktreePath}"`, { cwd: this.baseDir, stdio: "inherit" });
+        execSync3(`git worktree add -b ${branchName} "${worktreePath}"`, {
+          cwd: this.baseDir,
+          stdio: "inherit"
+        });
       }
-      console.log(chalk6.green(`\u2714 Worktree successfully created and isolated on branch '${branchName}'`));
+      console.log(
+        chalk9.green(`\u2714 Worktree successfully created and isolated on branch '${branchName}'`)
+      );
+      await this.linkDependencies(worktreePath);
       return worktreePath;
     } catch (error) {
-      console.error(chalk6.red("Failed to create git worktree:"), error);
+      console.error(chalk9.red("Failed to create git worktree:"), error);
       return null;
     }
   }
@@ -4171,18 +6208,25 @@ export {
   ContextLoader,
   DEFAULT_MODELS,
   ENV_KEY_MAP,
+  FRONTEND_FRAMEWORKS,
   GeminiProvider,
   GitWorktreeManager,
+  MiMoProvider,
   OpenAICompatibleProvider,
   PROVIDER_CATALOG,
   SUPPORTED_PROVIDERS,
   SpecGenerator,
   SpecRefiner,
   TaskGenerator,
+  buildTaskPrompt,
   createProvider,
+  generateSpecWithTasks,
+  isFrontendDeps,
   loadConstitution,
   loadTasksForSpec,
   printConstitutionHint,
-  printTasks
+  printTaskProgress,
+  printTasks,
+  updateTaskStatus
 };
 //# sourceMappingURL=index.mjs.map