archal 0.9.17 → 0.9.18

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const version = "0.9.17";
+const version = "0.9.18";
 const archal = { version };
 
 archal.default = archal;

package/dist/seed/dynamic-generator.cjs

@@ -7382,7 +7382,7 @@ var GENERATED_TWIN_CATALOG = [
     icon: "AP",
     name: "Apify",
     description: "Actors, runs, datasets, key-value stores, and request queues.",
-    toolCount: 43,
+    toolCount: 45,
     transport: "rest"
   },
   {
@@ -7390,7 +7390,7 @@ var GENERATED_TWIN_CATALOG = [
     icon: "DC",
     name: "Discord",
     description: "Guilds, channels, messages, webhooks, threads, commands, and interaction responses.",
-    toolCount: 68,
+    toolCount: 67,
     transport: "both"
   },
   {
@@ -7406,7 +7406,7 @@ var GENERATED_TWIN_CATALOG = [
     icon: "GW",
     name: "Google Workspace",
     description: "Gmail, Calendar, Drive, Sheets, and Contacts.",
-    toolCount: 9,
+    toolCount: 249,
     transport: "both"
   },
   {
@@ -7566,6 +7566,51 @@ var LIFETIME_PERIOD_RESETS_AT = new Date(Date.UTC(9999, 11, 31));
 var SCENARIO_USAGE_WINDOW_DAYS = 7;
 var SCENARIO_USAGE_WINDOW_MS = SCENARIO_USAGE_WINDOW_DAYS * 24 * 60 * 60 * 1e3;
 var SCENARIO_USAGE_WINDOW_SECONDS = SCENARIO_USAGE_WINDOW_DAYS * 24 * 60 * 60;
+var LLM_PRICING_USD_PER_M_TOKENS = {
+  // Google Gemini (verified 2026-05-05, standard tier <=200K input tokens)
+  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+  // OpenAI flagship text models (verified 2026-05-21, standard short-context tier)
+  "gpt-5.5": { input: 5, output: 30 },
+  "gpt-5.5-pro": { input: 30, output: 180 },
+  "gpt-5.4": { input: 2.5, output: 15 },
+  "gpt-5.4-mini": { input: 0.75, output: 4.5 },
+  "gpt-5.4-nano": { input: 0.2, output: 1.25 },
+  "gpt-5.4-pro": { input: 30, output: 180 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+  "gpt-4.1-nano": { input: 0.1, output: 0.4 },
+  "gpt-4.1": { input: 2, output: 8 },
+  // DeepSeek (verified 2026-05-05; legacy names map to v4-flash per vendor)
+  "deepseek-chat": { input: 0.14, output: 0.28 },
+  "deepseek-reasoner": { input: 0.14, output: 0.28 },
+  "deepseek-v4-flash": { input: 0.14, output: 0.28 }
+};
+var LLM_PRICING_FAMILY_RATES = [
+  { match: /^gemini-2\.5-pro/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gemini-2.5-pro"] },
+  { match: /^gemini-2\.5-flash/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gemini-2.5-flash"] },
+  { match: /^gpt-5\.5-pro/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-5.5-pro"] },
+  { match: /^gpt-5\.5/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-5.5"] },
+  { match: /^gpt-5\.4-pro/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-5.4-pro"] },
+  { match: /^gpt-5\.4-mini/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-5.4-mini"] },
+  { match: /^gpt-5\.4-nano/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-5.4-nano"] },
+  { match: /^gpt-5\.4/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-5.4"] },
+  { match: /^gpt-4o-mini/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-4o-mini"] },
+  { match: /^gpt-4o(?!-mini)/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-4o"] },
+  { match: /^gpt-4\.1-mini/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-4.1-mini"] },
+  { match: /^gpt-4\.1-nano/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-4.1-nano"] },
+  { match: /^gpt-4\.1(?!-mini|-nano)/i, rate: LLM_PRICING_USD_PER_M_TOKENS["gpt-4.1"] },
+  { match: /^claude-opus-/i, rate: { input: 15, output: 75 } },
+  { match: /^claude-haiku-/i, rate: { input: 0.8, output: 4 } },
+  { match: /^claude-sonnet-/i, rate: { input: 3, output: 15 } },
+  { match: /^opus-/i, rate: { input: 15, output: 75 } },
+  { match: /^haiku-/i, rate: { input: 0.8, output: 4 } },
+  { match: /^sonnet-/i, rate: { input: 3, output: 15 } },
+  { match: /^deepseek-chat/i, rate: LLM_PRICING_USD_PER_M_TOKENS["deepseek-chat"] },
+  { match: /^deepseek-reasoner/i, rate: LLM_PRICING_USD_PER_M_TOKENS["deepseek-reasoner"] },
+  { match: /^deepseek-v4-flash/i, rate: LLM_PRICING_USD_PER_M_TOKENS["deepseek-v4-flash"] }
+];
 
 // ../twins/core/src/errors.ts
 function errorMessage2(error48) {
@@ -35915,7 +35960,7 @@ function buildCodegenUserPrompt(twinName, setupDescription) {
   const declarations = SDK_DECLARATIONS[twinName];
   const example = SDK_EXAMPLES[twinName];
   if (!declarations) {
-    return `Twin: ${twinName}
+    return `Clone: ${twinName}
 
 Setup:
 ${setupDescription}
@@ -35936,7 +35981,7 @@ ${example.code}
 `;
   }
   prompt += `## Task
-Twin: ${twinName}
+Clone: ${twinName}
 
 Setup:
 ${setupDescription}
@@ -35962,7 +36007,7 @@ ${originalCode}
 Fix the code and output ONLY the corrected JavaScript. No explanations.`;
 }
 function buildSimplifiedCodegenPrompt(twinName, setupDescription) {
-  return `Create seed data for the "${twinName}" twin.
+  return `Create seed data for the "${twinName}" clone.
 
 Use ONLY these core functions (they are already defined globally):
 createUser(login), createRepo/createProject/createChannel/createCustomer(name),
@@ -36724,7 +36769,7 @@ RULES:
   - "3 active subscriptions" \u2192 ONE subscription entry with count:3
 - Entity type names: user, org, team, repo, branch, issue, pr, label, milestone, release, webhook, workflow, environment, secret, code_scanning_alert, collaborator, project, page, branch_protection, board, sprint, epic, component, version, filter, dashboard, customer, product, price, subscription, invoice, payment_method, coupon, tax_rate, webhook_endpoint, charge, dispute, channel, message`;
 function buildPlanPrompt(twinName, setupDescription) {
-  return `Twin: ${twinName}
+  return `Clone: ${twinName}
 
 Setup:
 ${setupDescription}`;
@@ -42874,6 +42919,8 @@ IMPORTANT CONSTRAINTS:
 - For RLS policies, use simple expressions like: USING (true) or USING (current_setting('app.user_id')::int = user_id)
 - Use serial or bigserial for primary keys, not uuid (unless explicitly asked)
 - Use simple types: text, int, boolean, timestamptz
+- Do NOT use JSON-style array literals like ["a", "b"] in INSERT values.
+  Use ARRAY['a', 'b'] for SQL array columns, or quoted JSON with ::jsonb for jsonb columns.
 - Always include INSERT statements with realistic test data
 
 
@@ -42894,6 +42941,222 @@ INSERT INTO users (email, name, role) VALUES
 ALTER TABLE users ENABLE ROW LEVEL SECURITY;
 CREATE POLICY "users_select" ON users FOR SELECT USING (true);
 CREATE POLICY "users_update_own" ON users FOR UPDATE USING (id = current_setting('app.user_id', true)::int);`;
+function sqlLiteral2(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function sqlIdent2(value) {
+  if (!value) throw new Error("SQL identifier must not be empty");
+  if (value.includes("\0")) throw new Error("SQL identifier must not contain null bytes");
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function sqlValueLiteral(value, columnType) {
+  const type = columnType?.toLowerCase() ?? "";
+  if (Array.isArray(value)) {
+    if (type.includes("[]")) {
+      const baseType = type.replace(/\[\].*$/, "") || "text";
+      if (value.length === 0) return `ARRAY[]::${baseType}[]`;
+      return `ARRAY[${value.map(sqlLiteral2).join(", ")}]`;
+    }
+    const json2 = sqlLiteral2(JSON.stringify(value));
+    if (type.includes("jsonb")) return `${json2}::jsonb`;
+    if (type.includes("json")) return `${json2}::json`;
+    return json2;
+  }
+  if (value && typeof value === "object") {
+    const json2 = sqlLiteral2(JSON.stringify(value));
+    if (type.includes("jsonb")) return `${json2}::jsonb`;
+    if (type.includes("json")) return `${json2}::json`;
+    return json2;
+  }
+  return sqlLiteral2(value);
+}
+function splitSqlTopLevel(input, separator) {
+  const parts = [];
+  let depth = 0;
+  let bracketDepth = 0;
+  let inQuote = false;
+  let start = 0;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === void 0) continue;
+    const next = i + 1 < input.length ? input[i + 1] : void 0;
+    if (ch === "'") {
+      if (inQuote && next === "'") {
+        i += 1;
+        continue;
+      }
+      inQuote = !inQuote;
+      continue;
+    }
+    if (inQuote) continue;
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    else if (ch === "[") bracketDepth += 1;
+    else if (ch === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+    if (depth === 0 && bracketDepth === 0 && ch === separator) {
+      parts.push(input.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  const tail = input.slice(start).trim();
+  if (tail) parts.push(tail);
+  return parts;
+}
+function splitSqlStatements(sql) {
+  return splitSqlTopLevel(sql, ";").map((statement) => statement.trim()).filter(Boolean);
+}
+function normalizeSqlIdentifier(raw) {
+  const parts = raw.split(".").map((part) => part.trim().replace(/^"|"$/g, "").replace(/""/g, '"')).filter(Boolean);
+  return parts[parts.length - 1] ?? raw.trim();
+}
+function collectTableSchemas(sql) {
+  const tableSchemas = /* @__PURE__ */ new Map();
+  for (const statement of splitSqlStatements(sql)) {
+    const match = statement.match(
+      /^CREATE\s+TABLE(?:\s+IF\s+NOT\s+EXISTS)?\s+([^\s(]+)\s*\(([\s\S]*)\)$/i
+    );
+    if (!match?.[1] || !match[2]) continue;
+    const columnTypes = /* @__PURE__ */ new Map();
+    const columnOrder = [];
+    for (const columnDef of splitSqlTopLevel(match[2], ",")) {
+      const columnMatch = columnDef.trim().match(/^("(?:""|[^"])+"|[a-zA-Z_][a-zA-Z0-9_]*)\s+([a-zA-Z0-9_."[\]]+)/);
+      if (!columnMatch?.[1] || !columnMatch[2]) continue;
+      const columnName = normalizeSqlIdentifier(columnMatch[1]);
+      columnTypes.set(columnName, columnMatch[2].toLowerCase());
+      columnOrder.push(columnName);
+    }
+    tableSchemas.set(normalizeSqlIdentifier(match[1]), { columnTypes, columnOrder });
+  }
+  return tableSchemas;
+}
+function normalizeJsonArrayLiteral(value, columnType) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return value;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+  if (!Array.isArray(parsed)) return value;
+  const type = columnType?.toLowerCase() ?? "";
+  if (type.includes("[]")) {
+    const baseType = type.replace(/\[\].*$/, "") || "text";
+    if (parsed.length === 0) return `ARRAY[]::${baseType}[]`;
+    return `ARRAY[${parsed.map(sqlLiteral2).join(", ")}]`;
+  }
+  const json2 = sqlLiteral2(JSON.stringify(parsed));
+  if (type.includes("jsonb")) return `${json2}::jsonb`;
+  if (type.includes("json")) return `${json2}::json`;
+  return json2;
+}
+function renderStructuredTableSql(value) {
+  const tables = Array.isArray(value) ? value : value && typeof value === "object" && Array.isArray(value["tables"]) ? value["tables"] : null;
+  if (!Array.isArray(tables)) return null;
+  const statements = [];
+  for (const table of tables) {
+    if (!table || typeof table !== "object") return null;
+    const record2 = table;
+    const tableName = typeof record2["name"] === "string" ? record2["name"] : void 0;
+    const columns = Array.isArray(record2["columns"]) ? record2["columns"] : void 0;
+    if (!tableName || !columns) return null;
+    const columnTypes = /* @__PURE__ */ new Map();
+    const columnDefinitions = columns.map((column) => {
+      if (!column || typeof column !== "object") throw new Error("invalid column");
+      const columnRecord = column;
+      const name = typeof columnRecord["name"] === "string" ? columnRecord["name"] : void 0;
+      const rawType = typeof columnRecord["type"] === "string" ? columnRecord["type"] : "text";
+      if (!name) throw new Error("invalid column name");
+      const isPrimary = columnRecord["is_primary"] === true || columnRecord["primary"] === true;
+      const type = isPrimary && /^(bigint|int|integer|serial|bigserial)$/i.test(rawType) ? "bigserial" : rawType;
+      columnTypes.set(name, type);
+      return `${sqlIdent2(name)} ${type}${isPrimary ? " PRIMARY KEY" : ""}`;
+    });
+    statements.push(`CREATE TABLE IF NOT EXISTS public.${sqlIdent2(tableName)} (${columnDefinitions.join(", ")});`);
+    const rows = Array.isArray(record2["rows"]) ? record2["rows"] : Array.isArray(record2["data"]) ? record2["data"] : [];
+    for (const row of rows) {
+      if (!row || typeof row !== "object") continue;
+      const entries = Object.entries(row).filter(([column]) => columnTypes.has(column));
+      if (entries.length === 0) continue;
+      statements.push(
+        `INSERT INTO public.${sqlIdent2(tableName)} (${entries.map(([column]) => sqlIdent2(column)).join(", ")}) VALUES (${entries.map(([column, rowValue]) => sqlValueLiteral(rowValue, columnTypes.get(column))).join(", ")});`
+      );
+    }
+  }
+  return statements.length > 0 ? statements.join("\n\n") : null;
+}
+function normalizeCreateTableStatement(statement) {
+  const match = statement.match(
+    /^(CREATE\s+TABLE(?:\s+IF\s+NOT\s+EXISTS)?\s+[^\s(]+\s*)\(([\s\S]*)\)$/i
+  );
+  if (!match?.[1] || !match[2]) return statement;
+  const columnDefs = splitSqlTopLevel(match[2], ",").map((columnDef) => {
+    const columnMatch = columnDef.trim().match(
+      /^("(?:""|[^"])+"|[a-zA-Z_][a-zA-Z0-9_]*)\s+([a-zA-Z0-9_."[\]]+)([\s\S]*)$/i
+    );
+    if (!columnMatch?.[2] || !columnMatch[3]) return columnDef;
+    const columnType = columnMatch[2].toLowerCase();
+    const rest = columnMatch[3].replace(
+      /\bDEFAULT\s+(\[[\s\S]*?\])(?=\s|,|$)/i,
+      (_full, value) => `DEFAULT ${normalizeJsonArrayLiteral(value, columnType)}`
+    );
+    return `${columnMatch[1]} ${columnMatch[2]}${rest}`;
+  });
+  return `${match[1]}(${columnDefs.join(", ")})`;
+}
+function normalizeSupabaseSql(sql) {
+  const tableSchemas = collectTableSchemas(sql);
+  return splitSqlStatements(sql).map((statement) => {
+    if (/^CREATE\s+TABLE/i.test(statement)) return normalizeCreateTableStatement(statement);
+    const match = statement.match(/^INSERT\s+INTO\s+([^\s(]+)\s*\(([^)]+)\)\s*VALUES\s*([\s\S]*)$/i) ?? statement.match(/^INSERT\s+INTO\s+([^\s(]+)\s+VALUES\s*([\s\S]*)$/i);
+    if (!match?.[1]) return statement;
+    const tableName = normalizeSqlIdentifier(match[1]);
+    const hasColumnList = match.length === 4;
+    const valuesSql = hasColumnList ? match[3] : match[2];
+    if (!valuesSql) return statement;
+    const schema = tableSchemas.get(tableName);
+    const columns = hasColumnList ? splitSqlTopLevel(match[2] ?? "", ",").map(normalizeSqlIdentifier) : schema?.columnOrder ?? [];
+    const tuples = [];
+    let depth = 0;
+    let bracketDepth = 0;
+    let inQuote = false;
+    let tupleStart = -1;
+    for (let i = 0; i < valuesSql.length; i++) {
+      const ch = valuesSql[i];
+      if (ch === void 0) continue;
+      const next = i + 1 < valuesSql.length ? valuesSql[i + 1] : void 0;
+      if (ch === "'") {
+        if (inQuote && next === "'") {
+          i += 1;
+          continue;
+        }
+        inQuote = !inQuote;
+      }
+      if (inQuote) continue;
+      if (ch === "[") bracketDepth += 1;
+      else if (ch === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+      else if (ch === "(" && bracketDepth === 0) {
+        if (depth === 0) tupleStart = i + 1;
+        depth += 1;
+      } else if (ch === ")" && bracketDepth === 0) {
+        depth -= 1;
+        if (depth === 0 && tupleStart >= 0) {
+          tuples.push(valuesSql.slice(tupleStart, i));
+          tupleStart = -1;
+        }
+      }
+    }
+    if (tuples.length === 0) return statement;
+    const normalizedTuples = tuples.map((tuple2) => {
+      const values = splitSqlTopLevel(tuple2, ",").map((value, index) => normalizeJsonArrayLiteral(value, schema?.columnTypes.get(columns[index] ?? "")));
+      return `(${values.join(", ")})`;
+    });
+    return hasColumnList ? `INSERT INTO ${match[1]} (${match[2]}) VALUES ${normalizedTuples.join(", ")}` : `INSERT INTO ${match[1]} VALUES ${normalizedTuples.join(", ")}`;
+  }).join(";\n") + ";";
+}
 function extractSupabaseSql(response) {
   let sql = response.trim();
   if (sql.startsWith("```")) {
@@ -42902,24 +43165,35 @@ function extractSupabaseSql(response) {
   if (sql.startsWith("{")) {
     try {
       const parsed = JSON.parse(sql);
+      const structuredSql = renderStructuredTableSql(parsed);
+      if (structuredSql) return normalizeSupabaseSql(structuredSql);
       const extracted = parsed["sql"] ?? parsed["query"] ?? parsed["script"] ?? parsed["content"];
-      if (extracted && typeof extracted === "string") return extracted;
+      if (extracted && typeof extracted === "string") return normalizeSupabaseSql(extracted);
+    } catch {
+    }
+  }
+  if (sql.startsWith('"')) {
+    try {
+      const parsed = JSON.parse(sql);
+      if (typeof parsed === "string") return normalizeSupabaseSql(parsed);
     } catch {
     }
   }
   if (sql.startsWith("[")) {
     try {
       const parsed = JSON.parse(sql);
+      const structuredSql = renderStructuredTableSql(parsed);
+      if (structuredSql) return normalizeSupabaseSql(structuredSql);
       const parts = [];
       for (const item of parsed) {
         const s = item["sql"] ?? item["query"] ?? item["script"];
         if (s && typeof s === "string") parts.push(s);
       }
-      if (parts.length > 0) return parts.join("\n\n");
+      if (parts.length > 0) return normalizeSupabaseSql(parts.join("\n\n"));
     } catch {
     }
   }
-  return sql;
+  return normalizeSupabaseSql(sql);
 }
 
 // ../packages/seedgen/src/runtime/session-context.ts
@@ -43264,7 +43538,7 @@ async function enrichSeedWithLlm(seed, twinName, setupDescription, deadline, coo
   try {
     const response = await callCodegenLlm({
       systemPrompt: ENRICH_SYSTEM_PROMPT,
-      userPrompt: `Twin: ${twinName}
+      userPrompt: `Clone: ${twinName}
 
 Setup description:
 ${setupDescription}
@@ -44442,6 +44716,10 @@ var GOOGLE_WORKSPACE_BOOTSTRAP_SCOPES = [
   "https://www.googleapis.com/auth/drive.readonly",
   "https://www.googleapis.com/auth/contacts.readonly"
 ];
+var GOOGLE_WORKSPACE_SYNTHETIC_EMAIL = "self@local.invalid";
+function isSyntheticGoogleWorkspaceEmail(email3) {
+  return email3 === GOOGLE_WORKSPACE_SYNTHETIC_EMAIL;
+}
 function googleWorkspaceEmailEntities(intent) {
   if (!intent || intent.twinName !== "google-workspace") return [];
   return intent.entities.filter((entity) => entity.kind === "email" && entity.key === "address" && typeof entity.value === "string" || entity.kind === "account" && entity.key === "email" && typeof entity.value === "string").map((entity) => normalizedEmail(entity.value)).filter((value) => Boolean(value));
@@ -44469,6 +44747,32 @@ function googleWorkspaceReferencedEmails(seed) {
   }
   return emails;
 }
+function googleWorkspaceBootstrapEmail(intentEmails, referencedEmails) {
+  return intentEmails.find((email3) => !isSyntheticGoogleWorkspaceEmail(email3)) ?? referencedEmails.find((email3) => !isSyntheticGoogleWorkspaceEmail(email3)) ?? "user@example.com";
+}
+function rewriteSyntheticGoogleWorkspaceAccountRefs(seed, email3) {
+  const collections = [
+    "calendars",
+    "calendarEvents",
+    "gmailThreads",
+    "gmailMessages",
+    "gmailDrafts",
+    "gmailAttachments",
+    "gmailHistory",
+    "driveFiles",
+    "contacts",
+    "googleAuthTokens"
+  ];
+  for (const collection of collections) {
+    for (const item of seed[collection] ?? []) {
+      const record2 = asRecord(item);
+      if (!record2) continue;
+      if (isSyntheticGoogleWorkspaceEmail(normalizedEmail(record2["accountEmail"]))) {
+        record2["accountEmail"] = email3;
+      }
+    }
+  }
+}
 function googleWorkspaceHasCalendarSurface(intent) {
   return intent.extractedSlots["workspace.surface.calendar"] === true || /\b(calendar|event|events|meeting|meetings|invite|invites)\b/i.test(intent.setupSummary);
 }
@@ -44503,6 +44807,15 @@ function ensureGoogleWorkspaceAccount(accounts, email3, primary) {
     primary
   });
 }
+function replaceGoogleWorkspaceAccount(account, email3) {
+  account["accountId"] = "acct_primary";
+  account["email"] = email3;
+  account["displayName"] = "Primary Account";
+  account["givenName"] = "Primary";
+  account["familyName"] = "Account";
+  account["timezone"] = "America/Los_Angeles";
+  account["primary"] = true;
+}
 function ensureGoogleWorkspaceAuthToken(authTokens, email3) {
   if (authTokens.some((token) => normalizedEmail(token["accountEmail"]) === email3)) return;
   const localPart = email3.split("@")[0] ?? email3;
@@ -44522,7 +44835,8 @@ function ensureGoogleWorkspaceAuthToken(authTokens, email3) {
 function ensureGoogleWorkspacePrimaryCalendar(calendars, accountEmail) {
   const existingPrimary = calendars.find((calendar) => calendar["calendarId"] === "primary");
   if (existingPrimary) {
-    existingPrimary["accountEmail"] = normalizedEmail(existingPrimary["accountEmail"]) ?? accountEmail;
+    const existingEmail = normalizedEmail(existingPrimary["accountEmail"]);
+    existingPrimary["accountEmail"] = !existingEmail || isSyntheticGoogleWorkspaceEmail(existingEmail) ? accountEmail : existingEmail;
     existingPrimary["primary"] = true;
     return "primary";
   }
@@ -44547,6 +44861,15 @@ function ensureGoogleWorkspaceCalendarRows(mergedSeed) {
   for (const item of mergedSeed["calendarEvents"] ?? []) {
     const event = asRecord(item);
     if (!event) continue;
+    if (typeof event["summary"] !== "string") {
+      event["summary"] = "Calendar event";
+    }
+    if (typeof event["description"] !== "string") {
+      event["description"] = "";
+    }
+    if (typeof event["location"] !== "string") {
+      event["location"] = "";
+    }
     const calendarId = typeof event["calendarId"] === "string" && event["calendarId"].trim() ? event["calendarId"].trim() : "primary";
     const accountEmail = normalizedEmail(event["accountEmail"]) ?? "self@local.invalid";
     if (existingCalendarIds.has(calendarId)) continue;
@@ -44586,21 +44909,28 @@ function ensureGoogleWorkspaceCalendarEvidence(mergedSeed, intent, accountEmail)
     organizerEmail: accountEmail,
     attendeeEmails: [],
     conferenceUrl: null,
-    extendedPropertiesShared: null
+    extendedPropertiesShared: {}
   });
 }
 function ensureGoogleWorkspaceScenarioAccounts(mergedSeed, intent) {
   if (!intent || intent.twinName !== "google-workspace") return mergedSeed;
   const accounts = ensureArray(mergedSeed, "accounts");
   const authTokens = ensureArray(mergedSeed, "googleAuthTokens");
+  const intentEmails = googleWorkspaceEmailEntities(intent);
+  let referencedEmails = googleWorkspaceReferencedEmails(mergedSeed);
+  const bootstrapEmail = googleWorkspaceBootstrapEmail(intentEmails, referencedEmails);
   if (accounts.length === 0) {
-    ensureGoogleWorkspaceAccount(accounts, "self@local.invalid", true);
+    ensureGoogleWorkspaceAccount(accounts, bootstrapEmail, true);
+  } else if (accounts.length === 1 && isSyntheticGoogleWorkspaceEmail(normalizedEmail(accounts[0]?.["email"]))) {
+    replaceGoogleWorkspaceAccount(accounts[0], bootstrapEmail);
   }
-  const primaryEmail = normalizedEmail(accounts.find((account) => account["primary"] === true)?.["email"]) ?? normalizedEmail(accounts[0]?.["email"]) ?? "self@local.invalid";
+  rewriteSyntheticGoogleWorkspaceAccountRefs(mergedSeed, bootstrapEmail);
+  referencedEmails = googleWorkspaceReferencedEmails(mergedSeed);
+  const primaryEmail = normalizedEmail(accounts.find((account) => account["primary"] === true)?.["email"]) ?? normalizedEmail(accounts[0]?.["email"]) ?? GOOGLE_WORKSPACE_SYNTHETIC_EMAIL;
   ensureGoogleWorkspaceAuthToken(authTokens, primaryEmail);
   const requiredEmails = Array.from(/* @__PURE__ */ new Set([
-    ...googleWorkspaceEmailEntities(intent),
-    ...googleWorkspaceReferencedEmails(mergedSeed),
+    ...intentEmails,
+    ...referencedEmails,
     ...accounts.map((account) => normalizedEmail(account["email"])).filter((value) => Boolean(value))
   ]));
   for (const email3 of requiredEmails) {
@@ -44627,7 +44957,7 @@ var DynamicSeedError = class extends Error {
     const details = validationErrors.length > 0 ? `:
 ${validationErrors.map((e) => `  - ${e}`).join("\n")}` : ".";
     const suffix = hint ?? "\n\nHint: Run `archal login` and retry. For deterministic reruns, use `--replay-seed <path>` with a previously saved managed seed snapshot.";
-    super(`Dynamic seed generation failed for twin "${twinName}"${details}${suffix}`);
+    super(`Dynamic seed generation failed for clone "${twinName}"${details}${suffix}`);
     this.name = "DynamicSeedError";
     this.twinName = twinName;
     this.validationErrors = validationErrors;
@@ -44693,7 +45023,7 @@ ${fkDetails}
 // ../packages/seedgen/src/runner/seed/dynamic-generator.ts
 var SEED_CODEGEN_MAX_TOKENS = 4096;
 var MAX_CODEGEN_ATTEMPTS = 3;
-var SEED_CACHE_PROMPT_TEMPLATE_VERSION = 4;
+var SEED_CACHE_PROMPT_TEMPLATE_VERSION = 5;
 var CODEGEN_TOTAL_BUDGET_MS = 12e4;
 function buildSeedCacheContext(twinName, systemPromptHash, intent, context) {
   return {
@@ -45222,8 +45552,8 @@ async function generateDynamicSeed(twinName, baseSeedName, baseSeedData, setupDe
     ],
     `
 
-Hint: Dynamic seed generation failed for the "${twinName}" twin. Try adding a \`seed: <name>\` line to your scenario's Config section to use a pre-built seed instead.
-Use a documented seed name for ${twinName}, or inspect the twin package assets in this repo.`
+Hint: Dynamic seed generation failed for the "${twinName}" clone. Try adding a \`seed: <name>\` line to your scenario's Config section to use a pre-built seed instead.
+Use a documented seed name for ${twinName}, or inspect the bundled clone assets in this repo.`
   );
 }
 // Annotate the CommonJS export names for ESM import in node: