@archal/cli 0.7.7 → 0.7.10

package/dist/index.js

@@ -233,6 +233,7 @@ function parseCriterionLine(line, index) {
   } else {
     type = inferCriterionType(description);
   }
+  if (!description) return null;
   return {
     id: `criterion-${index + 1}`,
     description,
@@ -333,7 +334,11 @@ ${expectedBehavior}`.toLowerCase();
     github: ["github", "repository", "pull request", "create_issue", "create_pull_request", "merge_pull_request"],
     slack: ["slack", "slack channel", "send_message", "slack message", "direct message"],
     linear: ["linear", "linear ticket", "linear project", "linear cycle"],
-    jira: ["jira", "jira sprint", "jira epic", "jira board"]
+    jira: ["jira", "jira sprint", "jira epic", "jira board"],
+    stripe: ["stripe", "payment", "refund", "subscription", "invoice", "charge"],
+    supabase: ["supabase", "database", "sql query", "database table"],
+    "google-workspace": ["google workspace", "gmail", "google calendar", "google drive", "google docs"],
+    browser: ["browser", "web page", "navigate to", "click on", "web content"]
   };
   for (const [twin, keywords] of Object.entries(twinKeywords)) {
     if (keywords.some((kw) => combined.includes(kw))) {
@@ -425,7 +430,9 @@ function validateScenario(scenario) {
     }
   }
   if (scenario.config.twins.length === 0) {
-    errors.push("Scenario does not reference any known twins (specify in Config section or mention services in Setup/Expected Behavior)");
+    errors.push(
+      'Scenario does not reference any known twins. Add a "## Config" section with "twins: github" (or slack, linear, jira, stripe, supabase, google-workspace, browser). Alternatively, mention the service name in ## Setup or ## Expected Behavior.'
+    );
   }
   if (scenario.config.timeout <= 0) {
     errors.push("Timeout must be a positive number");
@@ -2982,10 +2989,11 @@ var LlmApiError = class extends Error {
 };
 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("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";
+  const normalized = model.toLowerCase();
+  if (normalized.startsWith("gemini-")) return "gemini";
+  if (normalized.startsWith("claude-") || normalized.startsWith("sonnet-") || normalized.startsWith("haiku-") || normalized.startsWith("opus-")) return "anthropic";
+  if (normalized.startsWith("gpt-") || normalized.startsWith("o1-") || normalized.startsWith("o2-") || normalized.startsWith("o3-") || normalized.startsWith("o4-")) return "openai";
+  if (normalized.startsWith("llama") || normalized.startsWith("mixtral") || normalized.startsWith("mistral") || normalized.startsWith("deepseek") || normalized.startsWith("qwen") || normalized.startsWith("codestral") || normalized.startsWith("command")) return "openai-compatible";
   return "openai-compatible";
 }
 var PROVIDER_ENV_VARS = {
@@ -3011,8 +3019,18 @@ function validateKeyForProvider(key, provider) {
   return void 0;
 }
 function resolveProviderApiKey(explicitKey, provider) {
-  if (explicitKey) return explicitKey;
-  return process.env[PROVIDER_ENV_VARS[provider]] ?? "";
+  const normalizedExplicit = explicitKey.trim();
+  const providerEnvKey = process.env[PROVIDER_ENV_VARS[provider]]?.trim() ?? "";
+  if (!normalizedExplicit) return providerEnvKey;
+  const mismatch = validateKeyForProvider(normalizedExplicit, provider);
+  if (mismatch && providerEnvKey) {
+    debug("Configured API key appears mismatched for provider; falling back to provider env key", {
+      provider,
+      providerEnvVar: PROVIDER_ENV_VARS[provider]
+    });
+    return providerEnvKey;
+  }
+  return normalizedExplicit;
 }
 var REQUEST_TIMEOUT_MS3 = 6e4;
 var MAX_RETRIES2 = 3;
@@ -3061,7 +3079,7 @@ async function callLlmViaArchal(options) {
   debug("Archal backend response", { model: actualModel, remaining: String(result.data.remaining ?? "unknown") });
   const isSeedGen = options.intent === "seed-generate";
   if (!modelMismatchWarned && !isSeedGen && options.model && actualModel && !actualModel.includes(options.model) && !options.model.includes(actualModel)) {
-    warn(`Requested model "${options.model}" but Archal backend used "${actualModel}". To use a specific model, set provider to "direct" with your own API key.`);
+    debug(`Archal backend used "${actualModel}" (requested "${options.model}"). To use a specific model, set provider to "direct" with your own API key.`);
     modelMismatchWarned = true;
   }
   return result.data.text;
@@ -4182,8 +4200,35 @@ function filterByPredicate(items, predicate) {
   if (knownMatches.length > 0) {
     return { items: knownMatches, recognized: true };
   }
+  const ACTION_VERBS = /* @__PURE__ */ new Set([
+    "listed",
+    "fetched",
+    "retrieved",
+    "found",
+    "searched",
+    "queried",
+    "posted",
+    "sent",
+    "received",
+    "notified",
+    "alerted",
+    "reviewed",
+    "analyzed",
+    "inspected",
+    "checked",
+    "verified",
+    "triaged",
+    "escalated",
+    "assigned",
+    "tagged",
+    "labeled",
+    "updated",
+    "edited",
+    "patched",
+    "migrated"
+  ]);
   const isSingleWord = !lowerPredicate.includes(" ");
-  if (isSingleWord) {
+  if (isSingleWord && !ACTION_VERBS.has(lowerPredicate)) {
     const hasKnownField = items.some((item) => {
       if (typeof item !== "object" || item === null) return false;
       const obj = item;
@@ -5455,24 +5500,46 @@ ${JSON.stringify(context.stateDiff, null, 2)}
 ## Agent Trace Evidence
 ${traceEvidence}`;
 }
