ai-spec-dev 0.46.0 → 0.55.0

package/dist/index.mjs

@@ -339,12 +339,12 @@ var PROVIDER_CATALOG = {
   },
   deepseek: {
     displayName: "DeepSeek",
-    description: "DeepSeek \u2014 V3 (chat) / R1 (reasoning)",
+    description: "DeepSeek V3.2 (chat) / R1 (reasoner) \u2014 alias auto-tracks latest stable",
     models: [
       "deepseek-chat",
-      // DeepSeek-V3
+      // V3.2 (alias auto-updates as DeepSeek releases new versions)
       "deepseek-reasoner"
-      // DeepSeek-R1
+      // R1 (reasoning model)
     ],
     envKey: "DEEPSEEK_API_KEY",
     baseURL: "https://api.deepseek.com/v1"
@@ -4167,8 +4167,8 @@ ${currentSpec}`,
 // core/code-generator.ts
 import chalk10 from "chalk";
 import { execSync as execSync2, spawnSync } from "child_process";
-import * as path6 from "path";
-import * as fs10 from "fs-extra";
+import * as path7 from "path";
+import * as fs11 from "fs-extra";
 
 // prompts/codegen.prompt.ts
 var codeGenSystemPrompt = `You are a Senior Full-Stack Developer implementing features based on provided specifications.
@@ -4838,32 +4838,32 @@ function validateDsl(raw) {
   }
   return { valid: true, dsl: raw };
 }
-function validateFeature(raw, path10, errors) {
+function validateFeature(raw, path11, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path11, 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);
+  requireNonEmptyString(f["id"], `${path11}.id`, errors);
+  requireNonEmptyString(f["title"], `${path11}.title`, errors);
+  requireNonEmptyString(f["description"], `${path11}.description`, errors);
 }
-function validateModel(raw, path10, errors) {
+function validateModel(raw, path11, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path11, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const m = raw;
-  requireNonEmptyString(m["name"], `${path10}.name`, errors);
+  requireNonEmptyString(m["name"], `${path11}.name`, errors);
   if (!Array.isArray(m["fields"])) {
-    errors.push({ path: `${path10}.fields`, message: `Must be an array, got: ${typeLabel(m["fields"])}` });
+    errors.push({ path: `${path11}.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})` });
+      errors.push({ path: `${path11}.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);
+      validateModelField(fields[j2], `${path11}.fields[${j2}]`, errors);
     }
     const seenFieldNames = /* @__PURE__ */ new Set();
     for (let j2 = 0; j2 < Math.min(fields.length, MAX_FIELDS_PER_MODEL); j2++) {
@@ -4872,7 +4872,7 @@ function validateModel(raw, path10, errors) {
         const name = f["name"];
         if (seenFieldNames.has(name)) {
           errors.push({
-            path: `${path10}.fields[${j2}].name`,
+            path: `${path11}.fields[${j2}].name`,
             message: `Duplicate field name "${name}" \u2014 each field within a model must have a unique name`
           });
         } else {
@@ -4883,184 +4883,184 @@ function validateModel(raw, path10, 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" });
+      errors.push({ path: `${path11}.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" });
+          errors.push({ path: `${path11}.relations[${j2}]`, message: "Must be a string" });
         }
       }
     }
   }
 }
-function validateModelField(raw, path10, errors) {
+function validateModelField(raw, path11, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path11, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const f = raw;
-  requireNonEmptyString(f["name"], `${path10}.name`, errors);
-  requireNonEmptyString(f["type"], `${path10}.type`, errors);
+  requireNonEmptyString(f["name"], `${path11}.name`, errors);
+  requireNonEmptyString(f["type"], `${path11}.type`, errors);
   if (typeof f["required"] !== "boolean") {
-    errors.push({ path: `${path10}.required`, message: `Must be boolean, got: ${typeLabel(f["required"])}` });
+    errors.push({ path: `${path11}.required`, message: `Must be boolean, got: ${typeLabel(f["required"])}` });
   }
 }
-function validateEndpoint(raw, path10, errors) {
+function validateEndpoint(raw, path11, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path11, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const e = raw;
-  requireNonEmptyString(e["id"], `${path10}.id`, errors);
-  requireNonEmptyString(e["description"], `${path10}.description`, errors);
+  requireNonEmptyString(e["id"], `${path11}.id`, errors);
+  requireNonEmptyString(e["description"], `${path11}.description`, errors);
   if (!VALID_METHODS.includes(e["method"])) {
     errors.push({
-      path: `${path10}.method`,
+      path: `${path11}.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`,
+      path: `${path11}.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"])}` });
+    errors.push({ path: `${path11}.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`,
+      path: `${path11}.successStatus`,
       message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["successStatus"])}`
     });
   }
-  requireNonEmptyString(e["successDescription"], `${path10}.successDescription`, errors);
+  requireNonEmptyString(e["successDescription"], `${path11}.successDescription`, errors);
   if (e["request"] !== void 0) {
-    validateRequestSchema(e["request"], `${path10}.request`, errors);
+    validateRequestSchema(e["request"], `${path11}.request`, errors);
   }
   if (e["errors"] !== void 0) {
     if (!Array.isArray(e["errors"])) {
-      errors.push({ path: `${path10}.errors`, message: "Must be an array if present" });
+      errors.push({ path: `${path11}.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})` });
+        errors.push({ path: `${path11}.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);
+        validateResponseError(errs[j2], `${path11}.errors[${j2}]`, errors);
       }
     }
   }
 }
-function validateRequestSchema(raw, path10, errors) {
+function validateRequestSchema(raw, path11, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path11, 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);
+      validateFieldMap(r[key], `${path11}.${key}`, errors);
     }
   }
 }
