ai-spec-dev 0.42.0 → 0.46.0

package/dist/cli/index.mjs

@@ -4,6 +4,9 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -341,7 +344,6 @@ __export(spec_generator_exports, {
 import { GoogleGenerativeAI } from "@google/generative-ai";
 import Anthropic from "@anthropic-ai/sdk";
 import OpenAI from "openai";
-import axios from "axios";
 import { ProxyAgent } from "undici";
 function geminiRequestOptions() {
   const proxyUrl = process.env.GEMINI_PROXY || process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
@@ -387,7 +389,9 @@ var init_spec_generator = __esm({
         displayName: "MiMo (Xiaomi)",
         description: "\u5C0F\u7C73 MiMo \u2014 mimo-v2-pro (Anthropic-compatible API)",
         models: ["mimo-v2-pro"],
-        envKey: "MIMO_API_KEY"
+        envKey: "MIMO_API_KEY",
+        // Fallback env var — MiMo's token plan uses ANTHROPIC_AUTH_TOKEN
+        fallbackEnvKeys: ["ANTHROPIC_AUTH_TOKEN"]
         // baseURL not used — MiMo has a dedicated provider class
       },
       gemini: {
@@ -556,8 +560,8 @@ var init_spec_generator = __esm({
               ...systemInstruction ? { system: systemInstruction } : {},
               messages: [{ role: "user", content: prompt }]
             });
-            const block = message.content[0];
-            if (block.type === "text") return block.text;
+            const textBlock = message.content.find((b) => b.type === "text");
+            if (textBlock) return textBlock.text;
             throw new Error("Unexpected response type from Claude API");
           },
           { label: `${this.providerName}/${this.modelName}` }
@@ -602,43 +606,29 @@ var init_spec_generator = __esm({
       }
     };
     MiMoProvider = class {
+      client;
       providerName = "mimo";
       modelName;
-      apiKey;
-      baseUrl = "https://api.xiaomimimo.com/anthropic/v1/messages";
       constructor(apiKey, modelName = PROVIDER_CATALOG.mimo.models[0]) {
-        this.apiKey = apiKey;
+        const baseURL = process.env["MIMO_BASE_URL"] || process.env["ANTHROPIC_BASE_URL"] || "https://token-plan-cn.xiaomimimo.com/anthropic";
+        this.client = new Anthropic({ apiKey, baseURL });
         this.modelName = modelName;
       }
       async generate(prompt, systemInstruction) {
         return withReliability(
           async () => {
-            const body = {
+            const stream = this.client.messages.stream({
               model: this.modelName,
-              max_tokens: 16384,
-              messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
-              top_p: 0.95,
-              stream: false,
-              temperature: 1,
-              stop_sequences: null
-            };
-            if (systemInstruction) {
-              body.system = systemInstruction;
-            }
-            const response = await axios.post(this.baseUrl, body, {
-              headers: {
-                "api-key": this.apiKey,
-                "Content-Type": "application/json"
-              }
+              max_tokens: 65536,
+              ...systemInstruction ? { system: systemInstruction } : {},
+              messages: [{ role: "user", content: prompt }]
             });
-            const data = response.data;
-            const blocks = data?.content ?? [];
-            const textBlock = blocks.find((b) => b.type === "text");
-            if (textBlock?.text) return textBlock.text;
-            if (data?.stop_reason === "max_tokens") {
-              throw new Error(`MiMo response truncated (max_tokens reached). The prompt may be too long. Try a shorter spec or switch to a model with larger context.`);
-            }
-            throw new Error(`Unexpected MiMo response: ${JSON.stringify(response.data).slice(0, 200)}`);
+            const message = await stream.finalMessage();
+            const textBlock = message.content.find((b) => b.type === "text");
+            if (textBlock) return textBlock.text;
+            const thinkBlock = message.content.find((b) => b.type === "thinking");
+            if (thinkBlock) return thinkBlock.thinking;
+            return message.content.map((b) => b.text ?? "").join("");
           },
           { label: `${this.providerName}/${this.modelName}` }
         );
@@ -699,14 +689,71 @@ ${context.schema.slice(0, 3e3)}`);
   }
 });
 
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "ai-spec-dev",
+      version: "0.46.0",
+      description: "AI-driven Development Orchestrator SDK & CLI",
+      main: "dist/index.js",
+      types: "dist/index.d.ts",
+      bin: {
+        "ai-spec": "dist/cli/index.js"
+      },
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        test: "vitest run",
+        "test:watch": "vitest"
+      },
+      keywords: [
+        "ai",
+        "spec",
+        "codegen",
+        "gemini",
+        "claude"
+      ],
+      author: "",
+      license: "MIT",
+      dependencies: {
+        "@anthropic-ai/sdk": "^0.38.0",
+        "@google/generative-ai": "^0.21.0",
+        "@inquirer/editor": "^5.0.10",
+        "@inquirer/prompts": "^8.3.2",
+        "@rollup/rollup-darwin-arm64": "^4.60.1",
+        axios: "^1.13.6",
+        chalk: "^4.1.2",
+        commander: "^13.1.0",
+        dotenv: "^16.4.7",
+        "fs-extra": "^11.3.0",
+        openai: "^6.31.0",
+        undici: "^7.24.4"
+      },
+      devDependencies: {
+        "@types/fs-extra": "^11.0.4",
+        "@types/glob": "^8.1.0",
+        "@types/node": "^22.13.5",
+        glob: "^13.0.6",
+        "ts-node": "^10.9.2",
+        tsup: "^8.4.0",
+        typescript: "^5.7.3",
+        vitest: "^2.1.0"
+      }
+    };
+  }
+});
+
 // cli/index.ts
 import { Command } from "commander";
 import * as dotenv from "dotenv";
 
 // cli/commands/create.ts
 init_spec_generator();
+import * as path26 from "path";
+import * as fs27 from "fs-extra";
 import chalk26 from "chalk";
-import { input as input2 } from "@inquirer/prompts";
+import { input as input2, select as select7, checkbox } from "@inquirer/prompts";
 
 // core/workspace-loader.ts
 import * as fs from "fs-extra";
@@ -806,8 +853,8 @@ var WorkspaceLoader = class {
     const repos = [];
     for (const entry of entries) {
       const absPath = path.join(this.workspaceRoot, entry);
-      const stat4 = await fs.stat(absPath).catch(() => null);
-      if (!stat4 || !stat4.isDirectory()) continue;
+      const stat5 = await fs.stat(absPath).catch(() => null);
+      if (!stat5 || !stat5.isDirectory()) continue;
       if (entry.startsWith(".") || entry === "node_modules") continue;
       if (names && !names.includes(entry)) continue;
       const hasManifest = await fs.pathExists(path.join(absPath, "package.json")) || await fs.pathExists(path.join(absPath, "go.mod")) || await fs.pathExists(path.join(absPath, "Cargo.toml")) || await fs.pathExists(path.join(absPath, "pom.xml")) || await fs.pathExists(path.join(absPath, "build.gradle")) || await fs.pathExists(path.join(absPath, "requirements.txt")) || await fs.pathExists(path.join(absPath, "pyproject.toml")) || await fs.pathExists(path.join(absPath, "composer.json"));
@@ -871,6 +918,7 @@ var WorkspaceLoader = class {
 init_spec_generator();
 import * as path3 from "path";
 import * as fs3 from "fs-extra";
+import * as os2 from "os";
 import chalk2 from "chalk";
 import { input, select } from "@inquirer/prompts";
 
@@ -916,17 +964,42 @@ async function clearKey(provider) {
 
 // cli/utils.ts
 var CONFIG_FILE = ".ai-spec.json";
+var GLOBAL_CONFIG_FILE = path3.join(os2.homedir(), ".ai-spec-config.json");
+async function loadGlobalConfig() {
+  try {
+    if (await fs3.pathExists(GLOBAL_CONFIG_FILE)) {
+      return await fs3.readJson(GLOBAL_CONFIG_FILE);
+    }
+  } catch {
+  }
+  return {};
+}
+async function saveGlobalConfig(config2) {
+  await fs3.ensureFile(GLOBAL_CONFIG_FILE);
+  await fs3.writeJson(GLOBAL_CONFIG_FILE, config2, { spaces: 2 });
+}
 async function loadConfig(dir) {
+  const globalConfig = await loadGlobalConfig();
+  let localConfig = {};
   const p = path3.join(dir, CONFIG_FILE);
   if (await fs3.pathExists(p)) {
-    return fs3.readJson(p);
+    try {
+      localConfig = await fs3.readJson(p);
+    } catch {
+    }
   }
-  return {};
+  return { ...globalConfig, ...localConfig };
 }
 async function resolveApiKey(providerName, cliKey) {
   if (cliKey) return cliKey;
   const envVar = ENV_KEY_MAP[providerName];
   if (envVar && process.env[envVar]) return process.env[envVar];
+  const meta = PROVIDER_CATALOG[providerName];
+  if (meta?.fallbackEnvKeys) {
+    for (const key of meta.fallbackEnvKeys) {
+      if (process.env[key]) return process.env[key];
+    }
+  }
   const savedKey = await getSavedKey(providerName);
   if (savedKey) {
     const masked = savedKey.slice(0, 6) + "..." + savedKey.slice(-4);
@@ -1000,7 +1073,7 @@ var pe = "\0PERIOD" + Math.random() + "\0";
 var is = new RegExp(fe, "g");
 var rs = new RegExp(ue, "g");
 var ns = new RegExp(qt, "g");
-var os2 = new RegExp(de, "g");
+var os3 = new RegExp(de, "g");
 var hs = new RegExp(pe, "g");
 var as = /\\\\/g;
 var ls = /\\{/g;
@@ -1015,7 +1088,7 @@ function ps(n7) {
   return n7.replace(as, fe).replace(ls, ue).replace(cs, qt).replace(fs4, de).replace(us, pe);
 }
 function ms(n7) {
-  return n7.replace(is, "\\").replace(rs, "{").replace(ns, "}").replace(os2, ",").replace(hs, ".");
+  return n7.replace(is, "\\").replace(rs, "{").replace(ns, "}").replace(os3, ",").replace(hs, ".");
 }
 function me(n7) {
   if (!n7) return [""];
@@ -3945,11 +4018,11 @@ Ze.glob = Ze;
 // core/global-constitution.ts
 import * as fs5 from "fs-extra";
 import * as path4 from "path";
-import * as os3 from "os";
+import * as os4 from "os";
 var GLOBAL_CONSTITUTION_FILE = ".ai-spec-global-constitution.md";
 var SEARCH_ROOTS = [
   // Workspace root is injected at runtime — see loadGlobalConstitution()
-  os3.homedir()
+  os4.homedir()
 ];
 async function loadGlobalConstitution(extraRoots = []) {
   const roots = [...extraRoots, ...SEARCH_ROOTS];
@@ -3978,7 +4051,7 @@ function mergeConstitutions(globalContent, projectContent) {
   }
   return parts.join("\n");
 }
-async function saveGlobalConstitution(content, targetDir = os3.homedir()) {
+async function saveGlobalConstitution(content, targetDir = os4.homedir()) {
   const filePath = path4.join(targetDir, GLOBAL_CONSTITUTION_FILE);
   await fs5.writeFile(filePath, content, "utf-8");
   return filePath;
@@ -5011,32 +5084,32 @@ function validateDsl(raw) {
   }
   return { valid: true, dsl: raw };
 }
-function validateFeature(raw, path42, errors) {
+function validateFeature(raw, path43, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path42, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path43, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const f = raw;
-  requireNonEmptyString(f["id"], `${path42}.id`, errors);
-  requireNonEmptyString(f["title"], `${path42}.title`, errors);
-  requireNonEmptyString(f["description"], `${path42}.description`, errors);
+  requireNonEmptyString(f["id"], `${path43}.id`, errors);
+  requireNonEmptyString(f["title"], `${path43}.title`, errors);
+  requireNonEmptyString(f["description"], `${path43}.description`, errors);
 }
-function validateModel(raw, path42, errors) {
+function validateModel(raw, path43, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path42, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path43, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const m = raw;
-  requireNonEmptyString(m["name"], `${path42}.name`, errors);
+  requireNonEmptyString(m["name"], `${path43}.name`, errors);
   if (!Array.isArray(m["fields"])) {
-    errors.push({ path: `${path42}.fields`, message: `Must be an array, got: ${typeLabel(m["fields"])}` });
+    errors.push({ path: `${path43}.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: `${path42}.fields`, message: `Too many fields (${fields.length} > ${MAX_FIELDS_PER_MODEL})` });
+      errors.push({ path: `${path43}.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], `${path42}.fields[${j2}]`, errors);
+      validateModelField(fields[j2], `${path43}.fields[${j2}]`, errors);
     }
     const seenFieldNames = /* @__PURE__ */ new Set();
     for (let j2 = 0; j2 < Math.min(fields.length, MAX_FIELDS_PER_MODEL); j2++) {
@@ -5045,7 +5118,7 @@ function validateModel(raw, path42, errors) {
         const name = f["name"];
         if (seenFieldNames.has(name)) {
           errors.push({
-            path: `${path42}.fields[${j2}].name`,
+            path: `${path43}.fields[${j2}].name`,
             message: `Duplicate field name "${name}" \u2014 each field within a model must have a unique name`
           });
         } else {
@@ -5056,184 +5129,184 @@ function validateModel(raw, path42, errors) {
   }
   if (m["relations"] !== void 0) {
     if (!Array.isArray(m["relations"])) {
-      errors.push({ path: `${path42}.relations`, message: "Must be an array of strings if present" });
+      errors.push({ path: `${path43}.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: `${path42}.relations[${j2}]`, message: "Must be a string" });
+          errors.push({ path: `${path43}.relations[${j2}]`, message: "Must be a string" });
         }
       }
     }
   }
 }
-function validateModelField(raw, path42, errors) {
+function validateModelField(raw, path43, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path42, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path43, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const f = raw;
-  requireNonEmptyString(f["name"], `${path42}.name`, errors);
-  requireNonEmptyString(f["type"], `${path42}.type`, errors);
+  requireNonEmptyString(f["name"], `${path43}.name`, errors);
+  requireNonEmptyString(f["type"], `${path43}.type`, errors);
   if (typeof f["required"] !== "boolean") {
-    errors.push({ path: `${path42}.required`, message: `Must be boolean, got: ${typeLabel(f["required"])}` });
+    errors.push({ path: `${path43}.required`, message: `Must be boolean, got: ${typeLabel(f["required"])}` });
   }
 }
-function validateEndpoint(raw, path42, errors) {
+function validateEndpoint(raw, path43, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path42, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path43, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const e = raw;
-  requireNonEmptyString(e["id"], `${path42}.id`, errors);
-  requireNonEmptyString(e["description"], `${path42}.description`, errors);
+  requireNonEmptyString(e["id"], `${path43}.id`, errors);
+  requireNonEmptyString(e["description"], `${path43}.description`, errors);
   if (!VALID_METHODS.includes(e["method"])) {
     errors.push({
-      path: `${path42}.method`,
+      path: `${path43}.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: `${path42}.path`,
+      path: `${path43}.path`,
       message: `Must be a string starting with "/", got: ${JSON.stringify(e["path"])}`
     });
   }
   if (typeof e["auth"] !== "boolean") {
-    errors.push({ path: `${path42}.auth`, message: `Must be boolean, got: ${typeLabel(e["auth"])}` });
+    errors.push({ path: `${path43}.auth`, message: `Must be boolean, got: ${typeLabel(e["auth"])}` });
   }
   if (typeof e["successStatus"] !== "number" || e["successStatus"] < 100 || e["successStatus"] > 599) {
     errors.push({
-      path: `${path42}.successStatus`,
+      path: `${path43}.successStatus`,
       message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["successStatus"])}`
     });
   }
-  requireNonEmptyString(e["successDescription"], `${path42}.successDescription`, errors);
+  requireNonEmptyString(e["successDescription"], `${path43}.successDescription`, errors);
   if (e["request"] !== void 0) {
-    validateRequestSchema(e["request"], `${path42}.request`, errors);
+    validateRequestSchema(e["request"], `${path43}.request`, errors);
   }
   if (e["errors"] !== void 0) {
     if (!Array.isArray(e["errors"])) {
-      errors.push({ path: `${path42}.errors`, message: "Must be an array if present" });
+      errors.push({ path: `${path43}.errors`, message: "Must be an array if present" });
     } else {
       const errs = e["errors"];
       if (errs.length > MAX_ERRORS_PER_ENDPOINT) {
-        errors.push({ path: `${path42}.errors`, message: `Too many error entries (${errs.length} > ${MAX_ERRORS_PER_ENDPOINT})` });
+        errors.push({ path: `${path43}.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], `${path42}.errors[${j2}]`, errors);
+        validateResponseError(errs[j2], `${path43}.errors[${j2}]`, errors);
       }
     }
   }
 }
-function validateRequestSchema(raw, path42, errors) {
+function validateRequestSchema(raw, path43, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path42, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path43, 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], `${path42}.${key}`, errors);
+      validateFieldMap(r[key], `${path43}.${key}`, errors);
     }
   }
 }
-function validateFieldMap(raw, path42, errors) {
+function validateFieldMap(raw, path43, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path42, message: `Must be a flat object (FieldMap), got: ${typeLabel(raw)}` });
+    errors.push({ path: path43, 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: `${path42}.${k2}`, message: `Value must be a type-description string, got: ${typeLabel(v2)}` });
+      errors.push({ path: `${path43}.${k2}`, message: `Value must be a type-description string, got: ${typeLabel(v2)}` });
     }
   }
 }
-function validateResponseError(raw, path42, errors) {
+function validateResponseError(raw, path43, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path42, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path43, 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: `${path42}.status`, message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["status"])}` });
+    errors.push({ path: `${path43}.status`, message: `Must be an HTTP status code (100-599), got: ${JSON.stringify(e["status"])}` });
   }
-  requireNonEmptyString(e["code"], `${path42}.code`, errors);
-  requireNonEmptyString(e["description"], `${path42}.description`, errors);
+  requireNonEmptyString(e["code"], `${path43}.code`, errors);
+  requireNonEmptyString(e["description"], `${path43}.description`, errors);
 }
-function validateBehavior(raw, path42, errors) {
+function validateBehavior(raw, path43, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path42, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path43, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const b = raw;
-  requireNonEmptyString(b["id"], `${path42}.id`, errors);
-  requireNonEmptyString(b["description"], `${path42}.description`, errors);
+  requireNonEmptyString(b["id"], `${path43}.id`, errors);
+  requireNonEmptyString(b["description"], `${path43}.description`, errors);
   if (b["constraints"] !== void 0) {
     if (!Array.isArray(b["constraints"])) {
-      errors.push({ path: `${path42}.constraints`, message: "Must be an array of strings if present" });
+      errors.push({ path: `${path43}.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: `${path42}.constraints[${j2}]`, message: "Must be a string" });
+          errors.push({ path: `${path43}.constraints[${j2}]`, message: "Must be a string" });
         }
       }
     }
   }
 }
-function validateComponent(raw, path42, errors) {
+function validateComponent(raw, path43, errors) {
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    errors.push({ path: path42, message: `Must be an object, got: ${typeLabel(raw)}` });
+    errors.push({ path: path43, message: `Must be an object, got: ${typeLabel(raw)}` });
     return;
   }
   const c = raw;
-  requireNonEmptyString(c["id"], `${path42}.id`, errors);
-  requireNonEmptyString(c["name"], `${path42}.name`, errors);
-  requireNonEmptyString(c["description"], `${path42}.description`, errors);
+  requireNonEmptyString(c["id"], `${path43}.id`, errors);
+  requireNonEmptyString(c["name"], `${path43}.name`, errors);
+  requireNonEmptyString(c["description"], `${path43}.description`, errors);
   if (c["props"] !== void 0) {
     if (!Array.isArray(c["props"])) {
-      errors.push({ path: `${path42}.props`, message: "Must be an array if present" });
+      errors.push({ path: `${path43}.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: `${path42}.props[${j2}]`, message: "Must be an object" });
+          errors.push({ path: `${path43}.props[${j2}]`, message: "Must be an object" });
           continue;
         }
-        requireNonEmptyString(p["name"], `${path42}.props[${j2}].name`, errors);
-        requireNonEmptyString(p["type"], `${path42}.props[${j2}].type`, errors);
+        requireNonEmptyString(p["name"], `${path43}.props[${j2}].name`, errors);
+        requireNonEmptyString(p["type"], `${path43}.props[${j2}].type`, errors);
         if (typeof p["required"] !== "boolean") {
-          errors.push({ path: `${path42}.props[${j2}].required`, message: "Must be boolean" });
+          errors.push({ path: `${path43}.props[${j2}].required`, message: "Must be boolean" });
         }
       }
     }
   }
   if (c["events"] !== void 0) {
     if (!Array.isArray(c["events"])) {
-      errors.push({ path: `${path42}.events`, message: "Must be an array if present" });
+      errors.push({ path: `${path43}.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: `${path42}.events[${j2}]`, message: "Must be an object" });
+          errors.push({ path: `${path43}.events[${j2}]`, message: "Must be an object" });
           continue;
         }
-        requireNonEmptyString(e["name"], `${path42}.events[${j2}].name`, errors);
+        requireNonEmptyString(e["name"], `${path43}.events[${j2}].name`, errors);
       }
     }
   }
   if (c["state"] !== void 0) {
     if (typeof c["state"] !== "object" || Array.isArray(c["state"]) || c["state"] === null) {
-      errors.push({ path: `${path42}.state`, message: "Must be a flat object (Record<string, string>) if present" });
+      errors.push({ path: `${path43}.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: `${path42}.apiCalls`, message: "Must be an array of strings if present" });
+      errors.push({ path: `${path43}.apiCalls`, message: "Must be an array of strings if present" });
     }
   }
 }
@@ -5295,10 +5368,10 @@ function crossReferenceChecks(obj, errors) {
     }
   }
 }
-function requireNonEmptyString(v2, path42, errors) {
+function requireNonEmptyString(v2, path43, errors) {
   if (typeof v2 !== "string" || v2.trim().length === 0) {
     errors.push({
-      path: path42,
+      path: path43,
       message: `Must be a non-empty string, got: ${typeLabel(v2)}`
     });
   }
@@ -5509,13 +5582,18 @@ Output ONLY the corrected JSON. No explanation.`;
 
 // core/token-budget.ts
 import chalk5 from "chalk";
-var CJK_RANGE = /[\u4e00-\u9fff\u3400-\u4dbf\u3000-\u303f\uff00-\uffef]/g;
-function estimateTokens(text) {
-  if (!text) return 0;
-  const cjkCount = (text.match(CJK_RANGE) ?? []).length;
-  const nonCjkLength = text.length - cjkCount;
-  return Math.ceil(cjkCount + nonCjkLength / 4);
-}
+
+// core/config-defaults.ts
+var DEFAULT_LOG_DIR = ".ai-spec-logs";
+var DEFAULT_VCR_DIR = ".ai-spec-vcr";
+var DEFAULT_BACKUP_DIR = ".ai-spec-backup";
+var DEFAULT_REVIEW_HISTORY_FILE = ".ai-spec-reviews.json";
+var DEFAULT_OPENAPI_SERVER_URL = "http://localhost:3000";
+var DEFAULT_MAX_COMMAND_OUTPUT_CHARS = 3e4;
+var DEFAULT_MAX_FIX_FILE_CHARS = 6e4;
+var DEFAULT_DSL_MAX_RETRIES = 2;
+var DEFAULT_MAX_CONSTITUTION_CHARS = 4e3;
+var DEFAULT_MAX_REVIEW_FILE_CHARS = 3e3;
 var DEFAULT_TOKEN_BUDGETS = {
   gemini: 9e5,
   claude: 18e4,
@@ -5523,8 +5601,18 @@ var DEFAULT_TOKEN_BUDGETS = {
   deepseek: 6e4,
   default: 1e5
 };
+
+// core/token-budget.ts
+var CJK_RANGE = /[\u4e00-\u9fff\u3400-\u4dbf\u3000-\u303f\uff00-\uffef]/g;
+function estimateTokens(text) {
+  if (!text) return 0;
+  const cjkCount = (text.match(CJK_RANGE) ?? []).length;
+  const nonCjkLength = text.length - cjkCount;
+  return Math.ceil(cjkCount + nonCjkLength / 4);
+}
+var DEFAULT_TOKEN_BUDGETS2 = DEFAULT_TOKEN_BUDGETS;
 function getDefaultBudget(providerName) {
-  return DEFAULT_TOKEN_BUDGETS[providerName] ?? DEFAULT_TOKEN_BUDGETS.default;
+  return DEFAULT_TOKEN_BUDGETS2[providerName] ?? DEFAULT_TOKEN_BUDGETS2.default;
 }
 
 // core/safe-json.ts
@@ -5595,7 +5683,7 @@ function sanitizeDsl(raw) {
   }
   return dsl;
 }
-var MAX_RETRIES = 2;
+var MAX_RETRIES = DEFAULT_DSL_MAX_RETRIES;
 var DEFAULT_MAX_SPEC_CHARS = 12e3;
 function dslFilePath(specFilePath) {
   const dir = path7.dirname(specFilePath);
@@ -6319,12 +6407,11 @@ Shared component structure patterns:`);
 // core/run-snapshot.ts
 import * as fs10 from "fs-extra";
 import * as path9 from "path";
-var BACKUP_DIR = ".ai-spec-backup";
 var RunSnapshot = class {
   constructor(workingDir, runId) {
     this.workingDir = workingDir;
     this.runId = runId;
-    this.backupRoot = path9.join(workingDir, BACKUP_DIR, runId);
+    this.backupRoot = path9.join(workingDir, DEFAULT_BACKUP_DIR, runId);
   }
   backupRoot;
   snapshotted = /* @__PURE__ */ new Set();
@@ -6380,7 +6467,6 @@ function getActiveSnapshot() {
 import * as fs11 from "fs-extra";
 import * as path10 from "path";
 import chalk7 from "chalk";
-var LOG_DIR = ".ai-spec-logs";
 function appendJsonlLine(filePath, record) {
   try {
     fs11.appendFileSync(filePath, JSON.stringify(record) + "\n");
@@ -6451,8 +6537,8 @@ var RunLogger = class {
     this.workingDir = workingDir;
     this.runId = runId;
     this.startMs = Date.now();
-    this.logPath = path10.join(workingDir, LOG_DIR, `${runId}.json`);
-    this.jsonlPath = path10.join(workingDir, LOG_DIR, `${runId}.jsonl`);
+    this.logPath = path10.join(workingDir, DEFAULT_LOG_DIR, `${runId}.json`);
+    this.jsonlPath = path10.join(workingDir, DEFAULT_LOG_DIR, `${runId}.jsonl`);
     this.log = {
       runId,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7394,7 +7480,7 @@ ${context.routeSummary}
   }
   if (context.schema) {
     parts.push(`=== Prisma Schema ===
-${context.schema.slice(0, 4e3)}
+${context.schema.slice(0, DEFAULT_MAX_CONSTITUTION_CHARS)}
 `);
   }
   if (context.errorPatterns) {
@@ -7442,7 +7528,7 @@ async function loadAccumulatedLessons(projectRoot) {
   const nextSection = section.slice(marker.length).match(/\n## \d/);
   return nextSection ? section.slice(0, marker.length + nextSection.index) : section;
 }
-var REVIEW_HISTORY_FILE = ".ai-spec-reviews.json";
+var REVIEW_HISTORY_FILE = DEFAULT_REVIEW_HISTORY_FILE;
 async function loadReviewHistory(projectRoot) {
   const historyPath = path13.join(projectRoot, REVIEW_HISTORY_FILE);
   try {
@@ -7573,15 +7659,13 @@ ${specContent || "(No spec \u2014 review for general code quality)"}
 ${codeContext}`;
     const archReview = await this.provider.generate(archPrompt, reviewArchitectureSystemPrompt);
     console.log(chalk11.gray("  Pass 2/3: Implementation review..."));
+    const specDigest = specContent && specContent.length > 600 ? specContent.slice(0, 600) + "\n... [spec truncated \u2014 see Pass 0/1 for full text]" : specContent || "(No spec)";
     const history = await loadReviewHistory(this.projectRoot);
     const historyContext = buildHistoryContext(history);
     const implPrompt = `Review the implementation details of this change.
 
-=== Feature Spec ===
-${specContent || "(No spec \u2014 review for general code quality)"}
-
-=== Code ===
-${codeContext}
+=== Feature Spec (digest \u2014 full spec was provided in Pass 0/1) ===
+${specDigest}
 
 === Architecture Review (Pass 1 \u2014 do NOT repeat these findings) ===
 ${archReview}
@@ -7590,11 +7674,8 @@ ${historyContext}`;
     console.log(chalk11.gray("  Pass 3/3: Impact & complexity assessment..."));
     const impactPrompt = `Assess the impact and complexity of this change.
 
-=== Feature Spec ===
-${specContent || "(No spec \u2014 review for general code quality)"}
-
-=== Code ===
-${codeContext}
+=== Feature Spec (digest) ===
+${specDigest}
 
 === Architecture Review (Pass 1 \u2014 do NOT repeat) ===
 ${archReview}
@@ -7668,8 +7749,8 @@ ${sep}
         filesSection += `
 
 === ${filePath} ===
-${content.slice(0, 3e3)}`;
-        if (content.length > 3e3) filesSection += `
+${content.slice(0, DEFAULT_MAX_REVIEW_FILE_CHARS)}`;
+        if (content.length > DEFAULT_MAX_REVIEW_FILE_CHARS) filesSection += `
 ... (truncated, ${content.length} chars total)`;
       } catch {
         filesSection += `
@@ -8274,8 +8355,8 @@ import { execSync as execSync5 } from "child_process";
 import * as fs18 from "fs-extra";
 import * as path17 from "path";
 init_cli_ui();
-var MAX_COMMAND_OUTPUT_CHARS = 5e4;
-var MAX_FIX_FILE_CHARS = 6e4;
+var MAX_COMMAND_OUTPUT_CHARS = DEFAULT_MAX_COMMAND_OUTPUT_CHARS;
+var MAX_FIX_FILE_CHARS = DEFAULT_MAX_FIX_FILE_CHARS;
 function runCommand(cmd, cwd) {
   try {
     const output = execSync5(cmd, { cwd, encoding: "utf-8", timeout: 6e4 });
@@ -9484,8 +9565,8 @@ async function findLatestDslFile(projectDir) {
     const entries = await fs22.readdir(dir);
     for (const entry of entries) {
       const abs = path21.join(dir, entry);
-      const stat4 = await fs22.stat(abs);
-      if (stat4.isDirectory()) {
+      const stat5 = await fs22.stat(abs);
+      if (stat5.isDirectory()) {
         await scan(abs);
       } else if (entry.endsWith(".dsl.json")) {
         allFiles.push(abs);
@@ -11223,7 +11304,7 @@ ${optionsText}`;
 import { createHash as createHash2 } from "crypto";
 import * as fs24 from "fs-extra";
 import * as path23 from "path";
-var VCR_DIR = ".ai-spec-vcr";
+var VCR_DIR = DEFAULT_VCR_DIR;
 var VcrRecordingProvider = class {
   constructor(inner) {
     this.inner = inner;
@@ -11921,7 +12002,147 @@ async function runSingleRepoPipeline(idea, opts, currentDir, config2) {
   }
 }
 
+// core/repo-store.ts
+import * as fs26 from "fs-extra";
+import * as path25 from "path";
+import * as os5 from "os";
+var REPO_STORE_FILE = path25.join(os5.homedir(), ".ai-spec-repos.json");
+async function readStore2() {
+  try {
+    if (await fs26.pathExists(REPO_STORE_FILE)) {
+      return await fs26.readJson(REPO_STORE_FILE);
+    }
+  } catch (err) {
+    console.warn(`Warning: Could not read repo store at ${REPO_STORE_FILE}: ${err.message}.`);
+  }
+  return { repos: [] };
+}
+async function writeStore2(store) {
+  await fs26.ensureFile(REPO_STORE_FILE);
+  await fs26.writeJson(REPO_STORE_FILE, store, { spaces: 2 });
+}
+async function getRegisteredRepos() {
+  const store = await readStore2();
+  return store.repos;
+}
+async function registerRepo(repo) {
+  const store = await readStore2();
+  const idx = store.repos.findIndex((r) => r.path === repo.path);
+  if (idx >= 0) {
+    store.repos[idx] = repo;
+  } else {
+    store.repos.push(repo);
+  }
+  await writeStore2(store);
+}
+
 // cli/commands/create.ts
+init_spec_generator();
+async function promptRepoRole() {
+  return select7({
+    message: "What type of repo is this?",
+    choices: [
+      { name: "Frontend", value: "frontend" },
+      { name: "Backend", value: "backend" },
+      { name: "Mobile", value: "mobile" },
+      { name: "Shared / Other", value: "shared" }
+    ]
+  });
+}
+async function quickRegisterRepo(provider) {
+  const roleOverride = await promptRepoRole();
+  const roleLabels = {
+    frontend: "frontend",
+    backend: "backend",
+    mobile: "mobile",
+    shared: "shared"
+  };
+  const raw = await input2({
+    message: `Enter your ${roleLabels[roleOverride]} repo path (absolute path):`,
+    validate: (v2) => {
+      const trimmed = v2.trim();
+      if (trimmed.length === 0) return "Path cannot be empty";
+      if (!path26.isAbsolute(trimmed)) return "Please provide an absolute path";
+      return true;
+    }
+  });
+  const cleaned = raw.trim().replace(/\\ /g, " ");
+  const resolved = path26.resolve(cleaned);
+  if (!await fs27.pathExists(resolved)) {
+    console.log(chalk26.red(`  Path does not exist: ${resolved}`));
+    return quickRegisterRepo(provider);
+  }
+  const { type, role: detectedRole } = await detectRepoType(resolved);
+  const role = roleOverride ?? detectedRole;
+  const repoName = path26.basename(resolved);
+  console.log(chalk26.gray(`  Detected: ${repoName} \u2192 ${type} (${role})`));
+  const constitutionPath = path26.join(resolved, CONSTITUTION_FILE);
+  let hasConstitution = await fs27.pathExists(constitutionPath);
+  if (!hasConstitution) {
+    console.log(chalk26.blue(`  Generating constitution for ${repoName}...`));
+    try {
+      const gen = new ConstitutionGenerator(provider);
+      const content = await gen.generate(resolved);
+      await gen.saveConstitution(resolved, content);
+      hasConstitution = true;
+      console.log(chalk26.green(`  \u2714 Constitution saved`));
+    } catch (err) {
+      console.log(chalk26.yellow(`  \u26A0 Constitution failed: ${err.message}`));
+    }
+  }
+  const entry = {
+    name: repoName,
+    path: resolved,
+    type,
+    role,
+    hasConstitution,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await registerRepo(entry);
+  console.log(chalk26.green(`  \u2714 Repo registered: ${repoName}`));
+  return entry;
+}
+async function selectRepos(registeredRepos, provider) {
+  const ADD_NEW = "__add_new__";
+  const choices = [
+    ...registeredRepos.map((r) => ({
+      name: `${r.name} (${r.type} / ${r.role}) \u2192 ${r.path}`,
+      value: r.path
+    })),
+    { name: chalk26.cyan("+ Add new repo"), value: ADD_NEW }
+  ];
+  const selected = await checkbox({
+    message: "Select repo(s) for this feature (space to toggle, enter to confirm):",
+    choices,
+    required: true
+  });
+  const result = [];
+  for (const val of selected) {
+    if (val === ADD_NEW) {
+      const newRepo = await quickRegisterRepo(provider);
+      result.push(newRepo);
+    } else {
+      const repo = registeredRepos.find((r) => r.path === val);
+      if (repo) result.push(repo);
+    }
+  }
+  if (result.length === 0) {
+    console.log(chalk26.yellow("  No repos selected. Please select at least one."));
+    return selectRepos(registeredRepos, provider);
+  }
+  return result;
+}
+function buildWorkspaceConfig(repos) {
+  return {
+    name: "ai-spec-workspace",
+    repos: repos.map((r) => ({
+      name: r.name,
+      path: r.path,
+      type: r.type,
+      role: r.role
+    }))
+  };
+}
 function registerCreate(program2) {
   program2.command("create").description("Generate a feature spec and kick off code generation").argument("[idea]", "Feature idea in natural language (prompted if omitted)").option(
     "--provider <name>",
@@ -11944,25 +12165,76 @@ function registerCreate(program2) {
       });
     }
     const workspaceLoader = new WorkspaceLoader(currentDir);
-    const workspaceConfig = await workspaceLoader.load();
-    if (workspaceConfig) {
+    const existingWorkspaceConfig = await workspaceLoader.load();
+    if (existingWorkspaceConfig) {
       console.log(chalk26.cyan(`
-[Workspace] Detected workspace: ${workspaceConfig.name}`));
-      console.log(chalk26.gray(`  Repos: ${workspaceConfig.repos.map((r) => r.name).join(", ")}`));
-      const pipelineResults = await runMultiRepoPipeline(idea, workspaceConfig, opts, currentDir, config2);
+[Workspace] Detected workspace: ${existingWorkspaceConfig.name}`));
+      console.log(chalk26.gray(`  Repos: ${existingWorkspaceConfig.repos.map((r) => r.name).join(", ")}`));
+      const pipelineResults = await runMultiRepoPipeline(idea, existingWorkspaceConfig, opts, currentDir, config2);
       if (opts.serve) {
         await handleAutoServe(pipelineResults);
       }
       return;
     }
-    await runSingleRepoPipeline(idea, opts, currentDir, config2);
+    const providerName = opts.provider || config2.provider || "gemini";
+    const modelName = opts.model || config2.model || DEFAULT_MODELS[providerName];
+    const apiKey = await resolveApiKey(providerName, opts.key);
+    const specProvider = createProvider(providerName, apiKey, modelName);
+    const registeredRepos = await getRegisteredRepos();
+    if (registeredRepos.length === 0) {
+      console.log(chalk26.yellow("\n  No repos registered. Please register repos first."));
+      console.log(chalk26.gray("  Run: ai-spec init"));
+      console.log(chalk26.gray("  Or add a repo now:\n"));
+      const addNow = await select7({
+        message: "Add a repo now?",
+        choices: [
+          { name: "Yes \u2014 register a repo and continue", value: "yes" },
+          { name: "No \u2014 exit", value: "no" }
+        ]
+      });
+      if (addNow === "no") {
+        process.exit(0);
+      }
+      const newRepo = await quickRegisterRepo(specProvider);
+      registeredRepos.push(newRepo);
+    }
+    const validRepos = [];
+    for (const r of registeredRepos) {
+      if (await fs27.pathExists(r.path)) {
+        validRepos.push(r);
+      } else {
+        console.log(chalk26.yellow(`  \u26A0 Skipping ${r.name}: path not found (${r.path})`));
+      }
+    }
+    if (validRepos.length === 0) {
+      console.log(chalk26.red("  No valid repos available. Run: ai-spec init"));
+      process.exit(1);
+    }
+    const selectedRepos = await selectRepos(validRepos, specProvider);
+    if (selectedRepos.length === 1) {
+      const repo = selectedRepos[0];
+      console.log(chalk26.cyan(`
+[Repo] ${repo.name} (${repo.type}/${repo.role}) \u2192 ${repo.path}`));
+      await runSingleRepoPipeline(idea, opts, repo.path, config2);
+    } else {
+      const workspaceConfig = buildWorkspaceConfig(selectedRepos);
+      console.log(chalk26.cyan(`
+[Workspace] ${selectedRepos.length} repo(s) selected:`));
+      for (const repo of selectedRepos) {
+        console.log(chalk26.gray(`  ${repo.name} (${repo.type}/${repo.role}) \u2192 ${repo.path}`));
+      }
+      const pipelineResults = await runMultiRepoPipeline(idea, workspaceConfig, opts, currentDir, config2);
+      if (opts.serve) {
+        await handleAutoServe(pipelineResults);
+      }
+    }
   });
 }
 
 // cli/commands/review.ts
 init_spec_generator();
-import * as path25 from "path";
-import * as fs26 from "fs-extra";
+import * as path27 from "path";
+import * as fs28 from "fs-extra";
 import chalk27 from "chalk";
 function registerReview(program2) {
   program2.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(
@@ -11979,17 +12251,17 @@ function registerReview(program2) {
     const reviewer = new CodeReviewer(provider, currentDir);
     let specContent = "";
     let resolvedSpecFile;
-    if (specFile && await fs26.pathExists(specFile)) {
-      specContent = await fs26.readFile(specFile, "utf-8");
+    if (specFile && await fs28.pathExists(specFile)) {
+      specContent = await fs28.readFile(specFile, "utf-8");
       resolvedSpecFile = specFile;
       console.log(chalk27.gray(`Using spec: ${specFile}`));
     } else {
-      const specsDir = path25.join(currentDir, "specs");
-      if (await fs26.pathExists(specsDir)) {
-        const files = (await fs26.readdir(specsDir)).filter((f) => f.endsWith(".md")).sort().reverse();
+      const specsDir = path27.join(currentDir, "specs");
+      if (await fs28.pathExists(specsDir)) {
+        const files = (await fs28.readdir(specsDir)).filter((f) => f.endsWith(".md")).sort().reverse();
         if (files.length > 0) {
-          const latest = path25.join(specsDir, files[0]);
-          specContent = await fs26.readFile(latest, "utf-8");
+          const latest = path27.join(specsDir, files[0]);
+          specContent = await fs28.readFile(latest, "utf-8");
           resolvedSpecFile = latest;
           console.log(chalk27.gray(`Auto-detected spec: specs/${files[0]}`));
         }
@@ -12005,9 +12277,10 @@ function registerReview(program2) {
 
 // cli/commands/init.ts
 init_spec_generator();
-import * as path27 from "path";
-import * as fs28 from "fs-extra";
+import * as path28 from "path";
+import * as fs29 from "fs-extra";
 import chalk28 from "chalk";
+import { input as input3, select as select8, confirm as confirm2 } from "@inquirer/prompts";
 
 // 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.
@@ -12068,240 +12341,139 @@ ${summary}
   return parts.join("\n");
 }
 
-// core/project-index.ts
-import * as fs27 from "fs-extra";
-import * as path26 from "path";
-var INDEX_FILE = ".ai-spec-index.json";
-var KEY_DEPS = [
-  // Frameworks
-  "express",
-  "fastify",
-  "koa",
-  "@nestjs/core",
-  "hapi",
-  "next",
-  "react",
-  "vue",
-  "nuxt",
-  "svelte",
-  "react-native",
-  "expo",
-  // DB / ORM
-  "prisma",
-  "@prisma/client",
-  "mongoose",
-  "typeorm",
-  "sequelize",
-  "drizzle-orm",
-  // Auth
-  "jsonwebtoken",
-  "passport",
-  "next-auth",
-  "@clerk/nextjs",
-  // Build / Lang
-  "typescript",
-  "vite",
-  "webpack",
-  "esbuild",
-  "turbo",
-  // Testing
-  "jest",
-  "vitest",
-  "mocha",
-  "cypress",
-  "playwright",
-  // Infra
-  "redis",
-  "bull",
-  "socket.io",
-  "graphql",
-  "@trpc/server"
-];
-var SKIP_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  ".svn",
-  "dist",
-  "build",
-  "out",
-  ".next",
-  ".nuxt",
-  "coverage",
-  ".turbo",
-  ".cache",
-  "__pycache__",
-  "vendor",
-  ".ai-spec-vcr",
-  ".ai-spec-logs",
-  "specs"
-]);
-var MANIFEST_FILES = [
-  "package.json",
-  "go.mod",
-  "Cargo.toml",
-  "pom.xml",
-  "build.gradle",
-  "build.gradle.kts",
-  "requirements.txt",
-  "pyproject.toml",
-  "setup.py",
-  "composer.json"
-];
-async function isProjectRoot(absPath) {
-  for (const manifest of MANIFEST_FILES) {
-    if (await fs27.pathExists(path26.join(absPath, manifest))) return true;
-  }
-  return false;
+// cli/commands/init.ts
+var ROLE_LABELS = {
+  frontend: "frontend",
+  backend: "backend",
+  mobile: "mobile",
+  shared: "shared"
+};
+async function promptRepoRole2() {
+  return select8({
+    message: "What type of repo is this?",
+    choices: [
+      { name: "Frontend", value: "frontend" },
+      { name: "Backend", value: "backend" },
+      { name: "Mobile", value: "mobile" },
+      { name: "Shared / Other", value: "shared" }
+    ]
+  });
 }
-async function extractTechStack(absPath, type) {
-  const stack = [];
-  if (type === "go") stack.push("go");
-  if (type === "rust") stack.push("rust");
-  if (type === "java") stack.push("java");
-  if (type === "python") stack.push("python");
-  if (type === "php") stack.push("php");
-  const pkgPath = path26.join(absPath, "package.json");
-  if (!await fs27.pathExists(pkgPath)) return stack;
-  let pkg = {};
-  try {
-    pkg = await fs27.readJson(pkgPath);
-  } catch {
-    return stack;
-  }
-  const allDeps = {
-    ...pkg.dependencies ?? {},
-    ...pkg.devDependencies ?? {}
+async function promptRepoPath(role) {
+  const label = ROLE_LABELS[role];
+  const raw = await input3({
+    message: `Enter your ${label} repo path (absolute path):`,
+    validate: (v2) => {
+      const trimmed = v2.trim();
+      if (trimmed.length === 0) return "Path cannot be empty";
+      if (!path28.isAbsolute(trimmed)) return "Please provide an absolute path";
+      return true;
+    }
+  });
+  const cleaned = raw.trim().replace(/\\ /g, " ");
+  const resolved = path28.resolve(cleaned);
+  if (!await fs29.pathExists(resolved)) {
+    console.log(chalk28.red(`  Path does not exist: ${resolved}`));
+    return promptRepoPath(role);
+  }
+  const stat5 = await fs29.stat(resolved);
+  if (!stat5.isDirectory()) {
+    console.log(chalk28.red(`  Not a directory: ${resolved}`));
+    return promptRepoPath(role);
+  }
+  return resolved;
+}
+async function registerSingleRepo(repoPath, provider, roleOverride) {
+  const { type, role: detectedRole } = await detectRepoType(repoPath);
+  const role = roleOverride ?? detectedRole;
+  const repoName = path28.basename(repoPath);
+  console.log(chalk28.gray(`    Detected: ${repoName} \u2192 ${type} (${role})`));
+  const constitutionPath = path28.join(repoPath, CONSTITUTION_FILE);
+  let hasConstitution = await fs29.pathExists(constitutionPath);
+  if (!hasConstitution) {
+    console.log(chalk28.blue(`    Generating project constitution for ${repoName}...`));
+    try {
+      const gen = new ConstitutionGenerator(provider);
+      const content = await gen.generate(repoPath);
+      await gen.saveConstitution(repoPath, content);
+      hasConstitution = true;
+      console.log(chalk28.green(`    \u2714 Constitution saved: ${constitutionPath}`));
+    } catch (err) {
+      console.log(chalk28.yellow(`    \u26A0 Constitution generation failed: ${err.message}`));
+    }
+  } else {
+    console.log(chalk28.green(`    \u2714 Constitution already exists: ${constitutionPath}`));
+  }
+  const entry = {
+    name: repoName,
+    path: repoPath,
+    type,
+    role,
+    hasConstitution,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const depKeys = new Set(Object.keys(allDeps));
-  for (const dep of KEY_DEPS) {
-    if (depKeys.has(dep)) stack.push(dep);
-  }
-  return stack;
-}
-async function discoverProjects(rootDir, maxDepth) {
-  const found = [];
-  async function walk(absDir, depth) {
-    if (depth > maxDepth) return;
-    let entries;
+  await registerRepo(entry);
+  return entry;
+}
+async function buildProjectSummaries(repos) {
+  const summaries = [];
+  for (const repo of repos) {
+    if (!await fs29.pathExists(repo.path)) continue;
+    const lines = [
+      `Type: ${repo.type} (${repo.role})`
+    ];
     try {
-      entries = await fs27.readdir(absDir, { withFileTypes: true });
+      const loader = new ContextLoader(repo.path);
+      const ctx = await loader.loadProjectContext();
+      lines.push(`Tech stack: ${ctx.techStack.join(", ") || "unknown"}`);
+      lines.push(`Dependencies: ${ctx.dependencies.slice(0, 20).join(", ")}`);
     } catch {
-      return;
+      lines.push(`Tech stack: ${repo.type}`);
     }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
-      const childAbs = path26.join(absDir, entry.name);
-      const gitPath = path26.join(childAbs, ".git");
-      if (await fs27.pathExists(gitPath)) {
-        const gitStat = await fs27.stat(gitPath);
-        if (gitStat.isFile()) continue;
-      }
-      if (await isProjectRoot(childAbs)) {
-        found.push(path26.relative(rootDir, childAbs));
-      } else {
-        await walk(childAbs, depth + 1);
+    if (repo.hasConstitution) {
+      try {
+        const constitutionPath = path28.join(repo.path, CONSTITUTION_FILE);
+        const raw = await fs29.readFile(constitutionPath, "utf-8");
+        lines.push("", "Constitution excerpt:", raw.slice(0, 2e3));
+      } catch {
       }
     }
+    summaries.push({ name: repo.name, summary: lines.join("\n") });
   }
-  await walk(rootDir, 0);
-  return found;
+  return summaries;
 }
-async function loadIndex(scanRoot) {
-  const filePath = path26.join(scanRoot, INDEX_FILE);
-  try {
-    return await fs27.readJson(filePath);
-  } catch {
-    return null;
+async function generateGlobalConstitution(provider, repos, currentDir) {
+  console.log(chalk28.blue("\n\u2500\u2500\u2500 Generating Global Constitution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk28.gray(`  Based on ${repos.length} registered repo(s)`));
+  const summaries = await buildProjectSummaries(repos);
+  if (summaries.length === 0) {
+    console.log(chalk28.yellow("  No valid repos found \u2014 skipping global constitution."));
+    return;
   }
-}
-async function saveIndex(scanRoot, index) {
-  const filePath = path26.join(scanRoot, INDEX_FILE);
-  await fs27.writeJson(filePath, index, { spaces: 2 });
-  return filePath;
-}
-async function runScan(scanRoot, maxDepth = 2) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = await loadIndex(scanRoot);
-  const existingMap = new Map(
-    (existing?.projects ?? []).map((p) => [p.path, p])
-  );
-  const discoveredPaths = await discoverProjects(scanRoot, maxDepth);
-  const added = [];
-  const updated = [];
-  const unchanged = [];
-  const seenPaths = /* @__PURE__ */ new Set();
-  for (const relPath of discoveredPaths) {
-    const absPath = path26.join(scanRoot, relPath);
-    seenPaths.add(relPath);
-    const { type, role } = await detectRepoType(absPath);
-    const techStack = await extractTechStack(absPath, type);
-    const hasConstitution = await fs27.pathExists(path26.join(absPath, CONSTITUTION_FILE));
-    const hasWorkspace = await fs27.pathExists(path26.join(absPath, WORKSPACE_CONFIG_FILE));
-    const name = path26.basename(relPath);
-    const prev = existingMap.get(relPath);
-    if (!prev) {
-      const entry = {
-        name,
-        path: relPath,
-        type,
-        role,
-        techStack,
-        hasConstitution,
-        hasWorkspace,
-        firstSeen: now,
-        lastSeen: now
-      };
-      added.push(entry);
-      existingMap.set(relPath, entry);
-    } else {
-      const changed = prev.type !== type || prev.role !== role || prev.hasConstitution !== hasConstitution || prev.hasWorkspace !== hasWorkspace || JSON.stringify(prev.techStack.sort()) !== JSON.stringify(techStack.sort());
-      const entry = {
-        ...prev,
-        type,
-        role,
-        techStack,
-        hasConstitution,
-        hasWorkspace,
-        lastSeen: now,
-        missing: void 0
-        // clear missing flag if it came back
-      };
-      existingMap.set(relPath, entry);
-      if (changed) {
-        updated.push(entry);
-      } else {
-        unchanged.push(entry);
-      }
-    }
+  const prompt = buildGlobalConstitutionPrompt(summaries);
+  let globalConstitution;
+  try {
+    globalConstitution = await provider.generate(prompt, globalConstitutionSystemPrompt);
+  } catch (err) {
+    console.error(chalk28.red(`  \u2718 Failed to generate global constitution: ${err.message}`));
+    return;
   }
-  const nowMissing = [];
-  for (const [relPath, entry] of existingMap) {
-    if (!seenPaths.has(relPath) && !entry.missing) {
-      const gone = { ...entry, missing: true };
-      existingMap.set(relPath, gone);
-      nowMissing.push(gone);
-    }
+  const saved = await saveGlobalConstitution(globalConstitution, currentDir);
+  console.log(chalk28.green(`  \u2714 Global constitution saved: ${saved}`));
+  console.log(chalk28.gray("  Project constitutions will be merged with this at runtime."));
+  const lines = globalConstitution.split("\n");
+  console.log(chalk28.bold("\n  Preview:"));
+  console.log(chalk28.gray(lines.slice(0, 10).join("\n")));
+  if (lines.length > 10) {
+    console.log(chalk28.gray(`  ... (${lines.length} lines total)`));
   }
-  const projects = [...existingMap.values()].sort((a, b) => a.path.localeCompare(b.path));
-  const index = {
-    scanRoot,
-    lastScanned: now,
-    projects
-  };
-  return { index, added, updated, unchanged, nowMissing };
 }
-
-// cli/commands/init.ts
 function registerInit(program2) {
-  program2.command("init").description(`Analyze codebase and generate Project Constitution (${CONSTITUTION_FILE})`).option(
+  program2.command("init").description("Setup workspace: register repos, generate constitutions").option(
     "--provider <name>",
     `AI provider (${SUPPORTED_PROVIDERS.join("|")})`,
     void 0
-  ).option("--model <name>", "Model name").option("-k, --key <apiKey>", "API key").option("--force", "Overwrite existing constitution").option(
-    "--global",
-    `Generate a Global Constitution (~/${GLOBAL_CONSTITUTION_FILE}) instead of a project-level one`
-  ).option("--consolidate", "Consolidate \xA79 accumulated lessons into \xA71\u2013\xA78 core rules (prune & rebase)").option("--dry-run", "Preview consolidation result without writing (use with --consolidate)").action(async (opts) => {
+  ).option("--model <name>", "Model name").option("-k, --key <apiKey>", "API key").option("--force", "Overwrite existing constitutions").option("--consolidate", "Consolidate \xA79 accumulated lessons into \xA71\u2013\xA78 core rules").option("--dry-run", "Preview consolidation result without writing (use with --consolidate)").option("--add-repo", "Add a new repo to the registered list").action(async (opts) => {
     const currentDir = process.cwd();
     const config2 = await loadConfig(currentDir);
     const providerName = opts.provider || config2.provider || "gemini";
@@ -12320,7 +12492,7 @@ function registerInit(program2) {
           console.log(chalk28.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(chalk28.gray(`  \xA79    : ${result.before.lessonCount} \u2192 ${result.after.lessonCount} lessons remaining`));
           if (result.backupPath) {
-            console.log(chalk28.gray(`  Backup: ${path27.basename(result.backupPath)}`));
+            console.log(chalk28.gray(`  Backup: ${path28.basename(result.backupPath)}`));
           }
         }
       } catch (err) {
@@ -12329,119 +12501,125 @@ function registerInit(program2) {
       }
       return;
     }
-    if (opts.global) {
-      const existing = await loadGlobalConstitution([currentDir]);
-      if (existing && !opts.force) {
-        console.log(chalk28.yellow(`
-  Global constitution already exists at: ${existing.source}`));
-        console.log(chalk28.gray("  Use --force to overwrite it."));
-        return;
+    if (opts.addRepo) {
+      console.log(chalk28.blue("\n\u2500\u2500\u2500 Register New Repo \u2500\u2500\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 role = await promptRepoRole2();
+      const repoPath = await promptRepoPath(role);
+      const entry = await registerSingleRepo(repoPath, provider, role);
+      console.log(chalk28.green(`
+  \u2714 Repo registered: ${entry.name} (${entry.type} / ${entry.role})`));
+      console.log(chalk28.gray(`    Saved to: ${REPO_STORE_FILE}`));
+      const updateGlobal = await confirm2({
+        message: "Update global constitution with this repo's context?",
+        default: true
+      });
+      if (updateGlobal) {
+        const allRepos2 = await getRegisteredRepos();
+        await generateGlobalConstitution(provider, allRepos2, currentDir);
       }
-      console.log(chalk28.blue("\n\u2500\u2500\u2500 Generating Global Constitution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(chalk28.gray(`  Provider: ${providerName}/${modelName}`));
-      const projectSummaries = [];
-      const index = await loadIndex(currentDir);
-      if (index && index.projects.length > 0) {
-        const active = index.projects.filter((p) => !p.missing);
-        console.log(chalk28.gray(`  Found project index: ${active.length} project(s) \u2014 reading constitutions...`));
-        for (const entry of active) {
-          const absPath = path27.join(currentDir, entry.path);
-          const lines = [
-            `Type: ${entry.type} (${entry.role})`,
-            `Tech stack: ${entry.techStack.join(", ") || "unknown"}`
-          ];
-          if (entry.hasConstitution) {
-            try {
-              const constitutionPath2 = path27.join(absPath, CONSTITUTION_FILE);
-              const raw = await fs28.readFile(constitutionPath2, "utf-8");
-              const excerpt = raw.slice(0, 2e3);
-              lines.push("", "Constitution excerpt:", excerpt);
-            } catch {
-            }
-          }
-          projectSummaries.push({ name: entry.name, summary: lines.join("\n") });
+      return;
+    }
+    console.log(chalk28.blue("\n" + "\u2500".repeat(52)));
+    console.log(chalk28.bold("  ai-spec init \u2014 Workspace Setup"));
+    console.log(chalk28.blue("\u2500".repeat(52)));
+    console.log(chalk28.gray(`  Provider: ${providerName}/${modelName}
+`));
+    const existingRepos = await getRegisteredRepos();
+    if (existingRepos.length > 0) {
+      console.log(chalk28.cyan("  Registered repos:"));
+      for (const r of existingRepos) {
+        const constitutionIcon = r.hasConstitution ? chalk28.green("\u2714") : chalk28.gray("\u25CB");
+        console.log(chalk28.gray(`    ${constitutionIcon} ${r.name} (${r.type} / ${r.role}) \u2192 ${r.path}`));
+      }
+      console.log();
+    }
+    const action = existingRepos.length > 0 ? await select8({
+      message: "What would you like to do?",
+      choices: [
+        { name: "Add new repo(s)", value: "add" },
+        { name: "Re-generate constitutions for existing repos", value: "regen" },
+        { name: "Skip \u2014 proceed to global constitution", value: "skip" }
+      ]
+    }) : "add";
+    const newRepos = [];
+    if (action === "add") {
+      let addMore = true;
+      while (addMore) {
+        console.log(chalk28.blue(`
+  \u2500\u2500 Register Repo #${existingRepos.length + newRepos.length + 1} \u2500\u2500`));
+        const role = await promptRepoRole2();
+        const repoPath = await promptRepoPath(role);
+        const alreadyRegistered = [...existingRepos, ...newRepos].find((r) => r.path === repoPath);
+        if (alreadyRegistered) {
+          console.log(chalk28.yellow(`    Already registered: ${alreadyRegistered.name}`));
+        } else {
+          const entry = await registerSingleRepo(repoPath, provider, role);
+          newRepos.push(entry);
+          console.log(chalk28.green(`    \u2714 Registered: ${entry.name}`));
         }
-      } else {
-        console.log(chalk28.yellow("  No project index found. Run `ai-spec scan` first for better results."));
-        console.log(chalk28.gray("  Falling back: scanning current directory only..."));
-        const loader = new ContextLoader(currentDir);
-        const ctx = await loader.loadProjectContext();
-        projectSummaries.push({
-          name: path27.basename(currentDir),
-          summary: [
-            `Tech stack: ${ctx.techStack.join(", ") || "unknown"}`,
-            `Dependencies: ${ctx.dependencies.slice(0, 20).join(", ")}`
-          ].join("\n")
+        addMore = await confirm2({
+          message: "Add another repo?",
+          default: false
         });
       }
-      console.log(chalk28.gray(`  Generating from ${projectSummaries.length} project(s)...`));
-      const prompt = buildGlobalConstitutionPrompt(projectSummaries);
-      let globalConstitution;
-      try {
-        globalConstitution = await provider.generate(prompt, globalConstitutionSystemPrompt);
-      } catch (err) {
-        console.error(chalk28.red("  \u2718 Failed to generate global constitution:"), err);
-        process.exit(1);
-      }
-      const saved2 = await saveGlobalConstitution(globalConstitution, currentDir);
-      console.log(chalk28.green(`
-  \u2714 Global constitution saved: ${saved2}`));
-      console.log(chalk28.gray("  This will be automatically merged into all project constitutions in this workspace."));
-      console.log(chalk28.gray("  Project-level rules always override global rules.\n"));
-      console.log(chalk28.bold("  Preview:"));
-      console.log(chalk28.gray(globalConstitution.split("\n").slice(0, 12).join("\n")));
-      if (globalConstitution.split("\n").length > 12) {
-        console.log(chalk28.gray(`  ... (${globalConstitution.split("\n").length} lines total)`));
+    }
+    if (action === "regen") {
+      console.log(chalk28.blue("\n  Re-generating project constitutions..."));
+      for (const repo of existingRepos) {
+        if (!await fs29.pathExists(repo.path)) {
+          console.log(chalk28.yellow(`    \u26A0 ${repo.name}: path not found \u2014 skipping`));
+          continue;
+        }
+        const constitutionPath = path28.join(repo.path, CONSTITUTION_FILE);
+        if (await fs29.pathExists(constitutionPath) && !opts.force) {
+          console.log(chalk28.gray(`    ${repo.name}: constitution exists (use --force to overwrite)`));
+          continue;
+        }
+        console.log(chalk28.blue(`    ${repo.name}: generating constitution...`));
+        try {
+          const gen = new ConstitutionGenerator(provider);
+          const content = await gen.generate(repo.path);
+          await gen.saveConstitution(repo.path, content);
+          console.log(chalk28.green(`    \u2714 ${repo.name}: constitution saved`));
+        } catch (err) {
+          console.log(chalk28.yellow(`    \u26A0 ${repo.name}: failed \u2014 ${err.message}`));
+        }
       }
-      return;
     }
-    const constitutionPath = path27.join(currentDir, CONSTITUTION_FILE);
-    if (!opts.force && await fs28.pathExists(constitutionPath)) {
-      console.log(chalk28.yellow(`
-  ${CONSTITUTION_FILE} already exists.`));
-      console.log(chalk28.gray("  Use --force to overwrite it."));
-      console.log(chalk28.gray(`  Or edit it directly: ${constitutionPath}`));
+    const allRepos = await getRegisteredRepos();
+    if (allRepos.length === 0) {
+      console.log(chalk28.yellow("\n  No repos registered. Run `ai-spec init` again to add repos."));
       return;
     }
-    console.log(chalk28.blue("\n\u2500\u2500\u2500 Generating Project Constitution \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-    console.log(chalk28.gray(`  Provider: ${providerName}/${modelName}`));
-    console.log(chalk28.gray("  Analyzing codebase..."));
-    const generator = new ConstitutionGenerator(provider);
-    let constitution;
-    try {
-      constitution = await generator.generate(currentDir);
-    } catch (err) {
-      console.error(chalk28.red("  \u2718 Failed to generate constitution:"), err);
-      process.exit(1);
-    }
-    const saved = await generator.saveConstitution(currentDir, constitution);
-    const globalResult = await loadGlobalConstitution([path27.dirname(currentDir)]);
-    if (globalResult) {
-      console.log(chalk28.cyan(`
-  \u2139 Global constitution detected: ${globalResult.source}`));
-      console.log(chalk28.gray("    It will be merged with this project constitution at runtime."));
-      console.log(chalk28.gray("    Project rules take priority over global rules."));
-    }
-    console.log(chalk28.green(`
-  \u2714 Constitution saved: ${saved}`));
-    console.log(chalk28.gray("  This file will be automatically used in all future `ai-spec create` runs."));
-    console.log(chalk28.gray("  Edit it to add custom rules or red lines for your project.\n"));
-    console.log(chalk28.bold("  Preview:"));
-    console.log(chalk28.gray(constitution.split("\n").slice(0, 15).join("\n")));
-    if (constitution.split("\n").length > 15) {
-      console.log(chalk28.gray(`  ... (${constitution.split("\n").length} lines total)`));
-    }
+    const existingGlobal = await loadGlobalConstitution([currentDir]);
+    const shouldGenerateGlobal = !existingGlobal || opts.force || newRepos.length > 0 ? true : await confirm2({
+      message: "Global constitution exists. Re-generate it?",
+      default: false
+    });
+    if (shouldGenerateGlobal) {
+      await generateGlobalConstitution(provider, allRepos, currentDir);
+    }
+    console.log(chalk28.bold.green("\n\u2714 Init complete!"));
+    console.log(chalk28.gray(`  Repos registered: ${allRepos.length}`));
+    for (const r of allRepos) {
+      const icon = r.hasConstitution ? chalk28.green("\u2714") : chalk28.gray("\u25CB");
+      console.log(chalk28.gray(`    ${icon} ${r.name} (${r.type}/${r.role})`));
+    }
+    console.log(chalk28.gray(`
+  Repo store: ${REPO_STORE_FILE}`));
+    console.log(chalk28.gray(`  Next step: ai-spec create "your feature idea"`));
+    process.exit(0);
   });
 }
 
 // cli/commands/config.ts
-import * as path28 from "path";
-import * as fs29 from "fs-extra";
+import * as path29 from "path";
+import * as fs30 from "fs-extra";
 import chalk29 from "chalk";
 function registerConfig(program2) {
   program2.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("--codegen <mode>", "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("--min-harness-score <score>", "Minimum harness score (1-10) for pipeline success (0 = disabled)").option("--max-error-cycles <n>", "Maximum error-feedback fix cycles (1-10, default: 2)").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 = path28.join(currentDir, CONFIG_FILE);
+    const configPath = path29.join(currentDir, CONFIG_FILE);
     if (opts.clearKeys) {
       await clearAllKeys();
       console.log(chalk29.green(`\u2714 All saved API keys cleared.`));
@@ -12453,7 +12631,7 @@ function registerConfig(program2) {
       return;
     }
     if (opts.listKeys) {
-      const store = await fs29.readJson(KEY_STORE_FILE).catch(() => ({}));
+      const store = await fs30.readJson(KEY_STORE_FILE).catch(() => ({}));
       const providers = Object.keys(store);
       if (providers.length === 0) {
         console.log(chalk29.gray("No saved API keys."));
@@ -12469,7 +12647,7 @@ File: ${KEY_STORE_FILE}`));
       return;
     }
     if (opts.reset) {
-      await fs29.writeJson(configPath, {}, { spaces: 2 });
+      await fs30.writeJson(configPath, {}, { spaces: 2 });
       console.log(chalk29.green(`\u2714 Config reset: ${configPath}`));
       return;
     }
@@ -12513,7 +12691,7 @@ File: ${KEY_STORE_FILE}`));
       }
       updated.maxErrorCycles = cycles;
     }
-    await fs29.writeJson(configPath, updated, { spaces: 2 });
+    await fs30.writeJson(configPath, updated, { spaces: 2 });
     console.log(chalk29.green(`\u2714 Config saved to ${configPath}`));
     console.log(JSON.stringify(updated, null, 2));
   });
@@ -12521,14 +12699,10 @@ File: ${KEY_STORE_FILE}`));
 
 // cli/commands/model.ts
 init_spec_generator();
-import * as path29 from "path";
-import * as fs30 from "fs-extra";
 import chalk30 from "chalk";
-import { input as input3, select as select7, confirm as confirm2 } from "@inquirer/prompts";
+import { input as input4, select as select9, confirm as confirm3 } from "@inquirer/prompts";
 function registerModel(program2) {
   program2.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 = path29.join(currentDir, CONFIG_FILE);
     if (opts.list) {
       console.log(chalk30.bold("\nAvailable providers & models:\n"));
       for (const [key, meta] of Object.entries(PROVIDER_CATALOG)) {
@@ -12545,8 +12719,9 @@ function registerModel(program2) {
       }
       return;
     }
-    const existing = await loadConfig(currentDir);
+    const existing = await loadGlobalConfig();
     console.log(chalk30.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(chalk30.gray(`  Config: ${GLOBAL_CONFIG_FILE}`));
     if (Object.keys(existing).length > 0) {
       console.log(
         chalk30.gray(
@@ -12555,7 +12730,7 @@ function registerModel(program2) {
       );
     }
     console.log();
-    const target = await select7({
+    const target = await select9({
       message: "Configure model for:",
       choices: [
         { name: "Spec generation  (used for spec writing & refinement)", value: "spec" },
@@ -12564,7 +12739,7 @@ function registerModel(program2) {
       ]
     });
     async function pickProviderAndModel(label) {
-      const providerKey = await select7({
+      const providerKey = await select9({
         message: `${label} \u2014 select provider:`,
         choices: Object.entries(PROVIDER_CATALOG).map(([key, meta2]) => ({
           name: `${meta2.displayName.padEnd(22)} ${chalk30.gray(meta2.description)}`,
@@ -12577,12 +12752,12 @@ function registerModel(program2) {
         ...meta.models.map((m) => ({ name: m, value: m })),
         { name: chalk30.italic("\u270E  Enter custom model name..."), value: "__custom__" }
       ];
-      let chosenModel = await select7({
+      let chosenModel = await select9({
         message: `${label} \u2014 select model (${meta.displayName}):`,
         choices: modelChoices
       });
       if (chosenModel === "__custom__") {
-        chosenModel = await input3({
+        chosenModel = await input4({
           message: "Enter model name:",
           validate: (v2) => v2.trim().length > 0 || "Model name cannot be empty"
         });
@@ -12627,14 +12802,14 @@ function registerModel(program2) {
         )
       );
     }
-    const ok = await confirm2({ message: "Save to .ai-spec.json?", default: true });
+    const ok = await confirm3({ message: `Save to ${GLOBAL_CONFIG_FILE}?`, default: true });
     if (!ok) {
       console.log(chalk30.gray("  Cancelled."));
       return;
     }
-    await fs30.writeJson(configPath, updated, { spaces: 2 });
+    await saveGlobalConfig(updated);
     console.log(chalk30.green(`
-  \u2714 Saved to ${configPath}`));
+  \u2714 Saved to ${GLOBAL_CONFIG_FILE}`));
     const providerToCheck = updated.provider ?? "gemini";
     const envKey = ENV_KEY_MAP[providerToCheck];
     if (envKey && !process.env[envKey]) {
@@ -12651,14 +12826,14 @@ function registerModel(program2) {
 import * as path30 from "path";
 import * as fs31 from "fs-extra";
 import chalk31 from "chalk";
-import { input as input4, select as select8, confirm as confirm3 } from "@inquirer/prompts";
+import { input as input5, select as select10, confirm as confirm4 } from "@inquirer/prompts";
 function registerWorkspace(program2) {
   const workspaceCmd = program2.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 = path30.join(currentDir, WORKSPACE_CONFIG_FILE);
     if (await fs31.pathExists(configPath)) {
-      const overwrite = await confirm3({
+      const overwrite = await confirm4({
         message: `${WORKSPACE_CONFIG_FILE} already exists. Overwrite?`,
         default: false
       });
@@ -12668,12 +12843,12 @@ function registerWorkspace(program2) {
       }
     }
     console.log(chalk31.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 input4({
+    const workspaceName = await input5({
       message: "Workspace name:",
       validate: (v2) => v2.trim().length > 0 || "Name cannot be empty"
     });
     const repos = [];
-    const useAutoScan = await confirm3({
+    const useAutoScan = await confirm4({
       message: "Auto-scan sibling directories for repos?",
       default: true
     });
@@ -12687,7 +12862,7 @@ function registerWorkspace(program2) {
         for (const r of detected) {
           console.log(chalk31.gray(`    - ${r.name}: ${r.role} (${r.type}) at ${r.path}`));
         }
-        const keepAll = await confirm3({
+        const keepAll = await confirm4({
           message: `Include all ${detected.length} detected repo(s)?`,
           default: true
         });
@@ -12695,7 +12870,7 @@ function registerWorkspace(program2) {
           repos.push(...detected);
         } else {
           for (const r of detected) {
-            const keep = await confirm3({
+            const keep = await confirm4({
               message: `Include "${r.name}" (${r.role}, ${r.type})?`,
               default: true
             });
@@ -12719,14 +12894,14 @@ function registerWorkspace(program2) {
       { name: "react-native (React Native mobile)", value: "react-native" },
       { name: "unknown", value: "unknown" }
     ];
-    let addMore = await confirm3({
+    let addMore = await confirm4({
       message: repos.length > 0 ? "Manually add more repos?" : "Add repos manually?",
       default: repos.length === 0
     });
     while (addMore) {
       console.log(chalk31.cyan(`
   Adding repo #${repos.length + 1}`));
-      const repoName = await input4({
+      const repoName = await input5({
         message: "Repo name (e.g. api, web, app):",
         validate: (v2) => {
           if (!v2.trim()) return "Name cannot be empty";
@@ -12734,7 +12909,7 @@ function registerWorkspace(program2) {
           return true;
         }
       });
-      const repoPath = await input4({
+      const repoPath = await input5({
         message: `Relative path to "${repoName}" from here (default: ./${repoName}):`,
         default: `./${repoName}`
       });
@@ -12749,12 +12924,12 @@ function registerWorkspace(program2) {
       } else {
         console.log(chalk31.yellow(`    Path "${absPath}" not found \u2014 type/role will be manual.`));
       }
-      const repoType = await select8({
+      const repoType = await select10({
         message: `Repo type for "${repoName}":`,
         choices: repoTypeChoices,
         default: detectedType
       });
-      const repoRole = await select8({
+      const repoRole = await select10({
         message: `Repo role for "${repoName}":`,
         choices: [
           { name: "backend", value: "backend" },
@@ -12771,7 +12946,7 @@ function registerWorkspace(program2) {
         role: repoRole
       });
       console.log(chalk31.green(`  \u2714 Added: ${repoName} (${repoRole}, ${repoType})`));
-      addMore = await confirm3({
+      addMore = await confirm4({
         message: "Add another repo?",
         default: false
       });
@@ -12782,7 +12957,7 @@ function registerWorkspace(program2) {
     for (const r of repos) {
       console.log(chalk31.gray(`  - ${r.name}: ${r.role} (${r.type}) at ${r.path}`));
     }
-    const ok = await confirm3({ message: `Save to ${WORKSPACE_CONFIG_FILE}?`, default: true });
+    const ok = await confirm4({ message: `Save to ${WORKSPACE_CONFIG_FILE}?`, default: true });
     if (!ok) {
       console.log(chalk31.gray("  Cancelled."));
       return;
@@ -12827,7 +13002,7 @@ init_spec_generator();
 import * as path32 from "path";
 import * as fs33 from "fs-extra";
 import chalk33 from "chalk";
-import { input as input5 } from "@inquirer/prompts";
+import { input as input6 } from "@inquirer/prompts";
 
 // core/spec-updater.ts
 import chalk32 from "chalk";
@@ -13061,7 +13236,7 @@ function registerUpdate(program2) {
     const currentDir = process.cwd();
     const config2 = await loadConfig(currentDir);
     if (!change) {
-      change = await input5({
+      change = await input6({
         message: "Describe the change you want to make:",
         validate: (v2) => v2.trim().length > 0 || "Change description cannot be empty"
       });
@@ -13379,7 +13554,7 @@ function buildYamlDoc(obj) {
     return `${k2}: ${valStr}`;
   }).join("\n") + "\n";
 }
-function dslToOpenApi(dsl, serverUrl = "http://localhost:3000") {
+function dslToOpenApi(dsl, serverUrl = DEFAULT_OPENAPI_SERVER_URL) {
   const info = {
     title: dsl.feature.title,
     description: dsl.feature.description,
@@ -13426,7 +13601,7 @@ function dslToOpenApi(dsl, serverUrl = "http://localhost:3000") {
 }
 async function exportOpenApi(dsl, projectDir, opts = {}) {
   const format = opts.format ?? "yaml";
-  const serverUrl = opts.serverUrl ?? "http://localhost:3000";
+  const serverUrl = opts.serverUrl ?? DEFAULT_OPENAPI_SERVER_URL;
   const defaultName = `openapi.${format}`;
   const outputPath = opts.outputPath ? path33.isAbsolute(opts.outputPath) ? opts.outputPath : path33.join(projectDir, opts.outputPath) : path33.join(projectDir, defaultName);
   const doc = dslToOpenApi(dsl, serverUrl);
@@ -13622,12 +13797,12 @@ function registerMock(program2) {
 
 // cli/commands/learn.ts
 import chalk36 from "chalk";
-import { input as input6 } from "@inquirer/prompts";
+import { input as input7 } from "@inquirer/prompts";
 function registerLearn(program2) {
   program2.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) => {
     const currentDir = process.cwd();
     if (!lesson) {
-      lesson = await input6({
+      lesson = await input7({
         message: "What lesson or engineering decision should be recorded?",
         validate: (v2) => v2.trim().length > 0 || "Please enter a lesson"
       });
@@ -13669,9 +13844,8 @@ import chalk39 from "chalk";
 import * as fs37 from "fs-extra";
 import * as path36 from "path";
 import chalk38 from "chalk";
-var LOG_DIR2 = ".ai-spec-logs";
 async function loadRunLogs(workingDir) {
-  const logDir = path36.join(workingDir, LOG_DIR2);
+  const logDir = path36.join(workingDir, DEFAULT_LOG_DIR);
   if (!await fs37.pathExists(logDir)) return [];
   const files = await fs37.readdir(logDir);
   const jsonFiles = new Set(files.filter((f) => f.endsWith(".json")));
@@ -13816,7 +13990,7 @@ function printTrendReport(report, workingDir) {
       `  ${chalk38.gray(formatDate(e.startedAt))}  ${bar}${scoreStr}  ${hash}  ${dur}${errMark}  ${spec}`
     );
   }
-  const logRelDir = path36.relative(workingDir, path36.join(workingDir, LOG_DIR2));
+  const logRelDir = path36.relative(workingDir, path36.join(workingDir, DEFAULT_LOG_DIR));
   console.log(chalk38.gray(`
   ${entries.length} run(s) shown  \xB7  logs: ${logRelDir}/`));
   console.log(chalk38.cyan("\u2500".repeat(63)));
@@ -14475,7 +14649,233 @@ function registerVcr(program2) {
 
 // cli/commands/scan.ts
 import chalk44 from "chalk";
+import * as path42 from "path";
+
+// core/project-index.ts
+import * as fs42 from "fs-extra";
 import * as path41 from "path";
+var INDEX_FILE = ".ai-spec-index.json";
+var KEY_DEPS = [
+  // Frameworks
+  "express",
+  "fastify",
+  "koa",
+  "@nestjs/core",
+  "hapi",
+  "next",
+  "react",
+  "vue",
+  "nuxt",
+  "svelte",
+  "react-native",
+  "expo",
+  // DB / ORM
+  "prisma",
+  "@prisma/client",
+  "mongoose",
+  "typeorm",
+  "sequelize",
+  "drizzle-orm",
+  // Auth
+  "jsonwebtoken",
+  "passport",
+  "next-auth",
+  "@clerk/nextjs",
+  // Build / Lang
+  "typescript",
+  "vite",
+  "webpack",
+  "esbuild",
+  "turbo",
+  // Testing
+  "jest",
+  "vitest",
+  "mocha",
+  "cypress",
+  "playwright",
+  // Infra
+  "redis",
+  "bull",
+  "socket.io",
+  "graphql",
+  "@trpc/server"
+];
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "__pycache__",
+  "vendor",
+  ".ai-spec-vcr",
+  ".ai-spec-logs",
+  "specs"
+]);
+var MANIFEST_FILES = [
+  "package.json",
+  "go.mod",
+  "Cargo.toml",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "requirements.txt",
+  "pyproject.toml",
+  "setup.py",
+  "composer.json"
+];
+async function isProjectRoot(absPath) {
+  for (const manifest of MANIFEST_FILES) {
+    if (await fs42.pathExists(path41.join(absPath, manifest))) return true;
+  }
+  return false;
+}
+async function extractTechStack(absPath, type) {
+  const stack = [];
+  if (type === "go") stack.push("go");
+  if (type === "rust") stack.push("rust");
+  if (type === "java") stack.push("java");
+  if (type === "python") stack.push("python");
+  if (type === "php") stack.push("php");
+  const pkgPath = path41.join(absPath, "package.json");
+  if (!await fs42.pathExists(pkgPath)) return stack;
+  let pkg = {};
+  try {
+    pkg = await fs42.readJson(pkgPath);
+  } catch {
+    return stack;
+  }
+  const allDeps = {
+    ...pkg.dependencies ?? {},
+    ...pkg.devDependencies ?? {}
+  };
+  const depKeys = new Set(Object.keys(allDeps));
+  for (const dep of KEY_DEPS) {
+    if (depKeys.has(dep)) stack.push(dep);
+  }
+  return stack;
+}
+async function discoverProjects(rootDir, maxDepth) {
+  const found = [];
+  async function walk(absDir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await fs42.readdir(absDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+      const childAbs = path41.join(absDir, entry.name);
+      const gitPath = path41.join(childAbs, ".git");
+      if (await fs42.pathExists(gitPath)) {
+        const gitStat = await fs42.stat(gitPath);
+        if (gitStat.isFile()) continue;
+      }
+      if (await isProjectRoot(childAbs)) {
+        found.push(path41.relative(rootDir, childAbs));
+      } else {
+        await walk(childAbs, depth + 1);
+      }
+    }
+  }
+  await walk(rootDir, 0);
+  return found;
+}
+async function loadIndex(scanRoot) {
+  const filePath = path41.join(scanRoot, INDEX_FILE);
+  try {
+    return await fs42.readJson(filePath);
+  } catch {
+    return null;
+  }
+}
+async function saveIndex(scanRoot, index) {
+  const filePath = path41.join(scanRoot, INDEX_FILE);
+  await fs42.writeJson(filePath, index, { spaces: 2 });
+  return filePath;
+}
+async function runScan(scanRoot, maxDepth = 2) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = await loadIndex(scanRoot);
+  const existingMap = new Map(
+    (existing?.projects ?? []).map((p) => [p.path, p])
+  );
+  const discoveredPaths = await discoverProjects(scanRoot, maxDepth);
+  const added = [];
+  const updated = [];
+  const unchanged = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const relPath of discoveredPaths) {
+    const absPath = path41.join(scanRoot, relPath);
+    seenPaths.add(relPath);
+    const { type, role } = await detectRepoType(absPath);
+    const techStack = await extractTechStack(absPath, type);
+    const hasConstitution = await fs42.pathExists(path41.join(absPath, CONSTITUTION_FILE));
+    const hasWorkspace = await fs42.pathExists(path41.join(absPath, WORKSPACE_CONFIG_FILE));
+    const name = path41.basename(relPath);
+    const prev = existingMap.get(relPath);
+    if (!prev) {
+      const entry = {
+        name,
+        path: relPath,
+        type,
+        role,
+        techStack,
+        hasConstitution,
+        hasWorkspace,
+        firstSeen: now,
+        lastSeen: now
+      };
+      added.push(entry);
+      existingMap.set(relPath, entry);
+    } else {
+      const changed = prev.type !== type || prev.role !== role || prev.hasConstitution !== hasConstitution || prev.hasWorkspace !== hasWorkspace || JSON.stringify(prev.techStack.sort()) !== JSON.stringify(techStack.sort());
+      const entry = {
+        ...prev,
+        type,
+        role,
+        techStack,
+        hasConstitution,
+        hasWorkspace,
+        lastSeen: now,
+        missing: void 0
+        // clear missing flag if it came back
+      };
+      existingMap.set(relPath, entry);
+      if (changed) {
+        updated.push(entry);
+      } else {
+        unchanged.push(entry);
+      }
+    }
+  }
+  const nowMissing = [];
+  for (const [relPath, entry] of existingMap) {
+    if (!seenPaths.has(relPath) && !entry.missing) {
+      const gone = { ...entry, missing: true };
+      existingMap.set(relPath, gone);
+      nowMissing.push(gone);
+    }
+  }
+  const projects = [...existingMap.values()].sort((a, b) => a.path.localeCompare(b.path));
+  const index = {
+    scanRoot,
+    lastScanned: now,
+    projects
+  };
+  return { index, added, updated, unchanged, nowMissing };
+}
+
+// cli/commands/scan.ts
 var ROLE_COLOR = {
   backend: chalk44.blue,
   frontend: chalk44.green,
@@ -14549,7 +14949,7 @@ Scanning ${cwd} (depth: ${maxDepth})...`));
     }
     console.log(chalk44.cyan("\n\u2500".repeat(52)));
     console.log(chalk44.gray("  \xA7C = has constitution  W = workspace root"));
-    console.log(chalk44.gray(`  Index saved : ${path41.relative(cwd, path41.join(cwd, INDEX_FILE))}`));
+    console.log(chalk44.gray(`  Index saved : ${path42.relative(cwd, path42.join(cwd, INDEX_FILE))}`));
     console.log(chalk44.gray(`  Next steps  : ai-spec scan --list | ai-spec init [--global]`));
   });
 }
@@ -14557,7 +14957,7 @@ Scanning ${cwd} (depth: ${maxDepth})...`));
 // cli/index.ts
 dotenv.config();
 var program = new Command();
-program.name("ai-spec").description("AI-driven Development Orchestrator \u2014 spec, generate, review").version("0.14.1");
+program.name("ai-spec").description("AI-driven Development Orchestrator \u2014 spec, generate, review").version(require_package().version);
 registerCreate(program);
 registerReview(program);
 registerInit(program);