+function estimateTokens(value) {
+  const json = JSON.stringify(value);
+  return Math.ceil(json.length / 4);
+}
+var MAX_STATE_TOKENS = 4e4;
 function summarizeState(state) {
   const flat = flattenTwinState(state);
   const summary = {};
   for (const [key, value] of Object.entries(flat)) {
     if (Array.isArray(value)) {
-      if (value.length <= 100) {
+      if (value.length <= 50) {
         summary[key] = value;
       } else {
         summary[key] = {
           _count: value.length,
-          _first20: value.slice(0, 20),
-          _last20: value.slice(-20)
+          _first10: value.slice(0, 10),
+          _last10: value.slice(-10)
         };
       }
     } else {
       summary[key] = value;
     }
   }
+  let totalTokens = estimateTokens(summary);
+  if (totalTokens > MAX_STATE_TOKENS) {
+    const collectionSizes = Object.entries(summary).map(([key, value]) => ({ key, tokens: estimateTokens(value) })).sort((a, b) => b.tokens - a.tokens);
+    for (const { key } of collectionSizes) {
+      if (totalTokens <= MAX_STATE_TOKENS) break;
+      const value = summary[key];
+      if (!Array.isArray(value)) continue;
+      const before = estimateTokens(value);
+      summary[key] = {
+        _count: value.length,
+        _first5: value.slice(0, 5),
+        _last5: value.slice(-5),
+        _truncated: "Collection too large for evaluation \u2014 showing subset"
+      };
+      totalTokens -= before - estimateTokens(summary[key]);
+    }
+  }
   return summary;
 }
 function parseJudgeResponse(text) {
@@ -5572,6 +5639,15 @@ async function evaluateWithLlm(criterion, expectedBehavior, stateBefore, stateAf
       };
     }
     const message = err instanceof Error ? err.message : String(err);
+    if (err instanceof LlmApiError && err.status === 400 && message.includes("too long")) {
+      warn(`LLM judge prompt too large for criterion "${criterion.id}" \u2014 twin state may be too large for evaluation`);
+      return {
+        criterionId: criterion.id,
+        status: "fail",
+        confidence: 0,
+        explanation: "LLM evaluation skipped: prompt exceeded model context window. The scenario state is too large for probabilistic evaluation. Consider using deterministic [D] criteria for this scenario."
+      };
+    }
     error(`LLM judge call failed: ${message}`);
     return {
       criterionId: criterion.id,
@@ -7933,7 +8009,11 @@ function mergeCollectionSchema(entitySchema, overrides) {
       if (override.default !== void 0) def.default = override.default;
     }
     if (isRequired) {
-      delete def.default;
+      if (nullableSet.has(field)) {
+        def.default = null;
+      } else {
+        delete def.default;
+      }
       delete def.required;
     }
     merged[field] = def;
@@ -7951,6 +8031,9 @@ function buildSchemaFromOverrides(overrides) {
     const type = nullableSet.has(field) && !baseType.includes("null") && !baseType.includes("[]") ? `${baseType}|null` : baseType;
     schema[field] = {
       type,
+      // If field is both required AND nullable, give it a null default so
+      // the LLM can omit it without triggering a hard validation error.
+      ...nullableSet.has(field) && { default: null },
       ...override?.aliases && { aliases: override.aliases },
       ...override?.description && { description: override.description },
       ...override?.fk && { fk: override.fk },
@@ -8063,6 +8146,8 @@ function validateSeedAgainstSchema(twinName, seed, baseEntityCounts) {
             errors.push(
               `${entityLabel}: wrong field name "${usedAlias}" - use "${fieldName}" instead`
             );
+          } else if (def.type.includes("null")) {
+            entity[fieldName] = null;
           } else {
             errors.push(
               `${entityLabel}: missing required field "${fieldName}" (${def.type})`
@@ -8220,7 +8305,8 @@ var RELATIONSHIP_RULES = {
     { sourceCollection: "disputes", sourceField: "paymentIntentId", targetCollection: "paymentIntents", targetField: "paymentIntentId", optional: true }
   ],
   jira: [
-    { sourceCollection: "issues", sourceField: "projectId", targetCollection: "projects", targetField: "id" }
+    { sourceCollection: "issues", sourceField: "projectId", targetCollection: "projects", targetField: "id" },
+    { sourceCollection: "projects", sourceField: "leadAccountId", targetCollection: "users", targetField: "accountId" }
   ],
   linear: [
     { sourceCollection: "issues", sourceField: "teamId", targetCollection: "teams", targetField: "id" },
@@ -8464,15 +8550,17 @@ function autoFillMissingFKs(seed, twinName) {
     const targetEntities = result[rule.targetCollection];
     if (!sourceEntities || !targetEntities || targetEntities.length === 0) continue;
     const targetValues = targetEntities.map((e) => e[rule.targetField]).filter((v) => v !== void 0 && v !== null);
-    if (targetValues.length !== 1) continue;
-    const singleTarget = targetValues[0];
+    if (targetValues.length === 0) continue;
+    let fillIndex = 0;
     for (const entity of sourceEntities) {
       const e = entity;
       if (e[rule.sourceField] === void 0 || e[rule.sourceField] === null) {
-        warn(
-          `Auto-filling ${rule.sourceCollection}.${rule.sourceField} = ${String(singleTarget)} (only one ${rule.targetCollection} exists)`
+        const fillValue = targetValues[fillIndex % targetValues.length];
+        fillIndex++;
+        debug(
+          `Auto-filling ${rule.sourceCollection}.${rule.sourceField} = ${String(fillValue)} (from ${targetValues.length} ${rule.targetCollection})`
         );
-        e[rule.sourceField] = singleTarget;
+        e[rule.sourceField] = fillValue;
       }
     }
   }
@@ -8506,12 +8594,36 @@ function normalizeSeedData(seed, twinName) {
           }
         }
       }
+      const collectionSchema = schema[collection];
+      if (collectionSchema) {
+        for (const [field, fieldDef] of Object.entries(collectionSchema)) {
+          if (!(field in e) || e[field] === null || e[field] === void 0) continue;
+          const expectedType = fieldDef.type.split("|")[0].trim();
+          if (expectedType === "string" && typeof e[field] === "object" && e[field] !== null && !Array.isArray(e[field])) {
+            const obj = e[field];
+            const extracted = obj["login"] ?? obj["name"] ?? obj["value"] ?? obj["key"] ?? obj["id"] ?? obj["displayName"];
+            if (typeof extracted === "string") {
+              debug(`Seed normalization: coerced ${collection}.${field} from object to string "${extracted}"`);
+              e[field] = extracted;
+            } else {
+              const firstStr = Object.values(obj).find((v) => typeof v === "string");
+              if (firstStr) {
+                debug(`Seed normalization: coerced ${collection}.${field} from object to string "${firstStr}" (fallback)`);
+                e[field] = firstStr;
+              } else {
+                debug(`Seed normalization: could not coerce ${collection}.${field} from object to string, removing`);
+                delete e[field];
+              }
+            }
+          }
+        }
+      }
       if (collectionDefaults) {
         for (const [field, defaultValue] of Object.entries(collectionDefaults)) {
           if (!(field in e)) {
             e[field] = structuredClone(defaultValue);
           } else if (e[field] === null && defaultValue !== null) {
-            const fieldDef = schema[collection]?.[field];
+            const fieldDef = collectionSchema?.[field];
             if (fieldDef && !fieldDef.type.includes("null")) {
               e[field] = structuredClone(defaultValue);
             }
@@ -8520,6 +8632,15 @@ function normalizeSeedData(seed, twinName) {
       }
     }
   }
+  if (twinName === "github" && result["repos"]) {
+    for (const entity of result["repos"]) {
+      const e = entity;
+      if ((!e["fullName"] || typeof e["fullName"] !== "string") && typeof e["owner"] === "string" && typeof e["name"] === "string") {
+        e["fullName"] = `${e["owner"]}/${e["name"]}`;
+        debug(`Seed normalization: derived repos.fullName = "${e["fullName"]}"`);
+      }
+    }
+  }
   return result;
 }
 
@@ -8537,7 +8658,6 @@ 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"],
@@ -8696,13 +8816,20 @@ function validateSeedCoverage(intent, mergedSeed) {
   const entityIssues = [];
   const quoteErrors = [];
   const quoteWarnings = [];
+  const CORE_ENTITY_KEYS = /* @__PURE__ */ new Set(["owner", "name", "fullName", "channel_name", "key", "identifier", "number"]);
+  const entityWarnings = [];
   for (const entity of intent.entities) {
     if (typeof entity.value === "boolean") continue;
     if (!valueExistsInCollections(mergedSeed, entity.kind, entity.key, entity.value)) {
-      entityIssues.push({
+      const issue = {
         type: "missing_entity",
         message: `Expected ${entity.kind}.${entity.key}=${String(entity.value)} to exist`
-      });
+      };
+      if (CORE_ENTITY_KEYS.has(entity.key)) {
+        entityIssues.push(issue);
+      } else {
+        entityWarnings.push(issue);
+      }
     }
   }
   for (const quote of intent.quotedStrings) {
@@ -8715,18 +8842,14 @@ function validateSeedCoverage(intent, mergedSeed) {
         type: "missing_quote",
         message: `Expected quoted text to exist: "${quote}"`
       };
-      if (STRICT_QUOTE_TWINS.has(intent.twinName)) {
-        quoteErrors.push(issue);
-      } else {
-        quoteWarnings.push(issue);
-      }
+      quoteWarnings.push(issue);
     }
   }
   const errors = [...entityIssues, ...quoteErrors];
   return {
     valid: errors.length === 0,
     issues: errors,
-    warnings: quoteWarnings
+    warnings: [...quoteWarnings, ...entityWarnings]
   };
 }
 
@@ -8794,7 +8917,24 @@ var NON_SUBJECT_STARTS = /* @__PURE__ */ new Set([
   "could",
   "would",
   "may",
-  "might"
+  "might",
+  "for",
+  "with",
+  "in",
+  "at",
+  "to",
+  "from",
+  "by",
+  "on",
+  "per",
+  "via",
+  "into",
+  "onto",
+  "over",
+  "under",
+  "after",
+  "before",
+  "during"
 ]);
 function isReasonableCountSubject(subject, expected) {
   if (expected > MAX_REASONABLE_COUNT) return false;
@@ -8805,6 +8945,10 @@ function isReasonableCountSubject(subject, expected) {
   if (/\b(?:have|has|had|were|was|are|is|been|being|do|does|did|can|could|should|will|would|may|might)\b/.test(subject.toLowerCase())) return false;
   return true;
 }
+function appearsToBeClockSuffix(text, numberStart) {
+  const prefix = text.slice(Math.max(0, numberStart - 3), numberStart);
+  return /^\d{1,2}:$/.test(prefix);
+}
 function verifySeedCounts(setupText, seedState) {
   const mismatches = [];
   const flat = flattenTwinState(seedState);
@@ -8812,6 +8956,7 @@ function verifySeedCounts(setupText, seedState) {
   for (const match of setupText.matchAll(countPattern)) {
     const expected = parseInt(match[1], 10);
     const subject = match[2].trim();
+    if (match.index !== void 0 && appearsToBeClockSuffix(setupText, match.index)) continue;
     if (!subject || expected <= 0) continue;
     if (!isReasonableCountSubject(subject, expected)) continue;
     const resolved = resolveSubjectInState(subject, flat);
@@ -8824,6 +8969,7 @@ function verifySeedCounts(setupText, seedState) {
   for (const match of setupText.matchAll(simplePattern)) {
     const expected = parseInt(match[1], 10);
     const subject = match[2].trim();
+    if (match.index !== void 0 && appearsToBeClockSuffix(setupText, match.index)) continue;
     if (!subject || expected <= 0 || seenSubjects.has(subject.toLowerCase())) continue;
     if (!isReasonableCountSubject(subject, expected)) continue;
     const resolved = resolveSubjectInState(subject, flat);
@@ -9039,14 +9185,955 @@ function cacheNegativeSeed(twinName, baseSeedName, setupText, missingSlots, scop
   }
 }
 
+// src/runner/seed-blueprint.ts
+var BLUEPRINT_SYSTEM_PROMPT = `You are a precise data extraction tool. Given a scenario setup description, extract a structured JSON blueprint describing what test data needs to be created.
+
+Output ONLY valid JSON matching this schema:
+{
+  "identities": [
+    { "collection": "<collection_name>", "fields": { "<field>": "<value>", ... } }
+  ],
+  "collections": [
+    {
+      "name": "<collection_name>",
+      "totalCount": <number>,
+      "groups": [
+        {
+          "count": <number>,
+          "properties": { "<property>": <value>, ... }
+        }
+      ],
+      "contentHint": "<optional description of what content should look like>"
+    }
+  ]
+}
+
+Rules:
+- "identities" are named entities that MUST exist exactly (repos, channels, users with specific names)
+- "collections" describe bulk entities with count distributions
+- Group counts MUST sum to totalCount exactly
+- Use these property names for temporal attributes:
+  - "stale": true/false (not updated in 90+ days)
+  - "recentlyActive": true/false (updated within 30 days)
+- Use "state" for entity state: "open", "closed", "merged", etc.
+- Use "labels" for label arrays: ["bug", "keep-open"]
+- Use "assigned" for assignment: true/false or assignee name
+- Use "hasComments": true/false for whether entity has comments
+- Use "priority" for priority: "P0", "P1", "P2", "critical", "high", "medium", "low"
+- Use "private" for visibility: true/false
+- Keep it simple \u2014 only include what the setup text explicitly states
+- If the setup says "N of those" or "N of the X", that's a subset of the previous group
+- Do NOT include fields not mentioned in the setup text`;
+async function extractBlueprint(setupText, twinName, availableCollections, config) {
+  const userPrompt = `Twin: ${twinName}
+Available collections: ${availableCollections.join(", ")}
+
+Setup text:
+${setupText}
+
+Extract the seed blueprint as JSON.`;
+  try {
+    const provider = detectProvider(config.model);
+    const apiKey = resolveProviderApiKey(config.apiKey, provider);
+    const responseText = await callLlm({
+      provider,
+      model: config.model,
+      apiKey,
+      systemPrompt: BLUEPRINT_SYSTEM_PROMPT,
+      userPrompt,
+      maxTokens: 4096,
+      baseUrl: config.baseUrl,
+      providerMode: config.providerMode,
+      intent: "seed-generate",
+      responseFormat: "json"
+    });
+    if (!responseText) {
+      warn("Blueprint extraction returned no text");
+      return null;
+    }
+    const parsed = parseBlueprint(responseText, twinName);
+    if (!parsed) return null;
+    const validCollections = new Set(availableCollections);
+    parsed.collections = parsed.collections.filter((col) => {
+      if (validCollections.has(col.name)) return true;
+      warn(`Blueprint references unknown collection "${col.name}" for ${twinName} \u2014 dropping`);
+      return false;
+    });
+    for (const col of parsed.collections) {
+      const groupSum = col.groups.reduce((sum, g) => sum + g.count, 0);
+      if (groupSum !== col.totalCount) {
+        debug(`Blueprint group count mismatch for ${col.name}: groups sum to ${groupSum}, totalCount is ${col.totalCount}. Adjusting.`);
+        col.totalCount = groupSum;
+      }
+      if (col.totalCount === 0) {
+        debug(`Blueprint collection ${col.name} has 0 entities \u2014 dropping`);
+      }
+    }
+    parsed.collections = parsed.collections.filter((col) => col.totalCount > 0);
+    if (parsed.collections.length === 0 && parsed.identities.length === 0) {
+      warn("Blueprint extracted no valid collections or identities");
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warn(`Blueprint extraction failed: ${msg}`);
+    return null;
+  }
+}
+function parseBlueprint(text, twinName) {
+  try {
+    let cleaned = text.trim();
+    if (cleaned.startsWith("```")) {
+      cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "");
+    }
+    const raw = JSON.parse(cleaned);
+    if (!raw || typeof raw !== "object") return null;
+    const identities = [];
+    for (const id of raw.identities ?? []) {
+      if (id?.collection && typeof id.fields === "object") {
+        identities.push({ collection: String(id.collection), fields: id.fields });
+      }
+    }
+    const collections = [];
+    for (const col of raw.collections ?? []) {
+      if (!col?.name || typeof col.totalCount !== "number") continue;
+      const groups = [];
+      for (const g of col.groups ?? []) {
+        if (typeof g?.count === "number" && g.count > 0) {
+          groups.push({ count: g.count, properties: g.properties ?? {} });
+        }
+      }
+      if (groups.length === 0) {
+        groups.push({ count: col.totalCount, properties: {} });
+      }
+      collections.push({
+        name: String(col.name),
+        totalCount: col.totalCount,
+        groups,
+        contentHint: col.contentHint
+      });
+    }
+    return { twin: twinName, identities, collections };
+  } catch {
+    warn("Failed to parse blueprint JSON");
+    return null;
+  }
+}
+
+// src/runner/seed-builder.ts
+var MS_PER_DAY = 864e5;
+function daysAgo(days, base) {
+  const now = base ?? /* @__PURE__ */ new Date();
+  return new Date(now.getTime() - days * MS_PER_DAY).toISOString();
+}
+function recentDate(withinDays = 7, base) {
+  const now = base ?? /* @__PURE__ */ new Date();
+  const offset = Math.floor(Math.random() * withinDays) * MS_PER_DAY;
+  return new Date(now.getTime() - offset).toISOString();
+}
+function staleDate(minDays = 91, maxDays = 300, base) {
+  const now = base ?? /* @__PURE__ */ new Date();
+  const range = maxDays - minDays;
+  const offset = (minDays + Math.floor(Math.random() * range)) * MS_PER_DAY;
+  return new Date(now.getTime() - offset).toISOString();
+}
+var ISSUE_TITLES = [
+  "Fix login redirect loop on Safari",
+  "Add dark mode support to settings page",
+  "Rate limiter returns 500 instead of 429",
+  "Memory leak in WebSocket connection manager",
+  "Dropdown menus do not close on mobile",
+  "Search results do not highlight matching terms",
+  "File upload fails silently for large files",
+  "Add CSV export to analytics dashboard",
+  "Implement bulk actions for notifications",
+  "GraphQL query returns stale cached data",
+  "Table component lacks keyboard navigation",
+  "Create onboarding tutorial for new members",
+  "API response times degrade for large date ranges",
+  "Add two-factor authentication for admin accounts",
+  "Deprecated crypto API warnings in test suite",
+  "Evaluate replacing Moment.js with date-fns",
+  "Broken tooltip positioning on Safari 17",
+  "Login page shows blank screen on slow 3G",
+  "Intermittent 502 errors on reports endpoint",
+  "Tracking: migrate auth from cookies to JWT",
+  "Roadmap: accessibility audit and WCAG compliance",
+  "Upgrade Node.js runtime from 18 to 20 LTS",
+  "Refactor database connection pool configuration",
+  "Add retry logic for third-party API calls",
+  "Improve error messages for form validation",
+  "Pagination breaks when filtering by status",
+  "Email notification templates are not responsive",
+  "CI pipeline takes 45 minutes on large PRs",
+  "Localization support for date and number formats",
+  "Dashboard widgets do not resize on mobile"
+];
+var ISSUE_BODIES = [
+  "This has been reported multiple times by users. Needs investigation and a fix.",
+  "No one has started working on this yet. Low priority but would improve UX.",
+  "This is affecting production traffic. We need to address this soon.",
+  "Users have requested this feature multiple times. Would be a nice enhancement.",
+  "This is a long-running tracking issue. Should remain open for visibility.",
+  "Repro steps: 1) Open the app 2) Navigate to settings 3) Observe the issue.",
+  "This blocks other work. Please prioritize.",
+  "Nice to have. Not urgent but would reduce tech debt."
+];
+var PR_TITLES = [
+  "Fix null check in JWT validation",
+  "Add pagination to search results",
+  "Refactor database connection pooling",
+  "Update dependencies to latest versions",
+  "Improve error handling in API middleware",
+  "Add unit tests for auth module",
+  "Fix race condition in WebSocket handler",
+  "Migrate CSS to custom properties for theming"
+];
+var CHANNEL_PURPOSES = [
+  "General discussion",
+  "Engineering team updates",
+  "Product announcements",
+  "Customer support escalations",
+  "Random fun stuff",
+  "Incident response",
+  "Design feedback",
+  "Deploy notifications"
+];
+var MESSAGE_TEXTS = [
+  "Hey team, just a heads up about the deploy today.",
+  "Can someone review my PR? It's been open for a while.",
+  "The CI pipeline is green again after the fix.",
+  "Meeting notes from today's standup are in the doc.",
+  "Has anyone seen this error before? Getting a 502 intermittently.",
+  "Thanks for the quick turnaround on that bug fix!",
+  "Reminder: retro is at 3pm today.",
+  "I pushed a hotfix for the login issue. Please verify."
+];
+function generateNodeId(prefix, id) {
+  return `${prefix}_kgDOB${String(id).padStart(5, "0")}`;
+}
+function generateSha() {
+  const hex = "0123456789abcdef";
+  let sha = "";
+  for (let i = 0; i < 40; i++) sha += hex[Math.floor(Math.random() * 16)];
+  return sha;
+}
+function generateSlackId(prefix, index) {
+  const base = "ABCDEFG0123456789";
+  let id = prefix;
+  let n = index + 100;
+  for (let i = 0; i < 8; i++) {
+    id += base[n % base.length];
+    n = Math.floor(n / base.length) + i + 1;
+  }
+  return id;
+}
+function generateSlackTs(baseTs, index) {
+  return `${baseTs + index * 60}.${String(100001 + index * 100).padStart(6, "0")}`;
+}
+function generateUuid() {
+  const hex = "0123456789abcdef";
+  const parts = [8, 4, 4, 4, 12];
+  return parts.map((len) => {
+    let s = "";
+    for (let i = 0; i < len; i++) s += hex[Math.floor(Math.random() * 16)];
+    return s;
+  }).join("-");
+}
+function generateStripeId(prefix, index) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let id = prefix;
+  let n = index + 42;
+  for (let i = 0; i < 14; i++) {
+    id += chars[n % chars.length];
+    n = Math.floor(n / chars.length) + i + 7;
+  }
+  return id;
+}
+var DEFAULT_REACTIONS = {
+  totalCount: 0,
+  plusOne: 0,
+  minusOne: 0,
+  laugh: 0,
+  hooray: 0,
+  confused: 0,
+  heart: 0,
+  rocket: 0,
+  eyes: 0
+};
+function resolveTemporalProperties(props, base) {
+  const now = base ?? /* @__PURE__ */ new Date();
+  if (props["stale"] === true) {
+    const created2 = daysAgo(200 + Math.floor(Math.random() * 200), now);
+    const updated2 = staleDate(91, 300, now);
+    return { createdAt: created2, updatedAt: updated2 };
+  }
+  if (props["recentlyActive"] === true) {
+    const created2 = daysAgo(30 + Math.floor(Math.random() * 100), now);
+    const updated2 = recentDate(30, now);
+    return { createdAt: created2, updatedAt: updated2 };
+  }
+  const created = daysAgo(14 + Math.floor(Math.random() * 60), now);
+  const updated = recentDate(14, now);
+  return { createdAt: created, updatedAt: updated };
+}
+function resolveLabels(props, availableLabels) {
+  const labels = props["labels"];
+  if (Array.isArray(labels)) return labels.map(String);
+  return [];
+}
+function buildSeedFromBlueprint(blueprint, baseSeed) {
+  const seed = structuredClone(baseSeed);
+  const warnings = [];
+  const now = /* @__PURE__ */ new Date();
+  const existingLabels = /* @__PURE__ */ new Set();
+  for (const label of seed["labels"] ?? []) {
+    if (typeof label["name"] === "string") existingLabels.add(label["name"]);
+  }
+  for (const identity of blueprint.identities) {
+    processIdentity(identity, seed, warnings);
+  }
+  const baseCollections = new Set(Object.keys(baseSeed));
+  for (const spec of blueprint.collections) {
+    if (!baseCollections.has(spec.name) && !seed[spec.name]) {
+      warnings.push(`Blueprint references unknown collection "${spec.name}" \u2014 skipping`);
+      warn(`Blueprint references unknown collection "${spec.name}" for ${blueprint.twin} twin \u2014 skipping`);
+      continue;
+    }
+    processCollection(spec, seed, blueprint.twin, existingLabels, warnings, now);
+  }
+  return { seed, warnings };
+}
+function processIdentity(identity, seed, warnings) {
+  const collection = identity.collection;
+  if (!seed[collection]) {
+    seed[collection] = [];
+  }
+  const existing = seed[collection].find((entity2) => {
+    for (const [key, value] of Object.entries(identity.fields)) {
+      if (entity2[key] !== value) return false;
+    }
+    return true;
+  });
+  if (existing) {
+    debug(`Identity already exists in ${collection}: ${JSON.stringify(identity.fields)}`);
+    return;
+  }
+  const nextId = getMaxId(seed[collection]) + 1;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entity = {
+    id: nextId,
+    ...identity.fields,
+    createdAt: now,
+    updatedAt: now
+  };
+  fillDefaults(entity, collection);
+  seed[collection].push(entity);
+  debug(`Added identity to ${collection}: ${JSON.stringify(identity.fields)}`);
+}
+function processCollection(spec, seed, twinName, existingLabels, warnings, now) {
+  const collection = spec.name;
+  if (!seed[collection]) {
+    seed[collection] = [];
+  }
+  const existingCount = seed[collection].length;
+  if (existingCount > 0) {
+    debug(`Clearing ${existingCount} existing ${collection} entities (blueprint replaces)`);
+    seed[collection] = [];
+  }
+  const referencedLabels = /* @__PURE__ */ new Set();
+  for (const group of spec.groups) {
+    const labels = group.properties["labels"];
+    if (Array.isArray(labels)) {
+      for (const l of labels) {
+        const name = String(l);
+        if (!existingLabels.has(name)) referencedLabels.add(name);
+      }
+    }
+  }
+  if (referencedLabels.size > 0 && seed["labels"]) {
+    const labelColors = ["d73a4a", "a2eeef", "0e8a16", "fbca04", "d876e3", "e4e669", "f9d0c4", "bfdadc"];
+    let labelId = getMaxId(seed["labels"]) + 1;
+    const repoId = findFirstRepoId(seed);
+    for (const name of referencedLabels) {
+      const color = labelColors[labelId % labelColors.length];
+      seed["labels"].push({
+        id: labelId,
+        repoId: repoId ?? 1,
+        nodeId: generateNodeId("LA_kwDOBlab", labelId),
+        name,
+        description: `Label: ${name}`,
+        color,
+        isDefault: false,
+        createdAt: daysAgo(60, now),
+        updatedAt: daysAgo(60, now)
+      });
+      existingLabels.add(name);
+      labelId++;
+    }
+  }
+  let entityIndex = 0;
+  for (const group of spec.groups) {
+    for (let i = 0; i < group.count; i++) {
+      const entity = buildEntity(
+        collection,
+        twinName,
+        group.properties,
+        seed,
+        entityIndex,
+        spec.contentHint,
+        now
+      );
+      seed[collection].push(entity);
+      entityIndex++;
+    }
+  }
+  debug(`Built ${entityIndex} entities for ${collection}`);
+}
+function buildEntity(collection, twinName, properties, seed, index, contentHint, now) {
+  const nextId = getMaxId(seed[collection]) + 1;
+  const temporal = resolveTemporalProperties(properties, now);
+  if (twinName === "github") return buildGitHubEntity(collection, nextId, properties, seed, index, temporal, contentHint);
+  if (twinName === "slack") return buildSlackEntity(collection, nextId, properties, seed, index, temporal, contentHint);
+  if (twinName === "linear") return buildLinearEntity(collection, nextId, properties, seed, index, temporal, contentHint);
+  if (twinName === "stripe") return buildStripeEntity(collection, nextId, properties, seed, index, temporal, contentHint);
+  if (twinName === "jira") return buildJiraEntity(collection, nextId, properties, seed, index, temporal, contentHint);
+  return {
+    id: nextId,
+    ...properties,
+    createdAt: temporal.createdAt,
+    updatedAt: temporal.updatedAt
+  };
+}
+function buildGitHubEntity(collection, id, props, seed, index, temporal, contentHint) {
+  const repoId = findFirstRepoId(seed) ?? 1;
+  const owner = findRepoOwner(seed) ?? "acme";
+  switch (collection) {
+    case "issues": {
+      const state = String(props["state"] ?? "open");
+      const number = getMaxIssueNumber(seed) + 1;
+      const labels = resolveLabels(props, []);
+      const title = ISSUE_TITLES[index % ISSUE_TITLES.length];
+      const body = ISSUE_BODIES[index % ISSUE_BODIES.length];
+      const assigned = props["assigned"] === true;
+      return {
+        id,
+        repoId,
+        nodeId: generateNodeId("I_kwDOBiss", id),
+        number,
+        title: contentHint ? `${title} (${contentHint})` : title,
+        body,
+        state,
+        stateReason: state === "closed" ? "completed" : null,
+        locked: false,
+        assignees: assigned ? [owner] : [],
+        labels,
+        milestone: null,
+        authorLogin: owner,
+        closedAt: state === "closed" ? temporal.updatedAt : null,
+        closedBy: state === "closed" ? owner : null,
+        htmlUrl: `https://github.com/${owner}/webapp/issues/${number}`,
+        isPullRequest: false,
+        reactions: { ...DEFAULT_REACTIONS },
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    case "pullRequests": {
+      const state = String(props["state"] ?? "open");
+      const number = getMaxPRNumber(seed) + 1;
+      const title = PR_TITLES[index % PR_TITLES.length];
+      const sha = generateSha();
+      const baseSha = generateSha();
+      return {
+        id,
+        repoId,
+        nodeId: generateNodeId("PR_kwDOBpr", id),
+        number,
+        title,
+        body: `This PR addresses ${title.toLowerCase()}.`,
+        state,
+        merged: props["merged"] === true || state === "closed",
+        draft: props["draft"] === true,
+        headRef: `feature/fix-${index}`,
+        headSha: sha,
+        baseRef: "main",
+        baseSha,
+        authorLogin: owner,
+        labels: resolveLabels(props, []),
+        assignees: [],
+        requestedReviewers: [],
+        milestone: null,
+        additions: 10 + index * 5,
+        deletions: 3 + index * 2,
+        changedFiles: 1 + index % 5,
+        commits: 1 + index % 3,
+        comments: 0,
+        reviewComments: 0,
+        maintainerCanModify: true,
+        mergeable: state === "open",
+        mergedAt: props["merged"] === true ? temporal.updatedAt : null,
+        mergedBy: props["merged"] === true ? owner : null,
+        mergeCommitSha: props["merged"] === true ? generateSha() : null,
+        closedAt: state === "closed" ? temporal.updatedAt : null,
+        autoMerge: null,
+        htmlUrl: `https://github.com/${owner}/webapp/pull/${number}`,
+        diffUrl: `https://github.com/${owner}/webapp/pull/${number}.diff`,
+        patchUrl: `https://github.com/${owner}/webapp/pull/${number}.patch`,
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    case "comments": {
+      const issueNumber = resolveIssueNumberForComment(seed, index);
+      return {
+        id,
+        repoId,
+        nodeId: generateNodeId("IC_kwDOBcom", id),
+        issueNumber,
+        body: props["body"] ? String(props["body"]) : `Comment on issue #${issueNumber}`,
+        authorLogin: owner,
+        authorAssociation: "MEMBER",
+        htmlUrl: `https://github.com/${owner}/webapp/issues/${issueNumber}#issuecomment-${id}`,
+        reactions: { ...DEFAULT_REACTIONS },
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    case "labels": {
+      const colors = ["d73a4a", "a2eeef", "0e8a16", "fbca04", "d876e3"];
+      return {
+        id,
+        repoId,
+        nodeId: generateNodeId("LA_kwDOBlab", id),
+        name: props["name"] ? String(props["name"]) : `label-${id}`,
+        description: props["description"] ? String(props["description"]) : null,
+        color: colors[id % colors.length],
+        isDefault: false,
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    default:
+      return {
+        id,
+        repoId,
+        ...props,
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+  }
+}
+function buildSlackEntity(collection, id, props, seed, index, temporal, contentHint) {
+  const teamId = findSlackTeamId(seed) ?? "T0001TEAM";
+  switch (collection) {
+    case "channels": {
+      const channelId = generateSlackId("C", index);
+      const name = props["name"] ? String(props["name"]) : `channel-${index + 1}`;
+      const userIds = (seed["users"] ?? []).map((u) => u["user_id"]).filter(Boolean);
+      return {
+        id,
+        channel_id: channelId,
+        name,
+        is_channel: true,
+        is_group: false,
+        is_im: false,
+        is_mpim: false,
+        is_private: props["private"] === true,
+        is_archived: false,
+        is_general: name === "general",
+        creator: userIds[0] ?? "U0001AAAA",
+        topic: { value: "", creator: "", last_set: 0 },
+        purpose: { value: CHANNEL_PURPOSES[index % CHANNEL_PURPOSES.length], creator: "", last_set: 0 },
+        members: userIds,
+        num_members: userIds.length,
+        created: Math.floor(new Date(temporal.createdAt).getTime() / 1e3),
+        updated: Math.floor(new Date(temporal.updatedAt).getTime() / 1e3),
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    case "messages": {
+      const channels = seed["channels"] ?? [];
+      const targetChannel = channels.length > 0 ? channels[index % channels.length] : null;
+      const channelId = targetChannel ? String(targetChannel["channel_id"] ?? "C0001AAAA") : "C0001AAAA";
+      const channelMembers = targetChannel ? targetChannel["members"] ?? [] : [];
+      const users = seed["users"] ?? [];
+      let userId;
+      if (channelMembers.length > 0) {
+        userId = channelMembers[index % channelMembers.length];
+      } else {
+        userId = users.length > 0 ? String(users[index % users.length]["user_id"] ?? "U0001AAAA") : "U0001AAAA";
+      }
+      const baseTs = Math.floor(new Date(temporal.createdAt).getTime() / 1e3);
+      const ts = generateSlackTs(baseTs, index);
+      return {
+        id,
+        ts,
+        channel_id: channelId,
+        user_id: userId,
+        text: props["text"] ? String(props["text"]) : MESSAGE_TEXTS[index % MESSAGE_TEXTS.length],
+        type: "message",
+        subtype: null,
+        thread_ts: props["isReply"] === true ? generateSlackTs(baseTs, 0) : null,
+        reply_count: 0,
+        reply_users: [],
+        reply_users_count: 0,
+        latest_reply: null,
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    case "users": {
+      const userId = generateSlackId("U", index);
+      const name = props["name"] ? String(props["name"]) : `user${index + 1}`;
+      return {
+        id,
+        user_id: userId,
+        team_id: teamId,
+        name,
+        real_name: props["real_name"] ? String(props["real_name"]) : `User ${index + 1}`,
+        display_name: name,
+        email: `${name}@example.com`,
+        is_admin: props["is_admin"] === true,
+        is_owner: false,
+        is_bot: props["is_bot"] === true,
+        is_restricted: false,
+        is_ultra_restricted: false,
+        deleted: false,
+        color: "4bbe2e",
+        timezone: "America/Los_Angeles",
+        tz_label: "Pacific Daylight Time",
+        tz_offset: -25200,
+        is_email_confirmed: true,
+        who_can_share_contact_card: "EVERYONE",
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    default:
+      return {
+        id,
+        ...props,
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+  }
+}
+function buildLinearEntity(collection, id, props, seed, index, temporal, contentHint) {
+  switch (collection) {
+    case "issues": {
+      const teamId = findFirstId(seed, "teams") ?? 1;
+      const team = (seed["teams"] ?? []).find((t) => t["id"] === teamId);
+      const teamKey = team ? String(team["key"] ?? "ENG") : "ENG";
+      const number = index + 1;
+      const stateId = resolveLinearStateId(seed, props);
+      const priority = typeof props["priority"] === "number" ? props["priority"] : 3;
+      const priorityMap = {
+        0: "No priority",
+        1: "Urgent",
+        2: "High",
+        3: "Medium",
+        4: "Low"
+      };
+      return {
+        id,
+        linearId: generateUuid(),
+        teamId,
+        number,
+        identifier: `${teamKey}-${number}`,
+        title: ISSUE_TITLES[index % ISSUE_TITLES.length],
+        description: null,
+        descriptionData: null,
+        priority,
+        priorityLabel: priorityMap[priority] ?? "Medium",
+        stateId,
+        assigneeId: null,
+        creatorId: null,
+        projectId: null,
+        cycleId: null,
+        parentId: null,
+        labelIds: [],
+        estimate: null,
+        dueDate: null,
+        subIssueSortOrder: null,
+        sortOrder: index * -100,
+        snoozedUntilAt: null,
+        startedAt: null,
+        completedAt: null,
+        canceledAt: null,
+        archivedAt: null,
+        trashed: false,
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    default:
+      return {
+        id,
+        linearId: generateUuid(),
+        ...props,
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+  }
+}
+function buildStripeEntity(collection, id, props, seed, index, temporal, contentHint) {
+  switch (collection) {
+    case "paymentIntents": {
+      const piId = generateStripeId("pi_", index);
+      const amount = typeof props["amount"] === "number" ? props["amount"] : 1e3 + index * 500;
+      const status = String(props["status"] ?? "succeeded");
+      return {
+        id,
+        paymentIntentId: piId,
+        amount,
+        currency: String(props["currency"] ?? "usd"),
+        status,
+        customerId: props["customerId"] ? String(props["customerId"]) : null,
+        description: props["description"] ? String(props["description"]) : null,
+        paymentMethodId: null,
+        captureMethod: "automatic",
+        confirmationMethod: "automatic",
+        canceledAt: null,
+        cancellationReason: null,
+        latestChargeId: null,
+        metadata: {},
+        livemode: false,
+        created: Math.floor(new Date(temporal.createdAt).getTime() / 1e3),
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    case "customers": {
+      const custId = generateStripeId("cus_", index);
+      return {
+        id,
+        customerId: custId,
+        name: props["name"] ? String(props["name"]) : `Customer ${index + 1}`,
+        email: props["email"] ? String(props["email"]) : `customer${index + 1}@example.com`,
+        phone: null,
+        description: null,
+        currency: null,
+        defaultPaymentMethod: null,
+        address: null,
+        shipping: null,
+        balance: 0,
+        delinquent: false,
+        metadata: {},
+        livemode: false,
+        created: Math.floor(new Date(temporal.createdAt).getTime() / 1e3),
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    default:
+      return {
+        id,
+        ...props,
+        created: Math.floor(new Date(temporal.createdAt).getTime() / 1e3),
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+  }
+}
+function buildJiraEntity(collection, id, props, seed, index, temporal, contentHint) {
+  switch (collection) {
+    case "issues": {
+      const projectId = findFirstId(seed, "projects") ?? 1;
+      const project = (seed["projects"] ?? []).find((p) => p["id"] === projectId);
+      const projectKey = project ? String(project["key"] ?? "PROJ") : "PROJ";
+      const number = index + 1;
+      return {
+        id,
+        key: `${projectKey}-${number}`,
+        projectId,
+        issueTypeId: findFirstId(seed, "issueTypes") ?? 1,
+        summary: ISSUE_TITLES[index % ISSUE_TITLES.length],
+        description: null,
+        statusId: findFirstId(seed, "statuses") ?? 1,
+        priorityId: findFirstId(seed, "priorities") ?? 1,
+        reporterAccountId: findFirstAccountId(seed),
+        assigneeAccountId: props["assigned"] === true ? findFirstAccountId(seed) : null,
+        parentKey: null,
+        storyPoints: null,
+        resolution: null,
+        resolutionDate: null,
+        labels: resolveLabels(props, []),
+        components: [],
+        fixVersions: [],
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+    }
+    default:
+      return {
+        id,
+        ...props,
+        createdAt: temporal.createdAt,
+        updatedAt: temporal.updatedAt
+      };
+  }
+}
+function findFirstRepoId(seed) {
+  const repos = seed["repos"];
+  return repos?.[0]?.["id"];
+}
+function findRepoOwner(seed) {
+  const repos = seed["repos"];
+  return repos?.[0]?.["owner"];
+}
+function findFirstId(seed, collection) {
+  const entities = seed[collection];
+  return entities?.[0]?.["id"];
+}
+function findFirstAccountId(seed) {
+  const users = seed["users"];
+  return String(users?.[0]?.["accountId"] ?? "account-1");
+}
+function findSlackTeamId(seed) {
+  const workspaces = seed["workspaces"];
+  if (workspaces?.[0]) return String(workspaces[0]["team_id"]);
+  const users = seed["users"];
+  if (users?.[0]) return String(users[0]["team_id"] ?? "T0001TEAM");
+  return void 0;
+}
+function getMaxIssueNumber(seed) {
+  let max = 0;
+  for (const issue of seed["issues"] ?? []) {
+    const n = issue["number"];
+    if (typeof n === "number" && n > max) max = n;
+  }
+  return max;
+}
+function getMaxPRNumber(seed) {
+  let max = 0;
+  for (const pr of seed["pullRequests"] ?? []) {
+    const n = pr["number"];
+    if (typeof n === "number" && n > max) max = n;
+  }
+  return Math.max(max, getMaxIssueNumber(seed));
+}
+function resolveIssueNumberForComment(seed, index) {
+  const issues = seed["issues"] ?? [];
+  if (issues.length === 0) return 1;
+  const issue = issues[index % issues.length];
+  return issue["number"] ?? 1;
+}
+function resolveLinearStateId(seed, props) {
+  const states = seed["workflowStates"] ?? [];
+  if (states.length === 0) return 1;
+  const state = props["state"];
+  if (state === "completed" || state === "closed" || state === "done") {
+    const found = states.find((s) => s["type"] === "completed");
+    if (found) return found["id"];
+  }
+  if (state === "cancelled" || state === "canceled") {
+    const found = states.find((s) => s["type"] === "cancelled");
+    if (found) return found["id"];
+  }
+  if (state === "in_progress" || state === "started") {
+    const found = states.find((s) => s["type"] === "started");
+    if (found) return found["id"];
+  }
+  if (state === "backlog") {
+    const found = states.find((s) => s["type"] === "backlog");
+    if (found) return found["id"];
+  }
+  const unstarted = states.find((s) => s["type"] === "unstarted");
+  return unstarted?.["id"] ?? states[0]["id"];
+}
+function fillDefaults(entity, collection) {
+  switch (collection) {
+    case "repos":
+      entity["fullName"] = entity["fullName"] ?? `${entity["owner"] ?? "org"}/${entity["name"] ?? "repo"}`;
+      entity["private"] = entity["private"] ?? false;
+      entity["fork"] = entity["fork"] ?? false;
+      entity["defaultBranch"] = entity["defaultBranch"] ?? "main";
+      entity["archived"] = entity["archived"] ?? false;
+      entity["disabled"] = entity["disabled"] ?? false;
+      entity["visibility"] = entity["visibility"] ?? "public";
+      entity["hasIssues"] = entity["hasIssues"] ?? true;
+      entity["topics"] = entity["topics"] ?? [];
+      entity["openIssuesCount"] = entity["openIssuesCount"] ?? 0;
+      entity["stargazersCount"] = entity["stargazersCount"] ?? 0;
+      entity["forksCount"] = entity["forksCount"] ?? 0;
+      entity["watchersCount"] = entity["watchersCount"] ?? 0;
+      break;
+    case "users":
+      entity["type"] = entity["type"] ?? "User";
+      entity["siteAdmin"] = entity["siteAdmin"] ?? false;
+      entity["publicRepos"] = entity["publicRepos"] ?? 0;
+      entity["followers"] = entity["followers"] ?? 0;
+      entity["following"] = entity["following"] ?? 0;
+      break;
+  }
+}
+
 // src/runner/dynamic-seed-generator.ts
+function extractCountRequirements(setupText) {
+  const requirements = [];
+  const seen = /* @__PURE__ */ new Set();
+  const NON_ENTITY = /* @__PURE__ */ new Set([
+    "minutes",
+    "minute",
+    "hours",
+    "hour",
+    "days",
+    "day",
+    "weeks",
+    "week",
+    "months",
+    "month",
+    "years",
+    "year",
+    "seconds",
+    "second",
+    "ms",
+    "am",
+    "pm",
+    "st",
+    "nd",
+    "rd",
+    "th",
+    "usd",
+    "eur",
+    "gbp",
+    "percent",
+    "kb",
+    "mb",
+    "gb",
+    "tb"
+  ]);
+  const patterns = [
+    /\b(\d+)\s+([\w\s]+?)(?:\s+(?:that|which|are|with|in|labeled|assigned|have|has)\b)/gi,
+    /\b(\d+)\s+([\w\s]+?)(?:[.,;:)]|$)/gm
+  ];
+  for (const pattern of patterns) {
+    for (const match of setupText.matchAll(pattern)) {
+      const count = parseInt(match[1], 10);
+      const subject = match[2].trim().toLowerCase();
+      if (!subject || count <= 0 || count > 200) continue;
+      const firstWord = subject.split(/\s+/)[0] ?? "";
+      if (NON_ENTITY.has(firstWord)) continue;
+      if (/^(?:of|and|or|the|those|these|them)\b/.test(subject)) continue;
+      const key = `${count}:${subject}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      requirements.push(`- ${subject}: exactly ${count}`);
+    }
+  }
+  return requirements;
+}
 var DynamicSeedError = class extends Error {
   twinName;
   validationErrors;
   constructor(twinName, validationErrors) {
     const details = validationErrors.length > 0 ? `:
 ${validationErrors.map((e) => `  - ${e}`).join("\n")}` : ".";
-    super(`Dynamic seed generation failed for twin "${twinName}"${details}`);
+    const hint = "\n\nHint: Try `--static-seed` to skip dynamic generation and use pre-built seeds instead.";
+    super(`Dynamic seed generation failed for twin "${twinName}"${details}${hint}`);
     this.name = "DynamicSeedError";
     this.twinName = twinName;
     this.validationErrors = validationErrors;
@@ -9280,6 +10367,14 @@ ${context.expectedBehavior}
     prompt += context.successCriteria.map((criterion) => `- ${criterion}`).join("\n");
     prompt += "\n\n";
   }
+  const countReqs = extractCountRequirements(setupDescription);
+  if (countReqs.length > 0) {
+    prompt += `## MANDATORY Count Requirements
+The final seed state MUST have these exact counts. Do NOT deviate:
+`;
+    prompt += countReqs.join("\n");
+    prompt += "\n\n";
+  }
   prompt += `## Setup Description
 This is a multi-service scenario. Generate ONLY the ${twinName} seed data. Ignore setup details that belong to other services. Faithfully reproduce EVERY detail relevant to ${twinName}. Specific names, messages, amounts, and entities mentioned MUST exist in the generated data.
 
@@ -9682,6 +10777,87 @@ function parseSeedPatchResponse(text, twinName) {
   });
   return null;
 }
+async function tryBlueprintPath(twinName, baseSeedData, setupDescription, availableCollections, config, intent) {
+  try {
+    const blueprintConfig = {
+      apiKey: config.apiKey,
+      model: config.model,
+      baseUrl: config.baseUrl,
+      providerMode: config.providerMode
+    };
+    const blueprint = await extractBlueprint(
+      setupDescription,
+      twinName,
+      availableCollections,
+      blueprintConfig
+    );
+    if (!blueprint) {
+      debug("Blueprint extraction returned null");
+      return null;
+    }
+    if (blueprint.collections.length === 0 && blueprint.identities.length === 0) {
+      debug("Blueprint extraction returned empty blueprint");
+      return null;
+    }
+    debug("Blueprint extracted", {
+      identities: String(blueprint.identities.length),
+      collections: blueprint.collections.map((c) => `${c.name}:${c.totalCount}`).join(", ")
+    });
+    const { seed: builtSeed, warnings } = buildSeedFromBlueprint(blueprint, baseSeedData);
+    if (warnings.length > 0) {
+      debug("Blueprint builder warnings", { warnings: warnings.join("; ") });
+    }
+    let finalSeed = normalizeSeedData(builtSeed, twinName);
+    finalSeed = autoFillMissingFKs(finalSeed, twinName);
+    const relValidation = validateSeedRelationships(finalSeed, twinName);
+    if (!relValidation.valid) {
+      warn("Blueprint seed failed relationship validation", {
+        errors: relValidation.errors.slice(0, 5).join("; ")
+      });
+      return null;
+    }
+    if (intent) {
+      const coverage = validateSeedCoverage(intent, finalSeed);
+      if (!coverage.valid) {
+        warn("Blueprint seed failed coverage validation", {
+          errors: coverage.issues.map((i) => i.message).join("; ")
+        });
+        return null;
+      }
+    }
+    const flatForVerify = {};
+    flatForVerify[twinName] = finalSeed;
+    const countMismatches = verifySeedCounts(setupDescription, flatForVerify);
+    if (countMismatches.length > 0) {
+      debug("Blueprint seed has count mismatches (acceptable)", {
+        mismatches: countMismatches.map((m) => `${m.subject}: ${m.expected} vs ${m.actual}`).join("; ")
+      });
+    }
+    const syntheticPatch = {
+      add: {}
+    };
+    for (const [collection, entities] of Object.entries(finalSeed)) {
+      const baseCount = baseSeedData[collection]?.length ?? 0;
+      if (entities.length > baseCount) {
+        syntheticPatch.add[collection] = entities.slice(baseCount).map((e) => {
+          const { id: _id, createdAt: _ca, updatedAt: _ua, ...rest } = e;
+          return rest;
+        });
+      }
+    }
+    return {
+      seed: finalSeed,
+      patch: syntheticPatch,
+      fromCache: false,
+      source: "llm"
+      // Blueprint still uses LLM for extraction
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warn(`Blueprint path failed: ${msg}`);
+    return null;
+  }
+}
 async function generateDynamicSeed(twinName, baseSeedName, baseSeedData, setupDescription, config, intent, context) {
   const cacheScope = {
     baseSeedData,
@@ -9703,6 +10879,28 @@ async function generateDynamicSeed(twinName, baseSeedName, baseSeedData, setupDe
       "No API key configured for seed generation. Set ARCHAL_TOKEN or configure a provider API key."
     ]);
   }
+  progress(`Generating dynamic seed for ${twinName}...`);
+  const availableCollections = Object.keys(baseSeedData);
+  const blueprintResult = await tryBlueprintPath(
+    twinName,
+    baseSeedData,
+    setupDescription,
+    availableCollections,
+    config,
+    intent
+  );
+  if (blueprintResult) {
+    info("Dynamic seed generated via blueprint", { twin: twinName });
+    if (!config.noCache) {
+      const cacheContext = buildSeedCacheContext(twinName, intent, context);
+      cacheSeed(twinName, baseSeedName, setupDescription, blueprintResult.seed, blueprintResult.patch, {
+        baseSeedData,
+        cacheContext
+      });
+    }
+    return blueprintResult;
+  }
+  debug("Blueprint path failed or produced invalid seed, falling back to full LLM generation");
   const userPrompt = buildSeedGenerationPrompt(
     twinName,
     baseSeedData,
@@ -9710,7 +10908,6 @@ async function generateDynamicSeed(twinName, baseSeedName, baseSeedData, setupDe
     intent,
     context
   );
-  progress(`Generating dynamic seed for ${twinName}...`);
   let patch = null;
   let mergedSeed = null;
   let lastErrors = [];
@@ -9741,7 +10938,7 @@ Fix these issues:
         validationAttempt: String(validationAttempts + 1)
       });
       const provider = detectProvider(config.model);
-      const apiKey = resolveProviderApiKey(config.apiKey, provider);
+      const apiKey = effectiveMode === "archal" ? "" : resolveProviderApiKey(config.apiKey, provider);
       const responseText = await callLlm({
         provider,
         model: config.model,
@@ -9750,7 +10947,7 @@ Fix these issues:
         userPrompt: promptWithFeedback,
         maxTokens: 16384,
         baseUrl: config.baseUrl,
-        providerMode: config.providerMode,
+        providerMode: effectiveMode,
         intent: "seed-generate",
         responseFormat: "json"
       });
@@ -9860,6 +11057,22 @@ Fix these issues:
           continue;
         }
       }
+      if (mergedSeed && setupDescription && validationAttempts < MAX_ATTEMPTS - 1) {
+        const flatForVerify = {};
+        flatForVerify[twinName] = mergedSeed;
+        const countMismatches = verifySeedCounts(setupDescription, flatForVerify);
+        if (countMismatches.length > 0) {
+          const countErrors = countMismatches.map(
+            (m) => `Count mismatch: "${m.subject}" should be ${m.expected} but got ${m.actual}`
+          );
+          warn(`Seed count mismatch (attempt ${attempt + 1})`, {
+            errors: countErrors.join("; ")
+          });
+          lastErrors = countErrors;
+          validationAttempts++;
+          continue;
+        }
+      }
       break;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -10835,11 +12048,21 @@ function parseSqlSeed(sql) {
 function loadSeedStateFromPath(seedRoot, seedName) {
   const jsonPath = resolve4(seedRoot, `${seedName}.json`);
   if (existsSync10(jsonPath)) {
-    return JSON.parse(readFileSync12(jsonPath, "utf-8"));
+    try {
+      return JSON.parse(readFileSync12(jsonPath, "utf-8"));
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to parse seed file ${jsonPath}: ${detail}`);
+    }
   }
   const sqlPath = resolve4(seedRoot, `${seedName}.sql`);
   if (existsSync10(sqlPath)) {
-    return parseSqlSeed(readFileSync12(sqlPath, "utf-8"));
+    try {
+      return parseSqlSeed(readFileSync12(sqlPath, "utf-8"));
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to parse seed file ${sqlPath}: ${detail}`);
+    }
   }
   return null;
 }
@@ -11075,7 +12298,9 @@ ${baseTaskMessage}` : baseTaskMessage;
       };
     }
     if (trace.length === 0) {
-      warn(`Agent made no tool calls on run ${runIndex + 1}. The agent may have failed to act \u2014 check agent logs and task prompt.`);
+      warn(
+        `Agent made no tool calls on run ${runIndex + 1}. This usually means the model is too weak for this scenario. Try a more capable model (e.g. --engine-model claude-sonnet-4-6 or --engine-model gemini-2.5-pro). If using a custom agent, check that it correctly processes tool schemas and calls tools.`
+      );
     }
     progress(`Evaluating run ${runIndex + 1}...`);
     const evaluationResult = await evaluateRun(
@@ -11412,8 +12637,14 @@ Pass --allow-ambiguous-seed to opt into best-effort generation.`;
   for (const sel of seedSelections) {
     const mismatches = verifySeedCounts(scenario.setup, sel.seedData);
     if (mismatches.length === 0) continue;
+    const significantMismatches = mismatches.filter((m) => {
+      const delta = Math.abs(m.expected - m.actual);
+      const ratio = m.expected > 0 ? delta / m.expected : delta;
+      return delta > 5 || ratio > 0.5;
+    });
+    if (significantMismatches.length === 0) continue;
     warn(
-      `Seed count mismatch for ${sel.twinName}: ${mismatches.map((m) => `${m.subject}: expected ${m.expected}, got ${m.actual}`).join("; ")}`
+      `Seed count mismatch for ${sel.twinName}: ${significantMismatches.map((m) => `${m.subject}: expected ${m.expected}, got ${m.actual}`).join("; ")}`
     );
   }
   const scenarioDir = dirname2(resolve4(options.scenarioPath));
@@ -11605,7 +12836,7 @@ Pass --allow-ambiguous-seed to opt into best-effort generation.`;
   printHeader(scenario.title, seedSelections);
   const evaluatorProvider = detectProvider(model);
   const configProvider = detectProvider(config.model);
-  const evaluatorApiKey = options.model && evaluatorProvider !== configProvider ? resolveProviderApiKey("", evaluatorProvider) : resolveProviderApiKey(config.apiKey, evaluatorProvider);
+  const evaluatorApiKey = config.evaluatorProvider === "archal" ? "" : options.model && evaluatorProvider !== configProvider ? resolveProviderApiKey("", evaluatorProvider) : resolveProviderApiKey(config.apiKey, evaluatorProvider);
   const evaluatorConfig = {
     apiKey: evaluatorApiKey,
     model,
@@ -12132,7 +13363,10 @@ function createRunCommand() {
   ).addOption(new Option("--openclaw-url <url>", "Deprecated alias for --engine-endpoint").hideHelp()).addOption(new Option("--openclaw-token <token>", "Deprecated alias for --engine-token").hideHelp()).addOption(new Option("--openclaw-agent <id>", "Deprecated alias for --engine-model").hideHelp()).addOption(new Option("--openclaw-twin-urls <path>", "Deprecated alias for --engine-twin-urls").hideHelp()).addOption(new Option("--openclaw-timeout <seconds>", "Deprecated alias for --engine-timeout").hideHelp()).option("--api-base-urls <path>", "Path to JSON mapping service names to clone API base URLs for raw API code routing").option("--api-proxy-url <url>", "Proxy URL for raw API code routing metadata").option("--preflight-only", "Run environment/config preflight checks only and exit").option("--seed-cache", "Enable seed cache for dynamic generation (off by default)").option("--static-seed", "Use seed files as-is without LLM mutation (uses --seed name or auto-selected per twin)").option("--no-failure-analysis", "Skip LLM failure analysis on imperfect scores").option(
     "--allow-ambiguous-seed",
     "Allow dynamic seed generation when setup is underspecified"
-  ).option("--tag <tag>", "Only run if scenario has this tag (exit 0 if not)").option("-q, --quiet", "Suppress non-error output").option("-v, --verbose", "Enable debug logging").action(async (scenarioArg, opts) => {
+  ).option("--tag <tag>", "Only run if scenario has this tag (exit 0 if not)").option("-q, --quiet", "Suppress non-error output").option("-v, --verbose", "Enable debug logging").action(async (scenarioArg, opts, command) => {
+    const parentOpts = command.parent?.opts() ?? {};
+    if (parentOpts.quiet) opts.quiet = true;
+    if (parentOpts.verbose) opts.verbose = true;
     if (opts.quiet) {
       configureLogger({ quiet: true });
     }
@@ -12405,9 +13639,16 @@ function createRunCommand() {
     }
     if (opts.apiKey?.trim()) {
       warnIfKeyLooksInvalid(opts.apiKey.trim(), "--api-key");
-      process.env["ARCHAL_ENGINE_API_KEY"] = opts.apiKey.trim();
+      const key = opts.apiKey.trim();
+      process.env["ARCHAL_ENGINE_API_KEY"] = key;
+      if (key.startsWith("AIza")) {
+        process.env["GEMINI_API_KEY"] = process.env["GEMINI_API_KEY"] || key;
+      } else if (key.startsWith("sk-ant-")) {
+        process.env["ANTHROPIC_API_KEY"] = process.env["ANTHROPIC_API_KEY"] || key;
+      } else if (key.startsWith("sk-")) {
+        process.env["OPENAI_API_KEY"] = process.env["OPENAI_API_KEY"] || key;
+      }
       if (!opts.engineModel && !process.env["ARCHAL_ENGINE_MODEL"] && !opts.model?.trim()) {
-        const key = opts.apiKey.trim();
         if (key.startsWith("AIza")) {
           opts.engineModel = "gemini-2.0-flash";
         } else if (key.startsWith("sk-ant-")) {
@@ -12578,13 +13819,13 @@ function createRunCommand() {
           let statusReadySinceMs = null;
           const isRetryablePollFailure = (result) => result.offline || typeof result.status === "number" && result.status >= 500;
           const sleepForPollInterval = async () => new Promise((resolve12) => setTimeout(resolve12, SESSION_POLL_INTERVAL_MS));
-          process.stderr.write("Starting cloud session...\n");
+          if (!opts.quiet) process.stderr.write("Starting cloud session...\n");
           let pollCount = 0;
           while (Date.now() < readyDeadline) {
             pollCount++;
             if (pollCount % 4 === 0) {
               const elapsedSec = Math.round((Date.now() - (readyDeadline - SESSION_READY_TIMEOUT_MS)) / 1e3);
-              process.stderr.write(`  Still waiting for session to be ready (${elapsedSec}s)...
+              if (!opts.quiet) process.stderr.write(`  Still waiting for session to be ready (${elapsedSec}s)...
 `);
             }
             const freshCreds = getCredentials();
@@ -12655,7 +13896,7 @@ function createRunCommand() {
           }
           if (sessionReady) {
             const warmupSec = Math.round((Date.now() - (readyDeadline - SESSION_READY_TIMEOUT_MS)) / 1e3);
-            process.stderr.write(`Cloud session ready (${warmupSec}s).
+            if (!opts.quiet) process.stderr.write(`Cloud session ready (${warmupSec}s).
 `);
           }
           if (!sessionReady && !runFailureMessage) {
@@ -13018,12 +14259,33 @@ function buildEvidenceArtifacts(report) {
     runIndex: run.runIndex,
     steps: buildAgentTraceSteps(run)
   })).filter((run) => run.steps.length > 0);
+  const evaluations = reportRuns.flatMap(
+    (run) => (run.evaluations ?? []).map((ev) => ({
+      runIndex: run.runIndex,
+      criterionId: ev.criterionId,
+      status: ev.status,
+      result: ev.status,
+      confidence: ev.confidence,
+      explanation: ev.explanation
+    }))
+  );
+  const latestEvaluationByCriterion = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    const current = latestEvaluationByCriterion.get(evaluation.criterionId);
+    if (!current || evaluation.runIndex >= current.runIndex) {
+      latestEvaluationByCriterion.set(evaluation.criterionId, evaluation);
+    }
+  }
   const criteria = Object.entries(report.criterionDescriptions ?? {}).map(
-    ([id, description]) => ({
-      id,
-      label: description,
-      kind: report.criterionTypes?.[id] ?? null
-    })
+    ([id, description]) => {
+      const latest = latestEvaluationByCriterion.get(id);
+      return {
+        id,
+        label: description,
+        kind: report.criterionTypes?.[id] ?? null,
+        result: latest?.result ?? null
+      };
+    }
   );
   const runs = reportRuns.map((run) => ({
     runIndex: run.runIndex,
@@ -13033,6 +14295,7 @@ function buildEvidenceArtifacts(report) {
     evaluations: (run.evaluations ?? []).map((ev) => ({
       criterionId: ev.criterionId,
       status: ev.status,
+      result: ev.status,
       confidence: ev.confidence,
       explanation: ev.explanation
     }))
@@ -13041,6 +14304,7 @@ function buildEvidenceArtifacts(report) {
     satisfaction: report.satisfactionScore,
     scores: reportRuns.map((r) => r.overallScore),
     criteria,
+    evaluations,
     runs,
     traceEntries,
     thinkingTraceEntries,
@@ -15118,9 +16382,10 @@ function findBundledScenarios() {
   return results;
 }
 function detectProviderName(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";
+  const normalized = model.toLowerCase();
+  if (normalized.startsWith("gemini-")) return "Gemini";
+  if (normalized.startsWith("claude-") || normalized.startsWith("sonnet-") || normalized.startsWith("haiku-") || normalized.startsWith("opus-")) return "Anthropic";
+  if (normalized.startsWith("gpt-") || normalized.startsWith("o1-") || normalized.startsWith("o3-") || normalized.startsWith("o4-")) return "OpenAI";
   return "OpenAI-compatible";
 }
 function resolveEngineApiKey(explicitKey) {
@@ -15189,6 +16454,13 @@ Set one via:
       process.exit(1);
     }
     process.env["ARCHAL_ENGINE_API_KEY"] = engineApiKey;
+    if (engineApiKey.startsWith("AIza")) {
+      process.env["GEMINI_API_KEY"] = process.env["GEMINI_API_KEY"] || engineApiKey;
+    } else if (engineApiKey.startsWith("sk-ant-")) {
+      process.env["ANTHROPIC_API_KEY"] = process.env["ANTHROPIC_API_KEY"] || engineApiKey;
+    } else if (engineApiKey.startsWith("sk-")) {
+      process.env["OPENAI_API_KEY"] = process.env["OPENAI_API_KEY"] || engineApiKey;
+    }
     const runs = parseInt(opts.runs, 10);
     if (Number.isNaN(runs) || runs <= 0) {
       process.stderr.write("Error: --runs must be a positive integer\n");