ai-spec-dev 0.30.0 → 0.30.1

package/dist/cli/index.mjs

@@ -402,8 +402,8 @@ var init_workspace_loader = __esm({
         const repos = [];
         for (const entry of entries) {
           const absPath = path17.join(this.workspaceRoot, entry);
-          const stat4 = await fs18.stat(absPath).catch(() => null);
-          if (!stat4 || !stat4.isDirectory()) continue;
+          const stat3 = await fs18.stat(absPath).catch(() => null);
+          if (!stat3 || !stat3.isDirectory()) continue;
           if (entry.startsWith(".") || entry === "node_modules") continue;
           if (names && !names.includes(entry)) continue;
           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"));
@@ -467,9 +467,9 @@ var init_workspace_loader = __esm({
 
 // cli/index.ts
 import { Command } from "commander";
-import * as path23 from "path";
-import * as fs24 from "fs-extra";
-import chalk19 from "chalk";
+import * as path22 from "path";
+import * as fs23 from "fs-extra";
+import chalk18 from "chalk";
 import * as dotenv from "dotenv";
 import { input, confirm as confirm2, select as select3 } from "@inquirer/prompts";
 
@@ -4849,221 +4849,221 @@ function validateDsl(raw) {
   }
   return { valid: true, dsl: raw };
 }
-function validateFeature(raw, path24, errors) {
+function validateFeature(raw, path23, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path23, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const f = raw;
-  requireNonEmptyString(f["id"], `${path24}.id`, errors);
-  requireNonEmptyString(f["title"], `${path24}.title`, errors);
-  requireNonEmptyString(f["description"], `${path24}.description`, errors);
+  requireNonEmptyString(f["id"], `${path23}.id`, errors);
+  requireNonEmptyString(f["title"], `${path23}.title`, errors);
+  requireNonEmptyString(f["description"], `${path23}.description`, errors);
 }
-function validateModel(raw, path24, errors) {
+function validateModel(raw, path23, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path23, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const m = raw;
-  requireNonEmptyString(m["name"], `${path24}.name`, errors);
+  requireNonEmptyString(m["name"], `${path23}.name`, errors);
   if (!Array.isArray(m["fields"])) {
-    errors.push({ path: `${path24}.fields`, message: `Must be an array, got: ${typeLabel(m["fields"])}` });
+    errors.push({ path: `${path23}.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: `${path24}.fields`, message: `Too many fields (${fields.length} > ${MAX_FIELDS_PER_MODEL})` });
+      errors.push({ path: `${path23}.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], `${path24}.fields[${j2}]`, errors);
+      validateModelField(fields[j2], `${path23}.fields[${j2}]`, errors);
     }
   }
   if (m["relations"] !== void 0) {
     if (!Array.isArray(m["relations"])) {
-      errors.push({ path: `${path24}.relations`, message: "Must be an array of strings if present" });
+      errors.push({ path: `${path23}.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: `${path24}.relations[${j2}]`, message: "Must be a string" });
+          errors.push({ path: `${path23}.relations[${j2}]`, message: "Must be a string" });
         }
       }
     }
   }
 }
-function validateModelField(raw, path24, errors) {
+function validateModelField(raw, path23, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path23, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const f = raw;
-  requireNonEmptyString(f["name"], `${path24}.name`, errors);
-  requireNonEmptyString(f["type"], `${path24}.type`, errors);
+  requireNonEmptyString(f["name"], `${path23}.name`, errors);
+  requireNonEmptyString(f["type"], `${path23}.type`, errors);
   if (typeof f["required"] !== "boolean") {
-    errors.push({ path: `${path24}.required`, message: `Must be boolean, got: ${typeLabel(f["required"])}` });
+    errors.push({ path: `${path23}.required`, message: `Must be boolean, got: ${typeLabel(f["required"])}` });
   }
 }
-function validateEndpoint(raw, path24, errors) {
+function validateEndpoint(raw, path23, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path23, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const e = raw;
-  requireNonEmptyString(e["id"], `${path24}.id`, errors);
-  requireNonEmptyString(e["description"], `${path24}.description`, errors);
+  requireNonEmptyString(e["id"], `${path23}.id`, errors);
+  requireNonEmptyString(e["description"], `${path23}.description`, errors);
   if (!VALID_METHODS.includes(e["method"])) {
     errors.push({
-      path: `${path24}.method`,
+      path: `${path23}.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: `${path24}.path`,
+      path: `${path23}.path`,
       message: `Must be a string starting with "/", got: ${JSON.stringify(e["path"])}`
     });
   }
   if (typeof e["auth"] !== "boolean") {
-    errors.push({ path: `${path24}.auth`, message: `Must be boolean, got: ${typeLabel(e["auth"])}` });
+    errors.push({ path: `${path23}.auth`, message: `Must be boolean, got: ${typeLabel(e["auth"])}` });
   }
   if (typeof e["successStatus"] !== "number" || e["successStatus"] < 100 || e["successStatus"] > 599) {
     errors.push({
-      path: `${path24}.successStatus`,
+      path: `${path23}.successStatus`,
       message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["successStatus"])}`
     });
   }
-  requireNonEmptyString(e["successDescription"], `${path24}.successDescription`, errors);
+  requireNonEmptyString(e["successDescription"], `${path23}.successDescription`, errors);
   if (e["request"] !== void 0) {
-    validateRequestSchema(e["request"], `${path24}.request`, errors);
+    validateRequestSchema(e["request"], `${path23}.request`, errors);
   }
   if (e["errors"] !== void 0) {
     if (!Array.isArray(e["errors"])) {
-      errors.push({ path: `${path24}.errors`, message: "Must be an array if present" });
+      errors.push({ path: `${path23}.errors`, message: "Must be an array if present" });
     } else {
       const errs = e["errors"];
       if (errs.length > MAX_ERRORS_PER_ENDPOINT) {
-        errors.push({ path: `${path24}.errors`, message: `Too many error entries (${errs.length} > ${MAX_ERRORS_PER_ENDPOINT})` });
+        errors.push({ path: `${path23}.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], `${path24}.errors[${j2}]`, errors);
+        validateResponseError(errs[j2], `${path23}.errors[${j2}]`, errors);
       }
     }
   }
 }
-function validateRequestSchema(raw, path24, errors) {
+function validateRequestSchema(raw, path23, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path23, 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], `${path24}.${key}`, errors);
+      validateFieldMap(r[key], `${path23}.${key}`, errors);
     }
   }
 }
-function validateFieldMap(raw, path24, errors) {
+function validateFieldMap(raw, path23, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path24, message: `Must be a flat object (FieldMap), got: ${typeLabel(raw)}` });
+    errors.push({ path: path23, 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: `${path24}.${k2}`, message: `Value must be a type-description string, got: ${typeLabel(v2)}` });
+      errors.push({ path: `${path23}.${k2}`, message: `Value must be a type-description string, got: ${typeLabel(v2)}` });
     }
   }
 }
-function validateResponseError(raw, path24, errors) {
+function validateResponseError(raw, path23, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path23, 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: `${path24}.status`, message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["status"])}` });
+    errors.push({ path: `${path23}.status`, message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["status"])}` });
   }
-  requireNonEmptyString(e["code"], `${path24}.code`, errors);
-  requireNonEmptyString(e["description"], `${path24}.description`, errors);
+  requireNonEmptyString(e["code"], `${path23}.code`, errors);
+  requireNonEmptyString(e["description"], `${path23}.description`, errors);
 }
-function validateBehavior(raw, path24, errors) {
+function validateBehavior(raw, path23, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path23, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const b = raw;
-  requireNonEmptyString(b["id"], `${path24}.id`, errors);
-  requireNonEmptyString(b["description"], `${path24}.description`, errors);
+  requireNonEmptyString(b["id"], `${path23}.id`, errors);
+  requireNonEmptyString(b["description"], `${path23}.description`, errors);
   if (b["constraints"] !== void 0) {
     if (!Array.isArray(b["constraints"])) {
-      errors.push({ path: `${path24}.constraints`, message: "Must be an array of strings if present" });
+      errors.push({ path: `${path23}.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: `${path24}.constraints[${j2}]`, message: "Must be a string" });
+          errors.push({ path: `${path23}.constraints[${j2}]`, message: "Must be a string" });
         }
       }
     }
   }
 }
-function validateComponent(raw, path24, errors) {
+function validateComponent(raw, path23, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path24, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path23, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const c = raw;
-  requireNonEmptyString(c["id"], `${path24}.id`, errors);
-  requireNonEmptyString(c["name"], `${path24}.name`, errors);
-  requireNonEmptyString(c["description"], `${path24}.description`, errors);
+  requireNonEmptyString(c["id"], `${path23}.id`, errors);
+  requireNonEmptyString(c["name"], `${path23}.name`, errors);
+  requireNonEmptyString(c["description"], `${path23}.description`, errors);
   if (c["props"] !== void 0) {
     if (!Array.isArray(c["props"])) {
-      errors.push({ path: `${path24}.props`, message: "Must be an array if present" });
+      errors.push({ path: `${path23}.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: `${path24}.props[${j2}]`, message: "Must be an object" });
+          errors.push({ path: `${path23}.props[${j2}]`, message: "Must be an object" });
           continue;
         }
-        requireNonEmptyString(p["name"], `${path24}.props[${j2}].name`, errors);
-        requireNonEmptyString(p["type"], `${path24}.props[${j2}].type`, errors);
+        requireNonEmptyString(p["name"], `${path23}.props[${j2}].name`, errors);
+        requireNonEmptyString(p["type"], `${path23}.props[${j2}].type`, errors);
         if (typeof p["required"] !== "boolean") {
-          errors.push({ path: `${path24}.props[${j2}].required`, message: "Must be boolean" });
+          errors.push({ path: `${path23}.props[${j2}].required`, message: "Must be boolean" });
         }
       }
     }
   }
   if (c["events"] !== void 0) {
     if (!Array.isArray(c["events"])) {
-      errors.push({ path: `${path24}.events`, message: "Must be an array if present" });
+      errors.push({ path: `${path23}.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: `${path24}.events[${j2}]`, message: "Must be an object" });
+          errors.push({ path: `${path23}.events[${j2}]`, message: "Must be an object" });
           continue;
         }
-        requireNonEmptyString(e["name"], `${path24}.events[${j2}].name`, errors);
+        requireNonEmptyString(e["name"], `${path23}.events[${j2}].name`, errors);
       }
     }
   }
   if (c["state"] !== void 0) {
     if (typeof c["state"] !== "object" || Array.isArray(c["state"]) || c["state"] === null) {
-      errors.push({ path: `${path24}.state`, message: "Must be a flat object (Record<string, string>) if present" });
+      errors.push({ path: `${path23}.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: `${path24}.apiCalls`, message: "Must be an array of strings if present" });
+      errors.push({ path: `${path23}.apiCalls`, message: "Must be an array of strings if present" });
     }
   }
 }
-function requireNonEmptyString(v2, path24, errors) {
+function requireNonEmptyString(v2, path23, errors) {
   if (typeof v2 !== "string" || v2.trim().length === 0) {
     errors.push({
-      path: path24,
+      path: path23,
       message: `Must be a non-empty string, got: ${typeLabel(v2)}`
     });
   }
@@ -8318,108 +8318,6 @@ async function clearKey(provider) {
   await writeStore(store);
 }
 
-// cli/welcome.ts
-import chalk17 from "chalk";
-import * as os4 from "os";
-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 = chalk17.hex("#E8885A");
-var ROBOT = [
-  ROBOT_COLOR("      \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"),
-  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")
-];
-function visLen(s) {
-  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
-}
-function padR(s, width) {
-  const vl = visLen(s);
-  return vl >= width ? s : s + " ".repeat(width - vl);
-}
-function row(left, right) {
-  return padR(left, L_WIDTH) + " " + chalk17.gray("\u2502") + " " + padR(right, R_WIDTH);
-}
-function center(s, width) {
-  const vl = visLen(s);
-  const pad = Math.max(0, Math.floor((width - vl) / 2));
-  return " ".repeat(pad) + s;
-}
-async function getRecentSpecs(dir) {
-  const specsDir = path19.join(dir, "specs");
-  if (!await fs20.pathExists(specsDir)) return [];
-  try {
-    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 fs20.stat(path19.join(specsDir, f));
-        return { name: f, mtime: stat4.mtime.getTime() };
-      })
-    );
-    withStats.sort((a, b) => b.mtime - a.mtime);
-    return withStats.slice(0, 3).map(({ name, mtime }) => {
-      const ms2 = Date.now() - mtime;
-      const hours = Math.floor(ms2 / 36e5);
-      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 chalk17.white(slug) + chalk17.dim("  " + age);
-    });
-  } catch {
-    return [];
-  }
-}
-async function printWelcome(currentDir, config2) {
-  const username = os4.userInfo().username;
-  const homeDir = os4.homedir();
-  const shortDir = currentDir.startsWith(homeDir) ? "~" + currentDir.slice(homeDir.length) : currentDir;
-  const recentSpecs = await getRecentSpecs(currentDir);
-  const providerBit = config2?.provider ? config2.provider + (config2.model ? " \xB7 " + config2.model : "") : "";
-  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 = "  " + chalk17.dim(bottomTruncated);
-  const titleInner = `ai-spec v${VERSION} `;
-  const titleDashes = "\u2500".repeat(Math.max(0, TOTAL_W - titleInner.length - 4));
-  console.log(
-    "\n" + chalk17.hex("#FF6B35")("\u2500\u2500\u2500 " + titleInner + titleDashes)
-  );
-  const welcomeText = "Welcome back, " + chalk17.bold.white(username) + "!";
-  const leftLines = [
-    "",
-    center(welcomeText, L_WIDTH),
-    "",
-    ...ROBOT,
-    "",
-    bottomLine,
-    ""
-  ];
-  const rightLines = [
-    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"'),
-    "",
-    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(chalk17.gray("\u2500".repeat(TOTAL_W)));
-  console.log();
-}
-
 // prompts/global-constitution.prompt.ts
 var globalConstitutionSystemPrompt = `You are a Senior Software Architect. Analyze the provided multi-project context and generate a "Global Constitution" \u2014 a team-level baseline document that captures cross-project rules, shared conventions, and universal constraints that every repository in this workspace must follow.
 
@@ -8929,8 +8827,8 @@ Existing API/service files:`);
 }
 
 // core/mock-server-generator.ts