-function validateFieldMap(raw, path10, errors) {
+function validateFieldMap(raw, path11, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path10, message: `Must be a flat object (FieldMap), got: ${typeLabel(raw)}` });
+    errors.push({ path: path11, 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)}` });
+      errors.push({ path: `${path11}.${k2}`, message: `Value must be a type-description string, got: ${typeLabel(v2)}` });
     }
   }
 }
-function validateResponseError(raw, path10, errors) {
+function validateResponseError(raw, path11, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path11, 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"])}` });
+    errors.push({ path: `${path11}.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);
+  requireNonEmptyString(e["code"], `${path11}.code`, errors);
+  requireNonEmptyString(e["description"], `${path11}.description`, errors);
 }
-function validateBehavior(raw, path10, errors) {
+function validateBehavior(raw, path11, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path11, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const b = raw;
-  requireNonEmptyString(b["id"], `${path10}.id`, errors);
-  requireNonEmptyString(b["description"], `${path10}.description`, errors);
+  requireNonEmptyString(b["id"], `${path11}.id`, errors);
+  requireNonEmptyString(b["description"], `${path11}.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" });
+      errors.push({ path: `${path11}.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" });
+          errors.push({ path: `${path11}.constraints[${j2}]`, message: "Must be a string" });
         }
       }
     }
   }
 }
-function validateComponent(raw, path10, errors) {
+function validateComponent(raw, path11, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path10, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path11, 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);
+  requireNonEmptyString(c["id"], `${path11}.id`, errors);
+  requireNonEmptyString(c["name"], `${path11}.name`, errors);
+  requireNonEmptyString(c["description"], `${path11}.description`, errors);
   if (c["props"] !== void 0) {
     if (!Array.isArray(c["props"])) {
-      errors.push({ path: `${path10}.props`, message: "Must be an array if present" });
+      errors.push({ path: `${path11}.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" });
+          errors.push({ path: `${path11}.props[${j2}]`, message: "Must be an object" });
           continue;
         }
-        requireNonEmptyString(p["name"], `${path10}.props[${j2}].name`, errors);
-        requireNonEmptyString(p["type"], `${path10}.props[${j2}].type`, errors);
+        requireNonEmptyString(p["name"], `${path11}.props[${j2}].name`, errors);
+        requireNonEmptyString(p["type"], `${path11}.props[${j2}].type`, errors);
         if (typeof p["required"] !== "boolean") {
-          errors.push({ path: `${path10}.props[${j2}].required`, message: "Must be boolean" });
+          errors.push({ path: `${path11}.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" });
+      errors.push({ path: `${path11}.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" });
+          errors.push({ path: `${path11}.events[${j2}]`, message: "Must be an object" });
           continue;
         }
-        requireNonEmptyString(e["name"], `${path10}.events[${j2}].name`, errors);
+        requireNonEmptyString(e["name"], `${path11}.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" });
+      errors.push({ path: `${path11}.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" });
+      errors.push({ path: `${path11}.apiCalls`, message: "Must be an array of strings if present" });
     }
   }
 }
@@ -5122,10 +5122,10 @@ function crossReferenceChecks(obj, errors) {
     }
   }
 }
-function requireNonEmptyString(v2, path10, errors) {
+function requireNonEmptyString(v2, path11, errors) {
   if (typeof v2 !== "string" || v2.trim().length === 0) {
     errors.push({
-      path: path10,
+      path: path11,
       message: `Must be a non-empty string, got: ${typeLabel(v2)}`
     });
   }
@@ -6014,6 +6014,101 @@ function printTaskProgress(completed, total, task, mode) {
   }
 }
 
+// core/fix-history.ts
+import * as fs10 from "fs-extra";
+import * as path6 from "path";
+var FIX_HISTORY_FILE = ".ai-spec-fix-history.json";
+var FIX_HISTORY_VERSION = "1.0";
+async function loadFixHistory(repoRoot) {
+  const filePath = path6.join(repoRoot, FIX_HISTORY_FILE);
+  if (!await fs10.pathExists(filePath)) {
+    return { version: FIX_HISTORY_VERSION, entries: [] };
+  }
+  try {
+    const data = await fs10.readJson(filePath);
+    if (!data || typeof data !== "object" || !Array.isArray(data.entries)) {
+      return { version: FIX_HISTORY_VERSION, entries: [] };
+    }
+    return {
+      version: typeof data.version === "string" ? data.version : FIX_HISTORY_VERSION,
+      entries: data.entries
+    };
+  } catch {
+    return { version: FIX_HISTORY_VERSION, entries: [] };
+  }
+}
+function aggregateFixPatterns(history) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of history.entries) {
+    if (!byKey.has(entry.patternKey)) byKey.set(entry.patternKey, []);
+    byKey.get(entry.patternKey).push(entry);
+  }
+  const aggregates = [];
+  for (const [patternKey, entries] of byKey) {
+    entries.sort((a, b) => a.ts.localeCompare(b.ts));
+    const first = entries[0];
+    const last = entries[entries.length - 1];
+    const uniqueRunIds = new Set(entries.map((e) => e.runId)).size;
+    aggregates.push({
+      patternKey,
+      count: entries.length,
+      firstSeen: first.ts,
+      lastSeen: last.ts,
+      uniqueRunIds,
+      source: last.brokenImport.source,
+      names: last.brokenImport.names,
+      reason: last.brokenImport.reason,
+      fix: {
+        kind: last.fix.kind,
+        target: last.fix.target,
+        stage: last.fix.stage
+      }
+    });
+  }
+  aggregates.sort((a, b) => {
+    if (b.count !== a.count) return b.count - a.count;
+    return b.lastSeen.localeCompare(a.lastSeen);
+  });
+  return aggregates;
+}
+function buildHallucinationAvoidanceSection(history, opts = {}) {
+  const minCount = opts.minCount ?? 1;
+  const maxItems = opts.maxItems ?? 10;
+  const patterns = aggregateFixPatterns(history).filter((p) => p.count >= minCount);
+  if (patterns.length === 0) return null;
+  const top = patterns.slice(0, maxItems);
+  const lines = [
+    "=== Prior Hallucinations in This Project (DO NOT REPEAT) ===",
+    "",
+    "The following imports were previously hallucinated by AI codegen in this",
+    "project and had to be auto-fixed. When generating new files, actively avoid",
+    "these exact imports \u2014 they were wrong in the past and will be wrong again.",
+    ""
+  ];
+  for (const p of top) {
+    const namesLabel = p.names.length > 0 ? `{ ${p.names.join(", ")} }` : "(no names)";
+    const reasonLabel = p.reason === "file_not_found" ? "file did not exist" : "named export did not exist";
+    const countLabel = p.count === 1 ? "1x" : `${p.count}x`;
+    const dateLabel = p.lastSeen.slice(0, 10);
+    lines.push(`\u274C Do NOT: import ${namesLabel} from '${p.source}'`);
+    lines.push(`   Reason: ${reasonLabel} (seen ${countLabel}, last ${dateLabel})`);
+    if (p.fix.kind === "create_file") {
+      lines.push(`   Previously fixed by creating: ${p.fix.target}`);
+    } else if (p.fix.kind === "rewrite_import") {
+      lines.push(`   Previously fixed by rewriting the import path`);
+    } else {
+      lines.push(`   Previously fixed by appending to: ${p.fix.target}`);
+    }
+    lines.push("");
+  }
+  if (patterns.length > maxItems) {
+    lines.push(`(${patterns.length - maxItems} more pattern(s) hidden \u2014 run \`ai-spec fix-history\` to see all)`);
+    lines.push("");
+  }
+  lines.push("=== End of Prior Hallucinations ===");
+  return lines.join("\n");
+}
+
 // core/code-generator.ts
 var CodeGenerator = class {
   constructor(provider, mode = "claude-code") {
@@ -6078,8 +6173,8 @@ ${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 = path6.join(workingDir, ".claude-prompt.txt");
-    await fs10.writeFile(promptFile, promptContent, "utf-8");
+    const promptFile = path7.join(workingDir, ".claude-prompt.txt");
+    await fs11.writeFile(promptFile, promptContent, "utf-8");
     if (options.auto) {
       console.log(chalk10.cyan(`  \u{1F916} Auto mode: running claude -p (non-interactive)...`));
       console.log(chalk10.gray(`  Spec: ${specFilePath}`));
@@ -6172,7 +6267,7 @@ Implement ONLY this task. Do not implement other tasks.`;
     if (options.repoType && options.repoType !== "node-express" && options.repoType !== "node-koa" && options.repoType !== "unknown") {
       console.log(chalk10.gray(`  Language: ${options.repoType} (using language-specific codegen prompt)`));
     }
-    const spec = await fs10.readFile(specFilePath, "utf-8");
+    const spec = await fs11.readFile(specFilePath, "utf-8");
     let constitutionSection = context?.constitution ? `
 === Project Constitution (MUST follow) ===
 ${context.constitution}
@@ -6199,7 +6294,24 @@ ${buildFrontendContextSection(fctx)}
 `;
       console.log(chalk10.gray(`  Frontend context: ${fctx.framework} / ${fctx.httpClient} | hooks:${fctx.hookFiles.length} stores:${fctx.storeFiles.length}`));
     }
-    const allContextText = spec + constitutionSection + dslSection + frontendSection + installedPackagesSection + sharedConfigSection;
+    let fixHistorySection = "";
+    if (options.injectFixHistory !== false) {
+      try {
+        const history = await loadFixHistory(workingDir);
+        const section = buildHallucinationAvoidanceSection(history, {
+          maxItems: options.fixHistoryInjectMax ?? 10
+        });
+        if (section) {
+          fixHistorySection = `
+${section}
+`;
+          const patternCount = (section.match(/❌ Do NOT/g) ?? []).length;
+          console.log(chalk10.cyan(`  \u2713 Injected ${patternCount} prior hallucination pattern(s) from fix-history`));
+        }
+      } catch {
+      }
+    }
+    const allContextText = spec + constitutionSection + dslSection + frontendSection + installedPackagesSection + sharedConfigSection + fixHistorySection;
     const estimatedTokenCount = estimateTokens(allContextText);
     const budget = getDefaultBudget(this.provider.providerName);
     if (estimatedTokenCount > budget * 0.7) {
@@ -6218,7 +6330,7 @@ ${buildFrontendContextSection(fctx)}
     }
     const tasks = await loadTasksForSpec(specFilePath);
     if (tasks && tasks.length > 0) {
-      return this.runApiModeWithTasks(spec, tasks, specFilePath, workingDir, constitutionSection + dslSection + installedPackagesSection, frontendSection, sharedConfigSection, options, systemPrompt, context);
+      return this.runApiModeWithTasks(spec, tasks, specFilePath, workingDir, constitutionSection + dslSection + installedPackagesSection + fixHistorySection, frontendSection, sharedConfigSection, options, systemPrompt, context);
     }
     console.log(chalk10.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.
@@ -6229,7 +6341,7 @@ IMPORTANT: Check the "Frontend Project Context" section below. Extend existing h
 
 === Feature Spec ===
 ${spec}
-${constitutionSection}${dslSection}${frontendSection}${installedPackagesSection}${sharedConfigSection}
+${constitutionSection}${dslSection}${frontendSection}${installedPackagesSection}${sharedConfigSection}${fixHistorySection}
 === Project Context ===
 ${contextSummary}
 
@@ -6256,7 +6368,7 @@ Output ONLY a valid JSON array:
       const icon = item.action === "create" ? chalk10.green("+") : chalk10.yellow("~");
       console.log(`  ${icon} ${item.file}: ${chalk10.gray(item.description)}`);
     });
-    const { files } = await this.generateFiles(filePlan, spec, workingDir, constitutionSection + dslSection + frontendSection + installedPackagesSection, systemPrompt);
+    const { files } = await this.generateFiles(filePlan, spec, workingDir, constitutionSection + dslSection + frontendSection + installedPackagesSection + fixHistorySection, systemPrompt);
     return files;
   }
   async runApiModeWithTasks(spec, tasks, specFilePath, workingDir, constitutionSection, frontendSection = "", sharedConfigSection = "", options = {}, systemPrompt = getCodeGenSystemPrompt(), context) {
@@ -6316,7 +6428,7 @@ Output ONLY a valid JSON array:
         }
         const filePlan = await Promise.all(
           task.filesToTouch.filter((f) => !sharedConfigPaths.has(f)).map(async (f) => {
-            const exists = await fs10.pathExists(path6.join(workingDir, f));
+            const exists = await fs11.pathExists(path7.join(workingDir, f));
             return {
               file: f,
               action: exists ? "modify" : "create",
@@ -6356,7 +6468,7 @@ ${taskContext}`,
             const isViewFile = /src[\\/](views?|pages?)[\\/]/i.test(writtenFile);
             if (isCodeFile || isViewFile) {
               try {
-                const content = isViewFile ? `// view component \u2014 use this exact path for router imports` : await fs10.readFile(path6.join(workingDir, writtenFile), "utf-8");
+                const content = isViewFile ? `// view component \u2014 use this exact path for router imports` : await fs11.readFile(path7.join(workingDir, writtenFile), "utf-8");
                 generatedFileCache.set(writtenFile, content);
               } catch {
               }
@@ -6366,19 +6478,28 @@ ${taskContext}`,
       };
       const taskBatches = topoSortLayerTasks(layerTasks);
       const layerResults = [];
+      const maxConcurrency = Math.max(1, options.maxConcurrency ?? 3);
       for (const batch of taskBatches) {
         const batchIsParallel = batch.length > 1;
-        const batchResultPromises = batch.map((task) => executeTask(task, batchIsParallel));
-        const settled = await Promise.allSettled(batchResultPromises);
         const batchResults = [];
-        for (let i = 0; i < settled.length; i++) {
-          const outcome = settled[i];
-          if (outcome.status === "fulfilled") {
-            batchResults.push(outcome.value);
-          } else {
-            const task = batch[i];
-            console.log(chalk10.yellow(`  \u26A0 ${task.id} threw unexpectedly: ${outcome.reason?.message ?? outcome.reason}`));
-            batchResults.push({ task, files: [], createdFiles: [], success: 0, total: 0, impliesRegistration: false });
+        for (let chunkStart = 0; chunkStart < batch.length; chunkStart += maxConcurrency) {
+          const chunk = batch.slice(chunkStart, chunkStart + maxConcurrency);
+          if (batchIsParallel && batch.length > maxConcurrency) {
+            const chunkIdx = Math.floor(chunkStart / maxConcurrency) + 1;
+            const totalChunks = Math.ceil(batch.length / maxConcurrency);
+            console.log(chalk10.gray(`    \u21B3 chunk ${chunkIdx}/${totalChunks} (${chunk.length} tasks, concurrency cap: ${maxConcurrency})`));
+          }
+          const chunkResultPromises = chunk.map((task) => executeTask(task, batchIsParallel));
+          const settled = await Promise.allSettled(chunkResultPromises);
+          for (let i = 0; i < settled.length; i++) {
+            const outcome = settled[i];
+            if (outcome.status === "fulfilled") {
+              batchResults.push(outcome.value);
+            } else {
+              const task = chunk[i];
+              console.log(chalk10.yellow(`  \u26A0 ${task.id} threw unexpectedly: ${outcome.reason?.message ?? outcome.reason}`));
+              batchResults.push({ task, files: [], createdFiles: [], success: 0, total: 0, impliesRegistration: false });
+            }
           }
         }
         layerResults.push(...batchResults);
@@ -6408,7 +6529,7 @@ ${taskContext}`,
         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?$/, ""));
+          const newModuleNames = allCreatedInLayer.filter((f) => f !== sharedFile.path).map((f) => path7.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) {
@@ -6448,10 +6569,10 @@ Updating shared registration after layer [${layer}] completed. New modules: ${ne
     let successCount = 0;
     const writtenFiles = [];
     for (const item of filePlan) {
-      const fullPath = path6.join(workingDir, item.file);
+      const fullPath = path7.join(workingDir, item.file);
       let existingContent = "";
-      if (await fs10.pathExists(fullPath)) {
-        existingContent = await fs10.readFile(fullPath, "utf-8");
+      if (await fs11.pathExists(fullPath)) {
+        existingContent = await fs11.readFile(fullPath, "utf-8");
       }
       const codePrompt = `Implement this file.
 
@@ -6468,8 +6589,8 @@ ${existingContent || "Output only the complete file content."}`;
         const raw = await this.provider.generate(codePrompt, systemPrompt);
         const fileContent = stripCodeFences(raw);
         await getActiveSnapshot()?.snapshotFile(fullPath);
-        await fs10.ensureDir(path6.dirname(fullPath));
-        await fs10.writeFile(fullPath, fileContent, "utf-8");
+        await fs11.ensureDir(path7.dirname(fullPath));
+        await fs11.writeFile(fullPath, fileContent, "utf-8");
         getActiveLogger()?.fileWritten(item.file);
         fileSpinner.succeed(`${existingContent ? chalk10.yellow("~") : chalk10.green("+")} ${chalk10.bold(item.file)}`);
         successCount++;
@@ -6490,7 +6611,7 @@ ${existingContent || "Output only the complete file content."}`;
   // ── Mode: plan ─────────────────────────────────────────────────────────────
   async runPlanMode(specFilePath) {
     console.log(chalk10.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 fs10.readFile(specFilePath, "utf-8");
+    const spec = await fs11.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:
@@ -6509,13 +6630,13 @@ ${spec}`,
 // core/reviewer.ts
 import chalk12 from "chalk";
 import { execSync as execSync3 } from "child_process";
-import * as path8 from "path";
-import * as fs12 from "fs-extra";
+import * as path9 from "path";
+import * as fs13 from "fs-extra";
 
 // core/constitution-generator.ts
 import chalk11 from "chalk";
-import * as fs11 from "fs-extra";
-import * as path7 from "path";
+import * as fs12 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.
@@ -6595,8 +6716,8 @@ var ConstitutionGenerator = class {
     return this.provider.generate(prompt, constitutionSystemPrompt);
   }
   async saveConstitution(projectRoot, content) {
-    const filePath = path7.join(projectRoot, CONSTITUTION_FILE);
-    await fs11.writeFile(filePath, content, "utf-8");
+    const filePath = path8.join(projectRoot, CONSTITUTION_FILE);
+    await fs12.writeFile(filePath, content, "utf-8");
     return filePath;
   }
 };
@@ -6654,9 +6775,9 @@ ${sections.join("\n")}
   return parts.join("\n");
 }
 async function loadConstitution(projectRoot) {
-  const filePath = path7.join(projectRoot, CONSTITUTION_FILE);
-  if (await fs11.pathExists(filePath)) {
-    return fs11.readFile(filePath, "utf-8");
+  const filePath = path8.join(projectRoot, CONSTITUTION_FILE);
+  if (await fs12.pathExists(filePath)) {
+    return fs12.readFile(filePath, "utf-8");
   }
   return void 0;
 }
@@ -6672,10 +6793,10 @@ function printConstitutionHint(exists) {
 
 // core/reviewer.ts
 async function loadAccumulatedLessons(projectRoot) {
-  const constitutionPath = path8.join(projectRoot, CONSTITUTION_FILE);
+  const constitutionPath = path9.join(projectRoot, CONSTITUTION_FILE);
   let content;
   try {
-    content = await fs12.readFile(constitutionPath, "utf-8");
+    content = await fs13.readFile(constitutionPath, "utf-8");
   } catch {
     return null;
   }
@@ -6688,21 +6809,21 @@ async function loadAccumulatedLessons(projectRoot) {
 }
 var REVIEW_HISTORY_FILE = DEFAULT_REVIEW_HISTORY_FILE;
 async function loadReviewHistory(projectRoot) {
-  const historyPath = path8.join(projectRoot, REVIEW_HISTORY_FILE);
+  const historyPath = path9.join(projectRoot, REVIEW_HISTORY_FILE);
   try {
-    if (await fs12.pathExists(historyPath)) {
-      return await fs12.readJson(historyPath);
+    if (await fs13.pathExists(historyPath)) {
+      return await fs13.readJson(historyPath);
     }
   } catch {
   }
   return [];
 }
 async function appendReviewHistory(projectRoot, entry) {
-  const historyPath = path8.join(projectRoot, REVIEW_HISTORY_FILE);
+  const historyPath = path9.join(projectRoot, REVIEW_HISTORY_FILE);
   const existing = await loadReviewHistory(projectRoot);
   const updated = [...existing, entry].slice(-20);
   try {
-    await fs12.writeJson(historyPath, updated, { spaces: 2 });
+    await fs13.writeJson(historyPath, updated, { spaces: 2 });
   } catch {
   }
 }
@@ -6736,7 +6857,7 @@ function buildHistoryContext(history) {
   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}] ${path8.basename(entry.specFile)} \u2014 Score: ${entry.score}/10`);
+[${entry.date}] ${path9.basename(entry.specFile)} \u2014 Score: ${entry.score}/10`);
     entry.topIssues.forEach((issue) => lines.push(`  \xB7 ${issue}`));
   }
   return lines.join("\n") + "\n";
@@ -6856,7 +6977,7 @@ ${sep}
     if (score > 0 && specFile) {
       await appendReviewHistory(this.projectRoot, {
         date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
-        specFile: path8.relative(this.projectRoot, specFile),
+        specFile: path9.relative(this.projectRoot, specFile),
         score,
         ...complianceScore > 0 ? { complianceScore } : {},
         topIssues,
@@ -6901,9 +7022,9 @@ ${sep}
     );
     let filesSection = "";
     for (const filePath of filePaths) {
-      const fullPath = path8.join(workingDir, filePath);
+      const fullPath = path9.join(workingDir, filePath);
       try {
-        const content = await fs12.readFile(fullPath, "utf-8");
+        const content = await fs13.readFile(fullPath, "utf-8");
         filesSection += `
 
 === ${filePath} ===
@@ -6937,7 +7058,7 @@ ${content.slice(0, DEFAULT_MAX_REVIEW_FILE_CHARS)}`;
       const color = entry.score >= 8 ? chalk12.green : entry.score >= 6 ? chalk12.yellow : chalk12.red;
       const impactTag = entry.impactLevel ? chalk12.gray(` \u5F71\u54CD:${entry.impactLevel === "\u9AD8" ? chalk12.red(entry.impactLevel) : entry.impactLevel === "\u4E2D" ? chalk12.yellow(entry.impactLevel) : chalk12.green(entry.impactLevel)}`) : "";
       const complexityTag = entry.complexityLevel ? chalk12.gray(` \u590D\u6742\u5EA6:${entry.complexityLevel === "\u9AD8" ? chalk12.red(entry.complexityLevel) : entry.complexityLevel === "\u4E2D" ? chalk12.yellow(entry.complexityLevel) : chalk12.green(entry.complexityLevel)}`) : "";
-      console.log(`  ${entry.date}  [${color(bar)}] ${color(entry.score + "/10")}${impactTag}${complexityTag}  ${path8.basename(entry.specFile)}`);
+      console.log(`  ${entry.date}  [${color(bar)}] ${color(entry.score + "/10")}${impactTag}${complexityTag}  ${path9.basename(entry.specFile)}`);
     }
     console.log(chalk12.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"));
   }
@@ -6990,8 +7111,8 @@ function parseSpecAndTasks(raw) {
 
 // git/worktree.ts
 import { execSync as execSync4 } from "child_process";
-import * as path9 from "path";
-import * as fs13 from "fs-extra";
+import * as path10 from "path";
+import * as fs14 from "fs-extra";
 import chalk13 from "chalk";
 var GitWorktreeManager = class {
   constructor(baseDir) {
@@ -7017,12 +7138,12 @@ var GitWorktreeManager = class {
   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 fs13.pathExists(src)) continue;
-      if (await fs13.pathExists(dest)) continue;
+      const src = path10.join(this.baseDir, dir);
+      const dest = path10.join(worktreePath, dir);
+      if (!await fs14.pathExists(src)) continue;
+      if (await fs14.pathExists(dest)) continue;
       try {
-        await fs13.ensureSymlink(src, dest, "dir");
+        await fs14.ensureSymlink(src, dest, "dir");
         console.log(chalk13.gray(`  Symlinked ${dir}/ from base repo \u2192 worktree`));
       } catch (err) {
         console.log(chalk13.yellow(`  \u26A0 Could not symlink ${dir}/: ${err.message}`));
@@ -7037,11 +7158,11 @@ var GitWorktreeManager = class {
     }
     const featureName = this.sanitizeFeatureName(idea);
     const branchName = `feature/${featureName}`;
-    const repoName = path9.basename(this.baseDir);
-    const worktreePath = path9.resolve(this.baseDir, "..", `${repoName}-${featureName}`);
+    const repoName = path10.basename(this.baseDir);
+    const worktreePath = path10.resolve(this.baseDir, "..", `${repoName}-${featureName}`);
     console.log(chalk13.cyan(`
 --- Setting up Git Worktree ---`));
-    if (await fs13.pathExists(worktreePath)) {
+    if (await fs14.pathExists(worktreePath)) {
       console.log(chalk13.yellow(`\u26A0\uFE0F Worktree directory already exists at: ${worktreePath}`));
       await this.linkDependencies(worktreePath);
       return worktreePath;