ai-spec-dev 0.25.0 → 0.28.1

package/dist/cli/index.mjs

@@ -20,6 +20,7 @@ __export(codegen_prompt_exports, {
   codeGenSystemPrompt: () => codeGenSystemPrompt,
   getCodeGenSystemPrompt: () => getCodeGenSystemPrompt,
   reviewArchitectureSystemPrompt: () => reviewArchitectureSystemPrompt,
+  reviewImpactComplexitySystemPrompt: () => reviewImpactComplexitySystemPrompt,
   reviewImplementationSystemPrompt: () => reviewImplementationSystemPrompt,
   reviewSystemPrompt: () => reviewSystemPrompt
 });
@@ -39,7 +40,7 @@ function getCodeGenSystemPrompt(repoType) {
       return codeGenSystemPrompt;
   }
 }
-var codeGenSystemPrompt, codeGenGoSystemPrompt, codeGenPythonSystemPrompt, codeGenJavaSystemPrompt, codeGenRustSystemPrompt, codeGenPhpSystemPrompt, reviewSystemPrompt, reviewArchitectureSystemPrompt, reviewImplementationSystemPrompt;
+var codeGenSystemPrompt, codeGenGoSystemPrompt, codeGenPythonSystemPrompt, codeGenJavaSystemPrompt, codeGenRustSystemPrompt, codeGenPhpSystemPrompt, reviewSystemPrompt, reviewArchitectureSystemPrompt, reviewImplementationSystemPrompt, reviewImpactComplexitySystemPrompt;
 var init_codegen_prompt = __esm({
   "prompts/codegen.prompt.ts"() {
     "use strict";
@@ -266,6 +267,48 @@ Actionable, concrete improvements.
 Score: X/10 \u2014 Combined architecture + implementation assessment in one paragraph.
 
 Be specific. Reference actual code, not vague principles.`;
+    reviewImpactComplexitySystemPrompt = `You are a Senior Staff Engineer assessing the RISK and MAINTAINABILITY of a code change.
+
+Two previous review passes have already covered architecture compliance and implementation correctness. Do NOT repeat their findings.
+
+Your job is to answer exactly two questions:
+
+---
+
+## \u{1F30A} \u5F71\u54CD\u9762\u8BC4\u4F30 (Impact Assessment)
+
+Evaluate what this change touches beyond its own files:
+
+1. **\u76F4\u63A5\u5F71\u54CD\u6587\u4EF6** \u2014 List the files created or modified.
+2. **\u95F4\u63A5\u5F71\u54CD\u8303\u56F4** \u2014 Which existing modules, API consumers, or downstream services will be affected? (e.g., shared utilities modified, public interfaces changed, database schema altered)
+3. **\u7834\u574F\u6027\u53D8\u66F4 (Breaking Changes)** \u2014 Are there changes requiring coordinated updates elsewhere?
+   - API endpoint signature changes (path, method, required params)
+   - Database schema changes (renamed columns, dropped fields, new NOT NULL constraints)
+   - Config / env variable changes
+   - Exported function/type renames
+   - If none: state "\u65E0\u7834\u574F\u6027\u53D8\u66F4"
+4. **\u5F71\u54CD\u7B49\u7EA7** \u2014 Rate as \u4F4E / \u4E2D / \u9AD8 with one sentence justification.
+   - \u4F4E: isolated to new files, no shared interface changes
+   - \u4E2D: modifies shared utilities or existing public interfaces, backwards compatible
+   - \u9AD8: breaking changes, or touches core auth / payment / data integrity paths
+
+---
+
+## \u{1F9EE} \u4EE3\u7801\u590D\u6742\u5EA6\u8BC4\u4F30 (Complexity Assessment)
+
+Evaluate how hard the new code will be to understand and change in the future:
+
+1. **\u8BA4\u77E5\u590D\u6742\u5EA6\u70ED\u70B9** \u2014 Identify the 1-3 most complex functions/methods. For each, explain WHY (deep nesting, multiple early returns, implicit state mutation, mixed abstraction levels).
+2. **\u8026\u5408\u5EA6\u5206\u6790** \u2014 How tightly is the new code coupled to existing modules? Are dependencies injected or hardcoded? Any circular dependency risks?
+3. **\u53EF\u7EF4\u62A4\u6027\u98CE\u9669** \u2014 Flag patterns that will cause pain when requirements change:
+   - Magic numbers / hardcoded strings that should be constants
+   - Business logic buried in framework lifecycle hooks or constructors
+   - Implicit temporal coupling (functions that must be called in a specific order)
+4. **\u590D\u6742\u5EA6\u7B49\u7EA7** \u2014 Rate as \u4F4E / \u4E2D / \u9AD8 with one sentence justification.
+
+---
+
+Format using ONLY these two sections. Be specific. Reference file names and line ranges where relevant.`;
   }
 });
 
@@ -276,31 +319,31 @@ __export(workspace_loader_exports, {
   WorkspaceLoader: () => WorkspaceLoader,
   detectRepoType: () => detectRepoType
 });
-import * as fs16 from "fs-extra";
-import * as path15 from "path";
+import * as fs18 from "fs-extra";
+import * as path17 from "path";
 async function detectRepoType(repoAbsPath) {
-  if (await fs16.pathExists(path15.join(repoAbsPath, "go.mod"))) {
+  if (await fs18.pathExists(path17.join(repoAbsPath, "go.mod"))) {
     return { type: "go", role: "backend" };
   }
-  if (await fs16.pathExists(path15.join(repoAbsPath, "composer.json"))) {
+  if (await fs18.pathExists(path17.join(repoAbsPath, "composer.json"))) {
     return { type: "php", role: "backend" };
   }
-  if (await fs16.pathExists(path15.join(repoAbsPath, "Cargo.toml"))) {
+  if (await fs18.pathExists(path17.join(repoAbsPath, "Cargo.toml"))) {
     return { type: "rust", role: "backend" };
   }
-  if (await fs16.pathExists(path15.join(repoAbsPath, "pom.xml")) || await fs16.pathExists(path15.join(repoAbsPath, "build.gradle")) || await fs16.pathExists(path15.join(repoAbsPath, "build.gradle.kts"))) {
+  if (await fs18.pathExists(path17.join(repoAbsPath, "pom.xml")) || await fs18.pathExists(path17.join(repoAbsPath, "build.gradle")) || await fs18.pathExists(path17.join(repoAbsPath, "build.gradle.kts"))) {
     return { type: "java", role: "backend" };
   }
-  if (await fs16.pathExists(path15.join(repoAbsPath, "requirements.txt")) || await fs16.pathExists(path15.join(repoAbsPath, "pyproject.toml")) || await fs16.pathExists(path15.join(repoAbsPath, "setup.py"))) {
+  if (await fs18.pathExists(path17.join(repoAbsPath, "requirements.txt")) || await fs18.pathExists(path17.join(repoAbsPath, "pyproject.toml")) || await fs18.pathExists(path17.join(repoAbsPath, "setup.py"))) {
     return { type: "python", role: "backend" };
   }
-  const pkgPath = path15.join(repoAbsPath, "package.json");
-  if (!await fs16.pathExists(pkgPath)) {
+  const pkgPath = path17.join(repoAbsPath, "package.json");
+  if (!await fs18.pathExists(pkgPath)) {
     return { type: "unknown", role: "shared" };
   }
   let pkg = {};
   try {
-    pkg = await fs16.readJson(pkgPath);
+    pkg = await fs18.readJson(pkgPath);
   } catch {
     return { type: "unknown", role: "shared" };
   }
@@ -344,13 +387,13 @@ var init_workspace_loader = __esm({
        * Returns null if the file does not exist (graceful degradation).
        */
       async load() {
-        const configPath = path15.join(this.workspaceRoot, WORKSPACE_CONFIG_FILE);
-        if (!await fs16.pathExists(configPath)) {
+        const configPath = path17.join(this.workspaceRoot, WORKSPACE_CONFIG_FILE);
+        if (!await fs18.pathExists(configPath)) {
           return null;
         }
         let raw;
         try {
-          raw = await fs16.readJson(configPath);
+          raw = await fs18.readJson(configPath);
         } catch (err) {
           throw new Error(
             `Failed to parse ${WORKSPACE_CONFIG_FILE}: ${err.message}`
@@ -373,15 +416,15 @@ var init_workspace_loader = __esm({
        * Auto-detects type and role from dependencies.
        */
       async autoDetect(names) {
-        const entries = await fs16.readdir(this.workspaceRoot);
+        const entries = await fs18.readdir(this.workspaceRoot);
         const repos = [];
         for (const entry of entries) {
-          const absPath = path15.join(this.workspaceRoot, entry);
-          const stat4 = await fs16.stat(absPath).catch(() => null);
+          const absPath = path17.join(this.workspaceRoot, entry);
+          const stat4 = await fs18.stat(absPath).catch(() => null);
           if (!stat4 || !stat4.isDirectory()) continue;
           if (entry.startsWith(".") || entry === "node_modules") continue;
           if (names && !names.includes(entry)) continue;
-          const hasManifest = await fs16.pathExists(path15.join(absPath, "package.json")) || await fs16.pathExists(path15.join(absPath, "go.mod")) || await fs16.pathExists(path15.join(absPath, "Cargo.toml")) || await fs16.pathExists(path15.join(absPath, "pom.xml")) || await fs16.pathExists(path15.join(absPath, "build.gradle")) || await fs16.pathExists(path15.join(absPath, "requirements.txt")) || await fs16.pathExists(path15.join(absPath, "pyproject.toml")) || await fs16.pathExists(path15.join(absPath, "composer.json"));
+          const hasManifest = await fs18.pathExists(path17.join(absPath, "package.json")) || await fs18.pathExists(path17.join(absPath, "go.mod")) || await fs18.pathExists(path17.join(absPath, "Cargo.toml")) || await fs18.pathExists(path17.join(absPath, "pom.xml")) || await fs18.pathExists(path17.join(absPath, "build.gradle")) || await fs18.pathExists(path17.join(absPath, "requirements.txt")) || await fs18.pathExists(path17.join(absPath, "pyproject.toml")) || await fs18.pathExists(path17.join(absPath, "composer.json"));
           if (!hasManifest) continue;
           const { type, role } = await detectRepoType(absPath);
           repos.push({ name: entry, path: entry, type, role });
@@ -394,11 +437,11 @@ var init_workspace_loader = __esm({
       async resolveRepoPaths(config2) {
         const resolved = [];
         for (const repo of config2.repos) {
-          const absPath = path15.resolve(this.workspaceRoot, repo.path);
+          const absPath = path17.resolve(this.workspaceRoot, repo.path);
           let constitution;
-          const constitutionFile = path15.join(absPath, ".ai-spec-constitution.md");
-          if (await fs16.pathExists(constitutionFile)) {
-            constitution = await fs16.readFile(constitutionFile, "utf-8");
+          const constitutionFile = path17.join(absPath, ".ai-spec-constitution.md");
+          if (await fs18.pathExists(constitutionFile)) {
+            constitution = await fs18.readFile(constitutionFile, "utf-8");
           }
           resolved.push({ ...repo, constitution });
         }
@@ -408,19 +451,19 @@ var init_workspace_loader = __esm({
        * Save a workspace config to disk.
        */
       async save(config2) {
-        const configPath = path15.join(this.workspaceRoot, WORKSPACE_CONFIG_FILE);
+        const configPath = path17.join(this.workspaceRoot, WORKSPACE_CONFIG_FILE);
         const toSave = {
           name: config2.name,
           repos: config2.repos.map(({ constitution: _c, ...rest }) => rest)
         };
-        await fs16.writeJson(configPath, toSave, { spaces: 2 });
+        await fs18.writeJson(configPath, toSave, { spaces: 2 });
         return configPath;
       }
       /**
        * Resolve the absolute path of a repo given its config.
        */
       resolveAbsPath(repo) {
-        return path15.resolve(this.workspaceRoot, repo.path);
+        return path17.resolve(this.workspaceRoot, repo.path);
       }
       /**
        * Find which repos are backend (contract providers) and which depend on them.
@@ -442,9 +485,9 @@ var init_workspace_loader = __esm({
 
 // cli/index.ts
 import { Command } from "commander";
-import * as path21 from "path";
-import * as fs22 from "fs-extra";
-import chalk17 from "chalk";
+import * as path23 from "path";
+import * as fs24 from "fs-extra";
+import chalk19 from "chalk";
 import * as dotenv from "dotenv";
 import { input, confirm as confirm2, select as select3 } from "@inquirer/prompts";
 
@@ -559,6 +602,67 @@ model ExampleModel {
 
 \u6839\u636E\u7528\u6237\u7684\u60F3\u6CD5\u548C\u9879\u76EE\u4E0A\u4E0B\u6587\u751F\u6210\u4E0A\u8FF0\u5B8C\u6574 Spec\u3002\u786E\u4FDD API \u8BBE\u8BA1\u4E0E\u73B0\u6709\u9879\u76EE\u7684\u8DEF\u7531\u98CE\u683C\u3001\u9519\u8BEF\u7801\u89C4\u8303\u4FDD\u6301\u4E00\u81F4\uFF0C\u6570\u636E\u6A21\u578B\u4E0E\u73B0\u6709 Prisma Schema \u534F\u8C03\u3002`;
 
+// core/provider-utils.ts
+import chalk from "chalk";
+var sleep = (ms2) => new Promise((r) => setTimeout(r, ms2));
+var ProviderError = class extends Error {
+  constructor(message, kind, originalError) {
+    super(message);
+    this.kind = kind;
+    this.originalError = originalError;
+    this.name = "ProviderError";
+  }
+};
+function classifyError(err, label) {
+  const e = err;
+  const status = e.status ?? e.response?.status;
+  if (status === 401 || status === 403)
+    return new ProviderError(`Auth error \u2014 check your API key (${label})`, "auth", err);
+  if (status === 429)
+    return new ProviderError(`Rate limit hit (${label}) \u2014 try again later or switch provider`, "rate_limit", err);
+  if (e._timeout || e.message?.toLowerCase().includes("timed out"))
+    return new ProviderError(`Request timed out (${label})`, "timeout", err);
+  if (e.code === "ECONNRESET" || e.code === "ENOTFOUND" || e.code === "ECONNREFUSED")
+    return new ProviderError(`Network error \u2014 check connection/proxy (${label}): ${e.message}`, "network", err);
+  return new ProviderError(`Provider error (${label}): ${e.message}`, "provider", err);
+}
+function isRetryable(err) {
+  const e = err;
+  const status = e.status ?? e.response?.status;
+  if (status === 401 || status === 403) return false;
+  if (status === 429 || status !== void 0 && status >= 500) return true;
+  if (e.code === "ECONNRESET" || e.code === "ENOTFOUND" || e.code === "ECONNREFUSED") return true;
+  if (e.message?.toLowerCase().includes("timed out")) return true;
+  return true;
+}
+async function withReliability(fn, opts) {
+  const { retries = 2, timeoutMs = 9e4, label = "AI call", onRetry } = opts ?? {};
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await Promise.race([
+        fn(),
+        new Promise(
+          (_2, reject) => setTimeout(
+            () => reject(Object.assign(new Error(`timed out after ${timeoutMs / 1e3}s`), { _timeout: true })),
+            timeoutMs
+          )
+        )
+      ]);
+    } catch (err) {
+      if (!isRetryable(err) || attempt === retries) {
+        throw classifyError(err, label);
+      }
+      const waitMs = attempt === 0 ? 2e3 : 6e3;
+      console.warn(
+        chalk.yellow(`  \u26A0 ${label} failed (attempt ${attempt + 1}/${retries + 1}), retrying in ${waitMs / 1e3}s`) + chalk.gray(` \u2014 ${err.message}`)
+      );
+      onRetry?.(attempt + 1, err);
+      await sleep(waitMs);
+    }
+  }
+  throw new Error("unreachable");
+}
+
 // core/spec-generator.ts
 function geminiRequestOptions() {
   const proxyUrl = process.env.GEMINI_PROXY || process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
@@ -704,12 +808,17 @@ var GeminiProvider = class {
     this.modelName = modelName;
   }
   async generate(prompt, systemInstruction) {
-    const model = this.genAI.getGenerativeModel(
-      { model: this.modelName, ...systemInstruction ? { systemInstruction } : {} },
-      geminiRequestOptions()
+    return withReliability(
+      async () => {
+        const model = this.genAI.getGenerativeModel(
+          { model: this.modelName, ...systemInstruction ? { systemInstruction } : {} },
+          geminiRequestOptions()
+        );
+        const result = await model.generateContent(prompt);
+        return result.response.text();
+      },
+      { label: `${this.providerName}/${this.modelName}` }
     );
-    const result = await model.generateContent(prompt);
-    return result.response.text();
   }
 };
 var ClaudeProvider = class {
@@ -721,15 +830,20 @@ var ClaudeProvider = class {
     this.modelName = modelName;
   }
   async generate(prompt, systemInstruction) {
-    const message = await this.client.messages.create({
-      model: this.modelName,
-      max_tokens: 8192,
-      ...systemInstruction ? { system: systemInstruction } : {},
-      messages: [{ role: "user", content: prompt }]
-    });
-    const block = message.content[0];
-    if (block.type === "text") return block.text;
-    throw new Error("Unexpected response type from Claude API");
+    return withReliability(
+      async () => {
+        const message = await this.client.messages.create({
+          model: this.modelName,
+          max_tokens: 8192,
+          ...systemInstruction ? { system: systemInstruction } : {},
+          messages: [{ role: "user", content: prompt }]
+        });
+        const block = message.content[0];
+        if (block.type === "text") return block.text;
+        throw new Error("Unexpected response type from Claude API");
+      },
+      { label: `${this.providerName}/${this.modelName}` }
+    );
   }
 };
 var OpenAICompatibleProvider = class {
@@ -749,19 +863,24 @@ var OpenAICompatibleProvider = class {
     });
   }
   async generate(prompt, systemInstruction) {
-    const messages = [];
-    if (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,
-      ...this.extraBody ? { extra_body: this.extraBody } : {}
-    });
-    return completion.choices[0].message.content ?? "";
+    return withReliability(
+      async () => {
+        const messages = [];
+        if (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,
+          ...this.extraBody ? { extra_body: this.extraBody } : {}
+        });
+        return completion.choices[0].message.content ?? "";
+      },
+      { label: `${this.providerName}/${this.modelName}` }
+    );
   }
 };
 var MiMoProvider = class {
@@ -774,32 +893,37 @@ var MiMoProvider = class {
     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)}`);
+    return withReliability(
+      async () => {
+        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)}`);
+      },
+      { label: `${this.providerName}/${this.modelName}` }
+    );
   }
 };
 function createProvider(providerName, apiKey, modelName) {
@@ -4260,10 +4384,10 @@ ${preview}
 
 // core/spec-refiner.ts
 import { editor, confirm, select } from "@inquirer/prompts";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 
 // core/spec-versioning.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 import * as fs4 from "fs-extra";
 import * as path3 from "path";
 function slugify(idea) {
@@ -4348,7 +4472,7 @@ function computeSimpleDiff(oldLines, newLines) {
 var CONTEXT_LINES = 3;
 function printDiff(diff) {
   if (diff.added === 0 && diff.removed === 0) {
-    console.log(chalk.gray("  (no changes)"));
+    console.log(chalk2.gray("  (no changes)"));
     return;
   }
   const { lines } = diff;
@@ -4365,25 +4489,25 @@ function printDiff(diff) {
   let prevIdx = -2;
   for (const idx of sorted) {
     if (idx > prevIdx + 1 && prevIdx !== -2) {
-      console.log(chalk.cyan("  @@"));
+      console.log(chalk2.cyan("  @@"));
     }
     const l = lines[idx];
     if (l.type === "added") {
-      console.log(chalk.green(`  + ${l.content}`));
+      console.log(chalk2.green(`  + ${l.content}`));
     } else if (l.type === "removed") {
-      console.log(chalk.red(`  - ${l.content}`));
+      console.log(chalk2.red(`  - ${l.content}`));
     } else {
-      console.log(chalk.gray(`    ${l.content}`));
+      console.log(chalk2.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`));
+  if (diff.added > 0) parts.push(chalk2.green(`+${diff.added}`));
+  if (diff.removed > 0) parts.push(chalk2.red(`-${diff.removed}`));
+  if (parts.length === 0) parts.push(chalk2.gray("no change"));
+  console.log(chalk2.bold(`  ${label}: `) + parts.join("  ") + chalk2.gray(` lines`));
 }
 
 // core/spec-refiner.ts
@@ -4395,16 +4519,16 @@ var SpecRefiner = class {
     let currentSpec = initialSpec;
     let round = 1;
     while (true) {
-      console.log(chalk2.cyan(`
+      console.log(chalk3.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(chalk2.gray("  Opening spec in editor. Save and close to continue."));
+      console.log(chalk3.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(chalk2.green("  \u2714 Spec saved."));
+      console.log(chalk3.green("  \u2714 Spec saved."));
       const action = await select({
         message: "What would you like to do?",
         choices: [
@@ -4417,7 +4541,7 @@ var SpecRefiner = class {
         break;
       }
       if (action === "ai") {
-        console.log(chalk2.blue(`  AI (${this.provider.providerName}/${this.provider.modelName}) is polishing the spec...`));
+        console.log(chalk3.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.
@@ -4427,30 +4551,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(chalk2.yellow("\n  AI has suggested improvements. Opening diff in editor..."));
+          console.log(chalk3.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"));
+            console.log(chalk3.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"));
+            console.log(chalk3.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(chalk2.green("  \u2714 AI-improved spec accepted."));
+            console.log(chalk3.green("  \u2714 AI-improved spec accepted."));
           } else {
-            console.log(chalk2.gray("  AI improvements discarded. Keeping your version."));
+            console.log(chalk3.gray("  AI improvements discarded. Keeping your version."));
           }
         } catch (err) {
-          console.error(chalk2.red("  AI improvement failed:"), err);
-          console.log(chalk2.gray("  Continuing with current spec."));
+          console.error(chalk3.red("  AI improvement failed:"), err);
+          console.log(chalk3.gray("  Continuing with current spec."));
         }
       }
       round++;
@@ -4460,14 +4584,14 @@ ${currentSpec}`,
 };
 
 // core/code-generator.ts
-import chalk6 from "chalk";
+import chalk8 from "chalk";
 import { execSync } from "child_process";
-import * as path7 from "path";
-import * as fs8 from "fs-extra";
+import * as path9 from "path";
+import * as fs10 from "fs-extra";
 init_codegen_prompt();
 
 // core/task-generator.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import * as fs5 from "fs-extra";
 import * as path4 from "path";
 
@@ -4621,31 +4745,36 @@ function parseTasks(raw) {
 }
 function printTasks(tasks) {
   const layerColors = {
-    data: chalk3.magenta,
-    infra: chalk3.gray,
-    service: chalk3.blue,
-    api: chalk3.cyan,
-    view: chalk3.yellow,
-    route: chalk3.white,
-    test: chalk3.green
+    data: chalk4.magenta,
+    infra: chalk4.gray,
+    service: chalk4.blue,
+    api: chalk4.cyan,
+    view: chalk4.yellow,
+    route: chalk4.white,
+    test: chalk4.green
   };
-  console.log(chalk3.bold(`
+  console.log(chalk4.bold(`
   Tasks (${tasks.length}):`));
   for (const task of tasks) {
-    const color = layerColors[task.layer] ?? chalk3.white;
+    const color = layerColors[task.layer] ?? chalk4.white;
     const badge = color(`[${task.layer}]`);
-    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}`);
+    const prio = task.priority === "high" ? chalk4.red("\u25CF") : task.priority === "medium" ? chalk4.yellow("\u25CF") : chalk4.gray("\u25CF");
+    console.log(`  ${prio} ${chalk4.bold(task.id)} ${badge} ${task.title}`);
   }
 }
 async function loadTasksForSpec(specFilePath) {
   const base = path4.basename(specFilePath, ".md");
   const dir = path4.dirname(specFilePath);
   const tasksFile = path4.join(dir, `${base}-tasks.json`);
-  if (await fs5.pathExists(tasksFile)) {
-    return fs5.readJson(tasksFile);
+  if (!await fs5.pathExists(tasksFile)) return null;
+  try {
+    return await fs5.readJson(tasksFile);
+  } catch {
+    console.warn(
+      chalk4.yellow(`  \u26A0 Tasks file is corrupt or unreadable (${path4.basename(tasksFile)}).`) + chalk4.gray(` Re-run \`ai-spec tasks <spec>\` to regenerate.`)
+    );
+    return null;
   }
-  return null;
 }
 async function updateTaskStatus(specFilePath, taskId, status) {
   const tasks = await loadTasksForSpec(specFilePath);
@@ -4659,13 +4788,13 @@ async function updateTaskStatus(specFilePath, taskId, status) {
 }
 
 // core/dsl-extractor.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import * as fs6 from "fs-extra";
 import * as path5 from "path";
 import { select as select2 } from "@inquirer/prompts";
 
 // core/dsl-validator.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 var VALID_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
 var MAX_MODELS = 50;
 var MAX_FIELDS_PER_MODEL = 100;
@@ -4738,221 +4867,221 @@ function validateDsl(raw) {
   }
   return { valid: true, dsl: raw };
 }
-function validateFeature(raw, path22, errors) {
+function validateFeature(raw, path24, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path22, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const f = raw;
-  requireNonEmptyString(f["id"], `${path22}.id`, errors);
-  requireNonEmptyString(f["title"], `${path22}.title`, errors);
-  requireNonEmptyString(f["description"], `${path22}.description`, errors);
+  requireNonEmptyString(f["id"], `${path24}.id`, errors);
+  requireNonEmptyString(f["title"], `${path24}.title`, errors);
+  requireNonEmptyString(f["description"], `${path24}.description`, errors);
 }
-function validateModel(raw, path22, errors) {
+function validateModel(raw, path24, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path22, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const m = raw;
-  requireNonEmptyString(m["name"], `${path22}.name`, errors);
+  requireNonEmptyString(m["name"], `${path24}.name`, errors);
   if (!Array.isArray(m["fields"])) {
-    errors.push({ path: `${path22}.fields`, message: `Must be an array, got: ${typeLabel(m["fields"])}` });
+    errors.push({ path: `${path24}.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: `${path22}.fields`, message: `Too many fields (${fields.length} > ${MAX_FIELDS_PER_MODEL})` });
+      errors.push({ path: `${path24}.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], `${path22}.fields[${j2}]`, errors);
+      validateModelField(fields[j2], `${path24}.fields[${j2}]`, errors);
     }
   }
   if (m["relations"] !== void 0) {
     if (!Array.isArray(m["relations"])) {
-      errors.push({ path: `${path22}.relations`, message: "Must be an array of strings if present" });
+      errors.push({ path: `${path24}.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: `${path22}.relations[${j2}]`, message: "Must be a string" });
+          errors.push({ path: `${path24}.relations[${j2}]`, message: "Must be a string" });
         }
       }
     }
   }
 }
-function validateModelField(raw, path22, errors) {
+function validateModelField(raw, path24, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path22, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const f = raw;
-  requireNonEmptyString(f["name"], `${path22}.name`, errors);
-  requireNonEmptyString(f["type"], `${path22}.type`, errors);
+  requireNonEmptyString(f["name"], `${path24}.name`, errors);
+  requireNonEmptyString(f["type"], `${path24}.type`, errors);
   if (typeof f["required"] !== "boolean") {
-    errors.push({ path: `${path22}.required`, message: `Must be boolean, got: ${typeLabel(f["required"])}` });
+    errors.push({ path: `${path24}.required`, message: `Must be boolean, got: ${typeLabel(f["required"])}` });
   }
 }
-function validateEndpoint(raw, path22, errors) {
+function validateEndpoint(raw, path24, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path22, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const e = raw;
-  requireNonEmptyString(e["id"], `${path22}.id`, errors);
-  requireNonEmptyString(e["description"], `${path22}.description`, errors);
+  requireNonEmptyString(e["id"], `${path24}.id`, errors);
+  requireNonEmptyString(e["description"], `${path24}.description`, errors);
   if (!VALID_METHODS.includes(e["method"])) {
     errors.push({
-      path: `${path22}.method`,
+      path: `${path24}.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: `${path22}.path`,
+      path: `${path24}.path`,
       message: `Must be a string starting with "/", got: ${JSON.stringify(e["path"])}`
     });
   }
   if (typeof e["auth"] !== "boolean") {
-    errors.push({ path: `${path22}.auth`, message: `Must be boolean, got: ${typeLabel(e["auth"])}` });
+    errors.push({ path: `${path24}.auth`, message: `Must be boolean, got: ${typeLabel(e["auth"])}` });
   }
   if (typeof e["successStatus"] !== "number" || e["successStatus"] < 100 || e["successStatus"] > 599) {
     errors.push({
-      path: `${path22}.successStatus`,
+      path: `${path24}.successStatus`,
       message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["successStatus"])}`
     });
   }
-  requireNonEmptyString(e["successDescription"], `${path22}.successDescription`, errors);
+  requireNonEmptyString(e["successDescription"], `${path24}.successDescription`, errors);
   if (e["request"] !== void 0) {
-    validateRequestSchema(e["request"], `${path22}.request`, errors);
+    validateRequestSchema(e["request"], `${path24}.request`, errors);
   }
   if (e["errors"] !== void 0) {
     if (!Array.isArray(e["errors"])) {
-      errors.push({ path: `${path22}.errors`, message: "Must be an array if present" });
+      errors.push({ path: `${path24}.errors`, message: "Must be an array if present" });
     } else {
       const errs = e["errors"];
       if (errs.length > MAX_ERRORS_PER_ENDPOINT) {
-        errors.push({ path: `${path22}.errors`, message: `Too many error entries (${errs.length} > ${MAX_ERRORS_PER_ENDPOINT})` });
+        errors.push({ path: `${path24}.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], `${path22}.errors[${j2}]`, errors);
+        validateResponseError(errs[j2], `${path24}.errors[${j2}]`, errors);
       }
     }
   }
 }
-function validateRequestSchema(raw, path22, errors) {
+function validateRequestSchema(raw, path24, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path22, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path24, 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], `${path22}.${key}`, errors);
+      validateFieldMap(r[key], `${path24}.${key}`, errors);
     }
   }
 }
-function validateFieldMap(raw, path22, errors) {
+function validateFieldMap(raw, path24, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path22, message: `Must be a flat object (FieldMap), got: ${typeLabel(raw)}` });
+    errors.push({ path: path24, 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: `${path22}.${k2}`, message: `Value must be a type-description string, got: ${typeLabel(v2)}` });
+      errors.push({ path: `${path24}.${k2}`, message: `Value must be a type-description string, got: ${typeLabel(v2)}` });
     }
   }
 }
-function validateResponseError(raw, path22, errors) {
+function validateResponseError(raw, path24, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path22, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path24, 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: `${path22}.status`, message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["status"])}` });
+    errors.push({ path: `${path24}.status`, message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["status"])}` });
   }