-import * as path20 from "path";
-import * as fs21 from "fs-extra";
+import * as path19 from "path";
+import * as fs20 from "fs-extra";
 import { spawn } from "child_process";
 function typeToFixture(fieldName, typeDesc) {
   const t = typeDesc.toLowerCase();
@@ -9066,22 +8964,22 @@ function generateMockServerJs(dsl, port) {
 }
 function detectFrontendFramework(projectDir) {
   for (const f of ["vite.config.ts", "vite.config.js", "vite.config.mts"]) {
-    if (fs21.existsSync(path20.join(projectDir, f))) return "vite";
+    if (fs20.existsSync(path19.join(projectDir, f))) return "vite";
   }
   for (const f of ["next.config.js", "next.config.ts", "next.config.mjs"]) {
-    if (fs21.existsSync(path20.join(projectDir, f))) return "next";
+    if (fs20.existsSync(path19.join(projectDir, f))) return "next";
   }
-  const pkgPath = path20.join(projectDir, "package.json");
-  if (fs21.existsSync(pkgPath)) {
+  const pkgPath = path19.join(projectDir, "package.json");
+  if (fs20.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs20.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 (fs21.existsSync(path20.join(projectDir, f))) return "webpack";
+    if (fs20.existsSync(path19.join(projectDir, f))) return "webpack";
   }
   return "unknown";
 }
@@ -9261,7 +9159,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 (fs21.existsSync(path20.join(projectDir, f))) return f;
+    if (fs20.existsSync(path19.join(projectDir, f))) return f;
   }
   return null;
 }
@@ -9307,73 +9205,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 = path20.join(frontendDir, "vite.config.ai-spec-mock.ts");
-    await fs21.writeFile(mockConfigPath, mockConfigContent, "utf-8");
+    const mockConfigPath = path19.join(frontendDir, "vite.config.ai-spec-mock.ts");
+    await fs20.writeFile(mockConfigPath, mockConfigContent, "utf-8");
     actions.push({ type: "wrote-file", filePath: "vite.config.ai-spec-mock.ts" });
