@archal/cli 0.7.7 → 0.7.9

package/dist/index.js

@@ -2982,10 +2982,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 +3012,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;
@@ -7933,7 +7944,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 +7966,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 +8081,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})`
@@ -8537,7 +8557,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 +8715,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 +8741,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]
   };
 }
 
@@ -9039,14 +9061,928 @@ 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;
+    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;
+      }
+    }
+    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);
+  }
+  for (const spec of blueprint.collections) {
+    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 channelId = channels.length > 0 ? String(channels[index % channels.length]["channel_id"] ?? "C0001AAAA") : "C0001AAAA";
+      const users = seed["users"] ?? [];
+      const 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 +10216,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 +10626,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 +10728,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 +10757,6 @@ async function generateDynamicSeed(twinName, baseSeedName, baseSeedData, setupDe
     intent,
     context
   );
-  progress(`Generating dynamic seed for ${twinName}...`);
   let patch = null;
   let mergedSeed = null;
   let lastErrors = [];
@@ -9860,6 +10906,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);
@@ -12132,7 +13194,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 +13470,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 +13650,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 +13727,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 +14090,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 +14126,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 +14135,7 @@ function buildEvidenceArtifacts(report) {
     satisfaction: report.satisfactionScore,
     scores: reportRuns.map((r) => r.overallScore),
     criteria,
+    evaluations,
     runs,
     traceEntries,
     thinkingTraceEntries,
@@ -15118,9 +16213,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 +16285,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");