@archal/cli 0.7.0 → 0.7.3

package/dist/index.js

@@ -675,6 +675,46 @@ var SUPABASE_SEED_MAPPINGS = [
     weight: 2
   }
 ];
+var GOOGLE_WORKSPACE_SEED_MAPPINGS = [
+  {
+    keywords: ["empty", "blank", "new", "fresh", "clean", "no emails", "no files", "no events"],
+    seedName: "empty",
+    weight: 1
+  },
+  {
+    keywords: [
+      "workspace",
+      "gmail",
+      "drive",
+      "calendar",
+      "docs",
+      "sheets",
+      "slides",
+      "small team",
+      "meeting",
+      "inbox",
+      "file",
+      "folder"
+    ],
+    seedName: "small-team",
+    weight: 1
+  },
+  {
+    keywords: ["permission", "denied", "forbidden", "access denied", "unauthorized", "read-only"],
+    seedName: "permission-denied",
+    weight: 2
+  },
+  {
+    keywords: ["rate limit", "throttle", "too many requests", "429"],
+    seedName: "rate-limited",
+    weight: 2
+  },
+  {
+    keywords: ["quota", "limit exceeded", "storage full", "daily limit"],
+    seedName: "quota-exceeded",
+    weight: 2
+  }
+];
 var JIRA_SEED_MAPPINGS = [
   {
     keywords: ["empty", "blank", "new", "fresh", "clean", "no issues", "bare"],
@@ -743,7 +783,8 @@ var TWIN_SEED_REGISTRY = {
   stripe: STRIPE_SEED_MAPPINGS,
   linear: LINEAR_SEED_MAPPINGS,
   supabase: SUPABASE_SEED_MAPPINGS,
-  jira: JIRA_SEED_MAPPINGS
+  jira: JIRA_SEED_MAPPINGS,
+  "google-workspace": GOOGLE_WORKSPACE_SEED_MAPPINGS
 };
 var DEFAULT_SEEDS = {
   github: "small-project",
@@ -751,7 +792,8 @@ var DEFAULT_SEEDS = {
   stripe: "small-business",
   linear: "small-team",
   supabase: "small-project",
-  jira: "small-project"
+  jira: "small-project",
+  "google-workspace": "small-team"
 };
 function normalizeText(text) {
   return text.toLowerCase().replace(/[^a-z0-9\s/]/g, " ").replace(/\s+/g, " ").trim();
@@ -771,10 +813,11 @@ function scoreMappingAgainstText(text, mapping) {
 function selectSeedForTwin(twinName, setupDescription) {
   const mappings = TWIN_SEED_REGISTRY[twinName];
   if (!mappings || mappings.length === 0) {
-    debug(`No seed mappings for twin "${twinName}", using "default"`);
+    const fallbackSeed = DEFAULT_SEEDS[twinName] ?? "default";
+    debug(`No seed mappings for twin "${twinName}", using "${fallbackSeed}"`);
     return {
       twinName,
-      seedName: "default",
+      seedName: fallbackSeed,
       confidence: 0,
       matchedKeywords: []
     };
@@ -3005,7 +3048,7 @@ var RETRYABLE_STATUS_CODES2 = /* @__PURE__ */ new Set([429, 500, 502, 503, 529])
 function detectProvider(model) {
   if (model.startsWith("gemini-")) return "gemini";
   if (model.startsWith("claude-")) return "anthropic";
-  if (model.startsWith("gpt-") || model.startsWith("o1-") || model.startsWith("o3-") || model.startsWith("o4-")) return "openai";
+  if (model.startsWith("gpt-") || model.startsWith("o1-") || model.startsWith("o2-") || model.startsWith("o3-") || model.startsWith("o4-")) return "openai";
   if (model.startsWith("llama") || model.startsWith("mixtral") || model.startsWith("mistral") || model.startsWith("deepseek") || model.startsWith("qwen") || model.startsWith("codestral") || model.startsWith("command")) return "openai-compatible";
   return "openai-compatible";
 }
@@ -3197,7 +3240,11 @@ async function callAnthropic(options) {
   if (!textBlock?.text) throw new Error("Anthropic returned no text content");
   return textBlock.text;
 }
+function usesMaxCompletionTokens(model) {
+  return model.startsWith("gpt-5") || model.startsWith("o1-") || model.startsWith("o2-") || model.startsWith("o3-") || model.startsWith("o4-");
+}
 async function callOpenAi(options) {
+  const tokenConfig = usesMaxCompletionTokens(options.model) ? { max_completion_tokens: options.maxTokens } : { max_tokens: options.maxTokens };
   const response = await fetch("https://api.openai.com/v1/chat/completions", {
     method: "POST",
     headers: {
@@ -3206,7 +3253,7 @@ async function callOpenAi(options) {
     },
     body: JSON.stringify({
       model: options.model,
-      max_tokens: options.maxTokens,
+      ...tokenConfig,
       messages: [
         { role: "system", content: options.systemPrompt },
         { role: "user", content: options.userPrompt }
@@ -7367,8 +7414,8 @@ var GOOGLE_WORKSPACE_OVERRIDES = {
     }
   },
   eventAttendees: {
-    required: ["eventEntityId", "eventId", "email"],
-    nullable: ["displayName", "comment"],
+    required: ["eventId", "email"],
+    nullable: ["eventEntityId", "displayName", "comment"],
     fields: {
       eventEntityId: { fk: "events.id", description: "Numeric id of the event entity" },
       eventId: { description: "References events.eventId" },
@@ -8076,10 +8123,32 @@ var KIND_COLLECTION_HINTS = {
   event: ["events"],
   email: ["gmail_messages", "messages"]
 };
+var STRICT_QUOTE_TWINS = /* @__PURE__ */ new Set(["slack", "google-workspace"]);
+var ENTITY_KEY_ALIASES = {
+  "repo.owner": ["ownerLogin", "owner_login", "login", "owner.login", "owner.name"],
+  "issue.key": ["identifier"],
+  "email.address": ["email", "from", "to", "cc", "bcc"],
+  "file.name": ["title", "fileName", "filename", "subject", "summary"]
+};
+function normalizeCollectionName(name) {
+  return name.toLowerCase().replace(/[_\-\s]/g, "");
+}
+function singularize(value) {
+  return value.endsWith("s") ? value.slice(0, -1) : value;
+}
+function collectionNameMatches(candidate, hint) {
+  const normCandidate = normalizeCollectionName(candidate);
+  const normHint = normalizeCollectionName(hint);
+  return singularize(normCandidate) === singularize(normHint);
+}
 function toCollectionCandidates(seed, kind, value) {
   const candidates = /* @__PURE__ */ new Set();
   for (const hint of KIND_COLLECTION_HINTS[kind] ?? []) {
-    if (seed[hint]) candidates.add(hint);
+    for (const collection of Object.keys(seed)) {
+      if (collectionNameMatches(collection, hint)) {
+        candidates.add(collection);
+      }
+    }
   }
   if (kind === "stripe_entity" && typeof value === "string") {
     const normalized = value.toLowerCase().replace(/\s+/g, "_");
@@ -8089,16 +8158,55 @@ function toCollectionCandidates(seed, kind, value) {
     }
   }
   if (kind === "table" && typeof value === "string") {
-    for (const name of [value, value.toLowerCase()]) {
-      if (seed[name]) candidates.add(name);
+    for (const collection of Object.keys(seed)) {
+      if (collectionNameMatches(collection, value)) {
+        candidates.add(collection);
+      }
     }
   }
   return Array.from(candidates);
 }
+function getPathValue(record, path) {
+  const parts = path.split(".");
+  let current = record;
+  for (const part of parts) {
+    if (!current || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function getEntityFieldValues(record, kind, key) {
+  const values = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fields = [key, ...ENTITY_KEY_ALIASES[`${kind}.${key}`] ?? []];
+  for (const field of fields) {
+    const value = field.includes(".") ? getPathValue(record, field) : record[field];
+    if (!seen.has(value)) {
+      seen.add(value);
+      values.push(value);
+    }
+  }
+  return values;
+}
+function stringFieldMatches(fieldValue, target, kind, key) {
+  const normalizedField = fieldValue.trim().toLowerCase();
+  const normalizedTarget = target.trim().toLowerCase();
+  if (normalizedField === normalizedTarget) return true;
+  if (kind === "email" && key === "address") {
+    return normalizedField.includes(normalizedTarget);
+  }
+  return false;
+}
 function valueExistsInCollections(seed, kind, key, value) {
   if (kind === "table" && typeof value === "string") {
-    const tableName = value.trim().toLowerCase();
-    return Object.keys(seed).some((collection) => collection.toLowerCase() === tableName);
+    const tableName = value.trim();
+    return Object.keys(seed).some((collection) => collectionNameMatches(collection, tableName));
+  }
+  if (kind === "stripe_entity" && key === "type" && typeof value === "string") {
+    const requested = value.trim().toLowerCase();
+    if (requested === "account") {
+      return Object.keys(seed).some((collection) => collectionNameMatches(collection, "accounts"));
+    }
   }
   const normalized = typeof value === "string" ? value.trim().toLowerCase() : value;
   const candidates = toCollectionCandidates(seed, kind, value);
@@ -8108,17 +8216,29 @@ function valueExistsInCollections(seed, kind, key, value) {
     for (const row of rows) {
       if (!row || typeof row !== "object") continue;
       const record = row;
-      const fieldValue = record[key];
-      if (typeof normalized === "string") {
-        if (typeof fieldValue === "string" && fieldValue.trim().toLowerCase() === normalized) {
+      const fieldValues = getEntityFieldValues(record, kind, key);
+      for (const fieldValue of fieldValues) {
+        if (typeof normalized === "string") {
+          if (typeof fieldValue === "string" && stringFieldMatches(fieldValue, normalized, kind, key)) {
+            return true;
+          }
+          if (Array.isArray(fieldValue)) {
+            if (fieldValue.some((entry) => typeof entry === "string" && stringFieldMatches(entry, normalized, kind, key))) {
+              return true;
+            }
+          }
+        } else if (typeof normalized === "number") {
+          if (fieldValue === normalized) return true;
+          if (typeof fieldValue === "string" && Number(fieldValue) === normalized) return true;
+          if (typeof fieldValue === "number" && fieldValue === normalized) return true;
+          if (Array.isArray(fieldValue)) {
+            if (fieldValue.some((entry) => entry === normalized || Number(entry) === normalized)) {
+              return true;
+            }
+          }
+        } else if (fieldValue === normalized) {
           return true;
         }
-      } else if (typeof normalized === "number") {
-        if (fieldValue === normalized) return true;
-        if (typeof fieldValue === "string" && Number(fieldValue) === normalized) return true;
-        if (typeof fieldValue === "number" && fieldValue === normalized) return true;
-      } else if (fieldValue === normalized) {
-        return true;
       }
     }
   }
@@ -8160,7 +8280,8 @@ function quoteExists(seed, quote) {
 }
 function validateSeedCoverage(intent, mergedSeed) {
   const entityIssues = [];
-  const quoteIssues = [];
+  const quoteErrors = [];
+  const quoteWarnings = [];
   for (const entity of intent.entities) {
     if (typeof entity.value === "boolean") continue;
     if (!valueExistsInCollections(mergedSeed, entity.kind, entity.key, entity.value)) {
@@ -8176,17 +8297,22 @@ function validateSeedCoverage(intent, mergedSeed) {
     if (trimmedQuote.length > 0 && trimmedQuote.length <= 3) continue;
     if (/\[[A-Z][a-zA-Z\s]*\]/.test(trimmedQuote)) continue;
     if (!quoteExists(mergedSeed, quote)) {
-      quoteIssues.push({
+      const issue = {
         type: "missing_quote",
         message: `Expected quoted text to exist: "${quote}"`
-      });
+      };
+      if (STRICT_QUOTE_TWINS.has(intent.twinName)) {
+        quoteErrors.push(issue);
+      } else {
+        quoteWarnings.push(issue);
+      }
     }
   }
-  const errors = [...entityIssues, ...quoteIssues];
+  const errors = [...entityIssues, ...quoteErrors];
   return {
     valid: errors.length === 0,
     issues: errors,
-    warnings: []
+    warnings: quoteWarnings
   };
 }
 
@@ -9407,7 +9533,17 @@ function slackIntent(setup) {
   const requiredSlots = ["channel.name_or_dm.user"];
   const hashChannel = setup.match(/#([a-z][a-z0-9._-]*)/i)?.[1];
   const wordChannel = setup.match(/\bchannel\s+["']?([a-z0-9._-]+)["']?/i)?.[1];
-  const dmUser = setup.match(/@([a-z0-9._-]+)/i)?.[1];
+  let dmUser;
+  const mentionRegex = /@([a-z0-9._-]+)/gi;
+  let mentionMatch;
+  while ((mentionMatch = mentionRegex.exec(setup)) !== null) {
+    const mention = mentionMatch[1];
+    if (!mention) continue;
+    const prevChar = mentionMatch.index > 0 ? setup[mentionMatch.index - 1] : "";
+    if (prevChar && /[a-zA-Z0-9._%+-]/.test(prevChar)) continue;
+    dmUser = mention;
+    break;
+  }
   const mentionsDm = /\bdirect message\b|\bdm\b/i.test(setup);
   if (hashChannel || wordChannel) {
     const channel = hashChannel ?? wordChannel;
@@ -9598,7 +9734,6 @@ function jiraIntent(setup) {
 }
 function supabaseIntent(setup) {
   const extractedSlots = {};
-  const entities = [];
   const missingSlots = [];
   const requiredSlots = ["database.target"];
   const seenTables = /* @__PURE__ */ new Set();
@@ -9606,9 +9741,10 @@ function supabaseIntent(setup) {
   let backtickMatch;
   while ((backtickMatch = backtickTableRegex.exec(setup)) !== null) {
     const table2 = backtickMatch[1];
+    const before = setup.slice(Math.max(0, backtickMatch.index - 80), backtickMatch.index);
+    if (!/\b(table|tables)\b/i.test(before)) continue;
     if (seenTables.has(table2)) continue;
     seenTables.add(table2);
-    entities.push({ kind: "table", key: "name", value: table2 });
   }
   const tableNamedRegex = /\btables?\s+(?:named\s+)?["']?([a-zA-Z_][a-zA-Z0-9_]*)["']?/gi;
   let namedMatch;
@@ -9616,10 +9752,16 @@ function supabaseIntent(setup) {
     const table2 = namedMatch[1];
     if (seenTables.has(table2)) continue;
     seenTables.add(table2);
-    entities.push({ kind: "table", key: "name", value: table2 });
   }
-  const mentionsProject = /\bsupabase\s+project\s+"[^"\n]+"/i.test(setup);
-  const mentionsLogsOrService = /\blogs?\s+for\s+service\s+"[^"\n]+"/i.test(setup) || /\bservice\s+"[^"\n]+"\b/i.test(setup);
+  const sqlTableRegex = /\b(?:from|join|update|into|table)\s+([a-zA-Z_][a-zA-Z0-9_]*)\b/gi;
+  let sqlMatch;
+  while ((sqlMatch = sqlTableRegex.exec(setup)) !== null) {
+    const table2 = sqlMatch[1];
+    if (seenTables.has(table2)) continue;
+    seenTables.add(table2);
+  }
+  const mentionsProject = /\bsupabase\b[^.\n]*\b(project|projects|environment|database)\b/i.test(setup);
+  const mentionsLogsOrService = /\blogs?\s+for\s+service\s+"[^"\n]+"/i.test(setup) || /\bservice\s+"[^"\n]+"\b/i.test(setup) || /\bsupabase\s+logs?\b/i.test(setup) || /\blogs?\s+include\b/i.test(setup) || /\b(staging|production|prod)\b/i.test(setup);
   const mentionsEnvVars = /\benvironment\s+variables?\b/i.test(setup);
   const hasEnvVarTokens = /\b[A-Z][A-Z0-9_]{2,}\b/.test(setup);
   if (seenTables.size > 0 || mentionsProject || mentionsLogsOrService || mentionsEnvVars && hasEnvVarTokens) {
@@ -9640,8 +9782,11 @@ function supabaseIntent(setup) {
       setupSummary: setupSummary(setup),
       requiredSlots,
       extractedSlots,
-      entities,
-      quotedStrings: extractTwinQuotedStrings("supabase", setup)
+      // Supabase table names in setup can describe conceptual data sources
+      // that are not materialized in the base SQL schema. Keep intent broad
+      // to avoid false-hard failures in seed generation.
+      entities: [],
+      quotedStrings: []
     },
     missingSlots: []
   };
@@ -9651,6 +9796,7 @@ function googleWorkspaceIntent(setup) {
   const entities = [];
   const missingSlots = [];
   const requiredSlots = ["workspace.target"];
+  const emailLiteralRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,}$/i;
   const emailRegex = /\b([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,})\b/g;
   let emailMatch;
   const seenEmails = /* @__PURE__ */ new Set();
@@ -9660,7 +9806,7 @@ function googleWorkspaceIntent(setup) {
     seenEmails.add(email);
     entities.push({ kind: "email", key: "address", value: email });
   }
-  const quoteRegex = /"([^"\n]{1,2000})"/g;
+  const quoteRegex = /["`]([^"`\n]{1,2000})["`]/g;
   let quoteMatch;
   while ((quoteMatch = quoteRegex.exec(setup)) !== null) {
     const quoted = quoteMatch[1]?.trim();
@@ -9669,9 +9815,18 @@ function googleWorkspaceIntent(setup) {
     if (!/\b(drive|calendar|gmail|folder|file|doc|sheet|slide|meeting|event|inbox)\b/i.test(before)) {
       continue;
     }
+    if (emailLiteralRegex.test(quoted)) {
+      entities.push({ kind: "email", key: "address", value: quoted });
+      continue;
+    }
+    if (/\b(calendar|meeting|event)\b/i.test(before)) {
+      entities.push({ kind: "event", key: "summary", value: quoted });
+      continue;
+    }
     entities.push({ kind: "file", key: "name", value: quoted });
   }
-  if (entities.length > 0) {
+  const mentionsWorkspaceContext = /\b(google workspace|gmail|drive|calendar|docs?|sheets?|slides?|inbox|meeting|event|folder|file|email)\b/i.test(setup);
+  if (entities.length > 0 || mentionsWorkspaceContext) {
     extractedSlots["workspace.target"] = true;
   } else {
     missingSlots.push({
@@ -9944,18 +10099,162 @@ function parsePositiveIntFromEnv(name) {
   }
   return parsed;
 }
+function splitSqlTopLevel(input, separator) {
+  const parts = [];
+  let depth = 0;
+  let inQuote = false;
+  let start = 0;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    const next = i + 1 < input.length ? input[i + 1] : void 0;
+    if (ch === "'") {
+      if (inQuote && next === "'") {
+        i += 1;
+        continue;
+      }
+      inQuote = !inQuote;
+      continue;
+    }
+    if (inQuote) continue;
+    if (ch === "(") depth += 1;
+    if (ch === ")") depth = Math.max(0, depth - 1);
+    if (depth === 0 && ch === separator) {
+      parts.push(input.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  const tail = input.slice(start).trim();
+  if (tail) parts.push(tail);
+  return parts;
+}
+function splitSqlStatements(sql) {
+  const stripped = sql.replace(/--.*$/gm, "");
+  return splitSqlTopLevel(stripped, ";").map((stmt) => stmt.trim()).filter((stmt) => stmt.length > 0);
+}
+function normalizeSqlIdentifier(raw) {
+  const parts = raw.split(".").map((part) => part.trim().replace(/^"|"$/g, "").replace(/""/g, '"')).filter((part) => part.length > 0);
+  return parts[parts.length - 1] ?? raw.trim();
+}
+function parseSqlLiteral(raw) {
+  const value = raw.trim();
+  if (/^null$/i.test(value)) return null;
+  if (/^true$/i.test(value)) return true;
+  if (/^false$/i.test(value)) return false;
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) return Number(value);
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1).replace(/''/g, "'");
+  }
+  return value;
+}
+function parseSqlSeed(sql) {
+  const seed = {};
+  const tablesWithNumericId = /* @__PURE__ */ new Set();
+  const nextIds = /* @__PURE__ */ new Map();
+  const statements = splitSqlStatements(sql);
+  for (const statement of statements) {
+    const createMatch = statement.match(
+      /^CREATE\s+TABLE(?:\s+IF\s+NOT\s+EXISTS)?\s+([^\s(]+)\s*\(([\s\S]*)\)$/i
+    );
+    if (createMatch) {
+      const tableName2 = normalizeSqlIdentifier(createMatch[1]);
+      const schemaBody = createMatch[2];
+      if (/\bid\s+(?:serial|bigserial|integer|int|bigint)\b/i.test(schemaBody)) {
+        tablesWithNumericId.add(tableName2);
+      }
+      if (!seed[tableName2]) seed[tableName2] = [];
+      continue;
+    }
+    const insertMatch = statement.match(
+      /^INSERT\s+INTO\s+([^\s(]+)\s*\(([^)]+)\)\s*VALUES\s*([\s\S]*)$/i
+    );
+    if (!insertMatch) continue;
+    const tableName = normalizeSqlIdentifier(insertMatch[1]);
+    const columns = splitSqlTopLevel(insertMatch[2], ",").map((column) => normalizeSqlIdentifier(column));
+    const tuplesText = insertMatch[3];
+    const tuples = [];
+    let depth = 0;
+    let inQuote = false;
+    let tupleStart = -1;
+    for (let i = 0; i < tuplesText.length; i++) {
+      const ch = tuplesText[i];
+      const next = i + 1 < tuplesText.length ? tuplesText[i + 1] : void 0;
+      if (ch === "'") {
+        if (inQuote && next === "'") {
+          i += 1;
+          continue;
+        }
+        inQuote = !inQuote;
+      }
+      if (inQuote) continue;
+      if (ch === "(") {
+        if (depth === 0) tupleStart = i + 1;
+        depth += 1;
+      } else if (ch === ")") {
+        depth -= 1;
+        if (depth === 0 && tupleStart >= 0) {
+          tuples.push(tuplesText.slice(tupleStart, i));
+          tupleStart = -1;
+        }
+      }
+    }
+    const rows = seed[tableName] ?? [];
+    let nextId = nextIds.get(tableName) ?? 1;
+    for (const tuple of tuples) {
+      const rawValues = splitSqlTopLevel(tuple, ",");
+      const row = {};
+      for (let i = 0; i < columns.length; i++) {
+        const column = columns[i];
+        row[column] = parseSqlLiteral(rawValues[i] ?? "null");
+      }
+      if (tablesWithNumericId.has(tableName)) {
+        if (typeof row["id"] === "number") {
+          nextId = Math.max(nextId, row["id"] + 1);
+        } else if (typeof row["id"] === "string" && /^-?\d+$/.test(row["id"])) {
+          const parsed = Number(row["id"]);
+          row["id"] = parsed;
+          nextId = Math.max(nextId, parsed + 1);
+        } else {
+          row["id"] = nextId;
+          nextId += 1;
+        }
+      }
+      rows.push(row);
+    }
+    nextIds.set(tableName, nextId);
+    seed[tableName] = rows;
+  }
+  return seed;
+}
+function loadSeedStateFromPath(seedRoot, seedName) {
+  const jsonPath = resolve5(seedRoot, `${seedName}.json`);
+  if (existsSync11(jsonPath)) {
+    return JSON.parse(readFileSync13(jsonPath, "utf-8"));
+  }
+  const sqlPath = resolve5(seedRoot, `${seedName}.sql`);
+  if (existsSync11(sqlPath)) {
+    return parseSqlSeed(readFileSync13(sqlPath, "utf-8"));
+  }
+  return null;
+}
 function loadBaseSeedFromDisk(twinName, seedName) {
   const __dir = dirname3(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1"));
-  const monorepoPath = resolve5(__dir, "..", "..", "..", "twins", twinName, "seeds", `${seedName}.json`);
-  if (existsSync11(monorepoPath)) {
-    return JSON.parse(readFileSync13(monorepoPath, "utf-8"));
+  const monorepoSeedRoots = [
+    resolve5(__dir, "..", "..", "twins", twinName, "seeds"),
+    resolve5(__dir, "..", "..", "..", "twins", twinName, "seeds")
+  ];
+  for (const monorepoSeedRoot of monorepoSeedRoots) {
+    const monorepoSeed = loadSeedStateFromPath(monorepoSeedRoot, seedName);
+    if (monorepoSeed) {
+      return monorepoSeed;
+    }
   }
   try {
     const req = createRequire2(import.meta.url);
     const twinMain = req.resolve(`@archal/twin-${twinName}`);
-    const seedPath = resolve5(dirname3(twinMain), "..", "seeds", `${seedName}.json`);
-    if (existsSync11(seedPath)) {
-      return JSON.parse(readFileSync13(seedPath, "utf-8"));
+    const seedRoot = resolve5(dirname3(twinMain), "..", "seeds");
+    const seedState = loadSeedStateFromPath(seedRoot, seedName);
+    if (seedState) {
+      return seedState;
     }
   } catch {
   }
@@ -10422,34 +10721,27 @@ Run 'archal doctor' for a full system check.`
     successCriteria: scenario.successCriteria.map((criterion) => `${criterion.type}: ${criterion.description}`)
   };
   for (const sel of seedSelections) {
-    if (!options.allowAmbiguousSeed) {
-      if (!options.noSeedCache) {
-        const negative = getNegativeSeed(sel.twinName, sel.seedName, scenario.setup, { cacheContext: seedPromptContext });
-        if (negative && negative.missingSlots.length > 0) {
-          const details2 = formatMissingSlots(negative.missingSlots);
-          throw new Error(
-            `Setup is ambiguous for twin "${sel.twinName}" and cannot safely generate a dynamic seed.
-Missing details:
-${details2}
-Pass --allow-ambiguous-seed to opt into best-effort generation.`
-          );
-        }
-      }
-    }
     const intentResult = extractSeedIntent(sel.twinName, scenario.setup);
     extractedIntentByTwin.set(sel.twinName, intentResult.intent ?? void 0);
     if (intentResult.missingSlots.length === 0) {
       generationTargets.push(sel);
       continue;
     }
-    const details = formatMissingSlots(intentResult.missingSlots);
+    let missingSlots = intentResult.missingSlots;
+    if (!options.noSeedCache) {
+      const negative = getNegativeSeed(sel.twinName, sel.seedName, scenario.setup, { cacheContext: seedPromptContext });
+      if (negative && negative.missingSlots.length > 0) {
+        missingSlots = negative.missingSlots;
+      }
+    }
+    const details = formatMissingSlots(missingSlots);
     const message = `Setup is ambiguous for twin "${sel.twinName}" and cannot safely generate a dynamic seed.
 Missing details:
 ${details}
 Pass --allow-ambiguous-seed to opt into best-effort generation.`;
     if (!options.allowAmbiguousSeed) {
       if (!options.noSeedCache) {
-        cacheNegativeSeed(sel.twinName, sel.seedName, scenario.setup, intentResult.missingSlots, {
+        cacheNegativeSeed(sel.twinName, sel.seedName, scenario.setup, missingSlots, {
           cacheContext: seedPromptContext
         });
       }
@@ -10471,7 +10763,7 @@ Pass --allow-ambiguous-seed to opt into best-effort generation.`;
       const baseSeedData = loadBaseSeedFromDisk(sel.twinName, sel.seedName);
       if (!baseSeedData || Object.keys(baseSeedData).length === 0) {
         throw new Error(
-          `Could not load base seed "${sel.seedName}" for twin "${sel.twinName}" from disk. Ensure the seed file exists at twins/${sel.twinName}/seeds/${sel.seedName}.json`
+          `Could not load base seed "${sel.seedName}" for twin "${sel.twinName}" from disk. Ensure the seed file exists at twins/${sel.twinName}/seeds/${sel.seedName}.json or .sql`
         );
       }
       progress(`Generating dynamic seed for ${sel.twinName}...`);
@@ -11495,23 +11787,6 @@ function createRunCommand() {
         process.env["ARCHAL_ENGINE_API_KEY"] = userConfig.engineApiKey;
       }
     }
-    if (!process.env["ARCHAL_ENGINE_API_KEY"]) {
-      const providerEnvVars = [
-        { env: "GEMINI_API_KEY", defaultModel: "gemini-2.0-flash" },
-        { env: "OPENAI_API_KEY", defaultModel: "gpt-4o" },
-        { env: "ANTHROPIC_API_KEY", defaultModel: "claude-sonnet-4-20250514" }
-      ];
-      for (const { env, defaultModel } of providerEnvVars) {
-        const val = process.env[env]?.trim();
-        if (val) {
-          process.env["ARCHAL_ENGINE_API_KEY"] = val;
-          if (!opts.engineModel && !process.env["ARCHAL_ENGINE_MODEL"]) {
-            opts.engineModel = defaultModel;
-          }
-          break;
-        }
-      }
-    }
     let engine;
     try {
       engine = resolveEngineConfig(opts, timeout);
@@ -11527,6 +11802,37 @@ function createRunCommand() {
 `
       );
     }
+    if (engine.mode === "local" && !process.env["ARCHAL_ENGINE_API_KEY"]) {
+      const explicitModel = firstNonEmpty(
+        opts.engineModel,
+        process.env["ARCHAL_ENGINE_MODEL"],
+        resolveOpenClawModel(firstNonEmpty(opts.openclawAgent, process.env["OPENCLAW_AGENT_ID"]))
+      );
+      if (explicitModel) {
+        const provider = detectProvider(explicitModel);
+        const envVar = getProviderEnvVar(provider);
+        const providerKey = process.env[envVar]?.trim();
+        if (providerKey) {
+          process.env["ARCHAL_ENGINE_API_KEY"] = providerKey;
+        }
+      } else {
+        const providerEnvVars = [
+          { env: "GEMINI_API_KEY", defaultModel: "gemini-2.0-flash" },
+          { env: "OPENAI_API_KEY", defaultModel: "gpt-4o" },
+          { env: "ANTHROPIC_API_KEY", defaultModel: "claude-sonnet-4-20250514" }
+        ];
+        for (const { env, defaultModel } of providerEnvVars) {
+          const val = process.env[env]?.trim();
+          if (val) {
+            process.env["ARCHAL_ENGINE_API_KEY"] = val;
+            if (!opts.engineModel && !process.env["ARCHAL_ENGINE_MODEL"]) {
+              opts.engineModel = defaultModel;
+            }
+            break;
+          }
+        }
+      }
+    }
     if (engine.mode === "local" && !process.env["ARCHAL_ENGINE_API_KEY"]) {
       process.stderr.write(
         "Error: No API key found. The agent harness needs an API key to call the model.\nSet one of:\n  GEMINI_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY env var\n  archal config set engine.apiKey <key>\n  ARCHAL_ENGINE_API_KEY env var\n"
@@ -11591,11 +11897,19 @@ function createRunCommand() {
           );
         }
         if (!runFailureMessage) {
-          const SESSION_READY_TIMEOUT_MS = 12e4;
+          const configuredReadyTimeoutMs = (() => {
+            const raw = process.env["ARCHAL_SESSION_READY_TIMEOUT_MS"]?.trim();
+            if (!raw) return 3e5;
+            const parsed = Number.parseInt(raw, 10);
+            return Number.isNaN(parsed) || parsed <= 0 ? 3e5 : parsed;
+          })();
+          const SESSION_READY_TIMEOUT_MS = Math.max(12e4, configuredReadyTimeoutMs);
           const SESSION_POLL_INTERVAL_MS = 3e3;
+          const STATUS_READY_GRACE_MS = 15e3;
           const readyDeadline = Date.now() + SESSION_READY_TIMEOUT_MS;
           let sessionReady = false;
           let lastPollIssue;
+          let statusReadySinceMs = null;
           const isRetryablePollFailure = (result) => result.offline || typeof result.status === "number" && result.status >= 500;
           const sleepForPollInterval = async () => new Promise((resolve13) => setTimeout(resolve13, SESSION_POLL_INTERVAL_MS));
           while (Date.now() < readyDeadline) {
@@ -11642,11 +11956,26 @@ function createRunCommand() {
               break;
             }
             const healthAlive = healthResult.ok && healthResult.data.alive;
-            const statusAlive = statusResult.data.alive || statusResult.data.status === "ready";
+            const statusAlive = statusResult.data.alive || status === "ready";
             if (statusAlive && healthAlive) {
               sessionReady = true;
               break;
             }
+            if (statusAlive && !healthAlive) {
+              if (statusReadySinceMs === null) {
+                statusReadySinceMs = Date.now();
+              }
+              const readyForMs = Date.now() - statusReadySinceMs;
+              if (readyForMs >= STATUS_READY_GRACE_MS) {
+                warn(
+                  `Session ${backendSessionId} reported status=ready while health endpoint remained starting for ${readyForMs}ms; proceeding.`
+                );
+                sessionReady = true;
+                break;
+              }
+            } else {
+              statusReadySinceMs = null;
+            }
             lastPollIssue = `session still starting (status=${status}, health=${healthAlive ? "alive" : "starting"})`;
             await sleepForPollInterval();
           }