ai-spec-dev 0.30.0 → 0.31.0

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,8 +467,8 @@ var init_workspace_loader = __esm({
 
 // cli/index.ts
 import { Command } from "commander";
-import * as path23 from "path";
-import * as fs24 from "fs-extra";
+import * as path22 from "path";
+import * as fs23 from "fs-extra";
 import chalk19 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)}`
     });
   }
@@ -6106,6 +6106,16 @@ var RunLogger = class {
     this.log.errors.push(`[${event}] ${error}`);
     this.flush();
   }
+  /** Record the prompt hash for this run (call once at run start). */
+  setPromptHash(hash) {
+    this.log.promptHash = hash;
+    this.flush();
+  }
+  /** Record the harness self-eval score (call once at run end). */
+  setHarnessScore(score) {
+    this.log.harnessScore = score;
+    this.flush();
+  }
   fileWritten(filePath) {
     if (!this.log.filesWritten.includes(filePath)) {
       this.log.filesWritten.push(filePath);
@@ -8318,108 +8328,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 +8837,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 +8974,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 +9169,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 +9215,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 +9291,7 @@ async function restoreMockProxy(frontendDir) {
     } catch {
     }
   }
-  await fs21.remove(lockPath);
+  await fs20.remove(lockPath);
   return { restored: true };
 }
 function startMockServerBackground(serverJsPath, port) {
@@ -9396,23 +9304,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 +9350,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 +9405,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 +9560,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 +9569,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 +9581,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 +9599,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 +9619,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 +9628,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 +9647,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 +9657,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 +9887,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,18 +9895,115 @@ 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;
 }
 
+// core/prompt-hasher.ts
+init_codegen_prompt();
+init_codegen_prompt();
+import { createHash } from "crypto";
+function computePromptHash() {
+  const segments = [
+    codeGenSystemPrompt,
+    dslSystemPrompt,
+    specPrompt,
+    reviewArchitectureSystemPrompt,
+    reviewImplementationSystemPrompt,
+    reviewImpactComplexitySystemPrompt
+  ];
+  return createHash("sha256").update(segments.join("\0")).digest("hex").slice(0, 8);
+}
+
+// core/self-evaluator.ts
+import chalk18 from "chalk";
+var ENDPOINT_LAYER_PATTERNS = [
+  /src\/api/,
+  /src\/routes?/,
+  /src\/controller/,
+  /src\/handler/,
+  /src\/endpoints?/
+];
+var MODEL_LAYER_PATTERNS = [
+  /src\/model/,
+  /src\/schema/,
+  /src\/entit/,
+  /src\/db/,
+  /prisma/,
+  /src\/data/,
+  /src\/domain/
+];
+function extractReviewScore(reviewText) {
+  const match = reviewText.match(/Score:\s*(\d+(?:\.\d+)?)\s*\/\s*10/i);
+  return match ? parseFloat(match[1]) : null;
+}
+function runSelfEval(opts) {
+  const { dsl, generatedFiles, compilePassed, reviewText, promptHash, logger } = opts;
+  const endpointsTotal = dsl?.endpoints?.length ?? 0;
+  const modelsTotal = dsl?.models?.length ?? 0;
+  const endpointLayerCovered = generatedFiles.some(
+    (f) => ENDPOINT_LAYER_PATTERNS.some((p) => p.test(f))
+  );
+  const modelLayerCovered = generatedFiles.some(
+    (f) => MODEL_LAYER_PATTERNS.some((p) => p.test(f))
+  );
+  let dslCoverageScore = 10;
+  if (generatedFiles.length === 0) {
+    dslCoverageScore = 0;
+  } else {
+    if (endpointsTotal > 0 && !endpointLayerCovered) dslCoverageScore -= 4;
+    if (modelsTotal > 0 && !modelLayerCovered) dslCoverageScore -= 3;
+  }
+  const compileScore = compilePassed ? 10 : 5;
+  const reviewScore = reviewText ? extractReviewScore(reviewText) : null;
+  const harnessScore = reviewScore !== null ? Math.round((dslCoverageScore * 0.4 + compileScore * 0.3 + reviewScore * 0.3) * 10) / 10 : Math.round((dslCoverageScore * 0.55 + compileScore * 0.45) * 10) / 10;
+  const result = {
+    dslCoverageScore,
+    compileScore,
+    reviewScore,
+    harnessScore,
+    promptHash,
+    detail: {
+      endpointsTotal,
+      endpointLayerCovered,
+      modelsTotal,
+      modelLayerCovered,
+      filesWritten: generatedFiles.length
+    }
+  };
+  logger.setHarnessScore(harnessScore);
+  logger.stageEnd("self_eval", {
+    harnessScore,
+    dslCoverageScore,
+    compileScore,
+    reviewScore: reviewScore ?? void 0,
+    promptHash
+  });
+  return result;
+}
+function printSelfEval(result) {
+  const scoreColor = result.harnessScore >= 8 ? chalk18.green : result.harnessScore >= 6 ? chalk18.yellow : chalk18.red;
+  const filled = Math.round(result.harnessScore);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+  const compileTag = result.compileScore === 10 ? chalk18.green("pass") : chalk18.yellow("partial");
+  const reviewTag = result.reviewScore !== null ? `Review: ${result.reviewScore}/10` : chalk18.gray("Review: skipped");
+  console.log(chalk18.cyan("\n\u2500\u2500\u2500 Harness Self-Eval \u2500\u2500\u2500\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(`  Score  : ${scoreColor(`[${bar}] ${result.harnessScore}/10`)}`);
+  console.log(
+    `  DSL    : ${scoreColor(result.dslCoverageScore + "/10")}  Compile: ${compileTag}  ${reviewTag}`
+  );
+  console.log(chalk18.gray(`  Prompt : ${result.promptHash}`));
+  console.log(chalk18.gray("\u2500".repeat(49)));
+}
+
 // cli/index.ts
 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 {};
 }
@@ -10076,7 +10081,7 @@ program.command("create").description("Generate a feature spec and kick off code
       } else {
         const mockPort = 3001;
         const mockResult = await generateMockAssets(backendResult.dsl, backendResult.repoAbsPath, { port: mockPort });
-        const serverJsPath = path23.join(backendResult.repoAbsPath, "mock", "server.js");
+        const serverJsPath = path22.join(backendResult.repoAbsPath, "mock", "server.js");
         console.log(chalk19.green(`  \u2714 Mock assets generated (${mockResult.files.length} file(s))`));
         const pid = startMockServerBackground(serverJsPath, mockPort);
         console.log(chalk19.green(`  \u2714 Mock server started (PID ${pid}) \u2192 http://localhost:${mockPort}`));