-    const pkgPath = path20.join(frontendDir, "package.json");
-    if (await fs21.pathExists(pkgPath)) {
-      const pkg = await fs21.readJson(pkgPath);
+    const pkgPath = path19.join(frontendDir, "package.json");
+    if (await fs20.pathExists(pkgPath)) {
+      const pkg = await fs20.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 fs21.writeJson(pkgPath, pkg, { spaces: 2 });
+      await fs20.writeJson(pkgPath, pkg, { spaces: 2 });
       actions.push({ type: "added-pkg-script", key: "dev:mock", originalValue });
     }
     const lock2 = { framework, mockPort, frontendDir, actions };
-    await fs21.writeJson(path20.join(frontendDir, MOCK_LOCK_FILE), lock2, { spaces: 2 });
+    await fs20.writeJson(path19.join(frontendDir, MOCK_LOCK_FILE), lock2, { spaces: 2 });
     return { framework, applied: true, devCommand: "npm run dev:mock" };
   }
   if (framework === "cra") {
-    const pkgPath = path20.join(frontendDir, "package.json");
-    if (await fs21.pathExists(pkgPath)) {
-      const pkg = await fs21.readJson(pkgPath);
+    const pkgPath = path19.join(frontendDir, "package.json");
+    if (await fs20.pathExists(pkgPath)) {
+      const pkg = await fs20.readJson(pkgPath);
       const originalProxy = pkg.proxy ?? null;
       pkg.proxy = `http://localhost:${mockPort}`;
-      await fs21.writeJson(pkgPath, pkg, { spaces: 2 });
+      await fs20.writeJson(pkgPath, pkg, { spaces: 2 });
       actions.push({ type: "patched-pkg-proxy", originalProxy });
       const lock2 = { framework, mockPort, frontendDir, actions };
-      await fs21.writeJson(path20.join(frontendDir, MOCK_LOCK_FILE), lock2, { spaces: 2 });
+      await fs20.writeJson(path19.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 fs21.writeJson(path20.join(frontendDir, MOCK_LOCK_FILE), lock, { spaces: 2 });
+  await fs20.writeJson(path19.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 = path20.join(frontendDir, MOCK_LOCK_FILE);
-  if (!await fs21.pathExists(lockPath)) {
+  const lockPath = path19.join(frontendDir, MOCK_LOCK_FILE);
+  if (!await fs20.pathExists(lockPath)) {
     return { restored: false, note: "No lock file found \u2014 nothing to restore." };
   }
-  const lock = await fs21.readJson(lockPath);
+  const lock = await fs20.readJson(lockPath);
   for (const action of lock.actions) {
     if (action.type === "wrote-file") {
-      const fp = path20.join(frontendDir, action.filePath);
-      if (await fs21.pathExists(fp)) await fs21.remove(fp);
+      const fp = path19.join(frontendDir, action.filePath);
+      if (await fs20.pathExists(fp)) await fs20.remove(fp);
     } else if (action.type === "added-pkg-script") {
-      const pkgPath = path20.join(frontendDir, "package.json");
-      if (await fs21.pathExists(pkgPath)) {
-        const pkg = await fs21.readJson(pkgPath);
+      const pkgPath = path19.join(frontendDir, "package.json");
+      if (await fs20.pathExists(pkgPath)) {
+        const pkg = await fs20.readJson(pkgPath);
         if (action.originalValue == null) {
           delete pkg.scripts?.[action.key];
         } else {
           pkg.scripts = pkg.scripts ?? {};
           pkg.scripts[action.key] = action.originalValue;
         }
-        await fs21.writeJson(pkgPath, pkg, { spaces: 2 });
+        await fs20.writeJson(pkgPath, pkg, { spaces: 2 });
       }
     } else if (action.type === "patched-pkg-proxy") {
-      const pkgPath = path20.join(frontendDir, "package.json");
-      if (await fs21.pathExists(pkgPath)) {
-        const pkg = await fs21.readJson(pkgPath);
+      const pkgPath = path19.join(frontendDir, "package.json");
+      if (await fs20.pathExists(pkgPath)) {
+        const pkg = await fs20.readJson(pkgPath);
         if (action.originalProxy == null) {
           delete pkg.proxy;
         } else {
           pkg.proxy = action.originalProxy;
         }
-        await fs21.writeJson(pkgPath, pkg, { spaces: 2 });
+        await fs20.writeJson(pkgPath, pkg, { spaces: 2 });
       }
     }
   }
@@ -9383,7 +9281,7 @@ async function restoreMockProxy(frontendDir) {
     } catch {
     }
   }
-  await fs21.remove(lockPath);
+  await fs20.remove(lockPath);
   return { restored: true };
 }
 function startMockServerBackground(serverJsPath, port) {
@@ -9396,23 +9294,23 @@ function startMockServerBackground(serverJsPath, port) {
   return child.pid;
 }
 async function saveMockServerPid(frontendDir, pid) {
-  const lockPath = path20.join(frontendDir, MOCK_LOCK_FILE);
-  if (await fs21.pathExists(lockPath)) {
-    const lock = await fs21.readJson(lockPath);
+  const lockPath = path19.join(frontendDir, MOCK_LOCK_FILE);
+  if (await fs20.pathExists(lockPath)) {
+    const lock = await fs20.readJson(lockPath);
     lock.mockServerPid = pid;
-    await fs21.writeJson(lockPath, lock, { spaces: 2 });
+    await fs20.writeJson(lockPath, lock, { spaces: 2 });
   }
 }
 async function generateMockAssets(dsl, projectDir, opts = {}) {
   const port = opts.port ?? 3001;
-  const outputDir = path20.join(projectDir, opts.outputDir ?? "mock");
+  const outputDir = path19.join(projectDir, opts.outputDir ?? "mock");
   const result = { files: [] };
-  await fs21.ensureDir(outputDir);
+  await fs20.ensureDir(outputDir);
   const serverJs = generateMockServerJs(dsl, port);
-  const serverPath = path20.join(outputDir, "server.js");
-  await fs21.writeFile(serverPath, serverJs, "utf-8");
+  const serverPath = path19.join(outputDir, "server.js");
+  await fs20.writeFile(serverPath, serverJs, "utf-8");
   result.files.push({
-    path: path20.relative(projectDir, serverPath),
+    path: path19.relative(projectDir, serverPath),
     description: `Express mock server \u2014 run with: node mock/server.js`
   });
   const mockReadme = `# Mock Server
@@ -9442,52 +9340,52 @@ ${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 = path20.join(outputDir, "README.md");
-  await fs21.writeFile(readmePath, mockReadme, "utf-8");
+  const readmePath = path19.join(outputDir, "README.md");
+  await fs20.writeFile(readmePath, mockReadme, "utf-8");
   result.files.push({
-    path: path20.relative(projectDir, readmePath),
+    path: path19.relative(projectDir, readmePath),
     description: "Mock server usage guide"
   });
   if (opts.proxy) {
     const { content, filename } = generateProxyConfig(dsl, port, projectDir);
-    const proxyPath = path20.join(projectDir, filename);
-    await fs21.ensureDir(path20.dirname(proxyPath));
-    await fs21.writeFile(proxyPath, content, "utf-8");
+    const proxyPath = path19.join(projectDir, filename);
+    await fs20.ensureDir(path19.dirname(proxyPath));
+    await fs20.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 = path20.join(projectDir, "src", "mocks");
-    await fs21.ensureDir(mswDir);
+    const mswDir = path19.join(projectDir, "src", "mocks");
+    await fs20.ensureDir(mswDir);
     const handlersContent = generateMswHandlers(dsl);
-    const handlersPath = path20.join(mswDir, "handlers.ts");
-    await fs21.writeFile(handlersPath, handlersContent, "utf-8");
+    const handlersPath = path19.join(mswDir, "handlers.ts");
+    await fs20.writeFile(handlersPath, handlersContent, "utf-8");
     result.files.push({
-      path: path20.relative(projectDir, handlersPath),
+      path: path19.relative(projectDir, handlersPath),
       description: "MSW request handlers"
     });
     const browserContent = generateMswBrowser();
-    const browserPath = path20.join(mswDir, "browser.ts");
-    await fs21.writeFile(browserPath, browserContent, "utf-8");
+    const browserPath = path19.join(mswDir, "browser.ts");
+    await fs20.writeFile(browserPath, browserContent, "utf-8");
     result.files.push({
-      path: path20.relative(projectDir, browserPath),
+      path: path19.relative(projectDir, browserPath),
       description: "MSW browser worker setup"
     });
   }
   return result;
 }
 async function findLatestDslFile(projectDir) {
-  const specDir = path20.join(projectDir, ".ai-spec");
-  if (!await fs21.pathExists(specDir)) return null;
+  const specDir = path19.join(projectDir, ".ai-spec");
+  if (!await fs20.pathExists(specDir)) return null;
   const allFiles = [];
   async function scan(dir) {
-    const entries = await fs21.readdir(dir);
+    const entries = await fs20.readdir(dir);
     for (const entry of entries) {
-      const abs = path20.join(dir, entry);
-      const stat4 = await fs21.stat(abs);
-      if (stat4.isDirectory()) {
+      const abs = path19.join(dir, entry);
+      const stat3 = await fs20.stat(abs);
+      if (stat3.isDirectory()) {
         await scan(abs);
       } else if (entry.endsWith(".dsl.json")) {
         allFiles.push(abs);
@@ -9497,16 +9395,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 fs21.stat(f)).mtime }))
+    allFiles.map(async (f) => ({ f, mtime: (await fs20.stat(f)).mtime }))
   );
   withMtimes.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
   return withMtimes[0].f;
 }
 
 // core/spec-updater.ts
-import chalk18 from "chalk";
-import * as path21 from "path";
-import * as fs22 from "fs-extra";
+import chalk17 from "chalk";
+import * as path20 from "path";
+import * as fs21 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.
@@ -9652,8 +9550,8 @@ var SpecUpdater = class {
    * Returns all .md spec files sorted newest-first.
    */
   static async findLatestSpec(specsDir) {
-    if (!await fs22.pathExists(specsDir)) return null;
-    const files = await fs22.readdir(specsDir);
+    if (!await fs21.pathExists(specsDir)) return null;
+    const files = await fs21.readdir(specsDir);
     const pattern = /^feature-(.+)-v(\d+)\.md$/;
     let latest = null;
     for (const file of files) {
@@ -9661,8 +9559,8 @@ var SpecUpdater = class {
       if (!m) continue;
       const version = parseInt(m[2], 10);
       if (!latest || version > latest.version) {
-        const filePath = path21.join(specsDir, file);
-        const content = await fs22.readFile(filePath, "utf-8");
+        const filePath = path20.join(specsDir, file);
+        const content = await fs21.readFile(filePath, "utf-8");
         latest = { filePath, version, slug: m[1], content };
       }
     }
@@ -9673,16 +9571,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 fs22.readFile(existingSpecPath, "utf-8");
+    const existingSpec = await fs21.readFile(existingSpecPath, "utf-8");
     let existingDsl = null;
     const dslFile = await findLatestDslFile(projectDir);
     if (dslFile) {
       try {
-        existingDsl = await fs22.readJson(dslFile);
+        existingDsl = await fs21.readJson(dslFile);
       } catch {
       }
     }
-    console.log(chalk18.blue("  [1/3] Generating updated spec..."));
+    console.log(chalk17.blue("  [1/3] Generating updated spec..."));
     const updatePrompt = buildSpecUpdatePrompt(changeRequest, existingSpec, existingDsl, context);
     let updatedSpecContent;
     try {
@@ -9691,15 +9589,15 @@ var SpecUpdater = class {
     } catch (err) {
       throw new Error(`Spec update generation failed: ${err.message}`);
     }
-    const specBasename = path21.basename(existingSpecPath);
+    const specBasename = path20.basename(existingSpecPath);
     const slugMatch = specBasename.match(/^feature-(.+)-v\d+\.md$/);
     const slug = slugMatch ? slugMatch[1] : "feature";
-    const specsDir = path21.dirname(existingSpecPath);
+    const specsDir = path20.dirname(existingSpecPath);
     const { filePath: newSpecPath, version: newVersion } = await nextVersionPath(specsDir, slug);
-    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..."));
+    await fs21.ensureDir(specsDir);
+    await fs21.writeFile(newSpecPath, updatedSpecContent, "utf-8");
+    console.log(chalk17.green(`  \u2714 New spec written: ${path20.relative(projectDir, newSpecPath)}`));
+    console.log(chalk17.blue("  [2/3] Updating DSL..."));
     let updatedDsl = null;
     let newDslPath = null;
     if (existingDsl) {
@@ -9711,7 +9609,7 @@ var SpecUpdater = class {
           updatedDsl = parsed;
         }
       } catch {
-        console.log(chalk18.gray("  Targeted DSL update failed \u2014 falling back to full extraction."));
+        console.log(chalk17.gray("  Targeted DSL update failed \u2014 falling back to full extraction."));
       }
     }
     if (!updatedDsl) {
@@ -9720,15 +9618,15 @@ var SpecUpdater = class {
     }
     if (updatedDsl) {
       const dslPath = newSpecPath.replace(/\.md$/, ".dsl.json");
-      await fs22.writeJson(dslPath, updatedDsl, { spaces: 2 });
+      await fs21.writeJson(dslPath, updatedDsl, { spaces: 2 });
       newDslPath = dslPath;
-      console.log(chalk18.green(`  \u2714 DSL updated: ${path21.relative(projectDir, dslPath)}`));
+      console.log(chalk17.green(`  \u2714 DSL updated: ${path20.relative(projectDir, dslPath)}`));
     } else {
-      console.log(chalk18.yellow("  \u26A0 DSL update failed \u2014 continuing without DSL."));
+      console.log(chalk17.yellow("  \u26A0 DSL update failed \u2014 continuing without DSL."));
     }
     let affectedFiles = [];
     if (!opts.skipAffectedFiles && updatedDsl && existingDsl && context) {
-      console.log(chalk18.blue("  [3/3] Identifying affected files..."));
+      console.log(chalk17.blue("  [3/3] Identifying affected files..."));
       const systemPrompt = getCodeGenSystemPrompt(opts.repoType);
       const affectedPrompt = buildAffectedFilesPrompt(
         changeRequest,
@@ -9739,9 +9637,9 @@ var SpecUpdater = class {
       try {
         const affectedRaw = await this.provider.generate(affectedPrompt, systemPrompt);
         affectedFiles = parseAffectedFiles(affectedRaw);
-        console.log(chalk18.green(`  \u2714 ${affectedFiles.length} file(s) identified for update`));
+        console.log(chalk17.green(`  \u2714 ${affectedFiles.length} file(s) identified for update`));
       } catch {
-        console.log(chalk18.gray("  Could not identify affected files \u2014 use manual selection."));
+        console.log(chalk17.gray("  Could not identify affected files \u2014 use manual selection."));
       }
     }
     return { newSpecPath, newVersion, newDslPath, affectedFiles, updatedDsl };
@@ -9749,8 +9647,8 @@ var SpecUpdater = class {
 };
 
 // core/openapi-exporter.ts
-import * as path22 from "path";
-import * as fs23 from "fs-extra";
+import * as path21 from "path";
+import * as fs22 from "fs-extra";
 function dslTypeToOASchema(typeDesc, fieldName = "") {
   const t = typeDesc.toLowerCase();
   if (t === "string" || t.includes("string")) {
@@ -9979,7 +9877,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 ? path22.isAbsolute(opts.outputPath) ? opts.outputPath : path22.join(projectDir, opts.outputPath) : path22.join(projectDir, defaultName);
+  const outputPath = opts.outputPath ? path21.isAbsolute(opts.outputPath) ? opts.outputPath : path21.join(projectDir, opts.outputPath) : path21.join(projectDir, defaultName);
   const doc = dslToOpenApi(dsl, serverUrl);
   let content;
   if (format === "json") {
@@ -9987,8 +9885,8 @@ async function exportOpenApi(dsl, projectDir, opts = {}) {
   } else {
     content = buildYamlDoc(doc);
   }
-  await fs23.ensureDir(path22.dirname(outputPath));
-  await fs23.writeFile(outputPath, content, "utf-8");
+  await fs22.ensureDir(path21.dirname(outputPath));
+  await fs22.writeFile(outputPath, content, "utf-8");
   return outputPath;
 }
 
@@ -9996,9 +9894,9 @@ async function exportOpenApi(dsl, projectDir, opts = {}) {
 dotenv.config();
 var CONFIG_FILE = ".ai-spec.json";
 async function loadConfig(dir) {
-  const p = path23.join(dir, CONFIG_FILE);
-  if (await fs24.pathExists(p)) {
-    return fs24.readJson(p);
+  const p = path22.join(dir, CONFIG_FILE);
+  if (await fs23.pathExists(p)) {
+    return fs23.readJson(p);
   }
   return {};
 }
@@ -10023,20 +9921,20 @@ async function resolveApiKey(providerName, cliKey) {
     validate: (v2) => v2.trim().length > 0 || "API key cannot be empty"
   });
   await saveKey(providerName, newKey.trim());
-  console.log(chalk19.gray(`  Key saved to ${KEY_STORE_FILE}`));
+  console.log(chalk18.gray(`  Key saved to ${KEY_STORE_FILE}`));
   return newKey.trim();
 }
 function printBanner(opts) {
-  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(chalk18.blue("\n" + "\u2500".repeat(52)));
+  console.log(chalk18.bold("  ai-spec \u2014 AI-driven Development Orchestrator"));
+  console.log(chalk18.blue("\u2500".repeat(52)));
+  console.log(chalk18.gray(`  Spec    : ${opts.specProvider} / ${opts.specModel}`));
   console.log(
-    chalk19.gray(
+    chalk18.gray(
       `  Codegen : ${opts.codegenMode} (${opts.codegenProvider} / ${opts.codegenModel})`
     )
   );
-  console.log(chalk19.blue("\u2500".repeat(52) + "\n"));
+  console.log(chalk18.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");
@@ -10063,42 +9961,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(chalk19.cyan(`
+    console.log(chalk18.cyan(`
 [Workspace] Detected workspace: ${workspaceConfig.name}`));
-    console.log(chalk19.gray(`  Repos: ${workspaceConfig.repos.map((r) => r.name).join(", ")}`));
+    console.log(chalk18.gray(`  Repos: ${workspaceConfig.repos.map((r) => r.name).join(", ")}`));
     const pipelineResults = await runMultiRepoPipeline(idea, workspaceConfig, opts, currentDir, config2);
     if (opts.serve) {
-      console.log(chalk19.blue("\n\u2500\u2500\u2500 Auto-serve: starting mock server \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk18.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(chalk19.yellow("  No successful backend with DSL found \u2014 skipping auto-serve."));
+        console.log(chalk18.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 = path23.join(backendResult.repoAbsPath, "mock", "server.js");
-        console.log(chalk19.green(`  \u2714 Mock assets generated (${mockResult.files.length} file(s))`));
+        const serverJsPath = path22.join(backendResult.repoAbsPath, "mock", "server.js");
+        console.log(chalk18.green(`  \u2714 Mock assets generated (${mockResult.files.length} file(s))`));
         const pid = startMockServerBackground(serverJsPath, mockPort);
-        console.log(chalk19.green(`  \u2714 Mock server started (PID ${pid}) \u2192 http://localhost:${mockPort}`));
+        console.log(chalk18.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(chalk19.green(`  \u2714 Frontend proxy patched (${proxyResult.framework})`));
-            console.log(chalk19.bold.cyan(`
+            console.log(chalk18.green(`  \u2714 Frontend proxy patched (${proxyResult.framework})`));
+            console.log(chalk18.bold.cyan(`
   Ready! Run your frontend dev server:`));
-            console.log(chalk19.white(`    cd ${frontendResult.repoAbsPath}`));
-            console.log(chalk19.white(`    ${proxyResult.devCommand}`));
-            console.log(chalk19.gray(`
+            console.log(chalk18.white(`    cd ${frontendResult.repoAbsPath}`));
+            console.log(chalk18.white(`    ${proxyResult.devCommand}`));
+            console.log(chalk18.gray(`
   When done, restore: ai-spec mock --restore --frontend ${frontendResult.repoAbsPath}`));
           } else {
-            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}`));
+            console.log(chalk18.yellow(`  \u26A0 Auto-patch not available for ${proxyResult.framework}.`));
+            if (proxyResult.note) console.log(chalk18.gray(`    ${proxyResult.note}`));
+            console.log(chalk18.gray(`    Mock server: http://localhost:${mockPort}`));
           }
         } else {
-          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}`));
+          console.log(chalk18.gray(`  No frontend repo found \u2014 mock server is running at http://localhost:${mockPort}`));
+          console.log(chalk18.gray(`  Configure your frontend proxy manually to point to http://localhost:${mockPort}`));
         }
       }
     }
@@ -10119,7 +10017,7 @@ program.command("create").description("Generate a feature spec and kick off code
     codegenModel: codegenModelName
   });
   const runId = generateRunId();
-  console.log(chalk19.gray(`  Run ID: ${runId}`));
+  console.log(chalk18.gray(`  Run ID: ${runId}`));
   const runSnapshot = new RunSnapshot(currentDir, runId);
   setActiveSnapshot(runSnapshot);
   const runLogger = new RunLogger(currentDir, runId, {
@@ -10127,25 +10025,25 @@ program.command("create").description("Generate a feature spec and kick off code
     model: specModelName
   });
   setActiveLogger(runLogger);
-  console.log(chalk19.blue("[1/6] Loading project context..."));
+  console.log(chalk18.blue("[1/6] Loading project context..."));
   runLogger.stageStart("context_load");
   const loader = new ContextLoader(currentDir);
   const context = await loader.loadProjectContext();
   const { type: detectedRepoType } = await detectRepoType(currentDir);
   runLogger.stageEnd("context_load", { techStack: context.techStack, repoType: detectedRepoType });
-  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`));
+  console.log(chalk18.gray(`  Tech stack  : ${context.techStack.join(", ") || "unknown"} [${detectedRepoType}]`));
+  console.log(chalk18.gray(`  Dependencies: ${context.dependencies.length} packages`));
+  console.log(chalk18.gray(`  API files   : ${context.apiStructure.length} files`));
   if (context.schema) {
-    console.log(chalk19.gray(`  Prisma schema: found`));
+    console.log(chalk18.gray(`  Prisma schema: found`));
   }
   if (context.constitution) {
-    console.log(chalk19.green(`  Constitution : found (.ai-spec-constitution.md)`));
+    console.log(chalk18.green(`  Constitution : found (.ai-spec-constitution.md)`));
     if (context.constitution.length > 6e3) {
-      console.log(chalk19.yellow(`  \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
+      console.log(chalk18.yellow(`  \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
     }
   } else {
-    console.log(chalk19.yellow("  Constitution : not found \u2014 auto-generating..."));
+    console.log(chalk18.yellow("  Constitution : not found \u2014 auto-generating..."));
     try {
       const constitutionGen = new ConstitutionGenerator(
         createProvider(specProviderName, specApiKey, specModelName)
@@ -10153,12 +10051,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(chalk19.green(`  Constitution : \u2714 generated and saved (.ai-spec-constitution.md)`));
+      console.log(chalk18.green(`  Constitution : \u2714 generated and saved (.ai-spec-constitution.md)`));
     } catch (err) {
-      console.log(chalk19.yellow(`  Constitution : \u26A0 auto-generation failed (${err.message}), continuing without it.`));
+      console.log(chalk18.yellow(`  Constitution : \u26A0 auto-generation failed (${err.message}), continuing without it.`));
     }
   }
-  console.log(chalk19.blue(`
+  console.log(chalk18.blue(`
 [2/6] Generating spec with ${specProviderName}/${specModelName}...`));
   const specProvider = createProvider(specProviderName, specApiKey, specModelName);
   let initialSpec;
@@ -10168,30 +10066,30 @@ 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(chalk19.green("  \u2714 Spec generated."));
+      console.log(chalk18.green("  \u2714 Spec generated."));
     } else {
       const result = await generateSpecWithTasks(specProvider, idea, context);
       initialSpec = result.spec;
       initialTasks = result.tasks;
-      console.log(chalk19.green(`  \u2714 Spec generated.`));
+      console.log(chalk18.green(`  \u2714 Spec generated.`));
       if (initialTasks.length > 0) {
-        console.log(chalk19.green(`  \u2714 ${initialTasks.length} tasks generated (combined call).`));
+        console.log(chalk18.green(`  \u2714 ${initialTasks.length} tasks generated (combined call).`));
       } else {
-        console.log(chalk19.yellow("  \u26A0 Tasks not parsed from response \u2014 will retry separately after refinement."));
+        console.log(chalk18.yellow("  \u26A0 Tasks not parsed from response \u2014 will retry separately after refinement."));
       }
     }
     runLogger.stageEnd("spec_gen", { taskCount: initialTasks.length });
   } catch (err) {
     runLogger.stageFail("spec_gen", err.message);
-    console.error(chalk19.red("  \u2718 Spec generation failed:"), err);
+    console.error(chalk18.red("  \u2718 Spec generation failed:"), err);
     process.exit(1);
   }
   let finalSpec;
   if (opts.fast) {
-    console.log(chalk19.gray("\n[3/6] Skipping refinement (--fast)."));
+    console.log(chalk18.gray("\n[3/6] Skipping refinement (--fast)."));
     finalSpec = initialSpec;
   } else {
-    console.log(chalk19.blue("\n[3/6] Interactive spec refinement..."));
+    console.log(chalk18.blue("\n[3/6] Interactive spec refinement..."));
     runLogger.stageStart("spec_refine");
     const refiner = new SpecRefiner(specProvider);
     finalSpec = await refiner.refineLoop(initialSpec);
@@ -10202,7 +10100,7 @@ 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(chalk19.blue("\n[3.4/6] Spec quality assessment..."));
+      console.log(chalk18.blue("\n[3.4/6] Spec quality assessment..."));
     }
     runLogger.stageStart("spec_assess");
     const assessment = await assessSpec(specProvider, finalSpec, context.constitution ?? void 0);
@@ -10211,45 +10109,45 @@ program.command("create").description("Generate a feature spec and kick off code
       if (!opts.auto) printSpecAssessment(assessment);
       if (minScore > 0 && assessment.overallScore < minScore) {
         if (opts.force) {
-          console.log(chalk19.yellow(`
+          console.log(chalk18.yellow(`
   \u26A0 Score gate: ${assessment.overallScore}/10 < minimum ${minScore}/10 \u2014 bypassed with --force.`));
         } else {
           runLogger.stageFail("spec_assess", `Score gate: ${assessment.overallScore} < ${minScore}`);
-          console.log(chalk19.red(`
+          console.log(chalk18.red(`
   \u2718 Spec quality gate failed: overallScore ${assessment.overallScore}/10 < minimum ${minScore}/10`));
           if (!opts.auto) {
-            console.log(chalk19.gray(`  Address the issues above and re-run, or use --force to bypass.`));
+            console.log(chalk18.gray(`  Address the issues above and re-run, or use --force to bypass.`));
           } else {
-            console.log(chalk19.gray(`  Auto mode: gate enforced. Fix the spec or lower minSpecScore, or use --force to bypass.`));
+            console.log(chalk18.gray(`  Auto mode: gate enforced. Fix the spec or lower minSpecScore, or use --force to bypass.`));
           }
-          console.log(chalk19.gray(`  Gate threshold set in .ai-spec.json \u2192 "minSpecScore": ${minScore}`));
+          console.log(chalk18.gray(`  Gate threshold set in .ai-spec.json \u2192 "minSpecScore": ${minScore}`));
           process.exit(1);
         }
       }
     } else {
       runLogger.stageEnd("spec_assess", { skipped: true });
       if (!opts.auto) {
-        console.log(chalk19.gray("  (Assessment skipped \u2014 AI call failed or timed out)"));
+        console.log(chalk18.gray("  (Assessment skipped \u2014 AI call failed or timed out)"));
       }
     }
   }
   if (!opts.auto) {
-    console.log(chalk19.blue("\n[3.5/6] Approval Gate \u2014 review before code generation"));
+    console.log(chalk18.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(chalk19.gray(`  Spec length     : ${specLines} lines / ${specWords} words`));
-    if (taskCountHint) console.log(chalk19.gray(taskCountHint));
-    const previewSpecsDir = path23.join(currentDir, "specs");
+    console.log(chalk18.gray(`  Spec length     : ${specLines} lines / ${specWords} words`));
+    if (taskCountHint) console.log(chalk18.gray(taskCountHint));
+    const previewSpecsDir = path22.join(currentDir, "specs");
     const slug = featureSlug;
     const prevVersion = await findLatestVersion(previewSpecsDir, slug);
     if (prevVersion) {
-      console.log(chalk19.gray(`  Previous version: v${prevVersion.version} (${prevVersion.filePath})`));
+      console.log(chalk18.gray(`  Previous version: v${prevVersion.version} (${prevVersion.filePath})`));
       const diff = computeDiff(prevVersion.content, finalSpec);
-      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"));
+      console.log(chalk18.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(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"));
+      console.log(chalk18.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?",
@@ -10260,9 +10158,9 @@ program.command("create").description("Generate a feature spec and kick off code
       ]
     });
     if (gate === "view") {
-      console.log(chalk19.cyan("\n" + "\u2500".repeat(52)));
+      console.log(chalk18.cyan("\n" + "\u2500".repeat(52)));
       console.log(finalSpec);
-      console.log(chalk19.cyan("\u2500".repeat(52) + "\n"));
+      console.log(chalk18.cyan("\u2500".repeat(52) + "\n"));
       const confirm22 = await select3({
         message: "Proceed to code generation?",
         choices: [
@@ -10271,92 +10169,92 @@ program.command("create").description("Generate a feature spec and kick off code
         ]
       });
       if (confirm22 === "abort") {
-        console.log(chalk19.yellow("  Aborted. Spec was NOT saved."));
+        console.log(chalk18.yellow("  Aborted. Spec was NOT saved."));
         process.exit(0);
       }
     } else if (gate === "abort") {
-      console.log(chalk19.yellow("  Aborted. Spec was NOT saved."));
+      console.log(chalk18.yellow("  Aborted. Spec was NOT saved."));
       process.exit(0);
     }
-    console.log(chalk19.green("  \u2714 Approved \u2014 continuing to code generation."));
+    console.log(chalk18.green("  \u2714 Approved \u2014 continuing to code generation."));
   } else {
-    console.log(chalk19.gray("[3.5/6] Approval Gate: skipped (--auto)."));
+    console.log(chalk18.gray("[3.5/6] Approval Gate: skipped (--auto)."));
   }
   let extractedDsl = null;
   if (opts.skipDsl) {
-    console.log(chalk19.gray("\n[DSL] Skipped (--skip-dsl)."));
+    console.log(chalk18.gray("\n[DSL] Skipped (--skip-dsl)."));
   } else {
-    console.log(chalk19.blue("\n[DSL] Extracting structured DSL from spec..."));
-    console.log(chalk19.gray(`  Provider: ${specProviderName}/${specModelName}`));
+    console.log(chalk18.blue("\n[DSL] Extracting structured DSL from spec..."));
+    console.log(chalk18.gray(`  Provider: ${specProviderName}/${specModelName}`));
     runLogger.stageStart("dsl_extract");
     try {
       const isFrontend = isFrontendDeps(context.dependencies);
-      if (isFrontend) console.log(chalk19.gray("  Frontend project detected \u2014 using ComponentSpec extractor"));
+      if (isFrontend) console.log(chalk18.gray("  Frontend project detected \u2014 using ComponentSpec extractor"));
       const dslExtractor = new DslExtractor(specProvider);
       extractedDsl = await dslExtractor.extract(finalSpec, { auto: opts.auto, isFrontend });
       if (extractedDsl) {
         runLogger.stageEnd("dsl_extract", { endpoints: extractedDsl.endpoints?.length ?? 0, models: extractedDsl.models?.length ?? 0 });
-        console.log(chalk19.green("  \u2714 DSL extracted and validated."));
+        console.log(chalk18.green("  \u2714 DSL extracted and validated."));
       } else {
         runLogger.stageEnd("dsl_extract", { skipped: true });
-        console.log(chalk19.yellow("  \u26A0 DSL skipped \u2014 codegen will use Spec + Tasks only."));
+        console.log(chalk18.yellow("  \u26A0 DSL skipped \u2014 codegen will use Spec + Tasks only."));
       }
     } catch (err) {
       runLogger.stageFail("dsl_extract", err.message);
-      console.log(chalk19.yellow(`  \u26A0 DSL extraction error: ${err.message} \u2014 continuing without DSL.`));
+      console.log(chalk18.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(chalk19.blue("\n[4/6] Setting up git worktree..."));
+    console.log(chalk18.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(chalk19.gray(`[4/6] Skipping worktree${reason}.`));
+    console.log(chalk18.gray(`[4/6] Skipping worktree${reason}.`));
   }
-  const specsDir = path23.join(workingDir, "specs");
-  await fs24.ensureDir(specsDir);
+  const specsDir = path22.join(workingDir, "specs");
+  await fs23.ensureDir(specsDir);
   const { filePath: specFile, version: specVersion } = await nextVersionPath(specsDir, featureSlug);
-  await fs24.writeFile(specFile, finalSpec, "utf-8");
-  console.log(chalk19.green(`
-[5/6] \u2714 Spec saved: ${specFile}`) + chalk19.gray(` (v${specVersion})`));
+  await fs23.writeFile(specFile, finalSpec, "utf-8");
+  console.log(chalk18.green(`
+[5/6] \u2714 Spec saved: ${specFile}`) + chalk18.gray(` (v${specVersion})`));
   let savedDslFile = null;
   if (extractedDsl) {
     const dslExtractor = new DslExtractor(specProvider);
     savedDslFile = await dslExtractor.saveDsl(extractedDsl, specFile);
-    console.log(chalk19.green(`  \u2714 DSL saved : ${savedDslFile}`));
+    console.log(chalk18.green(`  \u2714 DSL saved : ${savedDslFile}`));
   }
   if (!opts.skipTasks) {
     const taskGen = new TaskGenerator(specProvider);
     let tasksToSave = initialTasks;
     if (tasksToSave.length === 0) {
-      console.log(chalk19.blue(`
+      console.log(chalk18.blue(`
   Generating tasks (separate call)...`));
       try {
         tasksToSave = await taskGen.generateTasks(finalSpec, context);
       } catch (err) {
-        console.log(chalk19.yellow(`  \u26A0 Task generation failed: ${err.message}`));
+        console.log(chalk18.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(chalk19.green(`  \u2714 Tasks saved: ${tasksFile}`));
+      console.log(chalk18.green(`  \u2714 Tasks saved: ${tasksFile}`));
     } else {
-      console.log(chalk19.yellow("  \u26A0 No tasks generated \u2014 code generation will use fallback file planning."));
+      console.log(chalk18.yellow("  \u26A0 No tasks generated \u2014 code generation will use fallback file planning."));
     }
   }
-  console.log(chalk19.blue(`
+  console.log(chalk18.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(chalk19.cyan("\n[TDD] Generating pre-implementation tests (will fail until code is written)..."));
+    console.log(chalk18.cyan("\n[TDD] Generating pre-implementation tests (will fail until code is written)..."));
     const testGen = new TestGenerator(codegenProvider);
     generatedTestFiles = await testGen.generateTdd(extractedDsl, workingDir);
   }
@@ -10370,13 +10268,13 @@ program.command("create").description("Generate a feature spec and kick off code
   });
   runLogger.stageEnd("codegen", { filesGenerated: generatedFiles.length });
   if (opts.tdd) {
-    console.log(chalk19.gray("\n[7/9] TDD mode \u2014 test files already written pre-implementation."));
+    console.log(chalk18.gray("\n[7/9] TDD mode \u2014 test files already written pre-implementation."));
   } else if (opts.skipTests) {
-    console.log(chalk19.gray("\n[7/9] Skipping test generation (--skip-tests)."));
+    console.log(chalk18.gray("\n[7/9] Skipping test generation (--skip-tests)."));
   } else if (!extractedDsl) {
-    console.log(chalk19.gray("\n[7/9] Skipping test generation (no DSL available)."));
+    console.log(chalk18.gray("\n[7/9] Skipping test generation (no DSL available)."));
   } else {
-    console.log(chalk19.blue(`
+    console.log(chalk18.blue(`
 [7/9] Test skeleton generation...`));
     runLogger.stageStart("test_gen");
     const testGen = new TestGenerator(codegenProvider);
@@ -10384,10 +10282,10 @@ program.command("create").description("Generate a feature spec and kick off code
     runLogger.stageEnd("test_gen", { filesGenerated: generatedTestFiles.length });
   }
   if (opts.skipErrorFeedback) {
-    console.log(chalk19.gray("[8/9] Skipping error feedback (--skip-error-feedback)."));
+    console.log(chalk18.gray("[8/9] Skipping error feedback (--skip-error-feedback)."));
   } else {
     if (opts.tdd) {
-      console.log(chalk19.cyan("[8/9] TDD mode \u2014 error feedback loop driving implementation to pass tests..."));
+      console.log(chalk18.cyan("[8/9] TDD mode \u2014 error feedback loop driving implementation to pass tests..."));
     }
     runLogger.stageStart("error_feedback");
     await runErrorFeedback(codegenProvider, workingDir, extractedDsl, {
@@ -10398,10 +10296,10 @@ program.command("create").description("Generate a feature spec and kick off code
   }
   let reviewResult = "";
   if (!opts.skipReview) {
-    console.log(chalk19.blue("\n[9/9] Automated code review (3-pass: architecture + implementation + impact/complexity)..."));
+    console.log(chalk18.blue("\n[9/9] Automated code review (3-pass: architecture + implementation + impact/complexity)..."));
     runLogger.stageStart("review");
     const reviewer = new CodeReviewer(specProvider, currentDir);
-    const savedSpec = await fs24.readFile(specFile, "utf-8");
+    const savedSpec = await fs23.readFile(specFile, "utf-8");
     if (codegenMode === "api" && generatedFiles.length > 0) {
       reviewResult = await reviewer.reviewFiles(savedSpec, generatedFiles, workingDir, specFile);
     } else {
@@ -10417,19 +10315,19 @@ program.command("create").description("Generate a feature spec and kick off code
     await accumulateReviewKnowledge(specProvider, currentDir, reviewResult);
   }
   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}`));
+  console.log(chalk18.bold.green("\n\u2714 All done!"));
+  console.log(chalk18.gray(`  Spec        : ${specFile}`));
+  if (savedDslFile) console.log(chalk18.gray(`  DSL         : ${savedDslFile}`));
   if (generatedTestFiles.length > 0) {
-    console.log(chalk19.gray(`  Tests       : ${generatedTestFiles.length} skeleton file(s) generated`));
+    console.log(chalk18.gray(`  Tests       : ${generatedTestFiles.length} skeleton file(s) generated`));
   }
-  console.log(chalk19.gray(`  Working dir : ${workingDir}`));
+  console.log(chalk18.gray(`  Working dir : ${workingDir}`));
   if (workingDir !== currentDir) {
-    console.log(chalk19.gray(`  Run \`cd ${workingDir}\` to enter the worktree.`));
+    console.log(chalk18.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}`));
+    console.log(chalk18.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(
@@ -10446,24 +10344,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 fs24.pathExists(specFile)) {
-    specContent = await fs24.readFile(specFile, "utf-8");
+  if (specFile && await fs23.pathExists(specFile)) {
+    specContent = await fs23.readFile(specFile, "utf-8");
     resolvedSpecFile = specFile;
-    console.log(chalk19.gray(`Using spec: ${specFile}`));
+    console.log(chalk18.gray(`Using spec: ${specFile}`));
   } else {
-    const specsDir = path23.join(currentDir, "specs");
-    if (await fs24.pathExists(specsDir)) {
-      const files = (await fs24.readdir(specsDir)).filter((f) => f.endsWith(".md")).sort().reverse();
+    const specsDir = path22.join(currentDir, "specs");
+    if (await fs23.pathExists(specsDir)) {
+      const files = (await fs23.readdir(specsDir)).filter((f) => f.endsWith(".md")).sort().reverse();
       if (files.length > 0) {
-        const latest = path23.join(specsDir, files[0]);
-        specContent = await fs24.readFile(latest, "utf-8");
+        const latest = path22.join(specsDir, files[0]);
+        specContent = await fs23.readFile(latest, "utf-8");
         resolvedSpecFile = latest;
-        console.log(chalk19.gray(`Auto-detected spec: specs/${files[0]}`));
+        console.log(chalk18.gray(`Auto-detected spec: specs/${files[0]}`));
       }
     }
   }
   if (!specContent) {
-    console.log(chalk19.yellow("No spec file found. Running review without spec context."));
+    console.log(chalk18.yellow("No spec file found. Running review without spec context."));
   }
   await reviewer.reviewCode(specContent, resolvedSpecFile);
   await reviewer.printScoreTrend();
@@ -10490,15 +10388,15 @@ program.command("init").description(`Analyze codebase and generate Project Const
         auto: opts.auto
       });
       if (result.written) {
-        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`));
+        console.log(chalk18.blue("\n  Summary:"));
+        console.log(chalk18.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(chalk18.gray(`  \xA79    : ${result.before.lessonCount} \u2192 ${result.after.lessonCount} lessons remaining`));
         if (result.backupPath) {
-          console.log(chalk19.gray(`  Backup: ${path23.basename(result.backupPath)}`));
+          console.log(chalk18.gray(`  Backup: ${path22.basename(result.backupPath)}`));
         }
       }
     } catch (err) {
-      console.error(chalk19.red(`  \u2718 Consolidation failed: ${err.message}`));
+      console.error(chalk18.red(`  \u2718 Consolidation failed: ${err.message}`));
       process.exit(1);
     }
     return;
@@ -10506,75 +10404,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(chalk19.yellow(`
+      console.log(chalk18.yellow(`
   Global constitution already exists at: ${existing.source}`));
-      console.log(chalk19.gray("  Use --force to overwrite it."));
+      console.log(chalk18.gray("  Use --force to overwrite it."));
       return;
     }
-    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..."));
+    console.log(chalk18.blue("\n\u2500\u2500\u2500 Generating Global Constitution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk18.gray(`  Provider: ${providerName}/${modelName}`));
+    console.log(chalk18.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: path23.basename(currentDir), summary }]);
+    const prompt = buildGlobalConstitutionPrompt([{ name: path22.basename(currentDir), summary }]);
     let globalConstitution;
     try {
       globalConstitution = await provider.generate(prompt, globalConstitutionSystemPrompt);
     } catch (err) {
-      console.error(chalk19.red("  \u2718 Failed to generate global constitution:"), err);
+      console.error(chalk18.red("  \u2718 Failed to generate global constitution:"), err);
       process.exit(1);
     }
     const saved2 = await saveGlobalConstitution(globalConstitution, currentDir);
-    console.log(chalk19.green(`
+    console.log(chalk18.green(`
   \u2714 Global constitution saved: ${saved2}`));
-    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")));
+    console.log(chalk18.gray("  This will be automatically merged into all project constitutions in this workspace."));
+    console.log(chalk18.gray("  Project-level rules always override global rules.\n"));
+    console.log(chalk18.bold("  Preview:"));
+    console.log(chalk18.gray(globalConstitution.split("\n").slice(0, 12).join("\n")));
     if (globalConstitution.split("\n").length > 12) {
-      console.log(chalk19.gray(`  ... (${globalConstitution.split("\n").length} lines total)`));
+      console.log(chalk18.gray(`  ... (${globalConstitution.split("\n").length} lines total)`));
     }
     return;
   }
-  const constitutionPath = path23.join(currentDir, CONSTITUTION_FILE);
-  if (!opts.force && await fs24.pathExists(constitutionPath)) {
-    console.log(chalk19.yellow(`
+  const constitutionPath = path22.join(currentDir, CONSTITUTION_FILE);
+  if (!opts.force && await fs23.pathExists(constitutionPath)) {
+    console.log(chalk18.yellow(`
   ${CONSTITUTION_FILE} already exists.`));
-    console.log(chalk19.gray("  Use --force to overwrite it."));
-    console.log(chalk19.gray(`  Or edit it directly: ${constitutionPath}`));
+    console.log(chalk18.gray("  Use --force to overwrite it."));
+    console.log(chalk18.gray(`  Or edit it directly: ${constitutionPath}`));
     return;
   }
-  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..."));
+  console.log(chalk18.blue("\n\u2500\u2500\u2500 Generating Project Constitution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk18.gray(`  Provider: ${providerName}/${modelName}`));
+  console.log(chalk18.gray("  Analyzing codebase..."));
   const generator = new ConstitutionGenerator(provider);
   let constitution;
   try {
     constitution = await generator.generate(currentDir);
   } catch (err) {
-    console.error(chalk19.red("  \u2718 Failed to generate constitution:"), err);
+    console.error(chalk18.red("  \u2718 Failed to generate constitution:"), err);
     process.exit(1);
   }
   const saved = await generator.saveConstitution(currentDir, constitution);
-  const globalResult = await loadGlobalConstitution([path23.dirname(currentDir)]);
+  const globalResult = await loadGlobalConstitution([path22.dirname(currentDir)]);
   if (globalResult) {
-    console.log(chalk19.cyan(`
+    console.log(chalk18.cyan(`
   \u2139 Global constitution detected: ${globalResult.source}`));
-    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(chalk18.gray("    It will be merged with this project constitution at runtime."));
+    console.log(chalk18.gray("    Project rules take priority over global rules."));
   }
-  console.log(chalk19.green(`
+  console.log(chalk18.green(`
   \u2714 Constitution saved: ${saved}`));
-  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")));
+  console.log(chalk18.gray("  This file will be automatically used in all future `ai-spec create` runs."));
+  console.log(chalk18.gray("  Edit it to add custom rules or red lines for your project.\n"));
+  console.log(chalk18.bold("  Preview:"));
+  console.log(chalk18.gray(constitution.split("\n").slice(0, 15).join("\n")));
   if (constitution.split("\n").length > 15) {
-    console.log(chalk19.gray(`  ... (${constitution.split("\n").length} lines total)`));
+    console.log(chalk18.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(
@@ -10582,44 +10480,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 = path23.join(currentDir, CONFIG_FILE);
+  const configPath = path22.join(currentDir, CONFIG_FILE);
   if (opts.clearKeys) {
     await clearAllKeys();
-    console.log(chalk19.green(`\u2714 All saved API keys cleared.`));
+    console.log(chalk18.green(`\u2714 All saved API keys cleared.`));
     return;
   }
   if (opts.clearKey) {
     await clearKey(opts.clearKey);
-    console.log(chalk19.green(`\u2714 Saved key for "${opts.clearKey}" removed.`));
+    console.log(chalk18.green(`\u2714 Saved key for "${opts.clearKey}" removed.`));
     return;
   }
   if (opts.listKeys) {
-    const store = await fs24.readJson(KEY_STORE_FILE).catch(() => ({}));
+    const store = await fs23.readJson(KEY_STORE_FILE).catch(() => ({}));
     const providers = Object.keys(store);
     if (providers.length === 0) {
-      console.log(chalk19.gray("No saved API keys."));
+      console.log(chalk18.gray("No saved API keys."));
     } else {
-      console.log(chalk19.bold("Saved API keys:"));
+      console.log(chalk18.bold("Saved API keys:"));
       for (const p of providers) {
         const k2 = store[p];
-        console.log(chalk19.gray(`  ${p}: ${k2.slice(0, 6)}...${k2.slice(-4)}`));
+        console.log(chalk18.gray(`  ${p}: ${k2.slice(0, 6)}...${k2.slice(-4)}`));
       }
-      console.log(chalk19.gray(`
+      console.log(chalk18.gray(`
 File: ${KEY_STORE_FILE}`));
     }
     return;
   }
   if (opts.reset) {
-    await fs24.writeJson(configPath, {}, { spaces: 2 });
-    console.log(chalk19.green(`\u2714 Config reset: ${configPath}`));
+    await fs23.writeJson(configPath, {}, { spaces: 2 });
+    console.log(chalk18.green(`\u2714 Config reset: ${configPath}`));
     return;
   }
   const existing = await loadConfig(currentDir);
   if (opts.show) {
     if (Object.keys(existing).length === 0) {
-      console.log(chalk19.gray("No config file found. Using built-in defaults."));
+      console.log(chalk18.gray("No config file found. Using built-in defaults."));
     } else {
-      console.log(chalk19.bold(`${configPath}:`));
+      console.log(chalk18.bold(`${configPath}:`));
       console.log(JSON.stringify(existing, null, 2));
     }
     return;
@@ -10633,27 +10531,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(chalk19.red("  --min-spec-score must be a number between 0 and 10"));
+      console.error(chalk18.red("  --min-spec-score must be a number between 0 and 10"));
       process.exit(1);
     }
     updated.minSpecScore = score;
   }
-  await fs24.writeJson(configPath, updated, { spaces: 2 });
-  console.log(chalk19.green(`\u2714 Config saved to ${configPath}`));
+  await fs23.writeJson(configPath, updated, { spaces: 2 });
+  console.log(chalk18.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 = path23.join(currentDir, CONFIG_FILE);
+  const configPath = path22.join(currentDir, CONFIG_FILE);
   if (opts.list) {
-    console.log(chalk19.bold("\nAvailable providers & models:\n"));
+    console.log(chalk18.bold("\nAvailable providers & models:\n"));
     for (const [key, meta] of Object.entries(PROVIDER_CATALOG)) {
       console.log(
-        `  ${chalk19.bold.cyan(key.padEnd(10))} ${chalk19.white(meta.displayName)}`
+        `  ${chalk18.bold.cyan(key.padEnd(10))} ${chalk18.white(meta.displayName)}`
       );
-      console.log(chalk19.gray(`             ${meta.description}`));
+      console.log(chalk18.gray(`             ${meta.description}`));
       console.log(
-        chalk19.gray(
+        chalk18.gray(
           `             env: ${meta.envKey}  |  models: ${meta.models.join(", ")}`
         )
       );
@@ -10662,10 +10560,10 @@ program.command("model").description("Interactively switch the active AI provide
     return;
   }
   const existing = await loadConfig(currentDir);
-  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"));
+  console.log(chalk18.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(
-      chalk19.gray(
+      chalk18.gray(
         `  Current: spec=${existing.provider ?? "gemini"}/${existing.model ?? DEFAULT_MODELS[existing.provider ?? "gemini"]}` + (existing.codegenProvider ? `  codegen=${existing.codegenProvider}/${existing.codegenModel ?? ""}` : "")
       )
     );
@@ -10683,7 +10581,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)} ${chalk19.gray(meta2.description)}`,
+        name: `${meta2.displayName.padEnd(22)} ${chalk18.gray(meta2.description)}`,
         value: key,
         short: meta2.displayName
       }))
@@ -10691,7 +10589,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: chalk19.italic("\u270E  Enter custom model name..."), value: "__custom__" }
+      { name: chalk18.italic("\u270E  Enter custom model name..."), value: "__custom__" }
     ];
     let chosenModel = await select3({
       message: `${label} \u2014 select model (${meta.displayName}):`,
@@ -10725,37 +10623,37 @@ program.command("model").description("Interactively switch the active AI provide
       if (!updated.codegen || updated.codegen === "claude-code") {
         updated.codegen = "api";
         console.log(
-          chalk19.yellow(
+          chalk18.yellow(
             `
   \u26A0  provider "${effectiveCodegenProvider}" \u4E0D\u652F\u6301 "claude-code" \u6A21\u5F0F\u3002`
           )
         );
-        console.log(chalk19.gray(`  \u5DF2\u81EA\u52A8\u5C06 codegen \u6A21\u5F0F\u8BBE\u4E3A "api"\u3002`));
+        console.log(chalk18.gray(`  \u5DF2\u81EA\u52A8\u5C06 codegen \u6A21\u5F0F\u8BBE\u4E3A "api"\u3002`));
       }
     }
   }
-  console.log(chalk19.blue("\n  Preview:"));
-  console.log(chalk19.gray(`    spec    \u2192 ${updated.provider}/${updated.model}`));
+  console.log(chalk18.blue("\n  Preview:"));
+  console.log(chalk18.gray(`    spec    \u2192 ${updated.provider}/${updated.model}`));
   if (updated.codegenProvider) {
     console.log(
-      chalk19.gray(
+      chalk18.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(chalk19.gray("  Cancelled."));
+    console.log(chalk18.gray("  Cancelled."));
     return;
   }
-  await fs24.writeJson(configPath, updated, { spaces: 2 });
-  console.log(chalk19.green(`
+  await fs23.writeJson(configPath, updated, { spaces: 2 });
+  console.log(chalk18.green(`
   \u2714 Saved to ${configPath}`));
   const providerToCheck = updated.provider ?? "gemini";
   const envKey = ENV_KEY_MAP[providerToCheck];
   if (envKey && !process.env[envKey]) {
     console.log(
-      chalk19.yellow(
+      chalk18.yellow(
         `  \u26A0  Remember to set ${envKey} in your environment or .env file.`
       )
     );
@@ -10774,29 +10672,29 @@ async function runSingleRepoPipelineInWorkspace(opts) {
     cliOpts,
     contractContextSection
   } = opts;
-  console.log(chalk19.blue(`
+  console.log(chalk18.blue(`
   [${repoName}] Loading project context...`));
   const loader = new ContextLoader(repoAbsPath);
   let context = await loader.loadProjectContext();
   const { type: detectedRepoType } = await detectRepoType(repoAbsPath);
-  console.log(chalk19.gray(`    Tech stack: ${context.techStack.join(", ") || "unknown"} [${detectedRepoType}]`));
-  console.log(chalk19.gray(`    Dependencies: ${context.dependencies.length} packages`));
+  console.log(chalk18.gray(`    Tech stack: ${context.techStack.join(", ") || "unknown"} [${detectedRepoType}]`));
+  console.log(chalk18.gray(`    Dependencies: ${context.dependencies.length} packages`));
   if (context.constitution && context.constitution.length > 6e3) {
-    console.log(chalk19.yellow(`    \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
+    console.log(chalk18.yellow(`    \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
   }
   if (!context.constitution) {
-    console.log(chalk19.yellow(`    Constitution: not found \u2014 auto-generating...`));
+    console.log(chalk18.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(chalk19.green(`    Constitution: generated`));
+      console.log(chalk18.green(`    Constitution: generated`));
     } catch (err) {
-      console.log(chalk19.yellow(`    Constitution: auto-generation failed (${err.message}), continuing.`));
+      console.log(chalk18.yellow(`    Constitution: auto-generation failed (${err.message}), continuing.`));
     }
   } else {
-    console.log(chalk19.green(`    Constitution: found`));
+    console.log(chalk18.green(`    Constitution: found`));
   }
   let fullIdea = idea;
   if (contractContextSection) {
@@ -10804,58 +10702,58 @@ async function runSingleRepoPipelineInWorkspace(opts) {
 
 ${contractContextSection}`;
   }
-  console.log(chalk19.blue(`  [${repoName}] Generating spec...`));
+  console.log(chalk18.blue(`  [${repoName}] Generating spec...`));
   let finalSpec;
   try {
     const result = await generateSpecWithTasks(specProvider, fullIdea, context);
     finalSpec = result.spec;
-    console.log(chalk19.green(`    Spec generated.`));
+    console.log(chalk18.green(`    Spec generated.`));
   } catch (err) {
-    console.error(chalk19.red(`    Spec generation failed: ${err.message}`));
+    console.error(chalk18.red(`    Spec generation failed: ${err.message}`));
     return { dsl: null, specFile: null };
   }
   let extractedDsl = null;
   if (!cliOpts.skipDsl) {
-    console.log(chalk19.blue(`  [${repoName}] Extracting DSL...`));
+    console.log(chalk18.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(chalk19.green(`    DSL extracted.`));
+        console.log(chalk18.green(`    DSL extracted.`));
       }
     } catch (err) {
-      console.log(chalk19.yellow(`    DSL extraction failed: ${err.message}`));
+      console.log(chalk18.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(chalk19.blue(`  [${repoName}] Setting up git worktree...`));
+    console.log(chalk18.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(chalk19.yellow(`    Worktree setup failed: ${err.message}. Using main branch.`));
+      console.log(chalk18.yellow(`    Worktree setup failed: ${err.message}. Using main branch.`));
     }
   } else {
-    console.log(chalk19.gray(`  [${repoName}] Skipping worktree${isFrontendRepo ? " (frontend repo)" : ""}.`));
+    console.log(chalk18.gray(`  [${repoName}] Skipping worktree${isFrontendRepo ? " (frontend repo)" : ""}.`));
   }
-  const specsDir = path23.join(workingDir, "specs");
-  await fs24.ensureDir(specsDir);
+  const specsDir = path22.join(workingDir, "specs");
+  await fs23.ensureDir(specsDir);
   const featureSlug = slugify(idea);
   const { filePath: specFile } = await nextVersionPath(specsDir, featureSlug);
-  await fs24.writeFile(specFile, finalSpec, "utf-8");
-  console.log(chalk19.green(`    Spec saved: ${path23.relative(repoAbsPath, specFile)}`));
+  await fs23.writeFile(specFile, finalSpec, "utf-8");
+  console.log(chalk18.green(`    Spec saved: ${path22.relative(repoAbsPath, specFile)}`));
   let savedDslFile = null;
   if (extractedDsl) {
     const dslExtractorForSave = new DslExtractor(specProvider);
     savedDslFile = await dslExtractorForSave.saveDsl(extractedDsl, specFile);
-    console.log(chalk19.green(`    DSL saved: ${path23.relative(repoAbsPath, savedDslFile)}`));
+    console.log(chalk18.green(`    DSL saved: ${path22.relative(repoAbsPath, savedDslFile)}`));
   }
-  console.log(chalk19.blue(`  [${repoName}] Running code generation (mode: ${codegenMode})...`));
+  console.log(chalk18.blue(`  [${repoName}] Running code generation (mode: ${codegenMode})...`));
   try {
     const codegen = new CodeGenerator(codegenProvider, codegenMode);
     await codegen.generateCode(specFile, workingDir, context, {
@@ -10863,29 +10761,29 @@ ${contractContextSection}`;
       dslFilePath: savedDslFile ?? void 0,
       repoType: detectedRepoType
     });
-    console.log(chalk19.green(`    Code generation complete.`));
+    console.log(chalk18.green(`    Code generation complete.`));
   } catch (err) {
-    console.log(chalk19.yellow(`    Code generation failed: ${err.message}`));
+    console.log(chalk18.yellow(`    Code generation failed: ${err.message}`));
   }
   if (!cliOpts.skipTests && extractedDsl) {
-    console.log(chalk19.blue(`  [${repoName}] Generating test skeletons...`));
+    console.log(chalk18.blue(`  [${repoName}] Generating test skeletons...`));
     try {
       const testGen = new TestGenerator(codegenProvider);
       const testFiles = await testGen.generate(extractedDsl, workingDir);
-      console.log(chalk19.green(`    ${testFiles.length} test file(s) generated.`));
+      console.log(chalk18.green(`    ${testFiles.length} test file(s) generated.`));
     } catch (err) {
-      console.log(chalk19.yellow(`    Test generation failed: ${err.message}`));
+      console.log(chalk18.yellow(`    Test generation failed: ${err.message}`));
     }
   }
   if (!cliOpts.skipErrorFeedback) {
     try {
       await runErrorFeedback(codegenProvider, workingDir, extractedDsl, { maxCycles: 1 });
     } catch (err) {
-      console.log(chalk19.yellow(`    Error feedback failed: ${err.message}`));
+      console.log(chalk18.yellow(`    Error feedback failed: ${err.message}`));
     }
   }
   if (!cliOpts.skipReview) {
-    console.log(chalk19.blue(`  [${repoName}] Running code review...`));
+    console.log(chalk18.blue(`  [${repoName}] Running code review...`));
     try {
       const reviewer = new CodeReviewer(specProvider);
       const originalDir = process.cwd();
@@ -10897,9 +10795,9 @@ ${contractContextSection}`;
         process.chdir(originalDir);
       }
       await accumulateReviewKnowledge(specProvider, repoAbsPath, reviewResult);
-      console.log(chalk19.green(`    Code review complete.`));
+      console.log(chalk18.green(`    Code review complete.`));
     } catch (err) {
-      console.log(chalk19.yellow(`    Code review failed: ${err.message}`));
+      console.log(chalk18.yellow(`    Code review failed: ${err.message}`));
     }
   }
   return { dsl: extractedDsl, specFile };
@@ -10922,7 +10820,7 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
     codegenModel: codegenModelName
   });
   const workspaceLoader = new WorkspaceLoader(currentDir);
-  console.log(chalk19.blue("\n[W1] Loading per-repo contexts..."));
+  console.log(chalk18.blue("\n[W1] Loading per-repo contexts..."));
   const contexts = /* @__PURE__ */ new Map();
   const frontendContexts = /* @__PURE__ */ new Map();
   for (const repo of workspace.repos) {
@@ -10934,27 +10832,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(chalk19.gray(`  ${repo.name}: ${fctx.framework} / ${fctx.httpClient} / hooks:${fctx.hookFiles.length} stores:${fctx.storeFiles.length}`));
+        console.log(chalk18.gray(`  ${repo.name}: ${fctx.framework} / ${fctx.httpClient} / hooks:${fctx.hookFiles.length} stores:${fctx.storeFiles.length}`));
       } else {
-        console.log(chalk19.gray(`  ${repo.name}: ${ctx.techStack.join(", ") || "unknown"} (${ctx.dependencies.length} deps)`));
+        console.log(chalk18.gray(`  ${repo.name}: ${ctx.techStack.join(", ") || "unknown"} (${ctx.dependencies.length} deps)`));
       }
     } catch (err) {
-      console.log(chalk19.yellow(`  ${repo.name}: context load failed \u2014 ${err.message}`));
+      console.log(chalk18.yellow(`  ${repo.name}: context load failed \u2014 ${err.message}`));
     }
   }
-  console.log(chalk19.blue("\n[W2] Decomposing requirement across repos..."));
+  console.log(chalk18.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(chalk19.green(`  Summary: ${decomposition.summary}`));
-    console.log(chalk19.gray(`  Repos affected: ${decomposition.repos.map((r) => r.repoName).join(", ")}`));
+    console.log(chalk18.green(`  Summary: ${decomposition.summary}`));
+    console.log(chalk18.gray(`  Repos affected: ${decomposition.repos.map((r) => r.repoName).join(", ")}`));
     if (decomposition.coordinationNotes) {
-      console.log(chalk19.gray(`  Coordination: ${decomposition.coordinationNotes}`));
+      console.log(chalk18.gray(`  Coordination: ${decomposition.coordinationNotes}`));
     }
   } catch (err) {
-    console.error(chalk19.red(`  Decomposition failed: ${err.message}`));
-    console.log(chalk19.yellow("  Falling back to running all repos independently."));
+    console.error(chalk18.red(`  Decomposition failed: ${err.message}`));
+    console.log(chalk18.yellow("  Falling back to running all repos independently."));
     decomposition = {
       originalRequirement: idea,
       summary: idea,
@@ -10970,11 +10868,11 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
     };
   }
   if (!opts.auto) {
-    console.log(chalk19.cyan("\n[W3] Decomposition Preview:"));
-    console.log(chalk19.cyan("\u2500".repeat(52)));
+    console.log(chalk18.cyan("\n[W3] Decomposition Preview:"));
+    console.log(chalk18.cyan("\u2500".repeat(52)));
     for (const r of decomposition.repos) {
-      console.log(chalk19.bold(`  ${r.repoName} (${r.role})`));
-      console.log(chalk19.gray(`    ${r.specIdea.slice(0, 150)}${r.specIdea.length > 150 ? "..." : ""}`));
+      console.log(chalk18.bold(`  ${r.repoName} (${r.role})`));
+      console.log(chalk18.gray(`    ${r.specIdea.slice(0, 150)}${r.specIdea.length > 150 ? "..." : ""}`));
       if (r.uxDecisions) {
         const ux = r.uxDecisions;
         const uxSummary = [
@@ -10983,13 +10881,13 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
           ux.optimisticUpdate ? "optimistic-update" : "",
           ux.errorRollback ? "rollback" : ""
         ].filter(Boolean).join(", ");
-        if (uxSummary) console.log(chalk19.cyan(`    UX: ${uxSummary}`));
+        if (uxSummary) console.log(chalk18.cyan(`    UX: ${uxSummary}`));
       }
       if (r.dependsOnRepos.length > 0) {
-        console.log(chalk19.gray(`    Depends on: ${r.dependsOnRepos.join(", ")}`));
+        console.log(chalk18.gray(`    Depends on: ${r.dependsOnRepos.join(", ")}`));
       }
     }
-    console.log(chalk19.cyan("\u2500".repeat(52)));
+    console.log(chalk18.cyan("\u2500".repeat(52)));
     const gate = await select3({
       message: "Proceed with multi-repo pipeline?",
       choices: [
@@ -10998,24 +10896,24 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
       ]
     });
     if (gate === "abort") {
-      console.log(chalk19.yellow("  Aborted."));
+      console.log(chalk18.yellow("  Aborted."));
       process.exit(0);
     }
   }
   const sortedRepoRequirements = RequirementDecomposer.sortByDependency(decomposition.repos);
   const contractDsls = /* @__PURE__ */ new Map();
-  console.log(chalk19.blue(`
+  console.log(chalk18.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(chalk19.yellow(`  Skipping ${repoReq.repoName} \u2014 not found in workspace config.`));
+      console.log(chalk18.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(chalk19.bold.blue(`
+    console.log(chalk18.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) {
@@ -11023,7 +10921,7 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
       for (const depName of repoReq.dependsOnRepos) {
         const depDsl = contractDsls.get(depName);
         if (depDsl) {
-          console.log(chalk19.gray(`    Using API contract from: ${depName}`));
+          console.log(chalk18.gray(`    Using API contract from: ${depName}`));
           const contract = buildFrontendApiContract(depDsl);
           contractParts.push(buildContractContextSection(contract));
         }
@@ -11043,7 +10941,7 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
         frontendContext: frontendCtx
       });
       contractContextSection = void 0;
-      console.log(chalk19.gray(`    Frontend context: ${frontendCtx.framework} / ${frontendCtx.httpClient} / ${frontendCtx.uiLibrary}`));
+      console.log(chalk18.gray(`    Frontend context: ${frontendCtx.framework} / ${frontendCtx.httpClient} / ${frontendCtx.uiLibrary}`));
     }
     try {
       const { dsl, specFile } = await runSingleRepoPipelineInWorkspace({
@@ -11060,22 +10958,22 @@ async function runMultiRepoPipeline(idea, workspace, opts, currentDir, config2)
       });
       if (repoReq.isContractProvider && dsl) {
         contractDsls.set(repoReq.repoName, dsl);
-        console.log(chalk19.green(`    Contract stored for downstream repos.`));
+        console.log(chalk18.green(`    Contract stored for downstream repos.`));
       }
       results.push({ repoName: repoReq.repoName, status: "success", specFile, dsl, repoAbsPath, role: repoReq.role });
-      console.log(chalk19.green(`  \u2714 ${repoReq.repoName} complete`));
+      console.log(chalk18.green(`  \u2714 ${repoReq.repoName} complete`));
     } catch (err) {
-      console.error(chalk19.red(`  \u2718 ${repoReq.repoName} failed: ${err.message}`));
+      console.error(chalk18.red(`  \u2718 ${repoReq.repoName} failed: ${err.message}`));
       results.push({ repoName: repoReq.repoName, status: "failed", specFile: null, dsl: null, repoAbsPath, role: repoReq.role });
     }
   }
-  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(chalk18.bold.green("\n\u2714 Multi-repo pipeline complete!"));
+  console.log(chalk18.gray(`  Workspace: ${workspace.name}`));
+  console.log(chalk18.gray(`  Requirement: ${idea}`));
   console.log();
   for (const r of results) {
-    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}`) : "";
+    const icon = r.status === "success" ? chalk18.green("\u2714") : r.status === "failed" ? chalk18.red("\u2718") : chalk18.gray("\u2212");
+    const specInfo = r.specFile ? chalk18.gray(` \u2192 ${r.specFile}`) : "";
     console.log(`  ${icon} ${r.repoName} (${r.status})${specInfo}`);
   }
   return results;
@@ -11083,18 +10981,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 = path23.join(currentDir, WORKSPACE_CONFIG_FILE);
-  if (await fs24.pathExists(configPath)) {
+  const configPath = path22.join(currentDir, WORKSPACE_CONFIG_FILE);
+  if (await fs23.pathExists(configPath)) {
     const overwrite = await confirm2({
       message: `${WORKSPACE_CONFIG_FILE} already exists. Overwrite?`,
       default: false
     });
     if (!overwrite) {
-      console.log(chalk19.gray("  Cancelled."));
+      console.log(chalk18.gray("  Cancelled."));
       return;
     }
   }
-  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"));
+  console.log(chalk18.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"
@@ -11108,11 +11006,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(chalk19.yellow("  No recognizable repos found in sibling directories."));
+      console.log(chalk18.yellow("  No recognizable repos found in sibling directories."));
     } else {
-      console.log(chalk19.cyan("\n  Detected repos:"));
+      console.log(chalk18.cyan("\n  Detected repos:"));
       for (const r of detected) {
-        console.log(chalk19.gray(`    - ${r.name}: ${r.role} (${r.type}) at ${r.path}`));
+        console.log(chalk18.gray(`    - ${r.name}: ${r.role} (${r.type}) at ${r.path}`));
       }
       const keepAll = await confirm2({
         message: `Include all ${detected.length} detected repo(s)?`,
@@ -11129,7 +11027,7 @@ workspaceCmd.command("init").description(`Interactive workspace setup \u2014 cre
           if (keep) repos.push(r);
         }
       }
-      console.log(chalk19.green(`  \u2714 ${repos.length} repo(s) added from auto-scan.`));
+      console.log(chalk18.green(`  \u2714 ${repos.length} repo(s) added from auto-scan.`));
     }
   }
   const repoTypeChoices = [
@@ -11151,7 +11049,7 @@ workspaceCmd.command("init").description(`Interactive workspace setup \u2014 cre
     default: repos.length === 0
   });
   while (addMore) {
-    console.log(chalk19.cyan(`
+    console.log(chalk18.cyan(`
   Adding repo #${repos.length + 1}`));
     const repoName = await input({
       message: "Repo name (e.g. api, web, app):",
@@ -11165,16 +11063,16 @@ workspaceCmd.command("init").description(`Interactive workspace setup \u2014 cre
       message: `Relative path to "${repoName}" from here (default: ./${repoName}):`,
       default: `./${repoName}`
     });
-    const absPath = path23.resolve(currentDir, repoPath);
+    const absPath = path22.resolve(currentDir, repoPath);
     let detectedType = "unknown";
     let detectedRole = "shared";
-    if (await fs24.pathExists(absPath)) {
+    if (await fs23.pathExists(absPath)) {
       const { type, role } = await detectRepoType(absPath);
       detectedType = type;
       detectedRole = role;
-      console.log(chalk19.gray(`    Auto-detected: type=${type}, role=${role}`));
+      console.log(chalk18.gray(`    Auto-detected: type=${type}, role=${role}`));
     } else {
-      console.log(chalk19.yellow(`    Path "${absPath}" not found \u2014 type/role will be manual.`));
+      console.log(chalk18.yellow(`    Path "${absPath}" not found \u2014 type/role will be manual.`));
     }
     const repoType = await select3({
       message: `Repo type for "${repoName}":`,
@@ -11197,53 +11095,53 @@ workspaceCmd.command("init").description(`Interactive workspace setup \u2014 cre
       type: repoType,
       role: repoRole
     });
-    console.log(chalk19.green(`  \u2714 Added: ${repoName} (${repoRole}, ${repoType})`));
+    console.log(chalk18.green(`  \u2714 Added: ${repoName} (${repoRole}, ${repoType})`));
     addMore = await confirm2({
       message: "Add another repo?",
       default: false
     });
   }
   const workspaceConfig = { name: workspaceName, repos };
-  console.log(chalk19.cyan("\n  Workspace summary:"));
-  console.log(chalk19.gray(`  Name: ${workspaceName}`));
+  console.log(chalk18.cyan("\n  Workspace summary:"));
+  console.log(chalk18.gray(`  Name: ${workspaceName}`));
   for (const r of repos) {
-    console.log(chalk19.gray(`  - ${r.name}: ${r.role} (${r.type}) at ${r.path}`));
+    console.log(chalk18.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(chalk19.gray("  Cancelled."));
+    console.log(chalk18.gray("  Cancelled."));
     return;
   }
   const loader = new WorkspaceLoader(currentDir);
   const saved = await loader.save(workspaceConfig);
-  console.log(chalk19.green(`
+  console.log(chalk18.green(`
   \u2714 Workspace saved: ${saved}`));
-  console.log(chalk19.gray(`  Run \`ai-spec create "your feature"\` \u2014 workspace mode will activate automatically.`));
+  console.log(chalk18.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(chalk19.yellow(`No ${WORKSPACE_CONFIG_FILE} found in ${currentDir}`));
-    console.log(chalk19.gray("  Run `ai-spec workspace init` to create one."));
+    console.log(chalk18.yellow(`No ${WORKSPACE_CONFIG_FILE} found in ${currentDir}`));
+    console.log(chalk18.gray("  Run `ai-spec workspace init` to create one."));
     return;
   }
-  console.log(chalk19.bold(`
+  console.log(chalk18.bold(`
 Workspace: ${config2.name}`));
-  console.log(chalk19.gray(`  Config: ${path23.join(currentDir, WORKSPACE_CONFIG_FILE)}`));
-  console.log(chalk19.gray(`  Repos (${config2.repos.length}):
+  console.log(chalk18.gray(`  Config: ${path22.join(currentDir, WORKSPACE_CONFIG_FILE)}`));
+  console.log(chalk18.gray(`  Repos (${config2.repos.length}):
 `));
   for (const repo of config2.repos) {
     const absPath = loader.resolveAbsPath(repo);
-    const exists = await fs24.pathExists(absPath);
-    const status = exists ? chalk19.green("found") : chalk19.red("not found");
+    const exists = await fs23.pathExists(absPath);
+    const status = exists ? chalk18.green("found") : chalk18.red("not found");
     console.log(
-      `  ${chalk19.bold(repo.name.padEnd(12))} ${repo.role.padEnd(10)} ${repo.type.padEnd(16)} ${status}`
+      `  ${chalk18.bold(repo.name.padEnd(12))} ${repo.role.padEnd(10)} ${repo.type.padEnd(16)} ${status}`
     );
-    console.log(chalk19.gray(`    path: ${absPath}`));
+    console.log(chalk18.gray(`    path: ${absPath}`));
     if (repo.constitution) {
-      console.log(chalk19.green(`    constitution: found`));
+      console.log(chalk18.green(`    constitution: found`));
     }
   }
 });
@@ -11260,30 +11158,30 @@ 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(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}`));
+  console.log(chalk18.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(chalk18.gray(`  Provider: ${providerName}/${modelName}`));
   const updateRunId = generateRunId();
   const updateSnapshot = new RunSnapshot(currentDir, updateRunId);
   setActiveSnapshot(updateSnapshot);
   const updateLogger = new RunLogger(currentDir, updateRunId, { provider: providerName, model: modelName });
   setActiveLogger(updateLogger);
-  console.log(chalk19.gray(`  Run ID: ${updateRunId}`));
+  console.log(chalk18.gray(`  Run ID: ${updateRunId}`));
   let specPath = opts.spec ?? null;
   if (!specPath) {
-    const specsDir = path23.join(currentDir, "specs");
+    const specsDir = path22.join(currentDir, "specs");
     const latest = await SpecUpdater.findLatestSpec(specsDir);
     if (!latest) {
-      console.error(chalk19.red("  No spec files found in specs/. Run `ai-spec create` first or use --spec <path>."));
+      console.error(chalk18.red("  No spec files found in specs/. Run `ai-spec create` first or use --spec <path>."));
       process.exit(1);
     }
     specPath = latest.filePath;
-    console.log(chalk19.gray(`  Using spec: ${path23.relative(currentDir, specPath)} (v${latest.version})`));
+    console.log(chalk18.gray(`  Using spec: ${path22.relative(currentDir, specPath)} (v${latest.version})`));
   }
-  console.log(chalk19.gray("  Loading project context..."));
+  console.log(chalk18.gray("  Loading project context..."));
   const loader = new ContextLoader(currentDir);
   const context = await loader.loadProjectContext();
   if (context.constitution && context.constitution.length > 6e3) {
-    console.log(chalk19.yellow(`  \u26A0 Constitution is long (${context.constitution.length.toLocaleString()} chars). Consider running: ai-spec init --consolidate`));
+    console.log(chalk18.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);
@@ -11295,19 +11193,19 @@ program.command("update").description("Update an existing spec with a change req
       repoType
     });
   } catch (err) {
-    console.error(chalk19.red(`  Update failed: ${err.message}`));
+    console.error(chalk18.red(`  Update failed: ${err.message}`));
     process.exit(1);
   }
-  console.log(chalk19.green(`
-  \u2714 Spec updated \u2192 v${result.newVersion}: ${path23.relative(currentDir, result.newSpecPath)}`));
+  console.log(chalk18.green(`
+  \u2714 Spec updated \u2192 v${result.newVersion}: ${path22.relative(currentDir, result.newSpecPath)}`));
   if (result.newDslPath) {
-    console.log(chalk19.green(`  \u2714 DSL updated: ${path23.relative(currentDir, result.newDslPath)}`));
+    console.log(chalk18.green(`  \u2714 DSL updated: ${path22.relative(currentDir, result.newDslPath)}`));
   }
   if (result.affectedFiles.length > 0) {
-    console.log(chalk19.cyan("\n  Affected files:"));
+    console.log(chalk18.cyan("\n  Affected files:"));
     for (const f of result.affectedFiles) {
-      const icon = f.action === "create" ? chalk19.green("+") : chalk19.yellow("~");
-      console.log(`    ${icon} ${f.file}: ${chalk19.gray(f.description)}`);
+      const icon = f.action === "create" ? chalk18.green("+") : chalk18.yellow("~");
+      console.log(`    ${icon} ${f.file}: ${chalk18.gray(f.description)}`);
     }
   }
   if (opts.codegen && result.affectedFiles.length > 0) {
@@ -11315,9 +11213,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(chalk19.blue("\n  Regenerating affected files..."));
+    console.log(chalk18.blue("\n  Regenerating affected files..."));
     const codeGenerator = new CodeGenerator(codegenProvider, "api");
-    const specContent = await fs24.readFile(result.newSpecPath, "utf-8");
+    const specContent = await fs23.readFile(result.newSpecPath, "utf-8");
     const constitutionSection = context.constitution ? `
 === Project Constitution (MUST follow) ===
 ${context.constitution}
@@ -11328,10 +11226,10 @@ ${JSON.stringify(result.updatedDsl, null, 2).slice(0, 3e3)}
 ` : "";
     updateLogger.stageStart("update_codegen");
     for (const affected of result.affectedFiles) {
-      const fullPath = path23.join(currentDir, affected.file);
+      const fullPath = path22.join(currentDir, affected.file);
       let existing = "";
       try {
-        existing = await fs24.readFile(fullPath, "utf-8");
+        existing = await fs23.readFile(fullPath, "utf-8");
       } catch {
       }
       const codePrompt = `Apply this change to the file.
@@ -11345,23 +11243,23 @@ ${specContent}
 ${constitutionSection}${dslSection}
 === ${existing ? "Current File (return the FULL updated content)" : "New File"} ===
 ${existing || "Create from scratch."}`;
-      process.stdout.write(`  ${existing ? chalk19.yellow("~") : chalk19.green("+")} ${affected.file}... `);
+      process.stdout.write(`  ${existing ? chalk18.yellow("~") : chalk18.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 fs24.ensureDir(path23.dirname(fullPath));
+        await fs23.ensureDir(path22.dirname(fullPath));
         await updateSnapshot.snapshotFile(fullPath);
-        await fs24.writeFile(fullPath, content, "utf-8");
+        await fs23.writeFile(fullPath, content, "utf-8");
         updateLogger.fileWritten(affected.file);
-        console.log(chalk19.green("\u2714"));
+        console.log(chalk18.green("\u2714"));
       } catch (err) {
         updateLogger.stageFail("update_codegen", `${affected.file}: ${err.message}`);
-        console.log(chalk19.red(`\u2718 ${err.message}`));
+        console.log(chalk18.red(`\u2718 ${err.message}`));
       }
     }
     updateLogger.stageEnd("update_codegen", { filesUpdated: result.affectedFiles.length });
-    const updatedSpecContent = await fs24.readFile(result.newSpecPath, "utf-8").catch(() => "");
+    const updatedSpecContent = await fs23.readFile(result.newSpecPath, "utf-8").catch(() => "");
     if (updatedSpecContent) {
       const updateReviewer = new CodeReviewer(provider, currentDir);
       const reviewResult = await updateReviewer.reviewCode(updatedSpecContent, result.newSpecPath).catch(() => "");
@@ -11373,13 +11271,13 @@ ${existing || "Create from scratch."}`;
   updateLogger.finish();
   updateLogger.printSummary();
   if (updateSnapshot.fileCount > 0) {
-    console.log(chalk19.gray(`  To undo changes: ai-spec restore ${updateRunId}`));
+    console.log(chalk18.gray(`  To undo changes: ai-spec restore ${updateRunId}`));
   }
   if (!opts.codegen && result.affectedFiles.length > 0) {
-    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`));
+    console.log(chalk18.blue("\n  Next steps:"));
+    console.log(chalk18.gray(`  \u2022 Re-run with --codegen to regenerate affected files automatically`));
+    console.log(chalk18.gray(`  \u2022 Or update files manually based on the affected files list above`));
+    console.log(chalk18.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) => {
@@ -11388,19 +11286,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(chalk19.red("  No .dsl.json file found. Run `ai-spec create` first or use --dsl <path>."));
+      console.error(chalk18.red("  No .dsl.json file found. Run `ai-spec create` first or use --dsl <path>."));
       process.exit(1);
     }
-    console.log(chalk19.gray(`  Using DSL: ${path23.relative(currentDir, dslPath)}`));
+    console.log(chalk18.gray(`  Using DSL: ${path22.relative(currentDir, dslPath)}`));
   }
   let dsl;
   try {
-    dsl = await fs24.readJson(dslPath);
+    dsl = await fs23.readJson(dslPath);
   } catch (err) {
-    console.error(chalk19.red(`  Failed to read DSL: ${err.message}`));
+    console.error(chalk18.red(`  Failed to read DSL: ${err.message}`));
     process.exit(1);
   }
-  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"));
+  console.log(chalk18.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 {
@@ -11409,31 +11307,31 @@ program.command("export").description("Export the latest DSL to OpenAPI 3.1.0 (Y
       serverUrl,
       outputPath: opts.output
     });
-    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`));
+    const rel = path22.relative(currentDir, outputPath);
+    console.log(chalk18.green(`  \u2714 OpenAPI ${format.toUpperCase()} exported: ${rel}`));
+    console.log(chalk18.gray(`  Feature  : ${dsl.feature.title}`));
+    console.log(chalk18.gray(`  Endpoints: ${dsl.endpoints.length}`));
+    console.log(chalk18.gray(`  Models   : ${dsl.models.length}`));
+    console.log(chalk18.gray(`  Server   : ${serverUrl}`));
+    console.log(chalk18.blue("\n  Next steps:"));
+    console.log(chalk18.gray(`  \u2022 Import ${rel} into Postman / Insomnia / Swagger UI`));
+    console.log(chalk18.gray(`  \u2022 Use openapi-generator to generate client SDKs`));
   } catch (err) {
-    console.error(chalk19.red(`  Export failed: ${err.message}`));
+    console.error(chalk18.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(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"));
+  console.log(chalk18.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 ? path23.resolve(opts.frontend) : currentDir;
+    const frontendDir = opts.frontend ? path22.resolve(opts.frontend) : currentDir;
     const r = await restoreMockProxy(frontendDir);
     if (r.restored) {
-      console.log(chalk19.green("  \u2714 Proxy restored and mock server stopped."));
+      console.log(chalk18.green("  \u2714 Proxy restored and mock server stopped."));
     } else {
-      console.log(chalk19.yellow(`  ${r.note ?? "Nothing to restore."}`));
+      console.log(chalk18.yellow(`  ${r.note ?? "Nothing to restore."}`));
     }
     return;
   }
@@ -11441,32 +11339,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(chalk19.red(`  No ${WORKSPACE_CONFIG_FILE} found. Run \`ai-spec workspace init\` first.`));
+      console.error(chalk18.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(chalk19.yellow("  No backend repos found in workspace."));
+      console.log(chalk18.yellow("  No backend repos found in workspace."));
       return;
     }
     for (const repo of backendRepos) {
       const repoAbsPath = workspaceLoader.resolveAbsPath(repo);
-      console.log(chalk19.cyan(`
+      console.log(chalk18.cyan(`
   Repo: ${repo.name} (${repoAbsPath})`));
       const dslFile = await findLatestDslFile(repoAbsPath);
       if (!dslFile) {
-        console.log(chalk19.yellow(`    No DSL file found \u2014 skipping.`));
+        console.log(chalk18.yellow(`    No DSL file found \u2014 skipping.`));
         continue;
       }
-      const dsl2 = await fs24.readJson(dslFile);
+      const dsl2 = await fs23.readJson(dslFile);
       const result2 = await generateMockAssets(dsl2, repoAbsPath, {
         port,
         msw: opts.msw,
         proxy: opts.proxy
       });
       for (const f of result2.files) {
-        console.log(chalk19.green(`    \u2714 ${f.path}`));
-        console.log(chalk19.gray(`      ${f.description}`));
+        console.log(chalk18.green(`    \u2714 ${f.path}`));
+        console.log(chalk18.gray(`      ${f.description}`));
       }
     }
     return;
@@ -11476,19 +11374,19 @@ program.command("mock").description("Generate a standalone mock server + proxy c
     dslPath = await findLatestDslFile(currentDir);
     if (!dslPath) {
       console.error(
-        chalk19.red(
+        chalk18.red(
           "  No .dsl.json file found in .ai-spec/. Run `ai-spec create` first or use --dsl <path>."
         )
       );
       process.exit(1);
     }
-    console.log(chalk19.gray(`  Using DSL: ${path23.relative(currentDir, dslPath)}`));
+    console.log(chalk18.gray(`  Using DSL: ${path22.relative(currentDir, dslPath)}`));
   }
   let dsl;
   try {
-    dsl = await fs24.readJson(dslPath);
+    dsl = await fs23.readJson(dslPath);
   } catch (err) {
-    console.error(chalk19.red(`  Failed to read DSL file: ${err.message}`));
+    console.error(chalk18.red(`  Failed to read DSL file: ${err.message}`));
     process.exit(1);
   }
   const result = await generateMockAssets(dsl, currentDir, {
@@ -11496,58 +11394,58 @@ program.command("mock").description("Generate a standalone mock server + proxy c
     msw: opts.msw,
     proxy: opts.proxy
   });
-  console.log(chalk19.green(`
+  console.log(chalk18.green(`
   \u2714 Mock assets generated (${result.files.length} file(s)):`));
   for (const f of result.files) {
-    console.log(chalk19.green(`    ${f.path}`));
-    console.log(chalk19.gray(`      ${f.description}`));
+    console.log(chalk18.green(`    ${f.path}`));
+    console.log(chalk18.gray(`      ${f.description}`));
   }
   if (opts.serve) {
-    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."));
+    const serverJsPath = path22.join(currentDir, "mock", "server.js");
+    if (!await fs23.pathExists(serverJsPath)) {
+      console.error(chalk18.red("  mock/server.js not found \u2014 generation may have failed."));
       process.exit(1);
     }
     const pid = startMockServerBackground(serverJsPath, port);
-    console.log(chalk19.green(`
+    console.log(chalk18.green(`
   \u2714 Mock server started (PID ${pid}) \u2192 http://localhost:${port}`));
     if (opts.frontend) {
-      const frontendDir = path23.resolve(opts.frontend);
+      const frontendDir = path22.resolve(opts.frontend);
       const proxyResult = await applyMockProxy(frontendDir, port, dsl.endpoints);
       await saveMockServerPid(frontendDir, pid);
       if (proxyResult.applied) {
-        console.log(chalk19.green(`  \u2714 Frontend proxy patched (${proxyResult.framework})`));
-        console.log(chalk19.bold.cyan(`
+        console.log(chalk18.green(`  \u2714 Frontend proxy patched (${proxyResult.framework})`));
+        console.log(chalk18.bold.cyan(`
   Ready! Open a new terminal and run:`));
-        console.log(chalk19.white(`    cd ${frontendDir}`));
-        console.log(chalk19.white(`    ${proxyResult.devCommand}`));
-        console.log(chalk19.gray(`
+        console.log(chalk18.white(`    cd ${frontendDir}`));
+        console.log(chalk18.white(`    ${proxyResult.devCommand}`));
+        console.log(chalk18.gray(`
   When done: ai-spec mock --restore --frontend ${frontendDir}`));
       } else {
-        console.log(chalk19.yellow(`  \u26A0 Auto-patch not available for ${proxyResult.framework}.`));
-        if (proxyResult.note) console.log(chalk19.gray(`    ${proxyResult.note}`));
+        console.log(chalk18.yellow(`  \u26A0 Auto-patch not available for ${proxyResult.framework}.`));
+        if (proxyResult.note) console.log(chalk18.gray(`    ${proxyResult.note}`));
       }
     } else {
-      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}`));
+      console.log(chalk18.gray(`  Tip: use --frontend <path> to also auto-patch your frontend proxy config.`));
+      console.log(chalk18.gray(`  Mock server: http://localhost:${port}`));
     }
     return;
   }
-  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}`));
+  console.log(chalk18.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(chalk18.white(`  1. Install express (if not already):`));
+  console.log(chalk18.gray(`       npm install --save-dev express`));
+  console.log(chalk18.white(`  2. Start mock server:`));
+  console.log(chalk18.gray(`       node mock/server.js`));
+  console.log(chalk18.gray(`       # or: ai-spec mock --serve --frontend <path-to-frontend>`));
+  console.log(chalk18.white(`  3. Configure your frontend to proxy API calls to:`));
+  console.log(chalk18.gray(`       http://localhost:${port}`));
   if (opts.proxy) {
-    console.log(chalk19.gray(`     (See the generated proxy config file for framework-specific instructions)`));
+    console.log(chalk18.gray(`     (See the generated proxy config file for framework-specific instructions)`));
   }
   if (opts.msw) {
-    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();`));
+    console.log(chalk18.white(`  4. MSW: import and start the worker in your app entry:`));
+    console.log(chalk18.gray(`       import { worker } from './mocks/browser';`));
+    console.log(chalk18.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) => {
@@ -11563,34 +11461,26 @@ program.command("learn").description("Append a lesson or engineering decision di
   }
   const result = await appendDirectLesson(currentDir, lesson.trim());
   if (result.appended) {
-    console.log(chalk19.green(`
+    console.log(chalk18.green(`
   \u2714 Lesson appended to constitution \xA79`));
-    console.log(chalk19.gray(`  File: .ai-spec-constitution.md`));
+    console.log(chalk18.gray(`  File: .ai-spec-constitution.md`));
   } else {
-    console.log(chalk19.yellow(`
+    console.log(chalk18.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}...`));
+  console.log(chalk18.blue(`Restoring run: ${runId}...`));
   const restored = await snapshot.restore();
   if (restored.length === 0) {
-    console.log(chalk19.yellow("  No backup found for this run ID."));
+    console.log(chalk18.yellow("  No backup found for this run ID."));
   } else {
-    restored.forEach((f) => console.log(chalk19.green(`  \u2714 restored: ${f}`)));
-    console.log(chalk19.bold.green(`
+    restored.forEach((f) => console.log(chalk18.green(`  \u2714 restored: ${f}`)));
+    console.log(chalk18.bold.green(`
 \u2714 ${restored.length} file(s) restored.`));
   }
 });
-if (process.argv.length <= 2) {
-  (async () => {
-    const currentDir = process.cwd();
-    const config2 = await loadConfig(currentDir);
-    await printWelcome(currentDir, config2);
-  })();
-} else {
-  program.parse();
-}
+program.parse();
 //# sourceMappingURL=index.mjs.map