-  requireNonEmptyString(e["code"], `${path22}.code`, errors);
-  requireNonEmptyString(e["description"], `${path22}.description`, errors);
+  requireNonEmptyString(e["code"], `${path24}.code`, errors);
+  requireNonEmptyString(e["description"], `${path24}.description`, errors);
 }
-function validateBehavior(raw, path22, errors) {
+function validateBehavior(raw, path24, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path22, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const b = raw;
-  requireNonEmptyString(b["id"], `${path22}.id`, errors);
-  requireNonEmptyString(b["description"], `${path22}.description`, errors);
+  requireNonEmptyString(b["id"], `${path24}.id`, errors);
+  requireNonEmptyString(b["description"], `${path24}.description`, errors);
   if (b["constraints"] !== void 0) {
     if (!Array.isArray(b["constraints"])) {
-      errors.push({ path: `${path22}.constraints`, message: "Must be an array of strings if present" });
+      errors.push({ path: `${path24}.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: `${path22}.constraints[${j2}]`, message: "Must be a string" });
+          errors.push({ path: `${path24}.constraints[${j2}]`, message: "Must be a string" });
         }
       }
     }
   }
 }
-function validateComponent(raw, path22, errors) {
+function validateComponent(raw, path24, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path22, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const c = raw;
-  requireNonEmptyString(c["id"], `${path22}.id`, errors);
-  requireNonEmptyString(c["name"], `${path22}.name`, errors);
-  requireNonEmptyString(c["description"], `${path22}.description`, errors);
+  requireNonEmptyString(c["id"], `${path24}.id`, errors);
+  requireNonEmptyString(c["name"], `${path24}.name`, errors);
+  requireNonEmptyString(c["description"], `${path24}.description`, errors);
   if (c["props"] !== void 0) {
     if (!Array.isArray(c["props"])) {
-      errors.push({ path: `${path22}.props`, message: "Must be an array if present" });
+      errors.push({ path: `${path24}.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: `${path22}.props[${j2}]`, message: "Must be an object" });
+          errors.push({ path: `${path24}.props[${j2}]`, message: "Must be an object" });
           continue;
         }
-        requireNonEmptyString(p["name"], `${path22}.props[${j2}].name`, errors);
-        requireNonEmptyString(p["type"], `${path22}.props[${j2}].type`, errors);
+        requireNonEmptyString(p["name"], `${path24}.props[${j2}].name`, errors);
+        requireNonEmptyString(p["type"], `${path24}.props[${j2}].type`, errors);
         if (typeof p["required"] !== "boolean") {
-          errors.push({ path: `${path22}.props[${j2}].required`, message: "Must be boolean" });
+          errors.push({ path: `${path24}.props[${j2}].required`, message: "Must be boolean" });
         }
       }
     }
   }
   if (c["events"] !== void 0) {
     if (!Array.isArray(c["events"])) {
-      errors.push({ path: `${path22}.events`, message: "Must be an array if present" });
+      errors.push({ path: `${path24}.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: `${path22}.events[${j2}]`, message: "Must be an object" });
+          errors.push({ path: `${path24}.events[${j2}]`, message: "Must be an object" });
           continue;
         }
-        requireNonEmptyString(e["name"], `${path22}.events[${j2}].name`, errors);
+        requireNonEmptyString(e["name"], `${path24}.events[${j2}].name`, errors);
       }
     }
   }
   if (c["state"] !== void 0) {
     if (typeof c["state"] !== "object" || Array.isArray(c["state"]) || c["state"] === null) {
-      errors.push({ path: `${path22}.state`, message: "Must be a flat object (Record<string, string>) if present" });
+      errors.push({ path: `${path24}.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: `${path22}.apiCalls`, message: "Must be an array of strings if present" });
+      errors.push({ path: `${path24}.apiCalls`, message: "Must be an array of strings if present" });
     }
   }
 }
-function requireNonEmptyString(v2, path22, errors) {
+function requireNonEmptyString(v2, path24, errors) {
   if (typeof v2 !== "string" || v2.trim().length === 0) {
     errors.push({
-      path: path22,
+      path: path24,
       message: `Must be a non-empty string, got: ${typeLabel(v2)}`
     });
   }
@@ -4963,29 +5092,29 @@ function typeLabel(v2) {
   return typeof v2;
 }
 function printValidationErrors(errors) {
-  console.log(chalk4.red(`
+  console.log(chalk5.red(`
   DSL Validation failed \u2014 ${errors.length} error(s):
 `));
   for (const err of errors) {
-    console.log(chalk4.red(`  \u2718 ${chalk4.bold(err.path)}: ${err.message}`));
+    console.log(chalk5.red(`  \u2718 ${chalk5.bold(err.path)}: ${err.message}`));
   }
   console.log();
 }
 function printDslSummary(dsl) {
-  console.log(chalk4.green("  \u2714 DSL valid"));
-  console.log(chalk4.gray(`    Models    : ${dsl.models.length}`));
-  console.log(chalk4.gray(`    Endpoints : ${dsl.endpoints.length}`));
-  console.log(chalk4.gray(`    Behaviors : ${dsl.behaviors.length}`));
+  console.log(chalk5.green("  \u2714 DSL valid"));
+  console.log(chalk5.gray(`    Models    : ${dsl.models.length}`));
+  console.log(chalk5.gray(`    Endpoints : ${dsl.endpoints.length}`));
+  console.log(chalk5.gray(`    Behaviors : ${dsl.behaviors.length}`));
   if (dsl.components && dsl.components.length > 0) {
-    console.log(chalk4.gray(`    Components: ${dsl.components.length}`));
+    console.log(chalk5.gray(`    Components: ${dsl.components.length}`));
     for (const cmp of dsl.components) {
-      console.log(chalk4.gray(`      ${cmp.id} ${cmp.name} \u2014 props:${cmp.props.length} events:${cmp.events.length}`));
+      console.log(chalk5.gray(`      ${cmp.id} ${cmp.name} \u2014 props:${cmp.props.length} events:${cmp.events.length}`));
     }
   }
   if (dsl.endpoints.length > 0) {
     for (const ep of dsl.endpoints) {
-      const auth = ep.auth ? chalk4.yellow(" [auth]") : "";
-      console.log(chalk4.gray(`      ${ep.method.padEnd(6)} ${ep.path}${auth} \u2014 ${ep.description}`));
+      const auth = ep.auth ? chalk5.yellow(" [auth]") : "";
+      console.log(chalk5.gray(`      ${ep.method.padEnd(6)} ${ep.path}${auth} \u2014 ${ep.description}`));
     }
   }
 }
@@ -5238,7 +5367,7 @@ var DslExtractor = class {
     for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
       const isRetry = attempt > 1;
       if (isRetry) {
-        console.log(chalk5.yellow(`
+        console.log(chalk6.yellow(`
   Retry ${attempt - 1}/${MAX_RETRIES - 1}: fixing validation errors...`));
       }
       const activeSystemPrompt = opts.isFrontend ? dslFrontendSystemPrompt : dslSystemPrompt;
@@ -5247,7 +5376,7 @@ var DslExtractor = class {
       try {
         rawOutput = await this.provider.generate(userPrompt, activeSystemPrompt);
       } catch (err) {
-        console.log(chalk5.red(`  \u2718 AI call failed: ${err.message}`));
+        console.log(chalk6.red(`  \u2718 AI call failed: ${err.message}`));
         return this.handleFailure(opts, "AI call failed");
       }
       lastRawOutput = rawOutput;
@@ -5255,7 +5384,7 @@ var DslExtractor = class {
       try {
         parsed = parseJsonFromOutput(rawOutput);
       } catch (parseErr) {
-        console.log(chalk5.red(`  \u2718 Failed to parse JSON from AI output: ${parseErr.message}`));
+        console.log(chalk6.red(`  \u2718 Failed to parse JSON from AI output: ${parseErr.message}`));
         lastErrors = [{ path: "root", message: "Output is not valid JSON \u2014 see raw output above" }];
         if (attempt < MAX_RETRIES) continue;
         return this.handleFailure(opts, "AI produced invalid JSON after retries");
@@ -5268,7 +5397,7 @@ var DslExtractor = class {
       printValidationErrors(result.errors);
       lastErrors = result.errors;
       if (attempt < MAX_RETRIES) {
-        console.log(chalk5.gray(`  Will retry with error feedback...`));
+        console.log(chalk6.gray(`  Will retry with error feedback...`));
         continue;
       }
       return this.handleFailure(opts, `DSL validation failed after ${MAX_RETRIES} attempts`);
@@ -5280,10 +5409,10 @@ var DslExtractor = class {
    * Returns null to skip, or throws to abort the pipeline.
    */
   async handleFailure(opts, reason) {
-    console.log(chalk5.yellow(`
+    console.log(chalk6.yellow(`
   \u26A0 DSL extraction failed: ${reason}`));
     if (opts.auto) {
-      console.log(chalk5.gray("  --auto mode: skipping DSL, continuing without it."));
+      console.log(chalk6.gray("  --auto mode: skipping DSL, continuing without it."));
       return null;
     }
     const action = await select2({
@@ -5294,10 +5423,10 @@ var DslExtractor = class {
       ]
     });
     if (action === "abort") {
-      console.log(chalk5.red("  Pipeline aborted by user."));
+      console.log(chalk6.red("  Pipeline aborted by user."));
       process.exit(1);
     }
-    console.log(chalk5.gray("  Continuing without DSL."));
+    console.log(chalk6.gray("  Continuing without DSL."));
     return null;
   }
   // ─── Save ────────────────────────────────────────────────────────────────────
@@ -5574,7 +5703,7 @@ ${preview}`);
       } catch {
       }
     }
-    const httpImportRegex = /^import\s+(?:\w+|\{[^}]+\})\s+from\s+['"](@\/[^'"]+|axios|ky)['"]/m;
+    const httpImportRegex = /^import(?!\s+type)\s+(?:[\w*]+|\{[^}]+\})\s+from\s+['"]((?:@{1,2}|~|#)[/\\][^'"]+|\.{1,2}\/[^'"]*(?:http|request|fetch|client|api)[^'"]*|axios|ky(?:-universal)?|undici|node-fetch|cross-fetch|got|superagent|alova|openapi-fetch)['"]/im;
     for (const relPath of ctx.existingApiFiles.slice(0, 5)) {
       try {
         const content = await fs7.readFile(path6.join(projectRoot, relPath), "utf-8");
@@ -5587,31 +5716,51 @@ ${preview}`);
       }
     }
     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(path6.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) {
+        const lines = content.split("\n");
+        let interfaceName = "";
+        let interfaceBlock = "";
+        for (let i = 0; i < lines.length; i++) {
+          const m = lines[i].match(/(?:interface|type)\s+(\w*(?:Params|Query|Request|Filter|Page)\w*)\s*[={<]/);
+          if (!m) continue;
+          const blockLines = [];
+          let depth = 0;
+          for (let j2 = i; j2 < Math.min(i + 40, lines.length); j2++) {
+            blockLines.push(lines[j2]);
+            depth += (lines[j2].match(/\{/g) ?? []).length;
+            depth -= (lines[j2].match(/\}/g) ?? []).length;
+            if (depth === 0 && j2 > i) break;
+          }
+          const blockText = blockLines.join("\n");
+          if (!paginationFieldNames.some((f) => new RegExp(`\\b${f}\\b`).test(blockText))) continue;
+          interfaceName = m[1];
+          interfaceBlock = blockText;
+          break;
+        }
+        if (!interfaceName) continue;
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (!/export\s+(async\s+)?(function|const)/.test(line)) continue;
+          if (!line.includes(interfaceName)) continue;
+          const fnLines = [];
+          let depth = 0;
+          for (let j2 = i; j2 < Math.min(i + 30, lines.length); j2++) {
+            fnLines.push(lines[j2]);
+            depth += (lines[j2].match(/\{/g) ?? []).length;
+            depth -= (lines[j2].match(/\}/g) ?? []).length;
+            if (depth === 0 && j2 > i) break;
+          }
           ctx.paginationExample = `// From ${relPath}
-${interfaceMatch[0]}
+${interfaceBlock}
 
-${fnMatch[0]}`;
+${fnLines.join("\n")}`;
           break;
         }
+        if (ctx.paginationExample) break;
       } catch {
       }
     }
@@ -5824,6 +5973,152 @@ Shared component structure patterns:`);
   return lines.join("\n");
 }
 
+// core/run-snapshot.ts
+import * as fs8 from "fs-extra";
+import * as path7 from "path";
+var BACKUP_DIR = ".ai-spec-backup";
+var RunSnapshot = class {
+  constructor(workingDir, runId) {
+    this.workingDir = workingDir;
+    this.runId = runId;
+    this.backupRoot = path7.join(workingDir, BACKUP_DIR, runId);
+  }
+  backupRoot;
+  snapshotted = /* @__PURE__ */ new Set();
+  /**
+   * Snapshot a file before it gets overwritten.
+   * No-op if the file does not exist yet (new file — nothing to restore).
+   * No-op if this file was already snapshotted in this run.
+   */
+  async snapshotFile(filePath) {
+    const fullPath = path7.isAbsolute(filePath) ? filePath : path7.join(this.workingDir, filePath);
+    if (!await fs8.pathExists(fullPath)) return;
+    if (this.snapshotted.has(fullPath)) return;
+    const relative7 = path7.relative(this.workingDir, fullPath);
+    const dest = path7.join(this.backupRoot, relative7);
+    await fs8.ensureDir(path7.dirname(dest));
+    await fs8.copy(fullPath, dest);
+    this.snapshotted.add(fullPath);
+  }
+  /** Restore all snapshotted files. Returns list of restored relative paths. */
+  async restore() {
+    if (!await fs8.pathExists(this.backupRoot)) return [];
+    const restored = [];
+    const walk = async (dir) => {
+      for (const entry of await fs8.readdir(dir, { withFileTypes: true })) {
+        const full = path7.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(full);
+        } else {
+          const relative7 = path7.relative(this.backupRoot, full);
+          const dest = path7.join(this.workingDir, relative7);
+          await fs8.ensureDir(path7.dirname(dest));
+          await fs8.copy(full, dest, { overwrite: true });
+          restored.push(relative7);
+        }
+      }
+    };
+    await walk(this.backupRoot);
+    return restored;
+  }
+  get fileCount() {
+    return this.snapshotted.size;
+  }
+};
+var _activeSnapshot = null;
+function setActiveSnapshot(snapshot) {
+  _activeSnapshot = snapshot;
+}
+function getActiveSnapshot() {
+  return _activeSnapshot;
+}
+
+// core/run-logger.ts
+import * as fs9 from "fs-extra";
+import * as path8 from "path";
+import chalk7 from "chalk";
+var LOG_DIR = ".ai-spec-logs";
+var RunLogger = class {
+  constructor(workingDir, runId, meta) {
+    this.workingDir = workingDir;
+    this.runId = runId;
+    this.startMs = Date.now();
+    this.logPath = path8.join(workingDir, LOG_DIR, `${runId}.json`);
+    this.log = {
+      runId,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      workingDir,
+      ...meta,
+      entries: [],
+      filesWritten: [],
+      errors: []
+    };
+    this.flush();
+  }
+  log;
+  startMs;
+  logPath;
+  stageStartMs = /* @__PURE__ */ new Map();
+  stageStart(event, data) {
+    this.stageStartMs.set(event, Date.now());
+    this.push(event, data);
+  }
+  stageEnd(event, data) {
+    const start = this.stageStartMs.get(event);
+    const durationMs = start !== void 0 ? Date.now() - start : void 0;
+    this.push(`${event}:done`, { ...data, durationMs });
+  }
+  stageFail(event, error, data) {
+    const start = this.stageStartMs.get(event);
+    const durationMs = start !== void 0 ? Date.now() - start : void 0;
+    this.push(`${event}:failed`, { ...data, error, durationMs });
+    this.log.errors.push(`[${event}] ${error}`);
+    this.flush();
+  }
+  fileWritten(filePath) {
+    if (!this.log.filesWritten.includes(filePath)) {
+      this.log.filesWritten.push(filePath);
+      this.flush();
+    }
+  }
+  finish() {
+    this.log.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.log.totalDurationMs = Date.now() - this.startMs;
+    this.flush();
+  }
+  printSummary() {
+    const dur = this.log.totalDurationMs ? ` in ${(this.log.totalDurationMs / 1e3).toFixed(1)}s` : "";
+    const errPart = this.log.errors.length > 0 ? chalk7.yellow(` \xB7 ${this.log.errors.length} error(s)`) : "";
+    console.log(
+      chalk7.gray(`
+  Run ID: ${chalk7.white(this.runId)}${dur}`) + chalk7.gray(` \xB7 ${this.log.filesWritten.length} file(s) written`) + errPart
+    );
+    console.log(chalk7.gray(`  Log   : ${path8.relative(this.workingDir, this.logPath)}`));
+  }
+  push(event, data) {
+    this.log.entries.push({ ts: (/* @__PURE__ */ new Date()).toISOString(), event, ...data ? { data } : {} });
+    this.flush();
+  }
+  flush() {
+    fs9.ensureDir(path8.dirname(this.logPath)).then(() => fs9.writeJson(this.logPath, this.log, { spaces: 2 })).catch(() => {
+    });
+  }
+};
+function generateRunId() {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const time = now.toTimeString().slice(0, 8).replace(/:/g, "");
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${date}-${time}-${rand}`;
+}
+var _activeLogger = null;
+function setActiveLogger(logger) {
+  _activeLogger = logger;
+}
+function getActiveLogger() {
+  return _activeLogger;
+}
+
 // core/code-generator.ts
 function buildSharedConfigSection(context) {
   if (!context?.sharedConfigFiles || context.sharedConfigFiles.length === 0) return "";
@@ -5990,13 +6285,13 @@ var CodeGenerator = class {
     let effectiveMode = this.mode;
     if (effectiveMode === "claude-code" && this.provider.providerName !== "claude") {
       console.log(
-        chalk6.yellow(
+        chalk8.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
+      console.log(chalk8.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(chalk8.gray(`  \u63D0\u793A\uFF1A\u8FD0\u884C \`ai-spec config --codegen api\` \u53EF\u56FA\u5316\u6B64\u8BBE\u7F6E\u3002
 `));
       effectiveMode = "api";
     }
@@ -6021,16 +6316,16 @@ var CodeGenerator = class {
     }
   }
   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"));
+    console.log(chalk8.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"));
+      console.log(chalk8.yellow("  \u26A0\uFE0F  Claude Code CLI not found. Falling back to plan mode."));
+      console.log(chalk8.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"));
+      console.log(chalk8.green("  \u2713 RTK detected \u2014 using rtk claude for token savings"));
     }
     const tasks = await loadTasksForSpec(specFilePath);
     if (options.auto && tasks && tasks.length > 0) {
@@ -6043,30 +6338,30 @@ ${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 = path7.join(workingDir, ".claude-prompt.txt");
-    await fs8.writeFile(promptFile, promptContent, "utf-8");
+    const promptFile = path9.join(workingDir, ".claude-prompt.txt");
+    await fs10.writeFile(promptFile, promptContent, "utf-8");
     if (options.auto) {
-      console.log(chalk6.cyan(`  \u{1F916} Auto mode: running claude -p (non-interactive)...`));
-      console.log(chalk6.gray(`  Spec: ${specFilePath}`));
+      console.log(chalk8.cyan(`  \u{1F916} Auto mode: running claude -p (non-interactive)...`));
+      console.log(chalk8.gray(`  Spec: ${specFilePath}`));
       try {
         execSync(`${claudeCmd} -p "${promptContent.replace(/"/g, '\\"')}"`, {
           cwd: workingDir,
           stdio: "inherit"
         });
-        console.log(chalk6.green("\n  \u2714 Claude Code completed."));
+        console.log(chalk8.green("\n  \u2714 Claude Code completed."));
       } catch {
-        console.log(chalk6.yellow("\n  Claude Code exited. Check output above."));
+        console.log(chalk8.yellow("\n  Claude Code exited. Check output above."));
       }
     } else {
-      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"));
+      console.log(chalk8.cyan(`  \u{1F680} Launching ${claudeCmd} in: ${workingDir}`));
+      console.log(chalk8.gray(`  Spec: ${specFilePath}`));
+      if (tasks) console.log(chalk8.gray(`  Tasks: ${tasks.length} tasks loaded into .claude-prompt.txt`));
+      console.log(chalk8.gray("  Prompt pre-loaded in .claude-prompt.txt\n"));
       try {
         execSync(claudeCmd, { cwd: workingDir, stdio: "inherit" });
-        console.log(chalk6.green("\n  \u2714 Claude Code session completed."));
+        console.log(chalk8.green("\n  \u2714 Claude Code session completed."));
       } catch {
-        console.log(chalk6.yellow("\n  Claude Code session ended. Continuing workflow."));
+        console.log(chalk8.yellow("\n  Claude Code session ended. Continuing workflow."));
       }
     }
   }
@@ -6079,10 +6374,10 @@ ${tasks.map((t) => `${t.id} [${t.layer}] ${t.title}
     const pending = tasks.filter((t) => t.status !== "done");
     const doneCount = tasks.length - pending.length;
     if (options.resume && doneCount > 0) {
-      console.log(chalk6.cyan(`
+      console.log(chalk8.cyan(`
   Resuming: ${doneCount}/${tasks.length} tasks already done \u2014 skipping.`));
     } else {
-      console.log(chalk6.cyan(`
+      console.log(chalk8.cyan(`
   Incremental mode: ${tasks.length} tasks`));
     }
     let completed = doneCount;
@@ -6110,32 +6405,32 @@ Implement ONLY this task. Do not implement other tasks.`;
         completed++;
       } catch {
         taskStatus = "failed";
-        console.log(chalk6.yellow(`
+        console.log(chalk8.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(
+      chalk8.bold(
         `
-  ${successCount === tasks.length ? chalk6.green("\u2714") : chalk6.yellow("!")} Incremental build: ${completed}/${tasks.length} tasks completed.`
+  ${successCount === tasks.length ? chalk8.green("\u2714") : chalk8.yellow("!")} Incremental build: ${completed}/${tasks.length} tasks completed.`
       )
     );
   }
   // ── Mode: api ─────────────────────────────────────────────────────────────
   async runApiMode(specFilePath, workingDir, context, options = {}) {
     console.log(
-      chalk6.blue(
+      chalk8.blue(
         `
 \u2500\u2500\u2500 Code Generation: API (${this.provider.providerName}/${this.provider.modelName}) \u2500\u2500\u2500`
       )
     );
     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)`));
+      console.log(chalk8.gray(`  Language: ${options.repoType} (using language-specific codegen prompt)`));
     }
-    const spec = await fs8.readFile(specFilePath, "utf-8");
+    const spec = await fs10.readFile(specFilePath, "utf-8");
     const constitutionSection = context?.constitution ? `
 === Project Constitution (MUST follow) ===
 ${context.constitution}
@@ -6151,7 +6446,7 @@ ${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}`));
+      console.log(chalk8.green(`  \u2713 DSL loaded \u2014 ${dsl.endpoints.length} endpoints, ${dsl.models.length} models${cmpSuffix}`));
     }
     const isFrontend = isFrontendDeps(context?.dependencies ?? []);
     let frontendSection = "";
@@ -6160,13 +6455,13 @@ ${buildDslContextSection(dsl)}
       frontendSection = `
 ${buildFrontendContextSection(fctx)}
 `;
-      console.log(chalk6.gray(`  Frontend context: ${fctx.framework} / ${fctx.httpClient} | hooks:${fctx.hookFiles.length} stores:${fctx.storeFiles.length}`));
+      console.log(chalk8.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, specFilePath, workingDir, constitutionSection + dslSection + installedPackagesSection, frontendSection, sharedConfigSection, options, systemPrompt, context);
     }
-    console.log(chalk6.gray("  [1/2] Planning implementation files..."));
+    console.log(chalk8.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,
@@ -6189,18 +6484,18 @@ Output ONLY a valid JSON array:
       const planResponse = await this.provider.generate(planPrompt, systemPrompt);
       filePlan = parseJsonArray(planResponse);
     } catch (err) {
-      console.error(chalk6.red("  Failed to generate file plan:"), err);
+      console.error(chalk8.red("  Failed to generate file plan:"), err);
     }
     if (filePlan.length === 0) {
-      console.log(chalk6.yellow("  Could not determine file plan. Falling back to plan mode."));
+      console.log(chalk8.yellow("  Could not determine file plan. Falling back to plan mode."));
       await this.runPlanMode(specFilePath);
       return [];
     }
-    console.log(chalk6.cyan(`
+    console.log(chalk8.cyan(`
   Plan: ${filePlan.length} file(s) to process`));
     filePlan.forEach((item) => {
-      const icon = item.action === "create" ? chalk6.green("+") : chalk6.yellow("~");
-      console.log(`  ${icon} ${item.file}: ${chalk6.gray(item.description)}`);
+      const icon = item.action === "create" ? chalk8.green("+") : chalk8.yellow("~");
+      console.log(`  ${icon} ${item.file}: ${chalk8.gray(item.description)}`);
     });
     const { files } = await this.generateFiles(filePlan, spec, workingDir, constitutionSection + dslSection + frontendSection + installedPackagesSection, systemPrompt);
     return files;
@@ -6209,13 +6504,13 @@ Output ONLY a valid JSON array:
     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)`));
+      console.log(chalk8.cyan(`
+  Task-based generation (resume): ${tasks.length} tasks (${chalk8.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)`));
+      console.log(chalk8.cyan(`
+  Task-based generation: ${tasks.length} tasks (${chalk8.green(doneCount + " already done")}, resuming from checkpoint)`));
     } else {
-      console.log(chalk6.cyan(`
+      console.log(chalk8.cyan(`
   Task-based generation: ${tasks.length} tasks`));
     }
     const sharedConfigPaths = new Set(
@@ -6247,9 +6542,9 @@ Output ONLY a valid JSON array:
         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));
+        const bar = chalk8.green("\u2588".repeat(filled)) + chalk8.gray("\u2591".repeat(barWidth - filled));
         console.log(
-          chalk6.bold(`
+          chalk8.bold(`
   [${bar}] ${pct}% \u26A1 Layer [${layer}] ${layerIcon} \u2014 ${layerTasks.length} tasks running in parallel`)
         );
       } else {
@@ -6257,12 +6552,12 @@ Output ONLY a valid JSON array:
       }
       const executeTask = async (task, batchIsParallel) => {
         if (task.filesToTouch.length === 0) {
-          if (!batchIsParallel) console.log(chalk6.gray("    No files specified, skipping."));
+          if (!batchIsParallel) console.log(chalk8.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(path7.join(workingDir, f));
+            const exists = await fs10.pathExists(path9.join(workingDir, f));
             return {
               file: f,
               action: exists ? "modify" : "create",
@@ -6302,7 +6597,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 fs8.readFile(path7.join(workingDir, writtenFile), "utf-8");
+                const content = isViewFile ? `// view component \u2014 use this exact path for router imports` : await fs10.readFile(path9.join(workingDir, writtenFile), "utf-8");
                 generatedFileCache.set(writtenFile, content);
               } catch {
               }
@@ -6314,7 +6609,12 @@ ${taskContext}`,
       const layerResults = [];
       for (const batch of taskBatches) {
         const batchIsParallel = batch.length > 1;
-        const batchResultPromises = batch.map((task) => executeTask(task, batchIsParallel));
+        const batchResultPromises = batch.map(
+          (task) => executeTask(task, batchIsParallel).catch((err) => {
+            console.log(chalk8.yellow(`  \u26A0 ${task.id} threw unexpectedly: ${err.message}`));
+            return { task, files: [], createdFiles: [], success: 0, total: 0, impliesRegistration: false };
+          })
+        );
         const batchResults = await Promise.all(batchResultPromises);
         layerResults.push(...batchResults);
         await updateCacheFromBatch(batchResults);
@@ -6327,14 +6627,14 @@ ${taskContext}`,
         totalFiles += result.total;
         allGeneratedFiles.push(...result.files);
         if (isParallel) {
-          const icon = result.success === result.total ? chalk6.green("\u2714") : chalk6.yellow("!");
+          const icon = result.success === result.total ? chalk8.green("\u2714") : chalk8.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`));
+          console.log(chalk8.yellow(`  \u26A0 ${result.task.id} marked as failed \u2014 re-run with --resume to retry`));
         }
       }
       completedTasks += layerTasks.length;
@@ -6343,13 +6643,13 @@ ${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) => path7.basename(f).replace(/\.[jt]sx?$/, ""));
+          const newModuleNames = allCreatedInLayer.filter((f) => f !== sharedFile.path).map((f) => path9.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(`
+          console.log(chalk8.gray(`
     + updating shared config: ${sharedFile.path} [${sharedFile.category}]`));
           const updatedGeneratedFilesSection = buildGeneratedFilesSection(generatedFileCache);
           await this.generateFiles(
@@ -6367,26 +6667,26 @@ Updating shared registration after layer [${layer}] completed. New modules: ${ne
       }
     }
     console.log(
-      chalk6.bold(
+      chalk8.bold(
         `
-  ${totalSuccess === totalFiles ? chalk6.green("\u2714") : chalk6.yellow("!")} Task-based generation: ${totalSuccess}/${totalFiles} files written across ${pendingTasks.length} tasks.`
+  ${totalSuccess === totalFiles ? chalk8.green("\u2714") : chalk8.yellow("!")} Task-based generation: ${totalSuccess}/${totalFiles} files written across ${pendingTasks.length} tasks.`
       )
     );
     return allGeneratedFiles;
   }
   async generateFiles(filePlan, spec, workingDir, constitutionSection, systemPrompt = getCodeGenSystemPrompt(), taskLabel) {
-    const prefix = taskLabel ? `  [${chalk6.cyan(taskLabel)}] ` : "  ";
+    const prefix = taskLabel ? `  [${chalk8.cyan(taskLabel)}] ` : "  ";
     if (!taskLabel) {
-      console.log(chalk6.gray(`
+      console.log(chalk8.gray(`
   Generating ${filePlan.length} file(s)...`));
     }
     let successCount = 0;
     const writtenFiles = [];
     for (const item of filePlan) {
-      const fullPath = path7.join(workingDir, item.file);
+      const fullPath = path9.join(workingDir, item.file);
       let existingContent = "";
-      if (await fs8.pathExists(fullPath)) {
-        existingContent = await fs8.readFile(fullPath, "utf-8");
+      if (await fs10.pathExists(fullPath)) {
+        existingContent = await fs10.readFile(fullPath, "utf-8");
       }
       const codePrompt = `Implement this file.
 
@@ -6401,19 +6701,21 @@ ${existingContent || "Output only the complete file content."}`;
       try {
         const raw = await this.provider.generate(codePrompt, systemPrompt);
         const fileContent = stripCodeFences(raw);
-        await fs8.ensureDir(path7.dirname(fullPath));
-        await fs8.writeFile(fullPath, fileContent, "utf-8");
-        console.log(`${prefix}${existingContent ? chalk6.yellow("~") : chalk6.green("+")} ${chalk6.bold(item.file)} ${chalk6.green("\u2714")}`);
+        await getActiveSnapshot()?.snapshotFile(fullPath);
+        await fs10.ensureDir(path9.dirname(fullPath));
+        await fs10.writeFile(fullPath, fileContent, "utf-8");
+        getActiveLogger()?.fileWritten(item.file);
+        console.log(`${prefix}${existingContent ? chalk8.yellow("~") : chalk8.green("+")} ${chalk8.bold(item.file)} ${chalk8.green("\u2714")}`);
         successCount++;
         writtenFiles.push(item.file);
       } catch (err) {
-        console.log(`${prefix}${chalk6.red("\u2718")} ${chalk6.bold(item.file)} \u2014 ${chalk6.red(err.message)}`);
+        console.log(`${prefix}${chalk8.red("\u2718")} ${chalk8.bold(item.file)} \u2014 ${chalk8.red(err.message)}`);
       }
     }
     if (!taskLabel) {
       console.log(
-        chalk6.bold(
-          `  ${successCount === filePlan.length ? chalk6.green("\u2714") : chalk6.yellow("!")} ${successCount}/${filePlan.length} files written.`
+        chalk8.bold(
+          `  ${successCount === filePlan.length ? chalk8.green("\u2714") : chalk8.yellow("!")} ${successCount}/${filePlan.length} files written.`
         )
       );
     }
@@ -6421,8 +6723,8 @@ ${existingContent || "Output only the complete file content."}`;
   }
   // ── Mode: plan ─────────────────────────────────────────────────────────────
   async runPlanMode(specFilePath) {
-    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");
+    console.log(chalk8.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 plan = await this.provider.generate(
       `Create a detailed, step-by-step implementation plan for the following feature spec.
 Be specific about:
@@ -6434,7 +6736,7 @@ Be specific about:
 ${spec}`,
       "You are a senior developer creating an actionable implementation guide."
     );
-    console.log(chalk6.cyan("\n") + plan);
+    console.log(chalk8.cyan("\n") + plan);
   }
 };
 function topoSortLayerTasks(tasks) {
@@ -6485,16 +6787,16 @@ 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 bar = chalk8.green("\u2588".repeat(filled)) + chalk8.gray("\u2591".repeat(barWidth - filled));
   const icon = LAYER_ICONS[task.layer] ?? "  ";
   if (mode === "skip") {
     console.log(
-      chalk6.gray(`
+      chalk8.gray(`
   [${bar}] ${pct}% \u2713 ${task.id} ${icon} ${task.title} \u2014 already done`)
     );
   } else {
     console.log(
-      chalk6.bold(`
+      chalk8.bold(`
   [${bar}] ${pct}% \u2192 ${task.id} ${icon} ${task.title}`)
     );
   }
@@ -6502,27 +6804,27 @@ function printTaskProgress(completed, total, task, mode) {
 
 // core/reviewer.ts
 init_codegen_prompt();
-import chalk7 from "chalk";
+import chalk9 from "chalk";
 import { execSync as execSync2 } from "child_process";
-import * as path8 from "path";
-import * as fs9 from "fs-extra";
+import * as path10 from "path";
+import * as fs11 from "fs-extra";
 var REVIEW_HISTORY_FILE = ".ai-spec-reviews.json";
 async function loadReviewHistory(projectRoot) {
-  const historyPath = path8.join(projectRoot, REVIEW_HISTORY_FILE);
+  const historyPath = path10.join(projectRoot, REVIEW_HISTORY_FILE);
   try {
-    if (await fs9.pathExists(historyPath)) {
-      return await fs9.readJson(historyPath);
+    if (await fs11.pathExists(historyPath)) {
+      return await fs11.readJson(historyPath);
     }
   } catch {
   }
   return [];
 }
 async function appendReviewHistory(projectRoot, entry) {
-  const historyPath = path8.join(projectRoot, REVIEW_HISTORY_FILE);
+  const historyPath = path10.join(projectRoot, REVIEW_HISTORY_FILE);
   const existing = await loadReviewHistory(projectRoot);
   const updated = [...existing, entry].slice(-20);
   try {
-    await fs9.writeJson(historyPath, updated, { spaces: 2 });
+    await fs11.writeJson(historyPath, updated, { spaces: 2 });
   } catch {
   }
 }
@@ -6530,6 +6832,14 @@ function extractScore(reviewText) {
   const match = reviewText.match(/Score:\s*(\d+(?:\.\d+)?)\s*\/\s*10/i);
   return match ? parseFloat(match[1]) : 0;
 }
+function extractImpactLevel(reviewText) {
+  const match = reviewText.match(/影响等级[：:]\s*(低|中|高)/);
+  return match ? match[1] : void 0;
+}
+function extractComplexityLevel(reviewText) {
+  const match = reviewText.match(/复杂度等级[：:]\s*(低|中|高)/);
+  return match ? match[1] : void 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);
@@ -6540,7 +6850,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}] ${path10.basename(entry.specFile)} \u2014 Score: ${entry.score}/10`);
     entry.topIssues.forEach((issue) => lines.push(`  \xB7 ${issue}`));
   }
   return lines.join("\n") + "\n";
@@ -6575,15 +6885,14 @@ var CodeReviewer = class {
     };
   }
   /**
-   * Two-pass review:
+   * Three-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.
+   *   Pass 3 — impact assessment + code complexity
    */
-  async runTwoPassReview(specContent, codeContext, specFile) {
-    console.log(chalk7.gray("  Pass 1/2: Architecture review..."));
+  async runThreePassReview(specContent, codeContext, specFile) {
+    console.log(chalk9.gray("  Pass 1/3: Architecture review..."));
     const archPrompt = `Review the architecture of this change.
 
 === Feature Spec ===
@@ -6592,7 +6901,7 @@ ${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..."));
+    console.log(chalk9.gray("  Pass 2/3: Implementation review..."));
     const history = await loadReviewHistory(this.projectRoot);
     const historyContext = buildHistoryContext(history);
     const implPrompt = `Review the implementation details of this change.
@@ -6607,61 +6916,85 @@ ${codeContext}
 ${archReview}
 ${historyContext}`;
     const implReview = await this.provider.generate(implPrompt, reviewImplementationSystemPrompt);
-    const combined = `${archReview}
+    console.log(chalk9.gray("  Pass 3/3: Impact & complexity assessment..."));
+    const impactPrompt = `Assess the impact and complexity of this change.
 
-${"\u2500".repeat(52)}
+=== Feature Spec ===
+${specContent || "(No spec \u2014 review for general code quality)"}
+
+=== Code ===
+${codeContext}
+
+=== Architecture Review (Pass 1 \u2014 do NOT repeat) ===
+${archReview}
 
+=== Implementation Review (Pass 2 \u2014 do NOT repeat) ===
 ${implReview}`;
+    const impactReview = await this.provider.generate(impactPrompt, reviewImpactComplexitySystemPrompt);
+    const sep = "\u2500".repeat(52);
+    const combined = `${archReview}
+
+${sep}
+
+${implReview}
+
+${sep}
+
+${impactReview}`;
     const score = extractScore(implReview) || extractScore(archReview);
     const topIssues = extractTopIssues(implReview);
+    const impactLevel = extractImpactLevel(impactReview);
+    const complexityLevel = extractComplexityLevel(impactReview);
     if (score > 0 && specFile) {
       await appendReviewHistory(this.projectRoot, {
         date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
-        specFile: path8.relative(this.projectRoot, specFile),
+        specFile: path10.relative(this.projectRoot, specFile),
         score,
-        topIssues
+        topIssues,
+        ...impactLevel ? { impactLevel } : {},
+        ...complexityLevel ? { complexityLevel } : {}
       });
     }
     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"));
+    console.log(chalk9.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(
-        chalk7.yellow("  No git diff found. Stage or commit changes first, then run review.")
+        chalk9.yellow("  No git diff found. Stage or commit changes first, then run review.")
       );
-      console.log(chalk7.gray("  Tip: run `git add .` then `ai-spec review` to review your work."));
+      console.log(chalk9.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(
-      chalk7.gray(`  Diff: ${files} file(s), ${chalk7.green("+" + added)} ${chalk7.red("-" + removed)}`)
+      chalk9.gray(`  Diff: ${files} file(s), ${chalk9.green("+" + added)} ${chalk9.red("-" + removed)}`)
     );
     console.log(
-      chalk7.blue(`  Reviewing with ${this.provider.providerName}/${this.provider.modelName}...`)
+      chalk9.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"));
+    const reviewResult = await this.runThreePassReview(specContent, codeContext, specFile);
+    console.log(chalk9.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"));
+    console.log(chalk9.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(chalk9.cyan("\n\u2500\u2500\u2500 Automated Code Review (file-based) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk9.gray(`  Reviewing ${filePaths.length} generated file(s)...`));
     console.log(
-      chalk7.blue(`  Reviewing with ${this.provider.providerName}/${this.provider.modelName}...`)
+      chalk9.blue(`  Reviewing with ${this.provider.providerName}/${this.provider.modelName}...`)
     );
     let filesSection = "";
     for (const filePath of filePaths) {
-      const fullPath = path8.join(workingDir, filePath);
+      const fullPath = path10.join(workingDir, filePath);
       try {
-        const content = await fs9.readFile(fullPath, "utf-8");
+        const content = await fs11.readFile(fullPath, "utf-8");
         filesSection += `
 
 === ${filePath} ===
@@ -6675,35 +7008,35 @@ ${content.slice(0, 3e3)}`;
 (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"));
+    const reviewResult = await this.runThreePassReview(specContent, filesSection, specFile);
+    console.log(chalk9.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"));
+    console.log(chalk9.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."));
+      console.log(chalk9.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"));
+    console.log(chalk9.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")}  ${path8.basename(entry.specFile)}`);
+      const color = entry.score >= 8 ? chalk9.green : entry.score >= 6 ? chalk9.yellow : chalk9.red;
+      console.log(`  ${entry.date}  [${color(bar)}] ${color(entry.score + "/10")}  ${path10.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"));
+    console.log(chalk9.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"));
   }
 };
 
 // git/worktree.ts
 import { execSync as execSync3 } from "child_process";
-import * as path9 from "path";
-import * as fs10 from "fs-extra";
-import chalk8 from "chalk";
+import * as path11 from "path";
+import * as fs12 from "fs-extra";
+import chalk10 from "chalk";
 var GitWorktreeManager = class {
   constructor(baseDir) {
     this.baseDir = baseDir;
@@ -6728,32 +7061,32 @@ 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 fs10.pathExists(src)) continue;
-      if (await fs10.pathExists(dest)) continue;
+      const src = path11.join(this.baseDir, dir);
+      const dest = path11.join(worktreePath, dir);
+      if (!await fs12.pathExists(src)) continue;
+      if (await fs12.pathExists(dest)) continue;
       try {
-        await fs10.ensureSymlink(src, dest, "dir");
-        console.log(chalk8.gray(`  Symlinked ${dir}/ from base repo \u2192 worktree`));
+        await fs12.ensureSymlink(src, dest, "dir");
+        console.log(chalk10.gray(`  Symlinked ${dir}/ from base repo \u2192 worktree`));
       } catch (err) {
-        console.log(chalk8.yellow(`  \u26A0 Could not symlink ${dir}/: ${err.message}`));
-        console.log(chalk8.yellow(`    Run \`npm install\` inside the worktree manually.`));
+        console.log(chalk10.yellow(`  \u26A0 Could not symlink ${dir}/: ${err.message}`));
+        console.log(chalk10.yellow(`    Run \`npm install\` inside the worktree manually.`));
       }
     }
   }
   async createWorktree(idea) {
     if (!this.isGitRepo()) {
-      console.log(chalk8.yellow("\u26A0\uFE0F Not a git repository. Skipping worktree creation."));
+      console.log(chalk10.yellow("\u26A0\uFE0F Not a git repository. Skipping worktree creation."));
       return null;
     }
     const featureName = this.sanitizeFeatureName(idea);
     const branchName = `feature/${featureName}`;
-    const repoName = path9.basename(this.baseDir);
-    const worktreePath = path9.resolve(this.baseDir, "..", `${repoName}-${featureName}`);
-    console.log(chalk8.cyan(`
+    const repoName = path11.basename(this.baseDir);
+    const worktreePath = path11.resolve(this.baseDir, "..", `${repoName}-${featureName}`);
+    console.log(chalk10.cyan(`
 --- Setting up Git Worktree ---`));
-    if (await fs10.pathExists(worktreePath)) {
-      console.log(chalk8.yellow(`\u26A0\uFE0F Worktree directory already exists at: ${worktreePath}`));
+    if (await fs12.pathExists(worktreePath)) {
+      console.log(chalk10.yellow(`\u26A0\uFE0F Worktree directory already exists at: ${worktreePath}`));
       await this.linkDependencies(worktreePath);
       return worktreePath;
     }
@@ -6767,7 +7100,7 @@ var GitWorktreeManager = class {
         branchExists = true;
       } catch {
       }
-      console.log(chalk8.gray(`Creating worktree at: ${worktreePath}`));
+      console.log(chalk10.gray(`Creating worktree at: ${worktreePath}`));
       if (branchExists) {
         execSync3(`git worktree add "${worktreePath}" ${branchName}`, {
           cwd: this.baseDir,
@@ -6780,21 +7113,21 @@ var GitWorktreeManager = class {
         });
       }
       console.log(
-        chalk8.green(`\u2714 Worktree successfully created and isolated on branch '${branchName}'`)
+        chalk10.green(`\u2714 Worktree successfully created and isolated on branch '${branchName}'`)
       );
       await this.linkDependencies(worktreePath);
       return worktreePath;
     } catch (error) {
-      console.error(chalk8.red("Failed to create git worktree:"), error);
+      console.error(chalk10.red("Failed to create git worktree:"), error);
       return null;
     }
   }
 };
 
 // core/constitution-generator.ts
-import chalk9 from "chalk";
-import * as fs11 from "fs-extra";
-import * as path10 from "path";
+import chalk11 from "chalk";
+import * as fs13 from "fs-extra";
+import * as path12 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.
@@ -6874,8 +7207,8 @@ var ConstitutionGenerator = class {
     return this.provider.generate(prompt, constitutionSystemPrompt);
   }
   async saveConstitution(projectRoot, content) {
-    const filePath = path10.join(projectRoot, CONSTITUTION_FILE);
-    await fs11.writeFile(filePath, content, "utf-8");
+    const filePath = path12.join(projectRoot, CONSTITUTION_FILE);
+    await fs13.writeFile(filePath, content, "utf-8");
     return filePath;
   }
 };
@@ -6934,9 +7267,9 @@ ${sections.join("\n")}
 }
 
 // core/constitution-consolidator.ts
-import chalk10 from "chalk";
-import * as fs12 from "fs-extra";
-import * as path11 from "path";
+import chalk12 from "chalk";
+import * as fs14 from "fs-extra";
+import * as path13 from "path";
 
 // prompts/consolidate.prompt.ts
 var consolidateSystemPrompt = `You are a Principal Engineer maintaining a living "Project Constitution" document.
@@ -6999,26 +7332,26 @@ var ConstitutionConsolidator = class {
   }
   async consolidate(projectRoot, opts = {}) {
     const minLessons = opts.minLessons ?? 5;
-    const constitutionPath = path11.join(projectRoot, CONSTITUTION_FILE);
-    if (!await fs12.pathExists(constitutionPath)) {
+    const constitutionPath = path13.join(projectRoot, CONSTITUTION_FILE);
+    if (!await fs14.pathExists(constitutionPath)) {
       throw new Error(`No constitution file found at ${constitutionPath}. Run \`ai-spec init\` first.`);
     }
-    const original = await fs12.readFile(constitutionPath, "utf-8");
+    const original = await fs14.readFile(constitutionPath, "utf-8");
     const before = parseConstitutionStats(original);
-    console.log(chalk10.blue("\n\u2500\u2500\u2500 Constitution Consolidation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    console.log(chalk10.gray(`  File    : ${CONSTITUTION_FILE}`));
-    console.log(chalk10.gray(`  Size    : ${before.totalLines} lines`));
-    console.log(chalk10.gray(`  \xA79 items: ${before.lessonCount} accumulated lessons`));
+    console.log(chalk12.blue("\n\u2500\u2500\u2500 Constitution Consolidation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk12.gray(`  File    : ${CONSTITUTION_FILE}`));
+    console.log(chalk12.gray(`  Size    : ${before.totalLines} lines`));
+    console.log(chalk12.gray(`  \xA79 items: ${before.lessonCount} accumulated lessons`));
     if (before.lessonCount < minLessons) {
       console.log(
-        chalk10.green(
+        chalk12.green(
           `
   \u2714 \xA79 has only ${before.lessonCount} lesson(s) \u2014 no consolidation needed yet (threshold: ${minLessons}).`
         )
       );
       return { written: false, before, after: before, backupPath: null };
     }
-    console.log(chalk10.cyan(`
+    console.log(chalk12.cyan(`
   Consolidating ${before.lessonCount} lesson(s) with AI...`));
     const prompt = buildConsolidatePrompt(original, before.lessonCount);
     let consolidated;
@@ -7030,28 +7363,28 @@ var ConstitutionConsolidator = class {
     }
     const after = parseConstitutionStats(consolidated);
     const diff = computeDiff(original, consolidated);
-    console.log(chalk10.blue("\n  Changes preview:"));
+    console.log(chalk12.blue("\n  Changes preview:"));
     printDiff(diff, 4);
     printDiffSummary(diff);
-    console.log(chalk10.cyan("\n  After consolidation:"));
-    console.log(chalk10.gray(`  Size    : ${after.totalLines} lines (was ${before.totalLines})`));
-    console.log(chalk10.gray(`  \xA79 items: ${after.lessonCount} remaining (was ${before.lessonCount})`));
+    console.log(chalk12.cyan("\n  After consolidation:"));
+    console.log(chalk12.gray(`  Size    : ${after.totalLines} lines (was ${before.totalLines})`));
+    console.log(chalk12.gray(`  \xA79 items: ${after.lessonCount} remaining (was ${before.lessonCount})`));
     const liftedCount = Math.max(0, before.lessonCount - after.lessonCount);
     if (liftedCount > 0) {
-      console.log(chalk10.green(`  \u2714 ~${liftedCount} lesson(s) lifted into \xA71\u2013\xA78 or removed`));
+      console.log(chalk12.green(`  \u2714 ~${liftedCount} lesson(s) lifted into \xA71\u2013\xA78 or removed`));
     }
     if (opts.dryRun) {
-      console.log(chalk10.yellow("\n  [dry-run] No changes written."));
+      console.log(chalk12.yellow("\n  [dry-run] No changes written."));
       return { written: false, before, after, backupPath: null };
     }
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[T:]/g, "-");
     const backupName = `.ai-spec-constitution.backup-${timestamp}.md`;
-    const backupPath = path11.join(projectRoot, backupName);
-    await fs12.writeFile(backupPath, original, "utf-8");
-    console.log(chalk10.gray(`
+    const backupPath = path13.join(projectRoot, backupName);
+    await fs14.writeFile(backupPath, original, "utf-8");
+    console.log(chalk12.gray(`
   Backup  : ${backupName}`));
-    await fs12.writeFile(constitutionPath, consolidated, "utf-8");
-    console.log(chalk10.green(`  \u2714 Constitution updated: ${CONSTITUTION_FILE}`));
+    await fs14.writeFile(constitutionPath, consolidated, "utf-8");
+    console.log(chalk12.green(`  \u2714 Constitution updated: ${CONSTITUTION_FILE}`));
     return { written: true, before, after, backupPath };
   }
 };
@@ -7092,9 +7425,9 @@ function parseSpecAndTasks(raw) {
 }
 
 // core/test-generator.ts
-import chalk11 from "chalk";
-import * as fs13 from "fs-extra";
-import * as path12 from "path";
+import chalk13 from "chalk";
+import * as fs15 from "fs-extra";
+import * as path14 from "path";
 
 // prompts/testgen.prompt.ts
 var testGenSystemPrompt = `You are a Senior QA Engineer generating test skeletons for a Node.js/TypeScript project.
@@ -7287,10 +7620,10 @@ function parseTestFiles(raw) {
   return [];
 }
 async function isFrontendProject(workingDir) {
-  const pkgPath = path12.join(workingDir, "package.json");
-  if (!await fs13.pathExists(pkgPath)) return false;
+  const pkgPath = path14.join(workingDir, "package.json");
+  if (!await fs15.pathExists(pkgPath)) return false;
   try {
-    const pkg = await fs13.readJson(pkgPath);
+    const pkg = await fs15.readJson(pkgPath);
     const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
     const keys = Object.keys(deps);
     return keys.some((k2) => FRONTEND_FRAMEWORKS.includes(k2));
@@ -7308,20 +7641,20 @@ var TestGenerator = class {
    * Returns the list of test file paths written.
    */
   async generate(dsl, workingDir) {
-    console.log(chalk11.blue("\n\u2500\u2500\u2500 Test Generation \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(chalk13.blue("\n\u2500\u2500\u2500 Test Generation \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"));
     const testDir = await this.detectTestDir(workingDir);
     const frontend = await isFrontendProject(workingDir);
     let prompt;
     let systemPrompt;
     if (frontend) {
       const ctx = await loadFrontendContext(workingDir);
-      console.log(chalk11.gray(`  Mode: frontend (${ctx.framework} / ${ctx.testFramework})`));
-      console.log(chalk11.gray(`  Test directory: ${testDir}`));
+      console.log(chalk13.gray(`  Mode: frontend (${ctx.framework} / ${ctx.testFramework})`));
+      console.log(chalk13.gray(`  Test directory: ${testDir}`));
       prompt = buildFrontendTestGenPrompt(dsl, testDir, ctx);
       systemPrompt = testGenFrontendSystemPrompt;
     } else {
-      console.log(chalk11.gray(`  Mode: backend`));
-      console.log(chalk11.gray(`  Test directory: ${testDir}`));
+      console.log(chalk13.gray(`  Mode: backend`));
+      console.log(chalk13.gray(`  Test directory: ${testDir}`));
       prompt = buildBackendTestGenPrompt(dsl, testDir);
       systemPrompt = testGenSystemPrompt;
     }
@@ -7329,23 +7662,23 @@ var TestGenerator = class {
     try {
       rawOutput = await this.provider.generate(prompt, systemPrompt);
     } catch (err) {
-      console.log(chalk11.yellow(`  \u26A0 Test generation AI call failed: ${err.message}`));
+      console.log(chalk13.yellow(`  \u26A0 Test generation AI call failed: ${err.message}`));
       return [];
     }
     const testFiles = parseTestFiles(rawOutput);
     if (testFiles.length === 0) {
-      console.log(chalk11.yellow("  \u26A0 Could not parse test files from AI output. Skipping."));
+      console.log(chalk13.yellow("  \u26A0 Could not parse test files from AI output. Skipping."));
       return [];
     }
     const writtenFiles = [];
     for (const tf of testFiles) {
-      const fullPath = path12.join(workingDir, tf.file);
-      await fs13.ensureDir(path12.dirname(fullPath));
-      await fs13.writeFile(fullPath, tf.content, "utf-8");
-      console.log(chalk11.green(`  + ${tf.file}`));
+      const fullPath = path14.join(workingDir, tf.file);
+      await fs15.ensureDir(path14.dirname(fullPath));
+      await fs15.writeFile(fullPath, tf.content, "utf-8");
+      console.log(chalk13.green(`  + ${tf.file}`));
       writtenFiles.push(tf.file);
     }
-    console.log(chalk11.green(`  \u2714 ${writtenFiles.length} test file(s) generated.`));
+    console.log(chalk13.green(`  \u2714 ${writtenFiles.length} test file(s) generated.`));
     return writtenFiles;
   }
   /**
@@ -7354,40 +7687,40 @@ var TestGenerator = class {
    * Only supports backend projects (uses supertest + DSL endpoints/models).
    */
   async generateTdd(dsl, workingDir) {
-    console.log(chalk11.blue("\n\u2500\u2500\u2500 TDD Test Generation (pre-implementation) \u2500\u2500\u2500\u2500"));
+    console.log(chalk13.blue("\n\u2500\u2500\u2500 TDD Test Generation (pre-implementation) \u2500\u2500\u2500\u2500"));
     const testDir = await this.detectTestDir(workingDir);
-    console.log(chalk11.gray(`  Mode: TDD (real assertions \u2014 tests will fail until implementation is complete)`));
-    console.log(chalk11.gray(`  Test directory: ${testDir}`));
+    console.log(chalk13.gray(`  Mode: TDD (real assertions \u2014 tests will fail until implementation is complete)`));
+    console.log(chalk13.gray(`  Test directory: ${testDir}`));
     const prompt = buildBackendTestGenPrompt(dsl, testDir);
     let rawOutput;
     try {
       rawOutput = await this.provider.generate(prompt, tddTestGenSystemPrompt);
     } catch (err) {
-      console.log(chalk11.yellow(`  \u26A0 TDD test generation failed: ${err.message}`));
+      console.log(chalk13.yellow(`  \u26A0 TDD test generation failed: ${err.message}`));
       return [];
     }
     const testFiles = parseTestFiles(rawOutput);
     if (testFiles.length === 0) {
-      console.log(chalk11.yellow("  \u26A0 Could not parse TDD test files from AI output. Skipping."));
+      console.log(chalk13.yellow("  \u26A0 Could not parse TDD test files from AI output. Skipping."));
       return [];
     }
     const writtenFiles = [];
     for (const tf of testFiles) {
-      const fullPath = path12.join(workingDir, tf.file);
-      await fs13.ensureDir(path12.dirname(fullPath));
-      await fs13.writeFile(fullPath, tf.content, "utf-8");
-      console.log(chalk11.green(`  + ${tf.file}`));
+      const fullPath = path14.join(workingDir, tf.file);
+      await fs15.ensureDir(path14.dirname(fullPath));
+      await fs15.writeFile(fullPath, tf.content, "utf-8");
+      console.log(chalk13.green(`  + ${tf.file}`));
       writtenFiles.push(tf.file);
     }
     console.log(
-      chalk11.green(`  \u2714 ${writtenFiles.length} TDD test file(s) written.`) + chalk11.gray(" (expected to fail \u2014 implementation will make them pass)")
+      chalk13.green(`  \u2714 ${writtenFiles.length} TDD test file(s) written.`) + chalk13.gray(" (expected to fail \u2014 implementation will make them pass)")
     );
     return writtenFiles;
   }
   async detectTestDir(workingDir) {
     const candidates = ["tests", "test", "__tests__", "src/__tests__", "spec"];
     for (const c of candidates) {
-      if (await fs13.pathExists(path12.join(workingDir, c))) return c;
+      if (await fs15.pathExists(path14.join(workingDir, c))) return c;
     }
     return "tests";
   }
@@ -7395,10 +7728,10 @@ var TestGenerator = class {
 
 // core/error-feedback.ts
 init_codegen_prompt();
-import chalk12 from "chalk";
+import chalk14 from "chalk";
 import { execSync as execSync4 } from "child_process";
-import * as fs14 from "fs-extra";
-import * as path13 from "path";
+import * as fs16 from "fs-extra";
+import * as path15 from "path";
 function runCommand(cmd, cwd) {
   try {
     const output = execSync4(cmd, { cwd, encoding: "utf-8", timeout: 6e4 });
@@ -7409,10 +7742,10 @@ function runCommand(cmd, cwd) {
   }
 }
 function detectBuildCommand(workingDir) {
-  if (!fs14.existsSync(path13.join(workingDir, "tsconfig.json"))) return null;
-  const pkgPath = path13.join(workingDir, "package.json");
+  if (!fs16.existsSync(path15.join(workingDir, "tsconfig.json"))) return null;
+  const pkgPath = path15.join(workingDir, "package.json");
   try {
-    const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     if (allDeps["vue-tsc"]) return "npx vue-tsc --noEmit";
     if (pkg.scripts?.["type-check"]) return "npm run type-check";
@@ -7422,53 +7755,53 @@ function detectBuildCommand(workingDir) {
   return "npx tsc --noEmit";
 }
 function detectTestCommand(workingDir) {
-  if (fs14.existsSync(path13.join(workingDir, "go.mod"))) return "go test ./...";
-  if (fs14.existsSync(path13.join(workingDir, "composer.json"))) {
-    return fs14.existsSync(path13.join(workingDir, "vendor", "bin", "phpunit")) ? "./vendor/bin/phpunit --colors=never" : "php artisan test --no-ansi";
+  if (fs16.existsSync(path15.join(workingDir, "go.mod"))) return "go test ./...";
+  if (fs16.existsSync(path15.join(workingDir, "composer.json"))) {
+    return fs16.existsSync(path15.join(workingDir, "vendor", "bin", "phpunit")) ? "./vendor/bin/phpunit --colors=never" : "php artisan test --no-ansi";
   }
-  if (fs14.existsSync(path13.join(workingDir, "Cargo.toml"))) return "cargo test";
-  if (fs14.existsSync(path13.join(workingDir, "pom.xml"))) return "mvn test -q";
-  if (fs14.existsSync(path13.join(workingDir, "build.gradle")) || fs14.existsSync(path13.join(workingDir, "build.gradle.kts"))) {
+  if (fs16.existsSync(path15.join(workingDir, "Cargo.toml"))) return "cargo test";
+  if (fs16.existsSync(path15.join(workingDir, "pom.xml"))) return "mvn test -q";
+  if (fs16.existsSync(path15.join(workingDir, "build.gradle")) || fs16.existsSync(path15.join(workingDir, "build.gradle.kts"))) {
     return "./gradlew test";
   }
-  if (fs14.existsSync(path13.join(workingDir, "requirements.txt")) || fs14.existsSync(path13.join(workingDir, "pyproject.toml")) || fs14.existsSync(path13.join(workingDir, "setup.py"))) {
+  if (fs16.existsSync(path15.join(workingDir, "requirements.txt")) || fs16.existsSync(path15.join(workingDir, "pyproject.toml")) || fs16.existsSync(path15.join(workingDir, "setup.py"))) {
     return "pytest";
   }
-  const pkgPath = path13.join(workingDir, "package.json");
+  const pkgPath = path15.join(workingDir, "package.json");
   try {
-    const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
     if (pkg.scripts?.test) return "npm test";
     if (pkg.scripts?.vitest) return "npx vitest run";
   } catch {
   }
   for (const f of ["vitest.config.ts", "vitest.config.js", "jest.config.ts", "jest.config.js"]) {
-    if (fs14.existsSync(path13.join(workingDir, f))) {
+    if (fs16.existsSync(path15.join(workingDir, f))) {
       return f.startsWith("vitest") ? "npx vitest run" : "npx jest --forceExit";
     }
   }
   return null;
 }
 function detectLintCommand(workingDir) {
-  if (fs14.existsSync(path13.join(workingDir, "go.mod"))) {
+  if (fs16.existsSync(path15.join(workingDir, "go.mod"))) {
     return "go vet ./...";
   }
-  if (fs14.existsSync(path13.join(workingDir, "composer.json"))) {
-    return fs14.existsSync(path13.join(workingDir, "vendor", "bin", "phpstan")) ? "./vendor/bin/phpstan analyse --no-progress --memory-limit=512M" : null;
+  if (fs16.existsSync(path15.join(workingDir, "composer.json"))) {
+    return fs16.existsSync(path15.join(workingDir, "vendor", "bin", "phpstan")) ? "./vendor/bin/phpstan analyse --no-progress --memory-limit=512M" : null;
   }
-  if (fs14.existsSync(path13.join(workingDir, "Cargo.toml"))) return "cargo clippy -- -D warnings";
-  if (fs14.existsSync(path13.join(workingDir, "pom.xml")) || fs14.existsSync(path13.join(workingDir, "build.gradle"))) {
+  if (fs16.existsSync(path15.join(workingDir, "Cargo.toml"))) return "cargo clippy -- -D warnings";
+  if (fs16.existsSync(path15.join(workingDir, "pom.xml")) || fs16.existsSync(path15.join(workingDir, "build.gradle"))) {
     return null;
   }
-  if (fs14.existsSync(path13.join(workingDir, "requirements.txt")) || fs14.existsSync(path13.join(workingDir, "pyproject.toml")) || fs14.existsSync(path13.join(workingDir, "setup.py"))) {
+  if (fs16.existsSync(path15.join(workingDir, "requirements.txt")) || fs16.existsSync(path15.join(workingDir, "pyproject.toml")) || fs16.existsSync(path15.join(workingDir, "setup.py"))) {
     return "ruff check . || flake8 .";
   }
-  const pkgPath = path13.join(workingDir, "package.json");
+  const pkgPath = path15.join(workingDir, "package.json");
   try {
-    const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
     if (pkg.scripts?.lint) return "npm run lint";
   } catch {
   }
-  if (fs14.existsSync(path13.join(workingDir, ".eslintrc")) || fs14.existsSync(path13.join(workingDir, ".eslintrc.js")) || fs14.existsSync(path13.join(workingDir, ".eslintrc.json")) || fs14.existsSync(path13.join(workingDir, "eslint.config.js"))) {
+  if (fs16.existsSync(path15.join(workingDir, ".eslintrc")) || fs16.existsSync(path15.join(workingDir, ".eslintrc.js")) || fs16.existsSync(path15.join(workingDir, ".eslintrc.json")) || fs16.existsSync(path15.join(workingDir, "eslint.config.js"))) {
     return "npx eslint . --max-warnings=0";
   }
   return null;
@@ -7504,10 +7837,10 @@ async function attemptFix(provider, errors, workingDir, dsl) {
     errorsByFile.get(file).push(err);
   }
   for (const [file, fileErrors] of errorsByFile) {
-    const fullPath = path13.join(workingDir, file);
+    const fullPath = path15.join(workingDir, file);
     let existingContent = "";
     try {
-      existingContent = await fs14.readFile(fullPath, "utf-8");
+      existingContent = await fs16.readFile(fullPath, "utf-8");
     } catch {
       results.push({ fixed: false, file, explanation: "File not found \u2014 cannot auto-fix." });
       continue;
@@ -7530,87 +7863,90 @@ Output ONLY the complete fixed file content. No markdown fences, no explanations
     try {
       const raw = await provider.generate(prompt, getCodeGenSystemPrompt());
       const fixed = raw.replace(/^```\w*\n?/gm, "").replace(/\n?```$/gm, "").trim();
-      await fs14.writeFile(fullPath, fixed, "utf-8");
+      await getActiveSnapshot()?.snapshotFile(fullPath);
+      await fs16.writeFile(fullPath, fixed, "utf-8");
       results.push({ fixed: true, file, explanation: `Fixed ${fileErrors.length} error(s)` });
-      console.log(chalk12.green(`  \u2714 Auto-fixed: ${file}`));
+      console.log(chalk14.green(`  \u2714 Auto-fixed: ${file}`));
     } catch (err) {
       results.push({ fixed: false, file, explanation: `AI fix failed: ${err.message}` });
-      console.log(chalk12.yellow(`  \u26A0 Could not auto-fix: ${file}`));
+      console.log(chalk14.yellow(`  \u26A0 Could not auto-fix: ${file}`));
     }
   }
   return results;
 }
 async function runErrorFeedback(provider, workingDir, dsl, opts = {}) {
   const maxCycles = opts.maxCycles ?? 2;
-  console.log(chalk12.blue("\n\u2500\u2500\u2500 Error Feedback \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(chalk14.blue("\n\u2500\u2500\u2500 Error Feedback \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"));
   const testCmd = opts.skipTests ? null : detectTestCommand(workingDir);
   const lintCmd = opts.skipLint ? null : detectLintCommand(workingDir);
   const buildCmd = opts.skipBuild ? null : detectBuildCommand(workingDir);
   if (!testCmd && !lintCmd && !buildCmd) {
-    console.log(chalk12.gray("  No test / lint / type-check commands detected. Skipping error feedback."));
+    console.log(chalk14.gray("  No test / lint / type-check commands detected. Skipping error feedback."));
     return true;
   }
-  if (buildCmd) console.log(chalk12.gray(`  Type-check: ${buildCmd}`));
+  if (buildCmd) console.log(chalk14.gray(`  Type-check: ${buildCmd}`));
   for (let cycle = 1; cycle <= maxCycles; cycle++) {
     const allErrors = [];
     if (buildCmd) {
-      console.log(chalk12.gray(`
+      console.log(chalk14.gray(`
   [cycle ${cycle}/${maxCycles}] Type-check: ${buildCmd}`));
       const buildResult = runCommand(buildCmd, workingDir);
       if (!buildResult.success) {
-        const isToolCrash = /ReferenceError:|TypeError:|SyntaxError:/.test(buildResult.output) && buildResult.output.includes("node_modules");
+        const hasUncaughtError = /ReferenceError:|TypeError:|SyntaxError:/.test(buildResult.output);
+        const hasToolStackFrame = buildResult.output.split("\n").some((l) => l.trim().startsWith("at ") && l.includes("node_modules"));
+        const isToolCrash = hasUncaughtError && hasToolStackFrame;
         if (isToolCrash) {
-          console.log(chalk12.yellow(`  \u26A0 Type-check tool crashed (possible version incompatibility). Skipping.`));
-          console.log(chalk12.gray(`    Tip: run \`${buildCmd}\` manually to investigate.`));
+          console.log(chalk14.yellow(`  \u26A0 Type-check tool crashed (possible version incompatibility). Skipping.`));
+          console.log(chalk14.gray(`    Tip: run \`${buildCmd}\` manually to investigate.`));
         } else {
           const buildErrors = parseErrors(buildResult.output, "build");
           allErrors.push(...buildErrors);
-          console.log(chalk12.yellow(`  \u2718 Type errors (${buildErrors.length} captured)`));
+          console.log(chalk14.yellow(`  \u2718 Type errors (${buildErrors.length} captured)`));
         }
       } else {
-        console.log(chalk12.green("  \u2714 Type-check passed."));
+        console.log(chalk14.green("  \u2714 Type-check passed."));
       }
     }
     if (testCmd) {
-      console.log(chalk12.gray(`
+      console.log(chalk14.gray(`
   [cycle ${cycle}/${maxCycles}] Running tests: ${testCmd}`));
       const testResult = runCommand(testCmd, workingDir);
       if (!testResult.success) {
         const testErrors = parseErrors(testResult.output, "test");
         allErrors.push(...testErrors);
-        console.log(chalk12.yellow(`  \u2718 Tests failed (${testErrors.length} error(s) captured)`));
+        console.log(chalk14.yellow(`  \u2718 Tests failed (${testErrors.length} error(s) captured)`));
       } else {
-        console.log(chalk12.green("  \u2714 Tests passed."));
+        console.log(chalk14.green("  \u2714 Tests passed."));
       }
     }
     if (lintCmd) {
-      console.log(chalk12.gray(`  [cycle ${cycle}/${maxCycles}] Running lint: ${lintCmd}`));
+      console.log(chalk14.gray(`  [cycle ${cycle}/${maxCycles}] Running lint: ${lintCmd}`));
       const lintResult = runCommand(lintCmd, workingDir);
       if (!lintResult.success) {
         const lintErrors = parseErrors(lintResult.output, "lint");
         allErrors.push(...lintErrors);
-        console.log(chalk12.yellow(`  \u2718 Lint failed (${lintErrors.length} error(s) captured)`));
+        console.log(chalk14.yellow(`  \u2718 Lint failed (${lintErrors.length} error(s) captured)`));
       } else {
-        console.log(chalk12.green("  \u2714 Lint passed."));
+        console.log(chalk14.green("  \u2714 Lint passed."));
       }
     }
     if (allErrors.length === 0) {
-      console.log(chalk12.green(`
+      console.log(chalk14.green(`
   \u2714 All checks passed after ${cycle} cycle(s).`));
       return true;
     }
     if (cycle < maxCycles) {
-      console.log(chalk12.cyan(`
+      console.log(chalk14.cyan(`
   Attempting auto-fix (${allErrors.length} error(s))...`));
       await attemptFix(provider, allErrors, workingDir, dsl);
     }
   }
-  console.log(chalk12.yellow("\n  \u26A0 Some errors remain after auto-fix cycles. Manual intervention needed."));
+  console.log(chalk14.yellow("\n  \u26A0 Some errors remain after auto-fix cycles. Manual intervention needed."));
   return false;
 }
 
 // core/spec-assessor.ts
-import chalk13 from "chalk";
+import chalk15 from "chalk";
 
 // prompts/spec-assess.prompt.ts
 var specAssessSystemPrompt = `You are a Senior Software Architect reviewing a feature specification before it goes to code generation.
@@ -7665,8 +8001,8 @@ Output ONLY the JSON object \u2014 no explanation, no markdown fences.`;
 // core/spec-assessor.ts
 function scoreBar(score) {
   const filled = Math.round(score);
-  const bar = chalk13.green("\u2588".repeat(filled)) + chalk13.gray("\u2591".repeat(10 - filled));
-  const color = score >= 8 ? chalk13.green : score >= 6 ? chalk13.yellow : chalk13.red;
+  const bar = chalk15.green("\u2588".repeat(filled)) + chalk15.gray("\u2591".repeat(10 - filled));
+  const color = score >= 8 ? chalk15.green : score >= 6 ? chalk15.yellow : chalk15.red;
   return `[${bar}] ${color(score + "/10")}`;
 }
 function parseAssessment(raw) {
@@ -7696,35 +8032,35 @@ ${spec}`;
   }
 }
 function printSpecAssessment(assessment) {
-  console.log(chalk13.blue("\n\u2500\u2500\u2500 Spec Quality Assessment \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk15.blue("\n\u2500\u2500\u2500 Spec Quality Assessment \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   console.log(`  Coverage    ${scoreBar(assessment.coverageScore)}  error handling, edge cases, auth`);
   console.log(`  Clarity     ${scoreBar(assessment.clarityScore)}  API contracts, response shapes`);
   console.log(`  Constitution${scoreBar(assessment.constitutionScore)}  naming, error codes, conventions`);
-  console.log(chalk13.bold(`  Overall     ${scoreBar(assessment.overallScore)}`));
+  console.log(chalk15.bold(`  Overall     ${scoreBar(assessment.overallScore)}`));
   if (!assessment.dslExtractable) {
     console.log(
-      chalk13.yellow(
+      chalk15.yellow(
         "\n  \u26A0  DSL extraction may be unreliable \u2014 clarityScore < 6 or no structured API section."
       )
     );
-    console.log(chalk13.gray("     Consider adding explicit request/response shapes before proceeding."));
+    console.log(chalk15.gray("     Consider adding explicit request/response shapes before proceeding."));
   }
   if (assessment.issues.length > 0) {
-    console.log(chalk13.yellow(`
+    console.log(chalk15.yellow(`
   Issues found (${assessment.issues.length}):`));
-    assessment.issues.forEach((issue) => console.log(chalk13.yellow(`  \xB7 ${issue}`)));
+    assessment.issues.forEach((issue) => console.log(chalk15.yellow(`  \xB7 ${issue}`)));
   }
   if (assessment.suggestions.length > 0) {
-    console.log(chalk13.cyan("\n  Suggestions:"));
-    assessment.suggestions.forEach((s) => console.log(chalk13.cyan(`  \u{1F4A1} ${s}`)));
+    console.log(chalk15.cyan("\n  Suggestions:"));
+    assessment.suggestions.forEach((s) => console.log(chalk15.cyan(`  \u{1F4A1} ${s}`)));
   }
-  console.log(chalk13.blue("\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"));
+  console.log(chalk15.blue("\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/knowledge-memory.ts
-import chalk14 from "chalk";
-import * as fs15 from "fs-extra";
-import * as path14 from "path";
+import chalk16 from "chalk";
+import * as fs17 from "fs-extra";
+import * as path16 from "path";
 function extractIssuesFromReview(reviewText) {
   const issues = [];
   const issuesMatch = reviewText.match(
@@ -7761,12 +8097,12 @@ var MEMORY_SECTION_HEADER = "\n\n## 9. \u79EF\u7D2F\u6559\u8BAD (Accumulated Les
 var MEMORY_SECTION_MARKER = "## 9. \u79EF\u7D2F\u6559\u8BAD";
 async function appendLessonsToConstitution(projectRoot, issues) {
   if (issues.length === 0) return;
-  const constitutionPath = path14.join(projectRoot, CONSTITUTION_FILE);
+  const constitutionPath = path16.join(projectRoot, CONSTITUTION_FILE);
   let content = "";
   try {
-    content = await fs15.readFile(constitutionPath, "utf-8");
+    content = await fs17.readFile(constitutionPath, "utf-8");
   } catch {
-    console.log(chalk14.gray("  No constitution file \u2014 skipping knowledge memory."));
+    console.log(chalk16.gray("  No constitution file \u2014 skipping knowledge memory."));
     return;
   }
   const hasMemorySection = content.includes(MEMORY_SECTION_MARKER);
@@ -7779,7 +8115,7 @@ async function appendLessonsToConstitution(projectRoot, issues) {
     newEntries.push(`- ${badge} **[${date}]** ${issue.description}`);
   }
   if (newEntries.length === 0) {
-    console.log(chalk14.gray("  No new lessons to add (all deduplicated)."));
+    console.log(chalk16.gray("  No new lessons to add (all deduplicated)."));
     return;
   }
   let updatedContent;
@@ -7792,22 +8128,22 @@ async function appendLessonsToConstitution(projectRoot, issues) {
   } else {
     updatedContent = content + MEMORY_SECTION_HEADER + newEntries.join("\n") + "\n";
   }
-  await fs15.writeFile(constitutionPath, updatedContent, "utf-8");
-  console.log(chalk14.green(`  \u2714 ${newEntries.length} lesson(s) appended to constitution (\xA79).`));
+  await fs17.writeFile(constitutionPath, updatedContent, "utf-8");
+  console.log(chalk16.green(`  \u2714 ${newEntries.length} lesson(s) appended to constitution (\xA79).`));
   const stats = parseConstitutionStats(updatedContent);
   if (stats.lessonCount >= 8) {
     console.log(
-      chalk14.yellow(
+      chalk16.yellow(
         `  \u26A0 \xA79 now has ${stats.lessonCount} accumulated lessons. Run \`ai-spec init --consolidate\` to prune and rebase.`
       )
     );
   }
 }
 async function appendDirectLesson(projectRoot, lessonText) {
-  const constitutionPath = path14.join(projectRoot, CONSTITUTION_FILE);
+  const constitutionPath = path16.join(projectRoot, CONSTITUTION_FILE);
   let content = "";
   try {
-    content = await fs15.readFile(constitutionPath, "utf-8");
+    content = await fs17.readFile(constitutionPath, "utf-8");
   } catch {
     return { appended: false, reason: "No constitution file found. Run `ai-spec init` first." };
   }
@@ -7828,11 +8164,11 @@ async function appendDirectLesson(projectRoot, lessonText) {
   } else {
     updatedContent = content + MEMORY_SECTION_HEADER + entry + "\n";
   }
-  await fs15.writeFile(constitutionPath, updatedContent, "utf-8");
+  await fs17.writeFile(constitutionPath, updatedContent, "utf-8");
   const stats = parseConstitutionStats(updatedContent);
   if (stats.lessonCount >= 8) {
     console.log(
-      chalk14.yellow(
+      chalk16.yellow(
         `  \u26A0 \xA79 now has ${stats.lessonCount} lessons. Run \`ai-spec init --consolidate\` to prune and rebase.`
       )
     );
@@ -7840,15 +8176,15 @@ async function appendDirectLesson(projectRoot, lessonText) {
   return { appended: true };
 }
 async function accumulateReviewKnowledge(provider, projectRoot, reviewText) {
-  console.log(chalk14.blue("\n\u2500\u2500\u2500 Knowledge Memory \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(chalk16.blue("\n\u2500\u2500\u2500 Knowledge Memory \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"));
   const issues = extractIssuesFromReview(reviewText);
   if (issues.length === 0) {
-    console.log(chalk14.gray("  No actionable issues found in review. Skipping."));
+    console.log(chalk16.gray("  No actionable issues found in review. Skipping."));
     return;
   }
-  console.log(chalk14.gray(`  Extracted ${issues.length} issue(s) from review:`));
+  console.log(chalk16.gray(`  Extracted ${issues.length} issue(s) from review:`));
   for (const issue of issues) {
-    console.log(chalk14.gray(`    - [${issue.category}] ${issue.description.slice(0, 80)}`));
+    console.log(chalk16.gray(`    - [${issue.category}] ${issue.description.slice(0, 80)}`));
   }
   await appendLessonsToConstitution(projectRoot, issues);
 }
@@ -7857,22 +8193,22 @@ async function accumulateReviewKnowledge(provider, projectRoot, reviewText) {
 init_workspace_loader();
 
 // core/key-store.ts
-import * as fs17 from "fs-extra";
-import * as path16 from "path";
+import * as fs19 from "fs-extra";
+import * as path18 from "path";
 import * as os3 from "os";
-var KEY_STORE_FILE = path16.join(os3.homedir(), ".ai-spec-keys.json");
+var KEY_STORE_FILE = path18.join(os3.homedir(), ".ai-spec-keys.json");
 async function readStore() {
   try {
-    if (await fs17.pathExists(KEY_STORE_FILE)) {
-      return await fs17.readJson(KEY_STORE_FILE);
+    if (await fs19.pathExists(KEY_STORE_FILE)) {
+      return await fs19.readJson(KEY_STORE_FILE);
     }
   } catch {
   }
   return {};
 }
 async function writeStore(store) {
-  await fs17.writeJson(KEY_STORE_FILE, store, { spaces: 2 });
-  await fs17.chmod(KEY_STORE_FILE, 384);
+  await fs19.writeJson(KEY_STORE_FILE, store, { spaces: 2 });
+  await fs19.chmod(KEY_STORE_FILE, 384);
 }
 async function getSavedKey(provider) {
   const store = await readStore();
@@ -7884,8 +8220,8 @@ async function saveKey(provider, key) {
   await writeStore(store);
 }
 async function clearAllKeys() {
-  if (await fs17.pathExists(KEY_STORE_FILE)) {
-    await fs17.remove(KEY_STORE_FILE);
+  if (await fs19.pathExists(KEY_STORE_FILE)) {
+    await fs19.remove(KEY_STORE_FILE);
   }
 }
 async function clearKey(provider) {
@@ -7895,19 +8231,19 @@ async function clearKey(provider) {
 }
 
 // cli/welcome.ts
-import chalk15 from "chalk";
+import chalk17 from "chalk";
 import * as os4 from "os";
-import * as path17 from "path";
-import * as fs18 from "fs-extra";
+import * as path19 from "path";
+import * as fs20 from "fs-extra";
 var VERSION = "0.14.1";
 var TOTAL_W = 76;
 var L_WIDTH = 44;
 var R_WIDTH = TOTAL_W - L_WIDTH - 4;
-var ROBOT_COLOR = chalk15.hex("#E8885A");
+var ROBOT_COLOR = chalk17.hex("#E8885A");
 var ROBOT = [
   ROBOT_COLOR("      \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"),
-  ROBOT_COLOR("      \u2502") + chalk15.bold.white(" \u25C9  ") + ROBOT_COLOR("   ") + chalk15.bold.white("\u25C9 ") + ROBOT_COLOR("\u2502"),
-  ROBOT_COLOR("      \u2502") + chalk15.dim("    \u2570\u2500\u256F    ") + ROBOT_COLOR("\u2502"),
+  ROBOT_COLOR("      \u2502") + chalk17.bold.white(" \u25C9  ") + ROBOT_COLOR("   ") + chalk17.bold.white("\u25C9 ") + ROBOT_COLOR("\u2502"),
+  ROBOT_COLOR("      \u2502") + chalk17.dim("    \u2570\u2500\u256F    ") + ROBOT_COLOR("\u2502"),
   ROBOT_COLOR("      \u2514\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2518"),
   ROBOT_COLOR("            \u2502"),
   ROBOT_COLOR("        \u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500")
@@ -7920,7 +8256,7 @@ function padR(s, width) {
   return vl >= width ? s : s + " ".repeat(width - vl);
 }
 function row(left, right) {
-  return padR(left, L_WIDTH) + " " + chalk15.gray("\u2502") + " " + padR(right, R_WIDTH);
+  return padR(left, L_WIDTH) + " " + chalk17.gray("\u2502") + " " + padR(right, R_WIDTH);
 }
 function center(s, width) {
   const vl = visLen(s);
@@ -7928,14 +8264,14 @@ function center(s, width) {
   return " ".repeat(pad) + s;
 }
 async function getRecentSpecs(dir) {
-  const specsDir = path17.join(dir, "specs");
-  if (!await fs18.pathExists(specsDir)) return [];
+  const specsDir = path19.join(dir, "specs");
+  if (!await fs20.pathExists(specsDir)) return [];
   try {
-    const files = await fs18.readdir(specsDir);
+    const files = await fs20.readdir(specsDir);
     const mdFiles = files.filter((f) => f.endsWith(".md"));
     const withStats = await Promise.all(
       mdFiles.map(async (f) => {
-        const stat4 = await fs18.stat(path17.join(specsDir, f));
+        const stat4 = await fs20.stat(path19.join(specsDir, f));
         return { name: f, mtime: stat4.mtime.getTime() };
       })
     );
@@ -7946,7 +8282,7 @@ async function getRecentSpecs(dir) {
       const days = Math.floor(hours / 24);
       const age = days > 0 ? `${days}d ago` : hours > 0 ? `${hours}h ago` : "just now";
       const slug = name.replace(/\.md$/, "").slice(0, R_WIDTH - age.length - 2);
-      return chalk15.white(slug) + chalk15.dim("  " + age);
+      return chalk17.white(slug) + chalk17.dim("  " + age);
     });
   } catch {
     return [];
@@ -7961,13 +8297,13 @@ async function printWelcome(currentDir, config2) {
   const bottomRaw = [providerBit, shortDir].filter(Boolean).join(" \xB7 ");
   const maxInfoLen = L_WIDTH - 2;
   const bottomTruncated = bottomRaw.length > maxInfoLen ? bottomRaw.slice(0, maxInfoLen - 1) + "\u2026" : bottomRaw;
-  const bottomLine = "  " + chalk15.dim(bottomTruncated);
+  const bottomLine = "  " + chalk17.dim(bottomTruncated);
   const titleInner = `ai-spec v${VERSION} `;
   const titleDashes = "\u2500".repeat(Math.max(0, TOTAL_W - titleInner.length - 4));
   console.log(
-    "\n" + chalk15.hex("#FF6B35")("\u2500\u2500\u2500 " + titleInner + titleDashes)
+    "\n" + chalk17.hex("#FF6B35")("\u2500\u2500\u2500 " + titleInner + titleDashes)
   );
-  const welcomeText = "Welcome back, " + chalk15.bold.white(username) + "!";
+  const welcomeText = "Welcome back, " + chalk17.bold.white(username) + "!";
   const leftLines = [
     "",
     center(welcomeText, L_WIDTH),
@@ -7978,21 +8314,21 @@ async function printWelcome(currentDir, config2) {
     ""
   ];
   const rightLines = [
-    chalk15.hex("#FF8C00").bold("Tips for getting started"),
-    chalk15.gray("\u2500".repeat(R_WIDTH)),
-    chalk15.white('ai-spec create "feature"'),
-    chalk15.gray("ai-spec workspace run"),
-    chalk15.gray('ai-spec update "change"'),
+    chalk17.hex("#FF8C00").bold("Tips for getting started"),
+    chalk17.gray("\u2500".repeat(R_WIDTH)),
+    chalk17.white('ai-spec create "feature"'),
+    chalk17.gray("ai-spec workspace run"),
+    chalk17.gray('ai-spec update "change"'),
     "",
-    chalk15.hex("#FF8C00").bold("Recent activity"),
-    chalk15.gray("\u2500".repeat(R_WIDTH)),
-    ...recentSpecs.length > 0 ? recentSpecs : [chalk15.dim("No recent activity")]
+    chalk17.hex("#FF8C00").bold("Recent activity"),
+    chalk17.gray("\u2500".repeat(R_WIDTH)),
+    ...recentSpecs.length > 0 ? recentSpecs : [chalk17.dim("No recent activity")]
   ];
   const maxLines = Math.max(leftLines.length, rightLines.length);
   for (let i = 0; i < maxLines; i++) {
     console.log(row(leftLines[i] ?? "", rightLines[i] ?? ""));
   }
-  console.log(chalk15.gray("\u2500".repeat(TOTAL_W)));
+  console.log(chalk17.gray("\u2500".repeat(TOTAL_W)));
   console.log();
 }
 
@@ -8505,8 +8841,8 @@ Existing API/service files:`);
 }
 
 // core/mock-server-generator.ts
-import * as path18 from "path";
-import * as fs19 from "fs-extra";
+import * as path20 from "path";
+import * as fs21 from "fs-extra";
 import { spawn } from "child_process";
 function typeToFixture(fieldName, typeDesc) {
   const t = typeDesc.toLowerCase();
@@ -8642,22 +8978,22 @@ function generateMockServerJs(dsl, port) {
 }
 function detectFrontendFramework(projectDir) {
   for (const f of ["vite.config.ts", "vite.config.js", "vite.config.mts"]) {
-    if (fs19.existsSync(path18.join(projectDir, f))) return "vite";
+    if (fs21.existsSync(path20.join(projectDir, f))) return "vite";
   }
   for (const f of ["next.config.js", "next.config.ts", "next.config.mjs"]) {
-    if (fs19.existsSync(path18.join(projectDir, f))) return "next";
+    if (fs21.existsSync(path20.join(projectDir, f))) return "next";
   }
-  const pkgPath = path18.join(projectDir, "package.json");
-  if (fs19.existsSync(pkgPath)) {
+  const pkgPath = path20.join(projectDir, "package.json");
+  if (fs21.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
       if (deps["react-scripts"]) return "cra";
     } catch {
     }
   }
   for (const f of ["webpack.config.js", "webpack.config.ts"]) {
-    if (fs19.existsSync(path18.join(projectDir, f))) return "webpack";
+    if (fs21.existsSync(path20.join(projectDir, f))) return "webpack";
   }
   return "unknown";
 }
@@ -8837,7 +9173,7 @@ export const worker = setupWorker(...handlers);
 var MOCK_LOCK_FILE = ".ai-spec-mock.lock.json";
 function findViteConfigFile(projectDir) {
   for (const f of ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"]) {
-    if (fs19.existsSync(path18.join(projectDir, f))) return f;
+    if (fs21.existsSync(path20.join(projectDir, f))) return f;
   }
   return null;
 }
@@ -8883,73 +9219,73 @@ async function applyMockProxy(frontendDir, mockPort, endpoints = []) {
   if (framework === "vite") {
     const viteConfigFile = findViteConfigFile(frontendDir) ?? "vite.config.ts";
     const mockConfigContent = generateViteMockConfigTs(viteConfigFile, mockPort, endpoints);
-    const mockConfigPath = path18.join(frontendDir, "vite.config.ai-spec-mock.ts");
-    await fs19.writeFile(mockConfigPath, mockConfigContent, "utf-8");
+    const mockConfigPath = path20.join(frontendDir, "vite.config.ai-spec-mock.ts");
+    await fs21.writeFile(mockConfigPath, mockConfigContent, "utf-8");
     actions.push({ type: "wrote-file", filePath: "vite.config.ai-spec-mock.ts" });
-    const pkgPath = path18.join(frontendDir, "package.json");
-    if (await fs19.pathExists(pkgPath)) {
-      const pkg = await fs19.readJson(pkgPath);
+    const pkgPath = path20.join(frontendDir, "package.json");
+    if (await fs21.pathExists(pkgPath)) {
+      const pkg = await fs21.readJson(pkgPath);
       pkg.scripts = pkg.scripts ?? {};
       const originalValue = pkg.scripts["dev:mock"] ?? null;
       pkg.scripts["dev:mock"] = "vite --config vite.config.ai-spec-mock.ts";
-      await fs19.writeJson(pkgPath, pkg, { spaces: 2 });
+      await fs21.writeJson(pkgPath, pkg, { spaces: 2 });
       actions.push({ type: "added-pkg-script", key: "dev:mock", originalValue });
     }
     const lock2 = { framework, mockPort, frontendDir, actions };
-    await fs19.writeJson(path18.join(frontendDir, MOCK_LOCK_FILE), lock2, { spaces: 2 });
+    await fs21.writeJson(path20.join(frontendDir, MOCK_LOCK_FILE), lock2, { spaces: 2 });
     return { framework, applied: true, devCommand: "npm run dev:mock" };
   }
   if (framework === "cra") {
-    const pkgPath = path18.join(frontendDir, "package.json");
-    if (await fs19.pathExists(pkgPath)) {
-      const pkg = await fs19.readJson(pkgPath);
+    const pkgPath = path20.join(frontendDir, "package.json");
+    if (await fs21.pathExists(pkgPath)) {
+      const pkg = await fs21.readJson(pkgPath);
       const originalProxy = pkg.proxy ?? null;
       pkg.proxy = `http://localhost:${mockPort}`;
-      await fs19.writeJson(pkgPath, pkg, { spaces: 2 });
+      await fs21.writeJson(pkgPath, pkg, { spaces: 2 });
       actions.push({ type: "patched-pkg-proxy", originalProxy });
       const lock2 = { framework, mockPort, frontendDir, actions };
-      await fs19.writeJson(path18.join(frontendDir, MOCK_LOCK_FILE), lock2, { spaces: 2 });
+      await fs21.writeJson(path20.join(frontendDir, MOCK_LOCK_FILE), lock2, { spaces: 2 });
       return { framework, applied: true, devCommand: "npm start" };
     }
     return { framework, applied: false, devCommand: null, note: "No package.json found." };
   }
   const lock = { framework, mockPort, frontendDir, actions };
-  await fs19.writeJson(path18.join(frontendDir, MOCK_LOCK_FILE), lock, { spaces: 2 });
+  await fs21.writeJson(path20.join(frontendDir, MOCK_LOCK_FILE), lock, { spaces: 2 });
   const manualNote = framework === "next" ? `Add rewrites in next.config.js to proxy API calls to http://localhost:${mockPort}` : `Add proxy in webpack.config.js devServer to target http://localhost:${mockPort}`;
   return { framework, applied: false, devCommand: null, note: manualNote };
 }
 async function restoreMockProxy(frontendDir) {
-  const lockPath = path18.join(frontendDir, MOCK_LOCK_FILE);
-  if (!await fs19.pathExists(lockPath)) {
+  const lockPath = path20.join(frontendDir, MOCK_LOCK_FILE);
+  if (!await fs21.pathExists(lockPath)) {
     return { restored: false, note: "No lock file found \u2014 nothing to restore." };
   }
-  const lock = await fs19.readJson(lockPath);
+  const lock = await fs21.readJson(lockPath);
   for (const action of lock.actions) {
     if (action.type === "wrote-file") {
-      const fp = path18.join(frontendDir, action.filePath);
-      if (await fs19.pathExists(fp)) await fs19.remove(fp);
+      const fp = path20.join(frontendDir, action.filePath);
+      if (await fs21.pathExists(fp)) await fs21.remove(fp);
     } else if (action.type === "added-pkg-script") {
-      const pkgPath = path18.join(frontendDir, "package.json");
-      if (await fs19.pathExists(pkgPath)) {
-        const pkg = await fs19.readJson(pkgPath);
+      const pkgPath = path20.join(frontendDir, "package.json");
+      if (await fs21.pathExists(pkgPath)) {
+        const pkg = await fs21.readJson(pkgPath);
         if (action.originalValue == null) {
           delete pkg.scripts?.[action.key];
         } else {
           pkg.scripts = pkg.scripts ?? {};
           pkg.scripts[action.key] = action.originalValue;
         }
-        await fs19.writeJson(pkgPath, pkg, { spaces: 2 });
+        await fs21.writeJson(pkgPath, pkg, { spaces: 2 });
       }
     } else if (action.type === "patched-pkg-proxy") {
-      const pkgPath = path18.join(frontendDir, "package.json");
-      if (await fs19.pathExists(pkgPath)) {
-        const pkg = await fs19.readJson(pkgPath);
+      const pkgPath = path20.join(frontendDir, "package.json");
+      if (await fs21.pathExists(pkgPath)) {
+        const pkg = await fs21.readJson(pkgPath);
         if (action.originalProxy == null) {
           delete pkg.proxy;
         } else {
           pkg.proxy = action.originalProxy;
         }
-        await fs19.writeJson(pkgPath, pkg, { spaces: 2 });
+        await fs21.writeJson(pkgPath, pkg, { spaces: 2 });
       }
     }
   }
@@ -8959,7 +9295,7 @@ async function restoreMockProxy(frontendDir) {
     } catch {
     }
   }
-  await fs19.remove(lockPath);
+  await fs21.remove(lockPath);
   return { restored: true };
 }
 function startMockServerBackground(serverJsPath, port) {
@@ -8972,23 +9308,23 @@ function startMockServerBackground(serverJsPath, port) {
   return child.pid;
 }
 async function saveMockServerPid(frontendDir, pid) {
-  const lockPath = path18.join(frontendDir, MOCK_LOCK_FILE);
-  if (await fs19.pathExists(lockPath)) {
-    const lock = await fs19.readJson(lockPath);
+  const lockPath = path20.join(frontendDir, MOCK_LOCK_FILE);
+  if (await fs21.pathExists(lockPath)) {
+    const lock = await fs21.readJson(lockPath);
     lock.mockServerPid = pid;
-    await fs19.writeJson(lockPath, lock, { spaces: 2 });
+    await fs21.writeJson(lockPath, lock, { spaces: 2 });
   }
 }
 async function generateMockAssets(dsl, projectDir, opts = {}) {
   const port = opts.port ?? 3001;
-  const outputDir = path18.join(projectDir, opts.outputDir ?? "mock");
+  const outputDir = path20.join(projectDir, opts.outputDir ?? "mock");
   const result = { files: [] };
-  await fs19.ensureDir(outputDir);
+  await fs21.ensureDir(outputDir);
   const serverJs = generateMockServerJs(dsl, port);
-  const serverPath = path18.join(outputDir, "server.js");
-  await fs19.writeFile(serverPath, serverJs, "utf-8");
+  const serverPath = path20.join(outputDir, "server.js");
+  await fs21.writeFile(serverPath, serverJs, "utf-8");
   result.files.push({
-    path: path18.relative(projectDir, serverPath),
+    path: path20.relative(projectDir, serverPath),
     description: `Express mock server \u2014 run with: node mock/server.js`
   });
   const mockReadme = `# Mock Server
@@ -9018,51 +9354,51 @@ ${dsl.endpoints.map(
 
 Append \`?simulate_error=1\` to any request to test error handling (not yet auto-wired \u2014 edit server.js manually).
 `;
-  const readmePath = path18.join(outputDir, "README.md");
-  await fs19.writeFile(readmePath, mockReadme, "utf-8");
+  const readmePath = path20.join(outputDir, "README.md");
+  await fs21.writeFile(readmePath, mockReadme, "utf-8");
   result.files.push({
-    path: path18.relative(projectDir, readmePath),
+    path: path20.relative(projectDir, readmePath),
     description: "Mock server usage guide"
   });
   if (opts.proxy) {
     const { content, filename } = generateProxyConfig(dsl, port, projectDir);
-    const proxyPath = path18.join(projectDir, filename);
-    await fs19.ensureDir(path18.dirname(proxyPath));
-    await fs19.writeFile(proxyPath, content, "utf-8");
+    const proxyPath = path20.join(projectDir, filename);
+    await fs21.ensureDir(path20.dirname(proxyPath));
+    await fs21.writeFile(proxyPath, content, "utf-8");
     result.files.push({
       path: filename,
       description: "Proxy config snippet \u2014 copy instructions into your framework config"
     });
   }
   if (opts.msw) {
-    const mswDir = path18.join(projectDir, "src", "mocks");
-    await fs19.ensureDir(mswDir);
+    const mswDir = path20.join(projectDir, "src", "mocks");
+    await fs21.ensureDir(mswDir);
     const handlersContent = generateMswHandlers(dsl);
-    const handlersPath = path18.join(mswDir, "handlers.ts");
-    await fs19.writeFile(handlersPath, handlersContent, "utf-8");
+    const handlersPath = path20.join(mswDir, "handlers.ts");
+    await fs21.writeFile(handlersPath, handlersContent, "utf-8");
     result.files.push({
-      path: path18.relative(projectDir, handlersPath),
+      path: path20.relative(projectDir, handlersPath),
       description: "MSW request handlers"
     });
     const browserContent = generateMswBrowser();
-    const browserPath = path18.join(mswDir, "browser.ts");
-    await fs19.writeFile(browserPath, browserContent, "utf-8");
+    const browserPath = path20.join(mswDir, "browser.ts");
+    await fs21.writeFile(browserPath, browserContent, "utf-8");
     result.files.push({
-      path: path18.relative(projectDir, browserPath),
+      path: path20.relative(projectDir, browserPath),
       description: "MSW browser worker setup"
     });
   }
   return result;
 }
 async function findLatestDslFile(projectDir) {
-  const specDir = path18.join(projectDir, ".ai-spec");
-  if (!await fs19.pathExists(specDir)) return null;
+  const specDir = path20.join(projectDir, ".ai-spec");
+  if (!await fs21.pathExists(specDir)) return null;
   const allFiles = [];
   async function scan(dir) {
-    const entries = await fs19.readdir(dir);
+    const entries = await fs21.readdir(dir);
     for (const entry of entries) {
-      const abs = path18.join(dir, entry);
-      const stat4 = await fs19.stat(abs);
+      const abs = path20.join(dir, entry);
+      const stat4 = await fs21.stat(abs);
       if (stat4.isDirectory()) {
         await scan(abs);
       } else if (entry.endsWith(".dsl.json")) {
@@ -9073,16 +9409,16 @@ async function findLatestDslFile(projectDir) {
   await scan(specDir);
   if (allFiles.length === 0) return null;
   const withMtimes = await Promise.all(
-    allFiles.map(async (f) => ({ f, mtime: (await fs19.stat(f)).mtime }))
+    allFiles.map(async (f) => ({ f, mtime: (await fs21.stat(f)).mtime }))
   );
   withMtimes.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
   return withMtimes[0].f;
 }
 
 // core/spec-updater.ts
-import chalk16 from "chalk";
-import * as path19 from "path";
-import * as fs20 from "fs-extra";
+import chalk18 from "chalk";
+import * as path21 from "path";
+import * as fs22 from "fs-extra";
 
 // prompts/update.prompt.ts
 var specUpdateSystemPrompt = `You are a Senior Software Architect updating an existing Feature Spec based on a change request.
@@ -9228,8 +9564,8 @@ var SpecUpdater = class {
    * Returns all .md spec files sorted newest-first.
    */
   static async findLatestSpec(specsDir) {
-    if (!await fs20.pathExists(specsDir)) return null;
-    const files = await fs20.readdir(specsDir);
+    if (!await fs22.pathExists(specsDir)) return null;
+    const files = await fs22.readdir(specsDir);
     const pattern = /^feature-(.+)-v(\d+)\.md$/;
     let latest = null;
     for (const file of files) {
@@ -9237,8 +9573,8 @@ var SpecUpdater = class {
       if (!m) continue;
       const version = parseInt(m[2], 10);
       if (!latest || version > latest.version) {
-        const filePath = path19.join(specsDir, file);
-        const content = await fs20.readFile(filePath, "utf-8");
+        const filePath = path21.join(specsDir, file);
+        const content = await fs22.readFile(filePath, "utf-8");
         latest = { filePath, version, slug: m[1], content };
       }
     }
@@ -9249,16 +9585,16 @@ var SpecUpdater = class {
    * Generates a new version of the spec, re-extracts the DSL, and identifies affected files.
    */
   async update(changeRequest, existingSpecPath, projectDir, context, opts = {}) {
-    const existingSpec = await fs20.readFile(existingSpecPath, "utf-8");
+    const existingSpec = await fs22.readFile(existingSpecPath, "utf-8");
     let existingDsl = null;
     const dslFile = await findLatestDslFile(projectDir);
     if (dslFile) {
       try {
-        existingDsl = await fs20.readJson(dslFile);
+        existingDsl = await fs22.readJson(dslFile);
       } catch {
       }
     }
-    console.log(chalk16.blue("  [1/3] Generating updated spec..."));
+    console.log(chalk18.blue("  [1/3] Generating updated spec..."));
     const updatePrompt = buildSpecUpdatePrompt(changeRequest, existingSpec, existingDsl, context);
     let updatedSpecContent;
     try {
@@ -9267,15 +9603,15 @@ var SpecUpdater = class {
     } catch (err) {
       throw new Error(`Spec update generation failed: ${err.message}`);
     }
-    const specBasename = path19.basename(existingSpecPath);
+    const specBasename = path21.basename(existingSpecPath);
     const slugMatch = specBasename.match(/^feature-(.+)-v\d+\.md$/);
     const slug = slugMatch ? slugMatch[1] : "feature";
-    const specsDir = path19.dirname(existingSpecPath);
+    const specsDir = path21.dirname(existingSpecPath);
     const { filePath: newSpecPath, version: newVersion } = await nextVersionPath(specsDir, slug);
-    await fs20.ensureDir(specsDir);
-    await fs20.writeFile(newSpecPath, updatedSpecContent, "utf-8");
-    console.log(chalk16.green(`  \u2714 New spec written: ${path19.relative(projectDir, newSpecPath)}`));
-    console.log(chalk16.blue("  [2/3] Updating DSL..."));
+    await fs22.ensureDir(specsDir);
+    await fs22.writeFile(newSpecPath, updatedSpecContent, "utf-8");
+    console.log(chalk18.green(`  \u2714 New spec written: ${path21.relative(projectDir, newSpecPath)}`));
+    console.log(chalk18.blue("  [2/3] Updating DSL..."));
     let updatedDsl = null;
     let newDslPath = null;
     if (existingDsl) {
@@ -9287,7 +9623,7 @@ var SpecUpdater = class {
           updatedDsl = parsed;
         }
       } catch {
-        console.log(chalk16.gray("  Targeted DSL update failed \u2014 falling back to full extraction."));
+        console.log(chalk18.gray("  Targeted DSL update failed \u2014 falling back to full extraction."));
       }
     }
     if (!updatedDsl) {
@@ -9296,15 +9632,15 @@ var SpecUpdater = class {
     }
     if (updatedDsl) {
       const dslPath = newSpecPath.replace(/\.md$/, ".dsl.json");
-      await fs20.writeJson(dslPath, updatedDsl, { spaces: 2 });
+      await fs22.writeJson(dslPath, updatedDsl, { spaces: 2 });
       newDslPath = dslPath;
-      console.log(chalk16.green(`  \u2714 DSL updated: ${path19.relative(projectDir, dslPath)}`));
+      console.log(chalk18.green(`  \u2714 DSL updated: ${path21.relative(projectDir, dslPath)}`));
     } else {
-      console.log(chalk16.yellow("  \u26A0 DSL update failed \u2014 continuing without DSL."));
+      console.log(chalk18.yellow("  \u26A0 DSL update failed \u2014 continuing without DSL."));
     }
     let affectedFiles = [];
     if (!opts.skipAffectedFiles && updatedDsl && existingDsl && context) {
-      console.log(chalk16.blue("  [3/3] Identifying affected files..."));
+      console.log(chalk18.blue("  [3/3] Identifying affected files..."));
       const systemPrompt = getCodeGenSystemPrompt(opts.repoType);
       const affectedPrompt = buildAffectedFilesPrompt(
         changeRequest,
@@ -9315,9 +9651,9 @@ var SpecUpdater = class {
       try {
         const affectedRaw = await this.provider.generate(affectedPrompt, systemPrompt);
         affectedFiles = parseAffectedFiles(affectedRaw);
-        console.log(chalk16.green(`  \u2714 ${affectedFiles.length} file(s) identified for update`));
+        console.log(chalk18.green(`  \u2714 ${affectedFiles.length} file(s) identified for update`));
       } catch {
-        console.log(chalk16.gray("  Could not identify affected files \u2014 use manual selection."));
+        console.log(chalk18.gray("  Could not identify affected files \u2014 use manual selection."));
       }
     }
     return { newSpecPath, newVersion, newDslPath, affectedFiles, updatedDsl };
@@ -9325,8 +9661,8 @@ var SpecUpdater = class {
 };
 
 // core/openapi-exporter.ts
-import * as path20 from "path";
-import * as fs21 from "fs-extra";
+import * as path22 from "path";
+import * as fs23 from "fs-extra";
 function dslTypeToOASchema(typeDesc, fieldName = "") {
   const t = typeDesc.toLowerCase();
   if (t === "string" || t.includes("string")) {
@@ -9555,7 +9891,7 @@ async function exportOpenApi(dsl, projectDir, opts = {}) {
   const format = opts.format ?? "yaml";
   const serverUrl = opts.serverUrl ?? "http://localhost:3000";
   const defaultName = `openapi.${format}`;
-  const outputPath = opts.outputPath ? path20.isAbsolute(opts.outputPath) ? opts.outputPath : path20.join(projectDir, opts.outputPath) : path20.join(projectDir, defaultName);
+  const outputPath = opts.outputPath ? path22.isAbsolute(opts.outputPath) ? opts.outputPath : path22.join(projectDir, opts.outputPath) : path22.join(projectDir, defaultName);
   const doc = dslToOpenApi(dsl, serverUrl);
   let content;
   if (format === "json") {
@@ -9563,8 +9899,8 @@ async function exportOpenApi(dsl, projectDir, opts = {}) {
   } else {
     content = buildYamlDoc(doc);
   }
-  await fs21.ensureDir(path20.dirname(outputPath));
-  await fs21.writeFile(outputPath, content, "utf-8");
+  await fs23.ensureDir(path22.dirname(outputPath));
+  await fs23.writeFile(outputPath, content, "utf-8");
   return outputPath;
 }
 
@@ -9572,9 +9908,9 @@ async function exportOpenApi(dsl, projectDir, opts = {}) {
 dotenv.config();
 var CONFIG_FILE = ".ai-spec.json";
 async function loadConfig(dir) {
-  const p = path21.join(dir, CONFIG_FILE);
-  if (await fs22.pathExists(p)) {
-    return fs22.readJson(p);
+  const p = path23.join(dir, CONFIG_FILE);
+  if (await fs24.pathExists(p)) {
+    return fs24.readJson(p);
   }
   return {};
 }
@@ -9599,20 +9935,20 @@ async function resolveApiKey(providerName, cliKey) {
     validate: (v2) => v2.trim().length > 0 || "API key cannot be empty"
   });
   await saveKey(providerName, newKey.trim());
-  console.log(chalk17.gray(`  Key saved to ${KEY_STORE_FILE}`));
+  console.log(chalk19.gray(`  Key saved to ${KEY_STORE_FILE}`));
   return newKey.trim();
 }
 function printBanner(opts) {
-  console.log(chalk17.blue("\n" + "\u2500".repeat(52)));
-  console.log(chalk17.bold("  ai-spec \u2014 AI-driven Development Orchestrator"));
-  console.log(chalk17.blue("\u2500".repeat(52)));
-  console.log(chalk17.gray(`  Spec    : ${opts.specProvider} / ${opts.specModel}`));
+  console.log(chalk19.blue("\n" + "\u2500".repeat(52)));
+  console.log(chalk19.bold("  ai-spec \u2014 AI-driven Development Orchestrator"));
+  console.log(chalk19.blue("\u2500".repeat(52)));
+  console.log(chalk19.gray(`  Spec    : ${opts.specProvider} / ${opts.specModel}`));
   console.log(
-    chalk17.gray(
+    chalk19.gray(
       `  Codegen : ${opts.codegenMode} (${opts.codegenProvider} / ${opts.codegenModel})`
     )
   );
-  console.log(chalk17.blue("\u2500".repeat(52) + "\n"));
+  console.log(chalk19.blue("\u2500".repeat(52) + "\n"));
 }
 var program = new Command();
 program.name("ai-spec").description("AI-driven Development Orchestrator \u2014 spec, generate, review").version("0.14.1");
@@ -9639,42 +9975,42 @@ program.command("create").description("Generate a feature spec and kick off code
   const workspaceLoader = new WorkspaceLoader(currentDir);
   const workspaceConfig = await workspaceLoader.load();
   if (workspaceConfig) {
-    console.log(chalk17.cyan(`
+    console.log(chalk19.cyan(`
 [Workspace] Detected workspace: ${workspaceConfig.name}`));
-    console.log(chalk17.gray(`  Repos: ${workspaceConfig.repos.map((r) => r.name).join(", ")}`));
+    console.log(chalk19.gray(`  Repos: ${workspaceConfig.repos.map((r) => r.name).join(", ")}`));
     const pipelineResults = await runMultiRepoPipeline(idea, workspaceConfig, opts, currentDir, config2);
     if (opts.serve) {
-      console.log(chalk17.blue("\n\u2500\u2500\u2500 Auto-serve: starting mock server \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk19.blue("\n\u2500\u2500\u2500 Auto-serve: starting mock server \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
       const backendResult = pipelineResults.find((r) => r.role === "backend" && r.status === "success" && r.dsl);
       const frontendResult = pipelineResults.find((r) => (r.role === "frontend" || r.role === "mobile") && r.status === "success");
       if (!backendResult) {
-        console.log(chalk17.yellow("  No successful backend with DSL found \u2014 skipping auto-serve."));
+        console.log(chalk19.yellow("  No successful backend with DSL found \u2014 skipping auto-serve."));
       } else {
         const mockPort = 3001;
         const mockResult = await generateMockAssets(backendResult.dsl, backendResult.repoAbsPath, { port: mockPort });
-        const serverJsPath = path21.join(backendResult.repoAbsPath, "mock", "server.js");
-        console.log(chalk17.green(`  \u2714 Mock assets generated (${mockResult.files.length} file(s))`));
+        const serverJsPath = path23.join(backendResult.repoAbsPath, "mock", "server.js");
+        console.log(chalk19.green(`  \u2714 Mock assets generated (${mockResult.files.length} file(s))`));
         const pid = startMockServerBackground(serverJsPath, mockPort);
-        console.log(chalk17.green(`  \u2714 Mock server started (PID ${pid}) \u2192 http://localhost:${mockPort}`));
+        console.log(chalk19.green(`  \u2714 Mock server started (PID ${pid}) \u2192 http://localhost:${mockPort}`));
         if (frontendResult) {
           const proxyResult = await applyMockProxy(frontendResult.repoAbsPath, mockPort, backendResult.dsl.endpoints);
           await saveMockServerPid(frontendResult.repoAbsPath, pid);
           if (proxyResult.applied) {
-            console.log(chalk17.green(`  \u2714 Frontend proxy patched (${proxyResult.framework})`));
-            console.log(chalk17.bold.cyan(`
+            console.log(chalk19.green(`  \u2714 Frontend proxy patched (${proxyResult.framework})`));
+            console.log(chalk19.bold.cyan(`
   Ready! Run your frontend dev server:`));
-            console.log(chalk17.white(`    cd ${frontendResult.repoAbsPath}`));
-            console.log(chalk17.white(`    ${proxyResult.devCommand}`));
-            console.log(chalk17.gray(`
+            console.log(chalk19.white(`    cd ${frontendResult.repoAbsPath}`));
+            console.log(chalk19.white(`    ${proxyResult.devCommand}`));
+            console.log(chalk19.gray(`
   When done, restore: ai-spec mock --restore --frontend ${frontendResult.repoAbsPath}`));
           } else {
-            console.log(chalk17.yellow(`  \u26A0 Auto-patch not available for ${proxyResult.framework}.`));
-            if (proxyResult.note) console.log(chalk17.gray(`    ${proxyResult.note}`));
-            console.log(chalk17.gray(`    Mock server: http://localhost:${mockPort}`));
+            console.log(chalk19.yellow(`  \u26A0 Auto-patch not available for ${proxyResult.framework}.`));
+            if (proxyResult.note) console.log(chalk19.gray(`    ${proxyResult.note}`));
+            console.log(chalk19.gray(`    Mock server: http://localhost:${mockPort}`));
           }
         } else {
-          console.log(chalk17.gray(`  No frontend repo found \u2014 mock server is running at http://localhost:${mockPort}`));
-          console.log(chalk17.gray(`  Configure your frontend proxy manually to point to http://localhost:${mockPort}`));
+          console.log(chalk19.gray(`  No frontend repo found \u2014 mock server is running at http://localhost:${mockPort}`));
+          console.log(chalk19.gray(`  Configure your frontend proxy manually to point to http://localhost:${mockPort}`));
         }
       }
     }
@@ -9694,23 +10030,32 @@ program.command("create").description("Generate a feature spec and kick off code
     codegenProvider: codegenProviderName,
     codegenModel: codegenModelName
   });
-  console.log(chalk17.blue("[1/6] Loading project context..."));
+  const runId = generateRunId();
+  console.log(chalk19.gray(`  Run ID: ${runId}`));
+  const runSnapshot = new RunSnapshot(currentDir, runId);
+  setActiveSnapshot(runSnapshot);
+  const runLogger = new RunLogger(currentDir, runId, {
+    provider: specProviderName,
+    model: specModelName
+  });
+  setActiveLogger(runLogger);
+  console.log(chalk19.blue("[1/6] Loading project context..."));
   const loader = new ContextLoader(currentDir);
   const context = await loader.loadProjectContext();
   const { type: detectedRepoType } = await detectRepoType(currentDir);
-  console.log(chalk17.gray(`  Tech stack  : ${context.techStack.join(", ") || "unknown"} [${detectedRepoType}]`));
-  console.log(chalk17.gray(`  Dependencies: ${context.dependencies.length} packages`));
-  console.log(chalk17.gray(`  API files   : ${context.apiStructure.length} files`));
+  console.log(chalk19.gray(`  Tech stack  : ${context.techStack.join(", ") || "unknown"} [${detectedRepoType}]`));
+  console.log(chalk19.gray(`  Dependencies: ${context.dependencies.length} packages`));
+  console.log(chalk19.gray(`  API files   : ${context.apiStructure.length} files`));
   if (context.schema) {
-    console.log(chalk17.gray(`  Prisma schema: found`));
+    console.log(chalk19.gray(`  Prisma schema: found`));
   }
   if (context.constitution) {
-    console.log(chalk17.green(`  Constitution : found (.ai-spec-constitution.md)`));
+    console.log(chalk19.green(`  Constitution : found (.ai-spec-constitution.md)`));
     if (context.constitution.length > 6e3) {
-      console.log(chalk17.yellow(`  \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
+      console.log(chalk19.yellow(`  \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
     }
   } else {
-    console.log(chalk17.yellow("  Constitution : not found \u2014 auto-generating..."));
+    console.log(chalk19.yellow("  Constitution : not found \u2014 auto-generating..."));
     try {
       const constitutionGen = new ConstitutionGenerator(
         createProvider(specProviderName, specApiKey, specModelName)
@@ -9718,12 +10063,12 @@ program.command("create").description("Generate a feature spec and kick off code
       const constitutionContent = await constitutionGen.generate(currentDir);
       await constitutionGen.saveConstitution(currentDir, constitutionContent);
       context.constitution = constitutionContent;
-      console.log(chalk17.green(`  Constitution : \u2714 generated and saved (.ai-spec-constitution.md)`));
+      console.log(chalk19.green(`  Constitution : \u2714 generated and saved (.ai-spec-constitution.md)`));
     } catch (err) {
-      console.log(chalk17.yellow(`  Constitution : \u26A0 auto-generation failed (${err.message}), continuing without it.`));
+      console.log(chalk19.yellow(`  Constitution : \u26A0 auto-generation failed (${err.message}), continuing without it.`));
     }
   }
-  console.log(chalk17.blue(`
+  console.log(chalk19.blue(`
 [2/6] Generating spec with ${specProviderName}/${specModelName}...`));
   const specProvider = createProvider(specProviderName, specApiKey, specModelName);
   let initialSpec;
@@ -9732,28 +10077,28 @@ program.command("create").description("Generate a feature spec and kick off code
     if (opts.skipTasks) {
       const generator = new SpecGenerator(specProvider);
       initialSpec = await generator.generateSpec(idea, context);
-      console.log(chalk17.green("  \u2714 Spec generated."));
+      console.log(chalk19.green("  \u2714 Spec generated."));
     } else {
       const result = await generateSpecWithTasks(specProvider, idea, context);
       initialSpec = result.spec;
       initialTasks = result.tasks;
-      console.log(chalk17.green(`  \u2714 Spec generated.`));
+      console.log(chalk19.green(`  \u2714 Spec generated.`));
       if (initialTasks.length > 0) {
-        console.log(chalk17.green(`  \u2714 ${initialTasks.length} tasks generated (combined call).`));
+        console.log(chalk19.green(`  \u2714 ${initialTasks.length} tasks generated (combined call).`));
       } else {
-        console.log(chalk17.yellow("  \u26A0 Tasks not parsed from response \u2014 will retry separately after refinement."));
+        console.log(chalk19.yellow("  \u26A0 Tasks not parsed from response \u2014 will retry separately after refinement."));
       }
     }
   } catch (err) {
-    console.error(chalk17.red("  \u2718 Spec generation failed:"), err);
+    console.error(chalk19.red("  \u2718 Spec generation failed:"), err);
     process.exit(1);
   }
   let finalSpec;
   if (opts.fast) {
-    console.log(chalk17.gray("\n[3/6] Skipping refinement (--fast)."));
+    console.log(chalk19.gray("\n[3/6] Skipping refinement (--fast)."));
     finalSpec = initialSpec;
   } else {
-    console.log(chalk17.blue("\n[3/6] Interactive spec refinement..."));
+    console.log(chalk19.blue("\n[3/6] Interactive spec refinement..."));
     const refiner = new SpecRefiner(specProvider);
     finalSpec = await refiner.refineLoop(initialSpec);
   }
@@ -9762,48 +10107,48 @@ program.command("create").description("Generate a feature spec and kick off code
   const shouldRunAssessment = !opts.skipAssessment && (!opts.auto || minScore > 0);
   if (shouldRunAssessment) {
     if (!opts.auto) {
-      console.log(chalk17.blue("\n[3.4/6] Spec quality assessment..."));
+      console.log(chalk19.blue("\n[3.4/6] Spec quality assessment..."));
     }
     const assessment = await assessSpec(specProvider, finalSpec, context.constitution ?? void 0);
     if (assessment) {
       if (!opts.auto) printSpecAssessment(assessment);
       if (minScore > 0 && assessment.overallScore < minScore) {
         if (opts.force) {
-          console.log(chalk17.yellow(`
+          console.log(chalk19.yellow(`
   \u26A0 Score gate: ${assessment.overallScore}/10 < minimum ${minScore}/10 \u2014 bypassed with --force.`));
         } else {
-          console.log(chalk17.red(`
+          console.log(chalk19.red(`
   \u2718 Spec quality gate failed: overallScore ${assessment.overallScore}/10 < minimum ${minScore}/10`));
           if (!opts.auto) {
-            console.log(chalk17.gray(`  Address the issues above and re-run, or use --force to bypass.`));
+            console.log(chalk19.gray(`  Address the issues above and re-run, or use --force to bypass.`));
           } else {
-            console.log(chalk17.gray(`  Auto mode: gate enforced. Fix the spec or lower minSpecScore, or use --force to bypass.`));
+            console.log(chalk19.gray(`  Auto mode: gate enforced. Fix the spec or lower minSpecScore, or use --force to bypass.`));
           }
-          console.log(chalk17.gray(`  Gate threshold set in .ai-spec.json \u2192 "minSpecScore": ${minScore}`));
+          console.log(chalk19.gray(`  Gate threshold set in .ai-spec.json \u2192 "minSpecScore": ${minScore}`));
           process.exit(1);
         }
       }
     } else if (!opts.auto) {
-      console.log(chalk17.gray("  (Assessment skipped \u2014 AI call failed or timed out)"));
+      console.log(chalk19.gray("  (Assessment skipped \u2014 AI call failed or timed out)"));
     }
   }
   if (!opts.auto) {
-    console.log(chalk17.blue("\n[3.5/6] Approval Gate \u2014 review before code generation"));
+    console.log(chalk19.blue("\n[3.5/6] Approval Gate \u2014 review before code generation"));
     const specLines = finalSpec.split("\n").length;
     const specWords = finalSpec.split(/\s+/).length;
     const taskCountHint = initialTasks.length > 0 ? `  Tasks generated : ${initialTasks.length}` : "";
-    console.log(chalk17.gray(`  Spec length     : ${specLines} lines / ${specWords} words`));
-    if (taskCountHint) console.log(chalk17.gray(taskCountHint));
-    const previewSpecsDir = path21.join(currentDir, "specs");
+    console.log(chalk19.gray(`  Spec length     : ${specLines} lines / ${specWords} words`));
+    if (taskCountHint) console.log(chalk19.gray(taskCountHint));
+    const previewSpecsDir = path23.join(currentDir, "specs");
     const slug = featureSlug;
     const prevVersion = await findLatestVersion(previewSpecsDir, slug);
     if (prevVersion) {
-      console.log(chalk17.gray(`  Previous version: v${prevVersion.version} (${prevVersion.filePath})`));
+      console.log(chalk19.gray(`  Previous version: v${prevVersion.version} (${prevVersion.filePath})`));
       const diff = computeDiff(prevVersion.content, finalSpec);
-      console.log(chalk17.cyan("\n  \u2500\u2500 Changes vs previous version \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk19.cyan("\n  \u2500\u2500 Changes vs previous version \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
       printDiffSummary(diff, `v${prevVersion.version} \u2192 v${prevVersion.version + 1}`);
       printDiff(diff);
-      console.log(chalk17.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"));
+      console.log(chalk19.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"));
     }
     const gate = await select3({
       message: "Ready to proceed to code generation?",
@@ -9814,9 +10159,9 @@ program.command("create").description("Generate a feature spec and kick off code
       ]
     });
     if (gate === "view") {
-      console.log(chalk17.cyan("\n" + "\u2500".repeat(52)));
+      console.log(chalk19.cyan("\n" + "\u2500".repeat(52)));
       console.log(finalSpec);
-      console.log(chalk17.cyan("\u2500".repeat(52) + "\n"));
+      console.log(chalk19.cyan("\u2500".repeat(52) + "\n"));
       const confirm22 = await select3({
         message: "Proceed to code generation?",
         choices: [
@@ -9825,88 +10170,88 @@ program.command("create").description("Generate a feature spec and kick off code
         ]
       });
       if (confirm22 === "abort") {
-        console.log(chalk17.yellow("  Aborted. Spec was NOT saved."));
+        console.log(chalk19.yellow("  Aborted. Spec was NOT saved."));
         process.exit(0);
       }
     } else if (gate === "abort") {
-      console.log(chalk17.yellow("  Aborted. Spec was NOT saved."));
+      console.log(chalk19.yellow("  Aborted. Spec was NOT saved."));
       process.exit(0);
     }
-    console.log(chalk17.green("  \u2714 Approved \u2014 continuing to code generation."));
+    console.log(chalk19.green("  \u2714 Approved \u2014 continuing to code generation."));
   } else {
-    console.log(chalk17.gray("[3.5/6] Approval Gate: skipped (--auto)."));
+    console.log(chalk19.gray("[3.5/6] Approval Gate: skipped (--auto)."));
   }
   let extractedDsl = null;
   if (opts.skipDsl) {
-    console.log(chalk17.gray("\n[DSL] Skipped (--skip-dsl)."));
+    console.log(chalk19.gray("\n[DSL] Skipped (--skip-dsl)."));
   } else {
-    console.log(chalk17.blue("\n[DSL] Extracting structured DSL from spec..."));
-    console.log(chalk17.gray(`  Provider: ${specProviderName}/${specModelName}`));
+    console.log(chalk19.blue("\n[DSL] Extracting structured DSL from spec..."));
+    console.log(chalk19.gray(`  Provider: ${specProviderName}/${specModelName}`));
     try {
       const isFrontend = isFrontendDeps(context.dependencies);
-      if (isFrontend) console.log(chalk17.gray("  Frontend project detected \u2014 using ComponentSpec extractor"));
+      if (isFrontend) console.log(chalk19.gray("  Frontend project detected \u2014 using ComponentSpec extractor"));
       const dslExtractor = new DslExtractor(specProvider);
       extractedDsl = await dslExtractor.extract(finalSpec, { auto: opts.auto, isFrontend });
       if (extractedDsl) {
-        console.log(chalk17.green("  \u2714 DSL extracted and validated."));
+        console.log(chalk19.green("  \u2714 DSL extracted and validated."));
       } else {
-        console.log(chalk17.yellow("  \u26A0 DSL skipped \u2014 codegen will use Spec + Tasks only."));
+        console.log(chalk19.yellow("  \u26A0 DSL skipped \u2014 codegen will use Spec + Tasks only."));
       }
     } catch (err) {
-      console.log(chalk17.yellow(`  \u26A0 DSL extraction error: ${err.message} \u2014 continuing without DSL.`));
+      console.log(chalk19.yellow(`  \u26A0 DSL extraction error: ${err.message} \u2014 continuing without DSL.`));
     }
   }
   const isFrontendProject2 = isFrontendDeps(context.dependencies ?? []);
   const skipWorktree = opts.worktree ? false : opts.skipWorktree || isFrontendProject2;
   let workingDir = currentDir;
   if (!skipWorktree) {
-    console.log(chalk17.blue("\n[4/6] Setting up git worktree..."));
+    console.log(chalk19.blue("\n[4/6] Setting up git worktree..."));
     const worktreeManager = new GitWorktreeManager(currentDir);
     const worktreePath = await worktreeManager.createWorktree(idea);
     if (worktreePath) workingDir = worktreePath;
   } else {
     const reason = opts.worktree ? "" : isFrontendProject2 ? " (frontend project \u2014 use --worktree to override)" : " (--skip-worktree)";
-    console.log(chalk17.gray(`[4/6] Skipping worktree${reason}.`));
+    console.log(chalk19.gray(`[4/6] Skipping worktree${reason}.`));
   }
-  const specsDir = path21.join(workingDir, "specs");
-  await fs22.ensureDir(specsDir);
+  const specsDir = path23.join(workingDir, "specs");
+  await fs24.ensureDir(specsDir);
   const { filePath: specFile, version: specVersion } = await nextVersionPath(specsDir, featureSlug);
-  await fs22.writeFile(specFile, finalSpec, "utf-8");
-  console.log(chalk17.green(`
-[5/6] \u2714 Spec saved: ${specFile}`) + chalk17.gray(` (v${specVersion})`));
+  await fs24.writeFile(specFile, finalSpec, "utf-8");
+  console.log(chalk19.green(`
+[5/6] \u2714 Spec saved: ${specFile}`) + chalk19.gray(` (v${specVersion})`));
   let savedDslFile = null;
   if (extractedDsl) {
     const dslExtractor = new DslExtractor(specProvider);
     savedDslFile = await dslExtractor.saveDsl(extractedDsl, specFile);
-    console.log(chalk17.green(`  \u2714 DSL saved : ${savedDslFile}`));
+    console.log(chalk19.green(`  \u2714 DSL saved : ${savedDslFile}`));
   }
   if (!opts.skipTasks) {
     const taskGen = new TaskGenerator(specProvider);
     let tasksToSave = initialTasks;
     if (tasksToSave.length === 0) {
-      console.log(chalk17.blue(`
+      console.log(chalk19.blue(`
   Generating tasks (separate call)...`));
       try {
         tasksToSave = await taskGen.generateTasks(finalSpec, context);
       } catch (err) {
-        console.log(chalk17.yellow(`  \u26A0 Task generation failed: ${err.message}`));
+        console.log(chalk19.yellow(`  \u26A0 Task generation failed: ${err.message}`));
       }
     }
     if (tasksToSave.length > 0) {
       const sorted = taskGen.sortByLayer(tasksToSave);
       const tasksFile = await taskGen.saveTasks(sorted, specFile);
       printTasks(sorted);
-      console.log(chalk17.green(`  \u2714 Tasks saved: ${tasksFile}`));
+      console.log(chalk19.green(`  \u2714 Tasks saved: ${tasksFile}`));
     } else {
-      console.log(chalk17.yellow("  \u26A0 No tasks generated \u2014 code generation will use fallback file planning."));
+      console.log(chalk19.yellow("  \u26A0 No tasks generated \u2014 code generation will use fallback file planning."));
     }
   }
-  console.log(chalk17.blue(`
+  console.log(chalk19.blue(`
 [6/6] Code generation (mode: ${codegenMode})...`));
   const codegenProvider = codegenProviderName === specProviderName && codegenApiKey === specApiKey ? specProvider : createProvider(codegenProviderName, codegenApiKey, codegenModelName);
   let generatedTestFiles = [];
   if (opts.tdd && extractedDsl) {
-    console.log(chalk17.cyan("\n[TDD] Generating pre-implementation tests (will fail until code is written)..."));
+    console.log(chalk19.cyan("\n[TDD] Generating pre-implementation tests (will fail until code is written)..."));
     const testGen = new TestGenerator(codegenProvider);
     generatedTestFiles = await testGen.generateTdd(extractedDsl, workingDir);
   }
@@ -9918,22 +10263,22 @@ program.command("create").description("Generate a feature spec and kick off code
     repoType: detectedRepoType
   });
   if (opts.tdd) {
-    console.log(chalk17.gray("\n[7/9] TDD mode \u2014 test files already written pre-implementation."));
+    console.log(chalk19.gray("\n[7/9] TDD mode \u2014 test files already written pre-implementation."));
   } else if (opts.skipTests) {
-    console.log(chalk17.gray("\n[7/9] Skipping test generation (--skip-tests)."));
+    console.log(chalk19.gray("\n[7/9] Skipping test generation (--skip-tests)."));
   } else if (!extractedDsl) {
-    console.log(chalk17.gray("\n[7/9] Skipping test generation (no DSL available)."));
+    console.log(chalk19.gray("\n[7/9] Skipping test generation (no DSL available)."));
   } else {
-    console.log(chalk17.blue(`
+    console.log(chalk19.blue(`
 [7/9] Test skeleton generation...`));
     const testGen = new TestGenerator(codegenProvider);
     generatedTestFiles = await testGen.generate(extractedDsl, workingDir);
   }
   if (opts.skipErrorFeedback) {
-    console.log(chalk17.gray("[8/9] Skipping error feedback (--skip-error-feedback)."));
+    console.log(chalk19.gray("[8/9] Skipping error feedback (--skip-error-feedback)."));
   } else {
     if (opts.tdd) {
-      console.log(chalk17.cyan("[8/9] TDD mode \u2014 error feedback loop driving implementation to pass tests..."));
+      console.log(chalk19.cyan("[8/9] TDD mode \u2014 error feedback loop driving implementation to pass tests..."));
     }
     await runErrorFeedback(codegenProvider, workingDir, extractedDsl, {
       maxCycles: opts.tdd ? 3 : 2
@@ -9942,9 +10287,9 @@ program.command("create").description("Generate a feature spec and kick off code
   }
   let reviewResult = "";
   if (!opts.skipReview) {
-    console.log(chalk17.blue("\n[9/9] Automated code review (2-pass: architecture + implementation)..."));
+    console.log(chalk19.blue("\n[9/9] Automated code review (3-pass: architecture + implementation + impact/complexity)..."));
     const reviewer = new CodeReviewer(specProvider, currentDir);
-    const savedSpec = await fs22.readFile(specFile, "utf-8");
+    const savedSpec = await fs24.readFile(specFile, "utf-8");
     if (codegenMode === "api" && generatedFiles.length > 0) {
       reviewResult = await reviewer.reviewFiles(savedSpec, generatedFiles, workingDir, specFile);
     } else {
@@ -9958,15 +10303,20 @@ program.command("create").description("Generate a feature spec and kick off code
     }
     await accumulateReviewKnowledge(specProvider, currentDir, reviewResult);
   }
-  console.log(chalk17.bold.green("\n\u2714 All done!"));
-  console.log(chalk17.gray(`  Spec        : ${specFile}`));
-  if (savedDslFile) console.log(chalk17.gray(`  DSL         : ${savedDslFile}`));
+  runLogger.finish();
+  console.log(chalk19.bold.green("\n\u2714 All done!"));
+  console.log(chalk19.gray(`  Spec        : ${specFile}`));
+  if (savedDslFile) console.log(chalk19.gray(`  DSL         : ${savedDslFile}`));
   if (generatedTestFiles.length > 0) {
-    console.log(chalk17.gray(`  Tests       : ${generatedTestFiles.length} skeleton file(s) generated`));
+    console.log(chalk19.gray(`  Tests       : ${generatedTestFiles.length} skeleton file(s) generated`));
   }
-  console.log(chalk17.gray(`  Working dir : ${workingDir}`));
+  console.log(chalk19.gray(`  Working dir : ${workingDir}`));
   if (workingDir !== currentDir) {
-    console.log(chalk17.gray(`  Run \`cd ${workingDir}\` to enter the worktree.`));
+    console.log(chalk19.gray(`  Run \`cd ${workingDir}\` to enter the worktree.`));
+  }
+  runLogger.printSummary();
+  if (runSnapshot.fileCount > 0) {
+    console.log(chalk19.gray(`  To undo changes: ai-spec restore ${runId}`));
   }
 });
 program.command("review").description("Run AI code review on current git diff against a spec").argument("[specFile]", "Path to spec file (auto-detects latest in specs/ if omitted)").option(
@@ -9983,24 +10333,24 @@ program.command("review").description("Run AI code review on current git diff ag
   const reviewer = new CodeReviewer(provider, currentDir);
   let specContent = "";
   let resolvedSpecFile;
-  if (specFile && await fs22.pathExists(specFile)) {
-    specContent = await fs22.readFile(specFile, "utf-8");
+  if (specFile && await fs24.pathExists(specFile)) {
+    specContent = await fs24.readFile(specFile, "utf-8");
     resolvedSpecFile = specFile;
-    console.log(chalk17.gray(`Using spec: ${specFile}`));
+    console.log(chalk19.gray(`Using spec: ${specFile}`));
   } else {
-    const specsDir = path21.join(currentDir, "specs");
-    if (await fs22.pathExists(specsDir)) {
-      const files = (await fs22.readdir(specsDir)).filter((f) => f.endsWith(".md")).sort().reverse();
+    const specsDir = path23.join(currentDir, "specs");
+    if (await fs24.pathExists(specsDir)) {
+      const files = (await fs24.readdir(specsDir)).filter((f) => f.endsWith(".md")).sort().reverse();
       if (files.length > 0) {
-        const latest = path21.join(specsDir, files[0]);
-        specContent = await fs22.readFile(latest, "utf-8");
+        const latest = path23.join(specsDir, files[0]);
+        specContent = await fs24.readFile(latest, "utf-8");
         resolvedSpecFile = latest;
-        console.log(chalk17.gray(`Auto-detected spec: specs/${files[0]}`));
+        console.log(chalk19.gray(`Auto-detected spec: specs/${files[0]}`));
       }
     }
   }
   if (!specContent) {
-    console.log(chalk17.yellow("No spec file found. Running review without spec context."));
+    console.log(chalk19.yellow("No spec file found. Running review without spec context."));
   }
   await reviewer.reviewCode(specContent, resolvedSpecFile);
   await reviewer.printScoreTrend();
@@ -10027,15 +10377,15 @@ program.command("init").description(`Analyze codebase and generate Project Const
         auto: opts.auto
       });
       if (result.written) {
-        console.log(chalk17.blue("\n  Summary:"));
-        console.log(chalk17.gray(`  Lines : ${result.before.totalLines} \u2192 ${result.after.totalLines} (${result.before.totalLines - result.after.totalLines > 0 ? "-" : "+"}${Math.abs(result.before.totalLines - result.after.totalLines)})`));
-        console.log(chalk17.gray(`  \xA79    : ${result.before.lessonCount} \u2192 ${result.after.lessonCount} lessons remaining`));
+        console.log(chalk19.blue("\n  Summary:"));
+        console.log(chalk19.gray(`  Lines : ${result.before.totalLines} \u2192 ${result.after.totalLines} (${result.before.totalLines - result.after.totalLines > 0 ? "-" : "+"}${Math.abs(result.before.totalLines - result.after.totalLines)})`));
+        console.log(chalk19.gray(`  \xA79    : ${result.before.lessonCount} \u2192 ${result.after.lessonCount} lessons remaining`));
         if (result.backupPath) {
-          console.log(chalk17.gray(`  Backup: ${path21.basename(result.backupPath)}`));
+          console.log(chalk19.gray(`  Backup: ${path23.basename(result.backupPath)}`));
         }
       }
     } catch (err) {
-      console.error(chalk17.red(`  \u2718 Consolidation failed: ${err.message}`));
+      console.error(chalk19.red(`  \u2718 Consolidation failed: ${err.message}`));
       process.exit(1);
     }
     return;
@@ -10043,75 +10393,75 @@ program.command("init").description(`Analyze codebase and generate Project Const
   if (opts.global) {
     const existing = await loadGlobalConstitution([currentDir]);
     if (existing && !opts.force) {
-      console.log(chalk17.yellow(`
+      console.log(chalk19.yellow(`
   Global constitution already exists at: ${existing.source}`));
-      console.log(chalk17.gray("  Use --force to overwrite it."));
+      console.log(chalk19.gray("  Use --force to overwrite it."));
       return;
     }
-    console.log(chalk17.blue("\n\u2500\u2500\u2500 Generating Global Constitution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    console.log(chalk17.gray(`  Provider: ${providerName}/${modelName}`));
-    console.log(chalk17.gray("  Scanning repos in workspace..."));
+    console.log(chalk19.blue("\n\u2500\u2500\u2500 Generating Global Constitution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk19.gray(`  Provider: ${providerName}/${modelName}`));
+    console.log(chalk19.gray("  Scanning repos in workspace..."));
     const loader = new ContextLoader(currentDir);
     const ctx = await loader.loadProjectContext();
     const summary = [
       `Tech stack: ${ctx.techStack.join(", ") || "unknown"}`,
       `Dependencies: ${ctx.dependencies.slice(0, 20).join(", ")}`
     ].join("\n");
-    const prompt = buildGlobalConstitutionPrompt([{ name: path21.basename(currentDir), summary }]);
+    const prompt = buildGlobalConstitutionPrompt([{ name: path23.basename(currentDir), summary }]);
     let globalConstitution;
     try {
       globalConstitution = await provider.generate(prompt, globalConstitutionSystemPrompt);
     } catch (err) {
-      console.error(chalk17.red("  \u2718 Failed to generate global constitution:"), err);
+      console.error(chalk19.red("  \u2718 Failed to generate global constitution:"), err);
       process.exit(1);
     }
     const saved2 = await saveGlobalConstitution(globalConstitution, currentDir);
-    console.log(chalk17.green(`
+    console.log(chalk19.green(`
   \u2714 Global constitution saved: ${saved2}`));
-    console.log(chalk17.gray("  This will be automatically merged into all project constitutions in this workspace."));
-    console.log(chalk17.gray("  Project-level rules always override global rules.\n"));
-    console.log(chalk17.bold("  Preview:"));
-    console.log(chalk17.gray(globalConstitution.split("\n").slice(0, 12).join("\n")));
+    console.log(chalk19.gray("  This will be automatically merged into all project constitutions in this workspace."));
+    console.log(chalk19.gray("  Project-level rules always override global rules.\n"));
+    console.log(chalk19.bold("  Preview:"));
+    console.log(chalk19.gray(globalConstitution.split("\n").slice(0, 12).join("\n")));
     if (globalConstitution.split("\n").length > 12) {
-      console.log(chalk17.gray(`  ... (${globalConstitution.split("\n").length} lines total)`));
+      console.log(chalk19.gray(`  ... (${globalConstitution.split("\n").length} lines total)`));
     }
     return;
   }
-  const constitutionPath = path21.join(currentDir, CONSTITUTION_FILE);
-  if (!opts.force && await fs22.pathExists(constitutionPath)) {
-    console.log(chalk17.yellow(`
+  const constitutionPath = path23.join(currentDir, CONSTITUTION_FILE);
+  if (!opts.force && await fs24.pathExists(constitutionPath)) {
+    console.log(chalk19.yellow(`
   ${CONSTITUTION_FILE} already exists.`));
-    console.log(chalk17.gray("  Use --force to overwrite it."));
-    console.log(chalk17.gray(`  Or edit it directly: ${constitutionPath}`));
+    console.log(chalk19.gray("  Use --force to overwrite it."));
+    console.log(chalk19.gray(`  Or edit it directly: ${constitutionPath}`));
     return;
   }
-  console.log(chalk17.blue("\n\u2500\u2500\u2500 Generating Project Constitution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  console.log(chalk17.gray(`  Provider: ${providerName}/${modelName}`));
-  console.log(chalk17.gray("  Analyzing codebase..."));
+  console.log(chalk19.blue("\n\u2500\u2500\u2500 Generating Project Constitution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk19.gray(`  Provider: ${providerName}/${modelName}`));
+  console.log(chalk19.gray("  Analyzing codebase..."));
   const generator = new ConstitutionGenerator(provider);
   let constitution;
   try {
     constitution = await generator.generate(currentDir);
   } catch (err) {
-    console.error(chalk17.red("  \u2718 Failed to generate constitution:"), err);
+    console.error(chalk19.red("  \u2718 Failed to generate constitution:"), err);
     process.exit(1);
   }
   const saved = await generator.saveConstitution(currentDir, constitution);
-  const globalResult = await loadGlobalConstitution([path21.dirname(currentDir)]);
+  const globalResult = await loadGlobalConstitution([path23.dirname(currentDir)]);
   if (globalResult) {
-    console.log(chalk17.cyan(`
+    console.log(chalk19.cyan(`
   \u2139 Global constitution detected: ${globalResult.source}`));
-    console.log(chalk17.gray("    It will be merged with this project constitution at runtime."));
-    console.log(chalk17.gray("    Project rules take priority over global rules."));
+    console.log(chalk19.gray("    It will be merged with this project constitution at runtime."));
+    console.log(chalk19.gray("    Project rules take priority over global rules."));
   }
-  console.log(chalk17.green(`
+  console.log(chalk19.green(`
   \u2714 Constitution saved: ${saved}`));
-  console.log(chalk17.gray("  This file will be automatically used in all future `ai-spec create` runs."));
-  console.log(chalk17.gray("  Edit it to add custom rules or red lines for your project.\n"));
-  console.log(chalk17.bold("  Preview:"));
-  console.log(chalk17.gray(constitution.split("\n").slice(0, 15).join("\n")));
+  console.log(chalk19.gray("  This file will be automatically used in all future `ai-spec create` runs."));
+  console.log(chalk19.gray("  Edit it to add custom rules or red lines for your project.\n"));
+  console.log(chalk19.bold("  Preview:"));
+  console.log(chalk19.gray(constitution.split("\n").slice(0, 15).join("\n")));
   if (constitution.split("\n").length > 15) {
-    console.log(chalk17.gray(`  ... (${constitution.split("\n").length} lines total)`));
+    console.log(chalk19.gray(`  ... (${constitution.split("\n").length} lines total)`));
   }
 });
 program.command("config").description(`Set default configuration for this project (saved to ${CONFIG_FILE})`).option("--provider <name>", "Default AI provider for spec generation").option("--model <name>", "Default model for spec generation").option(
@@ -10119,44 +10469,44 @@ program.command("config").description(`Set default configuration for this projec
   "Default code generation mode (claude-code|api|plan)"
 ).option("--codegen-provider <name>", "Default provider for code generation").option("--codegen-model <name>", "Default model for code generation").option("--min-spec-score <score>", "Minimum overall spec score (1-10) to pass Approval Gate (0 = disabled)").option("--show", "Print current configuration").option("--reset", "Reset configuration to empty").option("--clear-keys", "Delete all saved API keys from ~/.ai-spec-keys.json").option("--clear-key <provider>", "Delete saved API key for a specific provider").option("--list-keys", "Show which providers have a saved key").action(async (opts) => {
   const currentDir = process.cwd();
-  const configPath = path21.join(currentDir, CONFIG_FILE);
+  const configPath = path23.join(currentDir, CONFIG_FILE);
   if (opts.clearKeys) {
     await clearAllKeys();
-    console.log(chalk17.green(`\u2714 All saved API keys cleared.`));
+    console.log(chalk19.green(`\u2714 All saved API keys cleared.`));
     return;
   }
   if (opts.clearKey) {
     await clearKey(opts.clearKey);
-    console.log(chalk17.green(`\u2714 Saved key for "${opts.clearKey}" removed.`));
+    console.log(chalk19.green(`\u2714 Saved key for "${opts.clearKey}" removed.`));
     return;
   }
   if (opts.listKeys) {
-    const store = await fs22.readJson(KEY_STORE_FILE).catch(() => ({}));
+    const store = await fs24.readJson(KEY_STORE_FILE).catch(() => ({}));
     const providers = Object.keys(store);
     if (providers.length === 0) {
-      console.log(chalk17.gray("No saved API keys."));
+      console.log(chalk19.gray("No saved API keys."));
     } else {
-      console.log(chalk17.bold("Saved API keys:"));
+      console.log(chalk19.bold("Saved API keys:"));
       for (const p of providers) {
         const k2 = store[p];
-        console.log(chalk17.gray(`  ${p}: ${k2.slice(0, 6)}...${k2.slice(-4)}`));
+        console.log(chalk19.gray(`  ${p}: ${k2.slice(0, 6)}...${k2.slice(-4)}`));
       }
-      console.log(chalk17.gray(`
+      console.log(chalk19.gray(`
 File: ${KEY_STORE_FILE}`));
     }
     return;
   }
   if (opts.reset) {
-    await fs22.writeJson(configPath, {}, { spaces: 2 });
-    console.log(chalk17.green(`\u2714 Config reset: ${configPath}`));
+    await fs24.writeJson(configPath, {}, { spaces: 2 });
+    console.log(chalk19.green(`\u2714 Config reset: ${configPath}`));
     return;
   }
   const existing = await loadConfig(currentDir);
   if (opts.show) {
     if (Object.keys(existing).length === 0) {
-      console.log(chalk17.gray("No config file found. Using built-in defaults."));
+      console.log(chalk19.gray("No config file found. Using built-in defaults."));
     } else {
-      console.log(chalk17.bold(`${configPath}:`));
+      console.log(chalk19.bold(`${configPath}:`));
       console.log(JSON.stringify(existing, null, 2));
     }
     return;
@@ -10170,27 +10520,27 @@ File: ${KEY_STORE_FILE}`));
   if (opts.minSpecScore !== void 0) {
     const score = parseInt(opts.minSpecScore, 10);
     if (isNaN(score) || score < 0 || score > 10) {
-      console.error(chalk17.red("  --min-spec-score must be a number between 0 and 10"));
+      console.error(chalk19.red("  --min-spec-score must be a number between 0 and 10"));
       process.exit(1);
     }
     updated.minSpecScore = score;
   }
-  await fs22.writeJson(configPath, updated, { spaces: 2 });
-  console.log(chalk17.green(`\u2714 Config saved to ${configPath}`));
+  await fs24.writeJson(configPath, updated, { spaces: 2 });
+  console.log(chalk19.green(`\u2714 Config saved to ${configPath}`));
   console.log(JSON.stringify(updated, null, 2));
 });
 program.command("model").description("Interactively switch the active AI provider/model and save to .ai-spec.json").option("--list", "List all available providers and models").action(async (opts) => {
   const currentDir = process.cwd();
-  const configPath = path21.join(currentDir, CONFIG_FILE);
+  const configPath = path23.join(currentDir, CONFIG_FILE);
   if (opts.list) {
-    console.log(chalk17.bold("\nAvailable providers & models:\n"));
+    console.log(chalk19.bold("\nAvailable providers & models:\n"));
     for (const [key, meta] of Object.entries(PROVIDER_CATALOG)) {
       console.log(
-        `  ${chalk17.bold.cyan(key.padEnd(10))} ${chalk17.white(meta.displayName)}`
+        `  ${chalk19.bold.cyan(key.padEnd(10))} ${chalk19.white(meta.displayName)}`
       );
-      console.log(chalk17.gray(`             ${meta.description}`));
+      console.log(chalk19.gray(`             ${meta.description}`));
       console.log(
-        chalk17.gray(
+        chalk19.gray(
           `             env: ${meta.envKey}  |  models: ${meta.models.join(", ")}`
         )
       );
@@ -10199,10 +10549,10 @@ program.command("model").description("Interactively switch the active AI provide
     return;
   }
   const existing = await loadConfig(currentDir);
-  console.log(chalk17.blue("\n\u2500\u2500\u2500 Model Switcher \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(chalk19.blue("\n\u2500\u2500\u2500 Model Switcher \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"));
   if (Object.keys(existing).length > 0) {
     console.log(
-      chalk17.gray(
+      chalk19.gray(
         `  Current: spec=${existing.provider ?? "gemini"}/${existing.model ?? DEFAULT_MODELS[existing.provider ?? "gemini"]}` + (existing.codegenProvider ? `  codegen=${existing.codegenProvider}/${existing.codegenModel ?? ""}` : "")
       )
     );
@@ -10220,7 +10570,7 @@ program.command("model").description("Interactively switch the active AI provide
     const providerKey = await select3({
       message: `${label} \u2014 select provider:`,
       choices: Object.entries(PROVIDER_CATALOG).map(([key, meta2]) => ({
-        name: `${meta2.displayName.padEnd(22)} ${chalk17.gray(meta2.description)}`,
+        name: `${meta2.displayName.padEnd(22)} ${chalk19.gray(meta2.description)}`,
         value: key,
         short: meta2.displayName
       }))
@@ -10228,7 +10578,7 @@ program.command("model").description("Interactively switch the active AI provide
     const meta = PROVIDER_CATALOG[providerKey];
     const modelChoices = [
       ...meta.models.map((m) => ({ name: m, value: m })),
-      { name: chalk17.italic("\u270E  Enter custom model name..."), value: "__custom__" }
+      { name: chalk19.italic("\u270E  Enter custom model name..."), value: "__custom__" }
     ];
     let chosenModel = await select3({
       message: `${label} \u2014 select model (${meta.displayName}):`,
@@ -10262,37 +10612,37 @@ program.command("model").description("Interactively switch the active AI provide
       if (!updated.codegen || updated.codegen === "claude-code") {
         updated.codegen = "api";
         console.log(
-          chalk17.yellow(
+          chalk19.yellow(
             `
   \u26A0  provider "${effectiveCodegenProvider}" \u4E0D\u652F\u6301 "claude-code" \u6A21\u5F0F\u3002`
           )
         );
-        console.log(chalk17.gray(`  \u5DF2\u81EA\u52A8\u5C06 codegen \u6A21\u5F0F\u8BBE\u4E3A "api"\u3002`));
+        console.log(chalk19.gray(`  \u5DF2\u81EA\u52A8\u5C06 codegen \u6A21\u5F0F\u8BBE\u4E3A "api"\u3002`));
       }
     }
   }
-  console.log(chalk17.blue("\n  Preview:"));
-  console.log(chalk17.gray(`    spec    \u2192 ${updated.provider}/${updated.model}`));
+  console.log(chalk19.blue("\n  Preview:"));
+  console.log(chalk19.gray(`    spec    \u2192 ${updated.provider}/${updated.model}`));
   if (updated.codegenProvider) {
     console.log(
-      chalk17.gray(
+      chalk19.gray(
         `    codegen \u2192 ${updated.codegenProvider}/${updated.codegenModel}  (mode: ${updated.codegen ?? "claude-code"})`
       )
     );
   }
   const ok = await confirm2({ message: "Save to .ai-spec.json?", default: true });
   if (!ok) {
-    console.log(chalk17.gray("  Cancelled."));
+    console.log(chalk19.gray("  Cancelled."));
     return;
   }
-  await fs22.writeJson(configPath, updated, { spaces: 2 });
-  console.log(chalk17.green(`
+  await fs24.writeJson(configPath, updated, { spaces: 2 });
+  console.log(chalk19.green(`
   \u2714 Saved to ${configPath}`));
   const providerToCheck = updated.provider ?? "gemini";
   const envKey = ENV_KEY_MAP[providerToCheck];
   if (envKey && !process.env[envKey]) {
     console.log(
-      chalk17.yellow(
+      chalk19.yellow(
         `  \u26A0  Remember to set ${envKey} in your environment or .env file.`
       )
     );
@@ -10311,29 +10661,29 @@ async function runSingleRepoPipelineInWorkspace(opts) {
     cliOpts,
     contractContextSection
   } = opts;
-  console.log(chalk17.blue(`
+  console.log(chalk19.blue(`
   [${repoName}] Loading project context...`));
   const loader = new ContextLoader(repoAbsPath);
   let context = await loader.loadProjectContext();
   const { type: detectedRepoType } = await detectRepoType(repoAbsPath);
-  console.log(chalk17.gray(`    Tech stack: ${context.techStack.join(", ") || "unknown"} [${detectedRepoType}]`));
-  console.log(chalk17.gray(`    Dependencies: ${context.dependencies.length} packages`));
+  console.log(chalk19.gray(`    Tech stack: ${context.techStack.join(", ") || "unknown"} [${detectedRepoType}]`));
+  console.log(chalk19.gray(`    Dependencies: ${context.dependencies.length} packages`));
   if (context.constitution && context.constitution.length > 6e3) {
-    console.log(chalk17.yellow(`    \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
+    console.log(chalk19.yellow(`    \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
   }
   if (!context.constitution) {
-    console.log(chalk17.yellow(`    Constitution: not found \u2014 auto-generating...`));
+    console.log(chalk19.yellow(`    Constitution: not found \u2014 auto-generating...`));
     try {
       const constitutionGen = new ConstitutionGenerator(specProvider);
       const constitutionContent = await constitutionGen.generate(repoAbsPath);
       await constitutionGen.saveConstitution(repoAbsPath, constitutionContent);
       context.constitution = constitutionContent;
-      console.log(chalk17.green(`    Constitution: generated`));
+      console.log(chalk19.green(`    Constitution: generated`));
     } catch (err) {
-      console.log(chalk17.yellow(`    Constitution: auto-generation failed (${err.message}), continuing.`));
+      console.log(chalk19.yellow(`    Constitution: auto-generation failed (${err.message}), continuing.`));
     }
   } else {
-    console.log(chalk17.green(`    Constitution: found`));
+    console.log(chalk19.green(`    Constitution: found`));
   }
   let fullIdea = idea;
   if (contractContextSection) {
@@ -10341,58 +10691,58 @@ async function runSingleRepoPipelineInWorkspace(opts) {
 
 ${contractContextSection}`;
   }
-  console.log(chalk17.blue(`  [${repoName}] Generating spec...`));
+  console.log(chalk19.blue(`  [${repoName}] Generating spec...`));
   let finalSpec;
   try {
     const result = await generateSpecWithTasks(specProvider, fullIdea, context);
     finalSpec = result.spec;
-    console.log(chalk17.green(`    Spec generated.`));
+    console.log(chalk19.green(`    Spec generated.`));
   } catch (err) {
-    console.error(chalk17.red(`    Spec generation failed: ${err.message}`));
+    console.error(chalk19.red(`    Spec generation failed: ${err.message}`));
     return { dsl: null, specFile: null };
   }
   let extractedDsl = null;
   if (!cliOpts.skipDsl) {
-    console.log(chalk17.blue(`  [${repoName}] Extracting DSL...`));
+    console.log(chalk19.blue(`  [${repoName}] Extracting DSL...`));
     try {
       const dslExtractor = new DslExtractor(specProvider);
       const repoIsFrontend = isFrontendDeps(context.dependencies);
       extractedDsl = await dslExtractor.extract(finalSpec, { auto: true, isFrontend: repoIsFrontend });
       if (extractedDsl) {
-        console.log(chalk17.green(`    DSL extracted.`));
+        console.log(chalk19.green(`    DSL extracted.`));
       }
     } catch (err) {
-      console.log(chalk17.yellow(`    DSL extraction failed: ${err.message}`));
+      console.log(chalk19.yellow(`    DSL extraction failed: ${err.message}`));
     }
   }
   const isFrontendRepo = isFrontendDeps(context.dependencies ?? []);
   const skipWorktreeForRepo = cliOpts.worktree ? false : cliOpts.skipWorktree || isFrontendRepo;
   let workingDir = repoAbsPath;
   if (!skipWorktreeForRepo) {
-    console.log(chalk17.blue(`  [${repoName}] Setting up git worktree...`));
+    console.log(chalk19.blue(`  [${repoName}] Setting up git worktree...`));
     try {
       const worktreeManager = new GitWorktreeManager(repoAbsPath);
       const worktreePath = await worktreeManager.createWorktree(idea);
       if (worktreePath) workingDir = worktreePath;
     } catch (err) {
-      console.log(chalk17.yellow(`    Worktree setup failed: ${err.message}. Using main branch.`));
+      console.log(chalk19.yellow(`    Worktree setup failed: ${err.message}. Using main branch.`));
     }
   } else {
-    console.log(chalk17.gray(`  [${repoName}] Skipping worktree${isFrontendRepo ? " (frontend repo)" : ""}.`));
+    console.log(chalk19.gray(`  [${repoName}] Skipping worktree${isFrontendRepo ? " (frontend repo)" : ""}.`));
   }
-  const specsDir = path21.join(workingDir, "specs");
-  await fs22.ensureDir(specsDir);
+  const specsDir = path23.join(workingDir, "specs");
+  await fs24.ensureDir(specsDir);
   const featureSlug = slugify(idea);
   const { filePath: specFile } = await nextVersionPath(specsDir, featureSlug);
-  await fs22.writeFile(specFile, finalSpec, "utf-8");
-  console.log(chalk17.green(`    Spec saved: ${path21.relative(repoAbsPath, specFile)}`));
+  await fs24.writeFile(specFile, finalSpec, "utf-8");
+  console.log(chalk19.green(`    Spec saved: ${path23.relative(repoAbsPath, specFile)}`));
   let savedDslFile = null;
   if (extractedDsl) {
     const dslExtractorForSave = new DslExtractor(specProvider);
     savedDslFile = await dslExtractorForSave.saveDsl(extractedDsl, specFile);
-    console.log(chalk17.green(`    DSL saved: ${path21.relative(repoAbsPath, savedDslFile)}`));
+    console.log(chalk19.green(`    DSL saved: ${path23.relative(repoAbsPath, savedDslFile)}`));
   }
-  console.log(chalk17.blue(`  [${repoName}] Running code generation (mode: ${codegenMode})...`));
+  console.log(chalk19.blue(`  [${repoName}] Running code generation (mode: ${codegenMode})...`));
   try {
     const codegen = new CodeGenerator(codegenProvider, codegenMode);
     await codegen.generateCode(specFile, workingDir, context, {
@@ -10400,36 +10750,43 @@ ${contractContextSection}`;
       dslFilePath: savedDslFile ?? void 0,
       repoType: detectedRepoType
     });
-    console.log(chalk17.green(`    Code generation complete.`));
+    console.log(chalk19.green(`    Code generation complete.`));
   } catch (err) {
-    console.log(chalk17.yellow(`    Code generation failed: ${err.message}`));
+    console.log(chalk19.yellow(`    Code generation failed: ${err.message}`));
   }
   if (!cliOpts.skipTests && extractedDsl) {
-    console.log(chalk17.blue(`  [${repoName}] Generating test skeletons...`));
+    console.log(chalk19.blue(`  [${repoName}] Generating test skeletons...`));
     try {
       const testGen = new TestGenerator(codegenProvider);
       const testFiles = await testGen.generate(extractedDsl, workingDir);
-      console.log(chalk17.green(`    ${testFiles.length} test file(s) generated.`));
+      console.log(chalk19.green(`    ${testFiles.length} test file(s) generated.`));
     } catch (err) {
-      console.log(chalk17.yellow(`    Test generation failed: ${err.message}`));
+      console.log(chalk19.yellow(`    Test generation failed: ${err.message}`));
     }
   }
   if (!cliOpts.skipErrorFeedback) {
     try {
       await runErrorFeedback(codegenProvider, workingDir, extractedDsl, { maxCycles: 1 });
     } catch (err) {
-      console.log(chalk17.yellow(`    Error feedback failed: ${err.message}`));
+      console.log(chalk19.yellow(`    Error feedback failed: ${err.message}`));
     }
   }
   if (!cliOpts.skipReview) {
-    console.log(chalk17.blue(`  [${repoName}] Running code review...`));
+    console.log(chalk19.blue(`  [${repoName}] Running code review...`));
     try {
       const reviewer = new CodeReviewer(specProvider);
-      const reviewResult = await reviewer.reviewCode(finalSpec);
+      const originalDir = process.cwd();
+      let reviewResult;
+      try {
+        process.chdir(workingDir);
+        reviewResult = await reviewer.reviewCode(finalSpec);
+      } finally {
+        process.chdir(originalDir);
+      }
       await accumulateReviewKnowledge(specProvider, repoAbsPath, reviewResult);
-      console.log(chalk17.green(`    Code review complete.`));
+      console.log(chalk19.green(`    Code review complete.`));
     } catch (err) {
-      console.log(chalk17.yellow(`    Code review failed: ${err.message}`));
+      console.log(chalk19.yellow(`    Code review failed: ${err.message}`));
     }
   }
   return { dsl: extractedDsl, specFile };
@@ -10452,7 +10809,7 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
     codegenModel: codegenModelName
   });
   const workspaceLoader = new WorkspaceLoader(currentDir);
-  console.log(chalk17.blue("\n[W1] Loading per-repo contexts..."));
+  console.log(chalk19.blue("\n[W1] Loading per-repo contexts..."));
   const contexts = /* @__PURE__ */ new Map();
   const frontendContexts = /* @__PURE__ */ new Map();
   for (const repo of workspace.repos) {
@@ -10464,27 +10821,27 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
       if (repo.role === "frontend" || repo.role === "mobile") {
         const fctx = await loadFrontendContext(repoAbsPath);
         frontendContexts.set(repo.name, fctx);
-        console.log(chalk17.gray(`  ${repo.name}: ${fctx.framework} / ${fctx.httpClient} / hooks:${fctx.hookFiles.length} stores:${fctx.storeFiles.length}`));
+        console.log(chalk19.gray(`  ${repo.name}: ${fctx.framework} / ${fctx.httpClient} / hooks:${fctx.hookFiles.length} stores:${fctx.storeFiles.length}`));
       } else {
-        console.log(chalk17.gray(`  ${repo.name}: ${ctx.techStack.join(", ") || "unknown"} (${ctx.dependencies.length} deps)`));
+        console.log(chalk19.gray(`  ${repo.name}: ${ctx.techStack.join(", ") || "unknown"} (${ctx.dependencies.length} deps)`));
       }
     } catch (err) {
-      console.log(chalk17.yellow(`  ${repo.name}: context load failed \u2014 ${err.message}`));
+      console.log(chalk19.yellow(`  ${repo.name}: context load failed \u2014 ${err.message}`));
     }
   }
-  console.log(chalk17.blue("\n[W2] Decomposing requirement across repos..."));
+  console.log(chalk19.blue("\n[W2] Decomposing requirement across repos..."));
   const decomposer = new RequirementDecomposer(specProvider);
   let decomposition;
   try {
     decomposition = await decomposer.decompose(idea, workspace, contexts, frontendContexts);
-    console.log(chalk17.green(`  Summary: ${decomposition.summary}`));
-    console.log(chalk17.gray(`  Repos affected: ${decomposition.repos.map((r) => r.repoName).join(", ")}`));
+    console.log(chalk19.green(`  Summary: ${decomposition.summary}`));
+    console.log(chalk19.gray(`  Repos affected: ${decomposition.repos.map((r) => r.repoName).join(", ")}`));
     if (decomposition.coordinationNotes) {
-      console.log(chalk17.gray(`  Coordination: ${decomposition.coordinationNotes}`));
+      console.log(chalk19.gray(`  Coordination: ${decomposition.coordinationNotes}`));
     }
   } catch (err) {
-    console.error(chalk17.red(`  Decomposition failed: ${err.message}`));
-    console.log(chalk17.yellow("  Falling back to running all repos independently."));
+    console.error(chalk19.red(`  Decomposition failed: ${err.message}`));
+    console.log(chalk19.yellow("  Falling back to running all repos independently."));
     decomposition = {
       originalRequirement: idea,
       summary: idea,
@@ -10500,11 +10857,11 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
     };
   }
   if (!opts.auto) {
-    console.log(chalk17.cyan("\n[W3] Decomposition Preview:"));
-    console.log(chalk17.cyan("\u2500".repeat(52)));
+    console.log(chalk19.cyan("\n[W3] Decomposition Preview:"));
+    console.log(chalk19.cyan("\u2500".repeat(52)));
     for (const r of decomposition.repos) {
-      console.log(chalk17.bold(`  ${r.repoName} (${r.role})`));
-      console.log(chalk17.gray(`    ${r.specIdea.slice(0, 150)}${r.specIdea.length > 150 ? "..." : ""}`));
+      console.log(chalk19.bold(`  ${r.repoName} (${r.role})`));
+      console.log(chalk19.gray(`    ${r.specIdea.slice(0, 150)}${r.specIdea.length > 150 ? "..." : ""}`));
       if (r.uxDecisions) {
         const ux = r.uxDecisions;
         const uxSummary = [
@@ -10513,13 +10870,13 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
           ux.optimisticUpdate ? "optimistic-update" : "",
           ux.errorRollback ? "rollback" : ""
         ].filter(Boolean).join(", ");
-        if (uxSummary) console.log(chalk17.cyan(`    UX: ${uxSummary}`));
+        if (uxSummary) console.log(chalk19.cyan(`    UX: ${uxSummary}`));
       }
       if (r.dependsOnRepos.length > 0) {
-        console.log(chalk17.gray(`    Depends on: ${r.dependsOnRepos.join(", ")}`));
+        console.log(chalk19.gray(`    Depends on: ${r.dependsOnRepos.join(", ")}`));
       }
     }
-    console.log(chalk17.cyan("\u2500".repeat(52)));
+    console.log(chalk19.cyan("\u2500".repeat(52)));
     const gate = await select3({
       message: "Proceed with multi-repo pipeline?",
       choices: [
@@ -10528,24 +10885,24 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
       ]
     });
     if (gate === "abort") {
-      console.log(chalk17.yellow("  Aborted."));
+      console.log(chalk19.yellow("  Aborted."));
       process.exit(0);
     }
   }
   const sortedRepoRequirements = RequirementDecomposer.sortByDependency(decomposition.repos);
   const contractDsls = /* @__PURE__ */ new Map();
-  console.log(chalk17.blue(`
+  console.log(chalk19.blue(`
 [W4] Running pipeline for ${sortedRepoRequirements.length} repo(s)...`));
   const results = [];
   for (const repoReq of sortedRepoRequirements) {
     const repoConfig = workspace.repos.find((r) => r.name === repoReq.repoName);
     if (!repoConfig) {
-      console.log(chalk17.yellow(`  Skipping ${repoReq.repoName} \u2014 not found in workspace config.`));
+      console.log(chalk19.yellow(`  Skipping ${repoReq.repoName} \u2014 not found in workspace config.`));
       results.push({ repoName: repoReq.repoName, status: "skipped", specFile: null, dsl: null, repoAbsPath: "", role: repoReq.role });
       continue;
     }
     const repoAbsPath = workspaceLoader.resolveAbsPath(repoConfig);
-    console.log(chalk17.bold.blue(`
+    console.log(chalk19.bold.blue(`
   \u2500\u2500 ${repoReq.repoName} (${repoReq.role}) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
     let contractContextSection;
     if (repoReq.dependsOnRepos.length > 0) {
@@ -10553,7 +10910,7 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
       for (const depName of repoReq.dependsOnRepos) {
         const depDsl = contractDsls.get(depName);
         if (depDsl) {
-          console.log(chalk17.gray(`    Using API contract from: ${depName}`));
+          console.log(chalk19.gray(`    Using API contract from: ${depName}`));
           const contract = buildFrontendApiContract(depDsl);
           contractParts.push(buildContractContextSection(contract));
         }
@@ -10573,7 +10930,7 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
         frontendContext: frontendCtx
       });
       contractContextSection = void 0;
-      console.log(chalk17.gray(`    Frontend context: ${frontendCtx.framework} / ${frontendCtx.httpClient} / ${frontendCtx.uiLibrary}`));
+      console.log(chalk19.gray(`    Frontend context: ${frontendCtx.framework} / ${frontendCtx.httpClient} / ${frontendCtx.uiLibrary}`));
     }
     try {
       const { dsl, specFile } = await runSingleRepoPipelineInWorkspace({
@@ -10590,22 +10947,22 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
       });
       if (repoReq.isContractProvider && dsl) {
         contractDsls.set(repoReq.repoName, dsl);
-        console.log(chalk17.green(`    Contract stored for downstream repos.`));
+        console.log(chalk19.green(`    Contract stored for downstream repos.`));
       }
       results.push({ repoName: repoReq.repoName, status: "success", specFile, dsl, repoAbsPath, role: repoReq.role });
-      console.log(chalk17.green(`  \u2714 ${repoReq.repoName} complete`));
+      console.log(chalk19.green(`  \u2714 ${repoReq.repoName} complete`));
     } catch (err) {
-      console.error(chalk17.red(`  \u2718 ${repoReq.repoName} failed: ${err.message}`));
+      console.error(chalk19.red(`  \u2718 ${repoReq.repoName} failed: ${err.message}`));
       results.push({ repoName: repoReq.repoName, status: "failed", specFile: null, dsl: null, repoAbsPath, role: repoReq.role });
     }
   }
-  console.log(chalk17.bold.green("\n\u2714 Multi-repo pipeline complete!"));
-  console.log(chalk17.gray(`  Workspace: ${workspace.name}`));
-  console.log(chalk17.gray(`  Requirement: ${idea}`));
+  console.log(chalk19.bold.green("\n\u2714 Multi-repo pipeline complete!"));
+  console.log(chalk19.gray(`  Workspace: ${workspace.name}`));
+  console.log(chalk19.gray(`  Requirement: ${idea}`));
   console.log();
   for (const r of results) {
-    const icon = r.status === "success" ? chalk17.green("\u2714") : r.status === "failed" ? chalk17.red("\u2718") : chalk17.gray("\u2212");
-    const specInfo = r.specFile ? chalk17.gray(` \u2192 ${r.specFile}`) : "";
+    const icon = r.status === "success" ? chalk19.green("\u2714") : r.status === "failed" ? chalk19.red("\u2718") : chalk19.gray("\u2212");
+    const specInfo = r.specFile ? chalk19.gray(` \u2192 ${r.specFile}`) : "";
     console.log(`  ${icon} ${r.repoName} (${r.status})${specInfo}`);
   }
   return results;
@@ -10613,18 +10970,18 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
 var workspaceCmd = program.command("workspace").description("Manage multi-repo workspace configuration");
 workspaceCmd.command("init").description(`Interactive workspace setup \u2014 creates ${WORKSPACE_CONFIG_FILE}`).action(async () => {
   const currentDir = process.cwd();
-  const configPath = path21.join(currentDir, WORKSPACE_CONFIG_FILE);
-  if (await fs22.pathExists(configPath)) {
+  const configPath = path23.join(currentDir, WORKSPACE_CONFIG_FILE);
+  if (await fs24.pathExists(configPath)) {
     const overwrite = await confirm2({
       message: `${WORKSPACE_CONFIG_FILE} already exists. Overwrite?`,
       default: false
     });
     if (!overwrite) {
-      console.log(chalk17.gray("  Cancelled."));
+      console.log(chalk19.gray("  Cancelled."));
       return;
     }
   }
-  console.log(chalk17.blue("\n\u2500\u2500\u2500 Workspace Setup \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(chalk19.blue("\n\u2500\u2500\u2500 Workspace Setup \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"));
   const workspaceName = await input({
     message: "Workspace name:",
     validate: (v2) => v2.trim().length > 0 || "Name cannot be empty"
@@ -10638,11 +10995,11 @@ workspaceCmd.command("init").description(`Interactive workspace setup \u2014 cre
     const workspaceLoader = new WorkspaceLoader(currentDir);
     const detected = await workspaceLoader.autoDetect();
     if (detected.length === 0) {
-      console.log(chalk17.yellow("  No recognizable repos found in sibling directories."));
+      console.log(chalk19.yellow("  No recognizable repos found in sibling directories."));
     } else {
-      console.log(chalk17.cyan("\n  Detected repos:"));
+      console.log(chalk19.cyan("\n  Detected repos:"));
       for (const r of detected) {
-        console.log(chalk17.gray(`    - ${r.name}: ${r.role} (${r.type}) at ${r.path}`));
+        console.log(chalk19.gray(`    - ${r.name}: ${r.role} (${r.type}) at ${r.path}`));
       }
       const keepAll = await confirm2({
         message: `Include all ${detected.length} detected repo(s)?`,
@@ -10659,7 +11016,7 @@ workspaceCmd.command("init").description(`Interactive workspace setup \u2014 cre
           if (keep) repos.push(r);
         }
       }
-      console.log(chalk17.green(`  \u2714 ${repos.length} repo(s) added from auto-scan.`));
+      console.log(chalk19.green(`  \u2714 ${repos.length} repo(s) added from auto-scan.`));
     }
   }
   const repoTypeChoices = [
@@ -10681,7 +11038,7 @@ workspaceCmd.command("init").description(`Interactive workspace setup \u2014 cre
     default: repos.length === 0
   });
   while (addMore) {
-    console.log(chalk17.cyan(`
+    console.log(chalk19.cyan(`
   Adding repo #${repos.length + 1}`));
     const repoName = await input({
       message: "Repo name (e.g. api, web, app):",
@@ -10695,16 +11052,16 @@ workspaceCmd.command("init").description(`Interactive workspace setup \u2014 cre
       message: `Relative path to "${repoName}" from here (default: ./${repoName}):`,
       default: `./${repoName}`
     });
-    const absPath = path21.resolve(currentDir, repoPath);
+    const absPath = path23.resolve(currentDir, repoPath);
     let detectedType = "unknown";
     let detectedRole = "shared";
-    if (await fs22.pathExists(absPath)) {
+    if (await fs24.pathExists(absPath)) {
       const { type, role } = await detectRepoType(absPath);
       detectedType = type;
       detectedRole = role;
-      console.log(chalk17.gray(`    Auto-detected: type=${type}, role=${role}`));
+      console.log(chalk19.gray(`    Auto-detected: type=${type}, role=${role}`));
     } else {
-      console.log(chalk17.yellow(`    Path "${absPath}" not found \u2014 type/role will be manual.`));
+      console.log(chalk19.yellow(`    Path "${absPath}" not found \u2014 type/role will be manual.`));
     }
     const repoType = await select3({
       message: `Repo type for "${repoName}":`,
@@ -10727,53 +11084,53 @@ workspaceCmd.command("init").description(`Interactive workspace setup \u2014 cre
       type: repoType,
       role: repoRole
     });
-    console.log(chalk17.green(`  \u2714 Added: ${repoName} (${repoRole}, ${repoType})`));
+    console.log(chalk19.green(`  \u2714 Added: ${repoName} (${repoRole}, ${repoType})`));
     addMore = await confirm2({
       message: "Add another repo?",
       default: false
     });
   }
   const workspaceConfig = { name: workspaceName, repos };
-  console.log(chalk17.cyan("\n  Workspace summary:"));
-  console.log(chalk17.gray(`  Name: ${workspaceName}`));
+  console.log(chalk19.cyan("\n  Workspace summary:"));
+  console.log(chalk19.gray(`  Name: ${workspaceName}`));
   for (const r of repos) {
-    console.log(chalk17.gray(`  - ${r.name}: ${r.role} (${r.type}) at ${r.path}`));
+    console.log(chalk19.gray(`  - ${r.name}: ${r.role} (${r.type}) at ${r.path}`));
   }
   const ok = await confirm2({ message: `Save to ${WORKSPACE_CONFIG_FILE}?`, default: true });
   if (!ok) {
-    console.log(chalk17.gray("  Cancelled."));
+    console.log(chalk19.gray("  Cancelled."));
     return;
   }
   const loader = new WorkspaceLoader(currentDir);
   const saved = await loader.save(workspaceConfig);
-  console.log(chalk17.green(`
+  console.log(chalk19.green(`
   \u2714 Workspace saved: ${saved}`));
-  console.log(chalk17.gray(`  Run \`ai-spec create "your feature"\` \u2014 workspace mode will activate automatically.`));
+  console.log(chalk19.gray(`  Run \`ai-spec create "your feature"\` \u2014 workspace mode will activate automatically.`));
 });
 workspaceCmd.command("status").description("Show current workspace configuration").action(async () => {
   const currentDir = process.cwd();
   const loader = new WorkspaceLoader(currentDir);
   const config2 = await loader.load();
   if (!config2) {
-    console.log(chalk17.yellow(`No ${WORKSPACE_CONFIG_FILE} found in ${currentDir}`));
-    console.log(chalk17.gray("  Run `ai-spec workspace init` to create one."));
+    console.log(chalk19.yellow(`No ${WORKSPACE_CONFIG_FILE} found in ${currentDir}`));
+    console.log(chalk19.gray("  Run `ai-spec workspace init` to create one."));
     return;
   }
-  console.log(chalk17.bold(`
+  console.log(chalk19.bold(`
 Workspace: ${config2.name}`));
-  console.log(chalk17.gray(`  Config: ${path21.join(currentDir, WORKSPACE_CONFIG_FILE)}`));
-  console.log(chalk17.gray(`  Repos (${config2.repos.length}):
+  console.log(chalk19.gray(`  Config: ${path23.join(currentDir, WORKSPACE_CONFIG_FILE)}`));
+  console.log(chalk19.gray(`  Repos (${config2.repos.length}):
 `));
   for (const repo of config2.repos) {
     const absPath = loader.resolveAbsPath(repo);
-    const exists = await fs22.pathExists(absPath);
-    const status = exists ? chalk17.green("found") : chalk17.red("not found");
+    const exists = await fs24.pathExists(absPath);
+    const status = exists ? chalk19.green("found") : chalk19.red("not found");
     console.log(
-      `  ${chalk17.bold(repo.name.padEnd(12))} ${repo.role.padEnd(10)} ${repo.type.padEnd(16)} ${status}`
+      `  ${chalk19.bold(repo.name.padEnd(12))} ${repo.role.padEnd(10)} ${repo.type.padEnd(16)} ${status}`
     );
-    console.log(chalk17.gray(`    path: ${absPath}`));
+    console.log(chalk19.gray(`    path: ${absPath}`));
     if (repo.constitution) {
-      console.log(chalk17.green(`    constitution: found`));
+      console.log(chalk19.green(`    constitution: found`));
     }
   }
 });
@@ -10790,24 +11147,24 @@ program.command("update").description("Update an existing spec with a change req
   const modelName = opts.model || config2.model || DEFAULT_MODELS[providerName];
   const apiKey = await resolveApiKey(providerName, opts.key);
   const provider = createProvider(providerName, apiKey, modelName);
-  console.log(chalk17.blue("\n\u2500\u2500\u2500 ai-spec update \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(chalk17.gray(`  Provider: ${providerName}/${modelName}`));
+  console.log(chalk19.blue("\n\u2500\u2500\u2500 ai-spec update \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(chalk19.gray(`  Provider: ${providerName}/${modelName}`));
   let specPath = opts.spec ?? null;
   if (!specPath) {
-    const specsDir = path21.join(currentDir, "specs");
+    const specsDir = path23.join(currentDir, "specs");
     const latest = await SpecUpdater.findLatestSpec(specsDir);
     if (!latest) {
-      console.error(chalk17.red("  No spec files found in specs/. Run `ai-spec create` first or use --spec <path>."));
+      console.error(chalk19.red("  No spec files found in specs/. Run `ai-spec create` first or use --spec <path>."));
       process.exit(1);
     }
     specPath = latest.filePath;
-    console.log(chalk17.gray(`  Using spec: ${path21.relative(currentDir, specPath)} (v${latest.version})`));
+    console.log(chalk19.gray(`  Using spec: ${path23.relative(currentDir, specPath)} (v${latest.version})`));
   }
-  console.log(chalk17.gray("  Loading project context..."));
+  console.log(chalk19.gray("  Loading project context..."));
   const loader = new ContextLoader(currentDir);
   const context = await loader.loadProjectContext();
   if (context.constitution && context.constitution.length > 6e3) {
-    console.log(chalk17.yellow(`  \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
+    console.log(chalk19.yellow(`  \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
   }
   const { detectRepoType: _detectRepoType } = await Promise.resolve().then(() => (init_workspace_loader(), workspace_loader_exports));
   const { type: repoType } = await _detectRepoType(currentDir);
@@ -10819,19 +11176,19 @@ program.command("update").description("Update an existing spec with a change req
       repoType
     });
   } catch (err) {
-    console.error(chalk17.red(`  Update failed: ${err.message}`));
+    console.error(chalk19.red(`  Update failed: ${err.message}`));
     process.exit(1);
   }
-  console.log(chalk17.green(`
-  \u2714 Spec updated \u2192 v${result.newVersion}: ${path21.relative(currentDir, result.newSpecPath)}`));
+  console.log(chalk19.green(`
+  \u2714 Spec updated \u2192 v${result.newVersion}: ${path23.relative(currentDir, result.newSpecPath)}`));
   if (result.newDslPath) {
-    console.log(chalk17.green(`  \u2714 DSL updated: ${path21.relative(currentDir, result.newDslPath)}`));
+    console.log(chalk19.green(`  \u2714 DSL updated: ${path23.relative(currentDir, result.newDslPath)}`));
   }
   if (result.affectedFiles.length > 0) {
-    console.log(chalk17.cyan("\n  Affected files:"));
+    console.log(chalk19.cyan("\n  Affected files:"));
     for (const f of result.affectedFiles) {
-      const icon = f.action === "create" ? chalk17.green("+") : chalk17.yellow("~");
-      console.log(`    ${icon} ${f.file}: ${chalk17.gray(f.description)}`);
+      const icon = f.action === "create" ? chalk19.green("+") : chalk19.yellow("~");
+      console.log(`    ${icon} ${f.file}: ${chalk19.gray(f.description)}`);
     }
   }
   if (opts.codegen && result.affectedFiles.length > 0) {
@@ -10839,9 +11196,9 @@ program.command("update").description("Update an existing spec with a change req
     const codegenModelName = opts.codegenModel || config2.codegenModel || DEFAULT_MODELS[codegenProviderName];
     const codegenApiKey = opts.codegenKey ?? (codegenProviderName === providerName ? apiKey : await resolveApiKey(codegenProviderName, opts.codegenKey));
     const codegenProvider = createProvider(codegenProviderName, codegenApiKey, codegenModelName);
-    console.log(chalk17.blue("\n  Regenerating affected files..."));
+    console.log(chalk19.blue("\n  Regenerating affected files..."));
     const codeGenerator = new CodeGenerator(codegenProvider, "api");
-    const specContent = await fs22.readFile(result.newSpecPath, "utf-8");
+    const specContent = await fs24.readFile(result.newSpecPath, "utf-8");
     const constitutionSection = context.constitution ? `
 === Project Constitution (MUST follow) ===
 ${context.constitution}
@@ -10851,10 +11208,10 @@ ${context.constitution}
 ${JSON.stringify(result.updatedDsl, null, 2).slice(0, 3e3)}
 ` : "";
     for (const affected of result.affectedFiles) {
-      const fullPath = path21.join(currentDir, affected.file);
+      const fullPath = path23.join(currentDir, affected.file);
       let existing = "";
       try {
-        existing = await fs22.readFile(fullPath, "utf-8");
+        existing = await fs24.readFile(fullPath, "utf-8");
       } catch {
       }
       const codePrompt = `Apply this change to the file.
@@ -10868,24 +11225,24 @@ ${specContent}
 ${constitutionSection}${dslSection}
 === ${existing ? "Current File (return the FULL updated content)" : "New File"} ===
 ${existing || "Create from scratch."}`;
-      process.stdout.write(`  ${existing ? chalk17.yellow("~") : chalk17.green("+")} ${affected.file}... `);
+      process.stdout.write(`  ${existing ? chalk19.yellow("~") : chalk19.green("+")} ${affected.file}... `);
       try {
         const { getCodeGenSystemPrompt: _getPrompt } = await Promise.resolve().then(() => (init_codegen_prompt(), codegen_prompt_exports));
         const raw = await codegenProvider.generate(codePrompt, _getPrompt(repoType));
         const content = raw.replace(/^```\w*\n?/gm, "").replace(/\n?```$/gm, "").trim();
-        await fs22.ensureDir(path21.dirname(fullPath));
-        await fs22.writeFile(fullPath, content, "utf-8");
-        console.log(chalk17.green("\u2714"));
+        await fs24.ensureDir(path23.dirname(fullPath));
+        await fs24.writeFile(fullPath, content, "utf-8");
+        console.log(chalk19.green("\u2714"));
       } catch (err) {
-        console.log(chalk17.red(`\u2718 ${err.message}`));
+        console.log(chalk19.red(`\u2718 ${err.message}`));
       }
     }
   }
   if (!opts.codegen && result.affectedFiles.length > 0) {
-    console.log(chalk17.blue("\n  Next steps:"));
-    console.log(chalk17.gray(`  \u2022 Re-run with --codegen to regenerate affected files automatically`));
-    console.log(chalk17.gray(`  \u2022 Or update files manually based on the affected files list above`));
-    console.log(chalk17.gray(`  \u2022 Run \`ai-spec mock\` to refresh the mock server with the new DSL`));
+    console.log(chalk19.blue("\n  Next steps:"));
+    console.log(chalk19.gray(`  \u2022 Re-run with --codegen to regenerate affected files automatically`));
+    console.log(chalk19.gray(`  \u2022 Or update files manually based on the affected files list above`));
+    console.log(chalk19.gray(`  \u2022 Run \`ai-spec mock\` to refresh the mock server with the new DSL`));
   }
 });
 program.command("export").description("Export the latest DSL to OpenAPI 3.1.0 (YAML or JSON)").option("--openapi", "Export as OpenAPI 3.1.0 (default behaviour)").option("--format <fmt>", "Output format: yaml | json (default: yaml)", "yaml").option("--output <path>", "Output file path (default: openapi.yaml)").option("--server <url>", "API server URL in the OpenAPI document (default: http://localhost:3000)").option("--dsl <path>", "Path to a specific .dsl.json file (auto-detected if omitted)").action(async (opts) => {
@@ -10894,19 +11251,19 @@ program.command("export").description("Export the latest DSL to OpenAPI 3.1.0 (Y
   if (!dslPath) {
     dslPath = await findLatestDslFile(currentDir);
     if (!dslPath) {
-      console.error(chalk17.red("  No .dsl.json file found. Run `ai-spec create` first or use --dsl <path>."));
+      console.error(chalk19.red("  No .dsl.json file found. Run `ai-spec create` first or use --dsl <path>."));
       process.exit(1);
     }
-    console.log(chalk17.gray(`  Using DSL: ${path21.relative(currentDir, dslPath)}`));
+    console.log(chalk19.gray(`  Using DSL: ${path23.relative(currentDir, dslPath)}`));
   }
   let dsl;
   try {
-    dsl = await fs22.readJson(dslPath);
+    dsl = await fs24.readJson(dslPath);
   } catch (err) {
-    console.error(chalk17.red(`  Failed to read DSL: ${err.message}`));
+    console.error(chalk19.red(`  Failed to read DSL: ${err.message}`));
     process.exit(1);
   }
-  console.log(chalk17.blue("\n\u2500\u2500\u2500 ai-spec export \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(chalk19.blue("\n\u2500\u2500\u2500 ai-spec export \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"));
   const format = opts.format === "json" ? "json" : "yaml";
   const serverUrl = opts.server || "http://localhost:3000";
   try {
@@ -10915,31 +11272,31 @@ program.command("export").description("Export the latest DSL to OpenAPI 3.1.0 (Y
       serverUrl,
       outputPath: opts.output
     });
-    const rel = path21.relative(currentDir, outputPath);
-    console.log(chalk17.green(`  \u2714 OpenAPI ${format.toUpperCase()} exported: ${rel}`));
-    console.log(chalk17.gray(`  Feature  : ${dsl.feature.title}`));
-    console.log(chalk17.gray(`  Endpoints: ${dsl.endpoints.length}`));
-    console.log(chalk17.gray(`  Models   : ${dsl.models.length}`));
-    console.log(chalk17.gray(`  Server   : ${serverUrl}`));
-    console.log(chalk17.blue("\n  Next steps:"));
-    console.log(chalk17.gray(`  \u2022 Import ${rel} into Postman / Insomnia / Swagger UI`));
-    console.log(chalk17.gray(`  \u2022 Use openapi-generator to generate client SDKs`));
+    const rel = path23.relative(currentDir, outputPath);
+    console.log(chalk19.green(`  \u2714 OpenAPI ${format.toUpperCase()} exported: ${rel}`));
+    console.log(chalk19.gray(`  Feature  : ${dsl.feature.title}`));
+    console.log(chalk19.gray(`  Endpoints: ${dsl.endpoints.length}`));
+    console.log(chalk19.gray(`  Models   : ${dsl.models.length}`));
+    console.log(chalk19.gray(`  Server   : ${serverUrl}`));
+    console.log(chalk19.blue("\n  Next steps:"));
+    console.log(chalk19.gray(`  \u2022 Import ${rel} into Postman / Insomnia / Swagger UI`));
+    console.log(chalk19.gray(`  \u2022 Use openapi-generator to generate client SDKs`));
   } catch (err) {
-    console.error(chalk17.red(`  Export failed: ${err.message}`));
+    console.error(chalk19.red(`  Export failed: ${err.message}`));
     process.exit(1);
   }
 });
 program.command("mock").description("Generate a standalone mock server + proxy config from the latest DSL").option("--port <n>", "Mock server port (default: 3001)", "3001").option("--msw", "Also generate MSW (Mock Service Worker) handlers at src/mocks/").option("--proxy", "Also generate frontend proxy config snippet").option("--dsl <path>", "Path to a specific .dsl.json file (auto-detected if omitted)").option("--workspace", "Generate mock assets for all backend repos in the workspace").option("--serve", "Start mock server in background + patch frontend proxy (use with --frontend)").option("--frontend <path>", "Path to frontend project for proxy patching (used with --serve/--restore)").option("--restore", "Undo proxy changes and stop mock server (requires --frontend or auto-detects)").action(async (opts) => {
   const currentDir = process.cwd();
   const port = parseInt(opts.port, 10) || 3001;
-  console.log(chalk17.blue("\n\u2500\u2500\u2500 ai-spec mock \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(chalk19.blue("\n\u2500\u2500\u2500 ai-spec mock \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"));
   if (opts.restore) {
-    const frontendDir = opts.frontend ? path21.resolve(opts.frontend) : currentDir;
+    const frontendDir = opts.frontend ? path23.resolve(opts.frontend) : currentDir;
     const r = await restoreMockProxy(frontendDir);
     if (r.restored) {
-      console.log(chalk17.green("  \u2714 Proxy restored and mock server stopped."));
+      console.log(chalk19.green("  \u2714 Proxy restored and mock server stopped."));
     } else {
-      console.log(chalk17.yellow(`  ${r.note ?? "Nothing to restore."}`));
+      console.log(chalk19.yellow(`  ${r.note ?? "Nothing to restore."}`));
     }
     return;
   }
@@ -10947,32 +11304,32 @@ program.command("mock").description("Generate a standalone mock server + proxy c
     const workspaceLoader = new WorkspaceLoader(currentDir);
     const workspaceConfig = await workspaceLoader.load();
     if (!workspaceConfig) {
-      console.error(chalk17.red(`  No ${WORKSPACE_CONFIG_FILE} found. Run \`ai-spec workspace init\` first.`));
+      console.error(chalk19.red(`  No ${WORKSPACE_CONFIG_FILE} found. Run \`ai-spec workspace init\` first.`));
       process.exit(1);
     }
     const backendRepos = workspaceConfig.repos.filter((r) => r.role === "backend");
     if (backendRepos.length === 0) {
-      console.log(chalk17.yellow("  No backend repos found in workspace."));
+      console.log(chalk19.yellow("  No backend repos found in workspace."));
       return;
     }
     for (const repo of backendRepos) {
       const repoAbsPath = workspaceLoader.resolveAbsPath(repo);
-      console.log(chalk17.cyan(`
+      console.log(chalk19.cyan(`
   Repo: ${repo.name} (${repoAbsPath})`));
       const dslFile = await findLatestDslFile(repoAbsPath);
       if (!dslFile) {
-        console.log(chalk17.yellow(`    No DSL file found \u2014 skipping.`));
+        console.log(chalk19.yellow(`    No DSL file found \u2014 skipping.`));
         continue;
       }
-      const dsl2 = await fs22.readJson(dslFile);
+      const dsl2 = await fs24.readJson(dslFile);
       const result2 = await generateMockAssets(dsl2, repoAbsPath, {
         port,
         msw: opts.msw,
         proxy: opts.proxy
       });
       for (const f of result2.files) {
-        console.log(chalk17.green(`    \u2714 ${f.path}`));
-        console.log(chalk17.gray(`      ${f.description}`));
+        console.log(chalk19.green(`    \u2714 ${f.path}`));
+        console.log(chalk19.gray(`      ${f.description}`));
       }
     }
     return;
@@ -10982,19 +11339,19 @@ program.command("mock").description("Generate a standalone mock server + proxy c
     dslPath = await findLatestDslFile(currentDir);
     if (!dslPath) {
       console.error(
-        chalk17.red(
+        chalk19.red(
           "  No .dsl.json file found in .ai-spec/. Run `ai-spec create` first or use --dsl <path>."
         )
       );
       process.exit(1);
     }
-    console.log(chalk17.gray(`  Using DSL: ${path21.relative(currentDir, dslPath)}`));
+    console.log(chalk19.gray(`  Using DSL: ${path23.relative(currentDir, dslPath)}`));
   }
   let dsl;
   try {
-    dsl = await fs22.readJson(dslPath);
+    dsl = await fs24.readJson(dslPath);
   } catch (err) {
-    console.error(chalk17.red(`  Failed to read DSL file: ${err.message}`));
+    console.error(chalk19.red(`  Failed to read DSL file: ${err.message}`));
     process.exit(1);
   }
   const result = await generateMockAssets(dsl, currentDir, {
@@ -11002,58 +11359,58 @@ program.command("mock").description("Generate a standalone mock server + proxy c
     msw: opts.msw,
     proxy: opts.proxy
   });
-  console.log(chalk17.green(`
+  console.log(chalk19.green(`
   \u2714 Mock assets generated (${result.files.length} file(s)):`));
   for (const f of result.files) {
-    console.log(chalk17.green(`    ${f.path}`));
-    console.log(chalk17.gray(`      ${f.description}`));
+    console.log(chalk19.green(`    ${f.path}`));
+    console.log(chalk19.gray(`      ${f.description}`));
   }
   if (opts.serve) {
-    const serverJsPath = path21.join(currentDir, "mock", "server.js");
-    if (!await fs22.pathExists(serverJsPath)) {
-      console.error(chalk17.red("  mock/server.js not found \u2014 generation may have failed."));
+    const serverJsPath = path23.join(currentDir, "mock", "server.js");
+    if (!await fs24.pathExists(serverJsPath)) {
+      console.error(chalk19.red("  mock/server.js not found \u2014 generation may have failed."));
       process.exit(1);
     }
     const pid = startMockServerBackground(serverJsPath, port);
-    console.log(chalk17.green(`
+    console.log(chalk19.green(`
   \u2714 Mock server started (PID ${pid}) \u2192 http://localhost:${port}`));
     if (opts.frontend) {
-      const frontendDir = path21.resolve(opts.frontend);
+      const frontendDir = path23.resolve(opts.frontend);
       const proxyResult = await applyMockProxy(frontendDir, port, dsl.endpoints);
       await saveMockServerPid(frontendDir, pid);
       if (proxyResult.applied) {
-        console.log(chalk17.green(`  \u2714 Frontend proxy patched (${proxyResult.framework})`));
-        console.log(chalk17.bold.cyan(`
+        console.log(chalk19.green(`  \u2714 Frontend proxy patched (${proxyResult.framework})`));
+        console.log(chalk19.bold.cyan(`
   Ready! Open a new terminal and run:`));
-        console.log(chalk17.white(`    cd ${frontendDir}`));
-        console.log(chalk17.white(`    ${proxyResult.devCommand}`));
-        console.log(chalk17.gray(`
+        console.log(chalk19.white(`    cd ${frontendDir}`));
+        console.log(chalk19.white(`    ${proxyResult.devCommand}`));
+        console.log(chalk19.gray(`
   When done: ai-spec mock --restore --frontend ${frontendDir}`));
       } else {
-        console.log(chalk17.yellow(`  \u26A0 Auto-patch not available for ${proxyResult.framework}.`));
-        if (proxyResult.note) console.log(chalk17.gray(`    ${proxyResult.note}`));
+        console.log(chalk19.yellow(`  \u26A0 Auto-patch not available for ${proxyResult.framework}.`));
+        if (proxyResult.note) console.log(chalk19.gray(`    ${proxyResult.note}`));
       }
     } else {
-      console.log(chalk17.gray(`  Tip: use --frontend <path> to also auto-patch your frontend proxy config.`));
-      console.log(chalk17.gray(`  Mock server: http://localhost:${port}`));
+      console.log(chalk19.gray(`  Tip: use --frontend <path> to also auto-patch your frontend proxy config.`));
+      console.log(chalk19.gray(`  Mock server: http://localhost:${port}`));
     }
     return;
   }
-  console.log(chalk17.blue("\n\u2500\u2500\u2500 Quick start \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"));
-  console.log(chalk17.white(`  1. Install express (if not already):`));
-  console.log(chalk17.gray(`       npm install --save-dev express`));
-  console.log(chalk17.white(`  2. Start mock server:`));
-  console.log(chalk17.gray(`       node mock/server.js`));
-  console.log(chalk17.gray(`       # or: ai-spec mock --serve --frontend <path-to-frontend>`));
-  console.log(chalk17.white(`  3. Configure your frontend to proxy API calls to:`));
-  console.log(chalk17.gray(`       http://localhost:${port}`));
+  console.log(chalk19.blue("\n\u2500\u2500\u2500 Quick start \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"));
+  console.log(chalk19.white(`  1. Install express (if not already):`));
+  console.log(chalk19.gray(`       npm install --save-dev express`));
+  console.log(chalk19.white(`  2. Start mock server:`));
+  console.log(chalk19.gray(`       node mock/server.js`));
+  console.log(chalk19.gray(`       # or: ai-spec mock --serve --frontend <path-to-frontend>`));
+  console.log(chalk19.white(`  3. Configure your frontend to proxy API calls to:`));
+  console.log(chalk19.gray(`       http://localhost:${port}`));
   if (opts.proxy) {
-    console.log(chalk17.gray(`     (See the generated proxy config file for framework-specific instructions)`));
+    console.log(chalk19.gray(`     (See the generated proxy config file for framework-specific instructions)`));
   }
   if (opts.msw) {
-    console.log(chalk17.white(`  4. MSW: import and start the worker in your app entry:`));
-    console.log(chalk17.gray(`       import { worker } from './mocks/browser';`));
-    console.log(chalk17.gray(`       if (process.env.NODE_ENV === 'development') worker.start();`));
+    console.log(chalk19.white(`  4. MSW: import and start the worker in your app entry:`));
+    console.log(chalk19.gray(`       import { worker } from './mocks/browser';`));
+    console.log(chalk19.gray(`       if (process.env.NODE_ENV === 'development') worker.start();`));
   }
 });
 program.command("learn").description("Append a lesson or engineering decision directly to constitution \xA79").argument("[lesson]", "The lesson or decision to record (prompted if omitted)").action(async (lesson) => {
@@ -11069,14 +11426,27 @@ program.command("learn").description("Append a lesson or engineering decision di
   }
   const result = await appendDirectLesson(currentDir, lesson.trim());
   if (result.appended) {
-    console.log(chalk17.green(`
+    console.log(chalk19.green(`
   \u2714 Lesson appended to constitution \xA79`));
-    console.log(chalk17.gray(`  File: .ai-spec-constitution.md`));
+    console.log(chalk19.gray(`  File: .ai-spec-constitution.md`));
   } else {
-    console.log(chalk17.yellow(`
+    console.log(chalk19.yellow(`
   \u26A0 Not appended: ${result.reason}`));
   }
 });
+program.command("restore").description("Restore files modified by a previous run").argument("<runId>", "Run ID shown at the end of a create / generate run").action(async (runId) => {
+  const currentDir = process.cwd();
+  const snapshot = new RunSnapshot(currentDir, runId);
+  console.log(chalk19.blue(`Restoring run: ${runId}...`));
+  const restored = await snapshot.restore();
+  if (restored.length === 0) {
+    console.log(chalk19.yellow("  No backup found for this run ID."));
+  } else {
+    restored.forEach((f) => console.log(chalk19.green(`  \u2714 restored: ${f}`)));
+    console.log(chalk19.bold.green(`
+\u2714 ${restored.length} file(s) restored.`));
+  }
+});
 if (process.argv.length <= 2) {
   (async () => {
     const currentDir = process.cwd();