@@ -10127,6 +10132,8 @@ program.command("create").description("Generate a feature spec and kick off code
     model: specModelName
   });
   setActiveLogger(runLogger);
+  const promptHash = computePromptHash();
+  runLogger.setPromptHash(promptHash);
   console.log(chalk19.blue("[1/6] Loading project context..."));
   runLogger.stageStart("context_load");
   const loader = new ContextLoader(currentDir);
@@ -10240,7 +10247,7 @@ program.command("create").description("Generate a feature spec and kick off code
     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");
+    const previewSpecsDir = path22.join(currentDir, "specs");
     const slug = featureSlug;
     const prevVersion = await findLatestVersion(previewSpecsDir, slug);
     if (prevVersion) {
@@ -10318,10 +10325,10 @@ program.command("create").description("Generate a feature spec and kick off code
     const reason = opts.worktree ? "" : isFrontendProject2 ? " (frontend project \u2014 use --worktree to override)" : " (--skip-worktree)";
     console.log(chalk19.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");
+  await fs23.writeFile(specFile, finalSpec, "utf-8");
   console.log(chalk19.green(`
 [5/6] \u2714 Spec saved: ${specFile}`) + chalk19.gray(` (v${specVersion})`));
   let savedDslFile = null;
@@ -10383,14 +10390,16 @@ program.command("create").description("Generate a feature spec and kick off code
     generatedTestFiles = await testGen.generate(extractedDsl, workingDir);
     runLogger.stageEnd("test_gen", { filesGenerated: generatedTestFiles.length });
   }
+  let compilePassed = false;
   if (opts.skipErrorFeedback) {
     console.log(chalk19.gray("[8/9] Skipping error feedback (--skip-error-feedback)."));
+    compilePassed = true;
   } else {
     if (opts.tdd) {
       console.log(chalk19.cyan("[8/9] TDD mode \u2014 error feedback loop driving implementation to pass tests..."));
     }
     runLogger.stageStart("error_feedback");
-    await runErrorFeedback(codegenProvider, workingDir, extractedDsl, {
+    compilePassed = await runErrorFeedback(codegenProvider, workingDir, extractedDsl, {
       maxCycles: opts.tdd ? 3 : 2
       // TDD gets one extra cycle
     });
@@ -10401,7 +10410,7 @@ program.command("create").description("Generate a feature spec and kick off code
     console.log(chalk19.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 {
@@ -10416,6 +10425,16 @@ program.command("create").description("Generate a feature spec and kick off code
     runLogger.stageEnd("review");
     await accumulateReviewKnowledge(specProvider, currentDir, reviewResult);
   }
+  runLogger.stageStart("self_eval");
+  const selfEvalResult = runSelfEval({
+    dsl: extractedDsl,
+    generatedFiles,
+    compilePassed,
+    reviewText: reviewResult,
+    promptHash,
+    logger: runLogger
+  });
+  printSelfEval(selfEvalResult);
   runLogger.finish();
   console.log(chalk19.bold.green("\n\u2714 All done!"));
   console.log(chalk19.gray(`  Spec        : ${specFile}`));
@@ -10446,17 +10465,17 @@ 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}`));
   } 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]}`));
       }
@@ -10494,7 +10513,7 @@ program.command("init").description(`Analyze codebase and generate Project Const
         console.log(chalk19.gray(`  Lines : ${result.before.totalLines} \u2192 ${result.after.totalLines} (${result.before.totalLines - result.after.totalLines > 0 ? "-" : "+"}${Math.abs(result.before.totalLines - result.after.totalLines)})`));
         console.log(chalk19.gray(`  \xA79    : ${result.before.lessonCount} \u2192 ${result.after.lessonCount} lessons remaining`));
         if (result.backupPath) {
-          console.log(chalk19.gray(`  Backup: ${path23.basename(result.backupPath)}`));
+          console.log(chalk19.gray(`  Backup: ${path22.basename(result.backupPath)}`));
         }
       }
     } catch (err) {
@@ -10520,7 +10539,7 @@ program.command("init").description(`Analyze codebase and generate Project Const
       `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);
@@ -10540,8 +10559,8 @@ program.command("init").description(`Analyze codebase and generate Project Const
     }
     return;
   }
-  const constitutionPath = path23.join(currentDir, CONSTITUTION_FILE);
-  if (!opts.force && await fs24.pathExists(constitutionPath)) {
+  const constitutionPath = path22.join(currentDir, CONSTITUTION_FILE);
+  if (!opts.force && await fs23.pathExists(constitutionPath)) {
     console.log(chalk19.yellow(`
   ${CONSTITUTION_FILE} already exists.`));
     console.log(chalk19.gray("  Use --force to overwrite it."));
@@ -10560,7 +10579,7 @@ program.command("init").description(`Analyze codebase and generate Project Const
     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(`
   \u2139 Global constitution detected: ${globalResult.source}`));
@@ -10582,7 +10601,7 @@ 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.`));
@@ -10594,7 +10613,7 @@ program.command("config").description(`Set default configuration for this projec
     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."));
@@ -10610,7 +10629,7 @@ File: ${KEY_STORE_FILE}`));
     return;
   }
   if (opts.reset) {
-    await fs24.writeJson(configPath, {}, { spaces: 2 });
+    await fs23.writeJson(configPath, {}, { spaces: 2 });
     console.log(chalk19.green(`\u2714 Config reset: ${configPath}`));
     return;
   }
@@ -10638,13 +10657,13 @@ File: ${KEY_STORE_FILE}`));
     }
     updated.minSpecScore = score;
   }
-  await fs24.writeJson(configPath, updated, { spaces: 2 });
+  await fs23.writeJson(configPath, updated, { spaces: 2 });
   console.log(chalk19.green(`\u2714 Config saved to ${configPath}`));
   console.log(JSON.stringify(updated, null, 2));
 });
 program.command("model").description("Interactively switch the active AI provider/model and save to .ai-spec.json").option("--list", "List all available providers and models").action(async (opts) => {
   const currentDir = process.cwd();
-  const configPath = path23.join(currentDir, CONFIG_FILE);
+  const configPath = path22.join(currentDir, CONFIG_FILE);
   if (opts.list) {
     console.log(chalk19.bold("\nAvailable providers & models:\n"));
     for (const [key, meta] of Object.entries(PROVIDER_CATALOG)) {
@@ -10748,7 +10767,7 @@ program.command("model").description("Interactively switch the active AI provide
     console.log(chalk19.gray("  Cancelled."));
     return;
   }
-  await fs24.writeJson(configPath, updated, { spaces: 2 });
+  await fs23.writeJson(configPath, updated, { spaces: 2 });
   console.log(chalk19.green(`
   \u2714 Saved to ${configPath}`));
   const providerToCheck = updated.provider ?? "gemini";
@@ -10843,17 +10862,17 @@ ${contractContextSection}`;
   } else {
     console.log(chalk19.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(chalk19.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(chalk19.green(`    DSL saved: ${path22.relative(repoAbsPath, savedDslFile)}`));
   }
   console.log(chalk19.blue(`  [${repoName}] Running code generation (mode: ${codegenMode})...`));
   try {
@@ -11083,8 +11102,8 @@ 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
@@ -11165,10 +11184,10 @@ 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;
@@ -11231,12 +11250,12 @@ workspaceCmd.command("status").description("Show current workspace configuration
   }
   console.log(chalk19.bold(`
 Workspace: ${config2.name}`));
-  console.log(chalk19.gray(`  Config: ${path23.join(currentDir, WORKSPACE_CONFIG_FILE)}`));
+  console.log(chalk19.gray(`  Config: ${path22.join(currentDir, WORKSPACE_CONFIG_FILE)}`));
   console.log(chalk19.gray(`  Repos (${config2.repos.length}):
 `));
   for (const repo of config2.repos) {
     const absPath = loader.resolveAbsPath(repo);
-    const exists = await fs24.pathExists(absPath);
+    const exists = await fs23.pathExists(absPath);
     const status = exists ? chalk19.green("found") : chalk19.red("not found");
     console.log(
       `  ${chalk19.bold(repo.name.padEnd(12))} ${repo.role.padEnd(10)} ${repo.type.padEnd(16)} ${status}`
@@ -11270,14 +11289,14 @@ program.command("update").description("Update an existing spec with a change req
   console.log(chalk19.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>."));
       process.exit(1);
     }
     specPath = latest.filePath;
-    console.log(chalk19.gray(`  Using spec: ${path23.relative(currentDir, specPath)} (v${latest.version})`));
+    console.log(chalk19.gray(`  Using spec: ${path22.relative(currentDir, specPath)} (v${latest.version})`));
   }
   console.log(chalk19.gray("  Loading project context..."));
   const loader = new ContextLoader(currentDir);
@@ -11299,9 +11318,9 @@ program.command("update").description("Update an existing spec with a change req
     process.exit(1);
   }
   console.log(chalk19.green(`
-  \u2714 Spec updated \u2192 v${result.newVersion}: ${path23.relative(currentDir, result.newSpecPath)}`));
+  \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(chalk19.green(`  \u2714 DSL updated: ${path22.relative(currentDir, result.newDslPath)}`));
   }
   if (result.affectedFiles.length > 0) {
     console.log(chalk19.cyan("\n  Affected files:"));
@@ -11317,7 +11336,7 @@ program.command("update").description("Update an existing spec with a change req
     const codegenProvider = createProvider(codegenProviderName, codegenApiKey, codegenModelName);
     console.log(chalk19.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 +11347,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.
@@ -11350,9 +11369,9 @@ ${existing || "Create from scratch."}`;
         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"));
       } catch (err) {
@@ -11361,7 +11380,7 @@ ${existing || "Create from scratch."}`;
       }
     }
     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(() => "");
@@ -11391,11 +11410,11 @@ program.command("export").description("Export the latest DSL to OpenAPI 3.1.0 (Y
       console.error(chalk19.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(chalk19.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}`));
     process.exit(1);
@@ -11409,7 +11428,7 @@ program.command("export").description("Export the latest DSL to OpenAPI 3.1.0 (Y
       serverUrl,
       outputPath: opts.output
     });
-    const rel = path23.relative(currentDir, outputPath);
+    const rel = path22.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}`));
@@ -11428,7 +11447,7 @@ program.command("mock").description("Generate a standalone mock server + proxy c
   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"));
   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."));
@@ -11458,7 +11477,7 @@ program.command("mock").description("Generate a standalone mock server + proxy c
         console.log(chalk19.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,
@@ -11482,11 +11501,11 @@ program.command("mock").description("Generate a standalone mock server + proxy c
       );
       process.exit(1);
     }
-    console.log(chalk19.gray(`  Using DSL: ${path23.relative(currentDir, dslPath)}`));
+    console.log(chalk19.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}`));
     process.exit(1);
@@ -11503,8 +11522,8 @@ program.command("mock").description("Generate a standalone mock server + proxy c
     console.log(chalk19.gray(`      ${f.description}`));
   }
   if (opts.serve) {
-    const serverJsPath = path23.join(currentDir, "mock", "server.js");
-    if (!await fs24.pathExists(serverJsPath)) {
+    const serverJsPath = path22.join(currentDir, "mock", "server.js");
+    if (!await fs23.pathExists(serverJsPath)) {
       console.error(chalk19.red("  mock/server.js not found \u2014 generation may have failed."));
       process.exit(1);
     }
@@ -11512,7 +11531,7 @@ program.command("mock").description("Generate a standalone mock server + proxy c
     console.log(chalk19.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) {
@@ -11584,13 +11603,5 @@ program.command("restore").description("Restore files modified by a previous run
 \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