agenttwin 0.3.5 → 0.3.7

package/dist/api.js

@@ -61,9 +61,9 @@ function discoveryTransfer(value) {
     return v.map((s) => text(s));
   };
   const entrypoint = (v) => {
-    const path = text(v, 500);
-    if (path.startsWith("/") || path.includes("\\") || /(^|[\/])\.\.([\/#]|$)/.test(path) || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(path)) throw new Error("Entrypoint must be relative to the project");
-    return path;
+    const path2 = text(v, 500);
+    if (path2.startsWith("/") || path2.includes("\\") || /(^|[\/])\.\.([\/#]|$)/.test(path2) || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(path2)) throw new Error("Entrypoint must be relative to the project");
+    return path2;
   };
   const tools = input.tools.map((raw) => {
     const t = raw;
@@ -91,9 +91,63 @@ var init_dashboard_transfer = __esm({
   }
 });
 
+// src/runtime/contracts.ts
+function operationMatrix(spec) {
+  return {
+    schema: "agenttwin/contracts-v1",
+    unsupported: { status: 501, marker: "X-AgentTwin-Unsupported", coverage: "incomplete", forwardedToProduction: false },
+    adapters: CONTRACTS,
+    services: spec?.services.map((s) => ({
+      name: s.name,
+      adapter: s.adapter ?? "json-collection",
+      version: CONTRACTS[s.adapter ?? "json-collection"].version,
+      operations: s.adapter === "slack" ? CONTRACTS.slack.operations : s.adapter === "stripe" ? CONTRACTS.stripe.operations : s.collections.flatMap((c) => CONTRACTS["json-collection"].operations.map((op) => ({ ...op, endpoint: c.path })))
+    })) ?? []
+  };
+}
+var CONTRACTS;
+var init_contracts = __esm({
+  "src/runtime/contracts.ts"() {
+    "use strict";
+    CONTRACTS = {
+      "json-collection": {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token",
+        operations: [
+          { method: "GET", endpoint: "<collection path>", effect: "read", response: "{data: records}", errors: ["401 invalid_test_credential", "429 world_capacity"] },
+          { method: "POST", endpoint: "<collection path>", effect: "append", response: "201 record; 200 idempotency replay", errors: ["400 expected_json_object", "409 idempotency_conflict", "413 body_too_large", "429 world_capacity"] }
+        ],
+        limitations: ["Custom API contract, not a vendor replica", "No update/delete, pagination, OAuth, webhooks or schema validation", "Idempotency compares the exact parsed JSON serialization"]
+      },
+      stripe: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; official Stripe SDK configured with test endpoint",
+        operations: [
+          { method: "POST", endpoint: "/v1/customers", effect: "append customer", parameters: ["email", "name", "description"], errors: ["400 invalid parameters"] },
+          { method: "GET", endpoint: "/v1/customers[/<id>]", effect: "retrieve or list customers", parameters: ["limit", "starting_after"], errors: ["404 resource_missing", "400 invalid pagination"] },
+          { method: "POST", endpoint: "/v1/payment_intents", effect: "create test payment intent", parameters: ["amount", "currency", "customer", "payment_method", "confirm"], errors: ["400 invalid parameters", "400 resource_missing", "402 card_declined"] },
+          { method: "GET", endpoint: "/v1/payment_intents/<id>", effect: "retrieve intent", parameters: [], errors: ["404 resource_missing"] },
+          { method: "POST", endpoint: "/v1/payment_intents/<id>/confirm", effect: "test success or decline", parameters: ["payment_method"], errors: ["404 resource_missing", "400 unsupported test method", "402 card_declined"] }
+        ],
+        limitations: ["Bounded subset, not full Stripe parity; minimal object fields only; no real money", "Only pm_card_visa and pm_card_chargeDeclined test methods", "No webhooks, refunds, subscriptions, payment-method APIs, metadata, updates or deletes", "Customers list supports limit/starting_after; payment intent listing unsupported", "POST idempotency supported; reset clears records and keys; unsupported operations/parameters return 501 and make coverage incomplete"]
+      },
+      slack: {
+        version: "1.0.0",
+        authentication: "Bearer run-scoped test token; no Slack OAuth",
+        operations: [
+          { method: "POST", endpoint: "/api/chat.postMessage", effect: "append /messages", parameters: ["channel", "text"], errors: ["channel_not_found", "no_text"] },
+          { method: "GET|POST", endpoint: "/api/conversations.history", effect: "read /messages", parameters: ["channel"], errors: ["channel_not_found"] },
+          { method: "GET|POST", endpoint: "/api/conversations.list", effect: "read /channels", parameters: [], errors: [] }
+        ],
+        limitations: ["JSON and form bodies only", "No OAuth, scopes, pagination, threads, edits, deletes, attachments or webhooks", "Errors channel_not_found/no_text use HTTP 200 with ok:false", "Unmodeled parameters and operations return HTTP 501 and make coverage incomplete"]
+      }
+    };
+  }
+});
+
 // src/lib/files.ts
-import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
-import { join as join4, relative, sep } from "path";
+import { readdir as readdir3, readFile as readFile6, stat } from "fs/promises";
+import { join as join7, relative, sep } from "path";
 function shouldIgnoreDir(name) {
   return IGNORED_DIRS.has(name) || name === ".git";
 }
@@ -106,14 +160,14 @@ async function walkDir(root, maxFiles, budgetMs) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = await readdir2(dir, { withFileTypes: true });
+      entries = await readdir3(dir, { withFileTypes: true });
     } catch {
       limits.push(`Directory could not be read: ${relative(root, dir) || "."}`);
       continue;
     }
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const full = join4(dir, entry.name);
+      const full = join7(dir, entry.name);
       if (entry.isDirectory()) {
         if (!shouldIgnoreDir(entry.name)) stack.push(full);
       } else if (entry.isFile()) {
@@ -190,27 +244,27 @@ var init_files = __esm({
       scanLimits() {
         return [...new Set(this.cache.limits)].sort();
       }
-      async exists(path) {
+      async exists(path2) {
         try {
-          await stat(join4(this.cwd, path));
+          await stat(join7(this.cwd, path2));
           return true;
         } catch {
           return false;
         }
       }
-      async read(path, maxBytes = MAX_BYTES) {
-        const cached = this.cache.contents.get(path);
+      async read(path2, maxBytes = MAX_BYTES) {
+        const cached = this.cache.contents.get(path2);
         if (cached !== void 0) return cached;
-        const full = join4(this.cwd, path);
+        const full = join7(this.cwd, path2);
         try {
           const info = await stat(full);
           if (!info.isFile()) return void 0;
           if (info.size > maxBytes) {
-            this.cache.limits.push(`File excluded by size limit (${maxBytes} bytes): ${path}`);
+            this.cache.limits.push(`File excluded by size limit (${maxBytes} bytes): ${path2}`);
             return void 0;
           }
-          const text = await readFile4(full, "utf8");
-          this.cache.contents.set(path, text);
+          const text = await readFile6(full, "utf8");
+          this.cache.contents.set(path2, text);
           return text;
         } catch {
           return void 0;
@@ -232,10 +286,10 @@ var init_files = __esm({
       line(ref) {
         const idx = ref.lastIndexOf(":");
         if (idx < 0) return void 0;
-        const path = ref.slice(0, idx);
+        const path2 = ref.slice(0, idx);
         const num = Number(ref.slice(idx + 1));
         if (!Number.isInteger(num)) return void 0;
-        const text = this.cache.contents.get(path);
+        const text = this.cache.contents.get(path2);
         if (text === void 0) return void 0;
         const lines = text.split(/\r?\n/);
         return lines[num - 1];
@@ -258,12 +312,38 @@ function exportedEntrypoints(source) {
     if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") continue;
     const declaration = node.declaration;
     if (!declaration) continue;
-    if (declaration.type === "FunctionDeclaration" && declaration.id && declaration.body.loc) result.push({ name: declaration.id.name, startLine: node.loc.start.line, endLine: declaration.body.loc.end.line });
+    if (declaration.type === "FunctionDeclaration" && declaration.body.loc) result.push({ name: declaration.id?.name ?? "default", startLine: node.loc.start.line, endLine: declaration.body.loc.end.line });
     if (declaration.type === "VariableDeclaration") for (const variable of declaration.declarations) {
       const fn = variable.init;
       if (variable.id.type === "Identifier" && fn && (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression") && fn.body.type === "BlockStatement" && fn.body.loc) result.push({ name: variable.id.name, startLine: node.loc.start.line, endLine: fn.body.loc.end.line });
     }
   }
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    const value = node;
+    if (value.type === "CallExpression" || value.type === "NewExpression") {
+      const callee = value.callee;
+      const operation = callee?.type === "MemberExpression" && !callee.computed ? callee.property?.name : void 0;
+      const worker = value.type === "NewExpression" && callee?.type === "Identifier" && callee.name === "Worker";
+      const route = ["get", "post", "put", "patch", "delete"].includes(operation);
+      const job = ["process", "subscribe", "consume"].includes(operation);
+      const trigger = value.arguments?.[0]?.type === "StringLiteral" ? value.arguments[0].value : void 0;
+      if (worker || job || route && typeof trigger === "string" && trigger.startsWith("/")) {
+        for (const argument of value.arguments ?? []) {
+          if ((argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression") && argument.body?.type === "BlockStatement" && argument.body.loc) {
+            const prefix = worker || job ? "job" : "route";
+            result.push({ name: `${prefix}:${operation ?? "Worker"}:${trigger ?? "callback"}@${argument.loc.start.line}`, startLine: argument.loc.start.line, endLine: argument.body.loc.end.line });
+          }
+        }
+      }
+    }
+    for (const [key, child] of Object.entries(value)) {
+      if (["loc", "start", "end", "comments", "tokens"].includes(key)) continue;
+      if (Array.isArray(child)) child.forEach(visit);
+      else if (child && typeof child === "object") visit(child);
+    }
+  };
+  visit(file.program);
   return result;
 }
 var init_entrypoints = __esm({
@@ -332,14 +412,14 @@ var init_stripe = __esm({
             evidence: []
           };
         }
-        const get = async (path) => {
-          const response = await ctx.fetch(`https://api.stripe.com${path}`, {
+        const get = async (path2) => {
+          const response = await ctx.fetch(`https://api.stripe.com${path2}`, {
             method: "GET",
             headers: { Authorization: `Bearer ${key}` },
             signal: ctx.signal
           });
           if (!response.ok) {
-            throw new Error(`Stripe ${path} -> HTTP ${response.status}`);
+            throw new Error(`Stripe ${path2} -> HTTP ${response.status}`);
           }
           return await response.json();
         };
@@ -494,19 +574,48 @@ var init_github = __esm({
 function planned(unknown) {
   return { supported: [], verified: [], unknown, implemented: false };
 }
+function partial(adapter) {
+  return { implemented: true, supported: CONTRACTS[adapter].operations.map((operation) => `${operation.method} ${operation.endpoint}`), verified: [], unknown: [...CONTRACTS[adapter].limitations, "Customer workflow coverage requires preparation and execution"] };
+}
 var NO_TWIN, PROVIDERS;
 var init_catalog = __esm({
   "src/discovery/providers/catalog.ts"() {
     "use strict";
+    init_contracts();
     init_stripe();
     init_github();
     NO_TWIN = ["all behavior (no twin implemented)"];
     PROVIDERS = [
+      {
+        id: "betterstack",
+        title: "Better Stack",
+        category: "observability",
+        twin: planned(NO_TWIN),
+        signatures: {
+          packages: { node: ["@logtail/node", "@logtail/browser"], python: ["logtail-python"], go: ["github.com/BetterStackHQ/slog-betterstack"] },
+          imports: ["@logtail/node", "@logtail/browser", "logtail"],
+          hosts: ["telemetry.betterstack.com", "in.logs.betterstack.com", "uptime.betterstack.com"],
+          envPrefixes: ["BETTERSTACK_", "LOGTAIL_"]
+        },
+        docs: "https://betterstack.com/docs/"
+      },
+      {
+        id: "opentelemetry",
+        title: "OpenTelemetry",
+        category: "observability",
+        twin: planned(NO_TWIN),
+        signatures: {
+          packages: { node: ["@opentelemetry/api", "@opentelemetry/sdk-node", "@opentelemetry/exporter-trace-otlp-http"], python: ["opentelemetry-api", "opentelemetry-sdk"], go: ["go.opentelemetry.io/otel"] },
+          imports: ["@opentelemetry/", "opentelemetry", "go\\.opentelemetry\\.io/otel"],
+          envPrefixes: ["OTEL_"]
+        },
+        docs: "https://opentelemetry.io/docs/"
+      },
       {
         id: "stripe",
         title: "Stripe",
         category: "payments",
-        twin: planned(["refunds", "payouts", "disputes", "webhook ordering"]),
+        twin: partial("stripe"),
         probe: stripeProbe,
         signatures: {
           packages: {
@@ -529,7 +638,7 @@ var init_catalog = __esm({
         id: "slack",
         title: "Slack",
         category: "comms",
-        twin: planned(NO_TWIN),
+        twin: partial("slack"),
         signatures: {
           packages: {
             node: ["@slack/web-api", "@slack/bolt", "@slack/events-api", "@slack/socket-mode"],
@@ -782,11 +891,54 @@ var init_catalog = __esm({
   }
 });
 
+// src/inventory/store.ts
+import { mkdir as mkdir3, readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import { join as join8 } from "path";
+function storeDir(cwd) {
+  return join8(cwd, STORE_DIR);
+}
+function storePath(cwd, name) {
+  return join8(storeDir(cwd), name);
+}
+async function readJson(path2) {
+  try {
+    return JSON.parse(await readFile7(path2, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+var STORE_DIR, STORE_GITIGNORE, readDecisions;
+var init_store = __esm({
+  "src/inventory/store.ts"() {
+    "use strict";
+    STORE_DIR = ".agenttwin";
+    STORE_GITIGNORE = [
+      "inventory.json",
+      "plan.json",
+      "permissions.local.json",
+      "report.html",
+      "demo/",
+      "trial/",
+      "feedback.json",
+      "cache/",
+      "logs/",
+      "connections/",
+      "observations.local.json",
+      "explorations/",
+      "control.json",
+      "runs/",
+      ""
+    ].join("\n");
+    readDecisions = (cwd) => readJson(storePath(cwd, "decisions.json"));
+  }
+});
+
 // src/inventory/project-products.ts
 async function projectProducts(cwd, data, base) {
   const current = new Set(base.tools.map((t) => t.id));
   const known = new Set(PROVIDERS.map((p) => p.title));
-  const tools = data.tools.filter((t) => current.has(t.id) || !known.has(t.title) && t.category !== "access" && t.category !== "tooling");
+  const excluded = new Set(((await readDecisions(cwd))?.items ?? []).filter((d) => d.kind === "exclude_tool").map((d) => d.target));
+  const tools = data.tools.filter((t) => !excluded.has(t.id) && (current.has(t.id) || !known.has(t.title) && t.category !== "access" && t.category !== "tooling"));
   const ids = new Set(tools.map((t) => t.id));
   const workflows = data.workflows.map((w) => ({ ...w, tools: w.tools.filter((id) => ids.has(id)), steps: w.steps.filter((s) => ids.has(s.tool)) }));
   const google = tools.find((t) => /Google \(Gmail/.test(t.title));
@@ -801,15 +953,15 @@ async function projectProducts(cwd, data, base) {
   const files = await createFileIndex(cwd);
   const paths = (await files.walk()).filter((p) => /\.(?:ts|tsx|js|mjs|py)$/.test(p) && !/(?:^|\/)(?:artifacts|tests?|testbed|docs?|fixtures?|examples?|public|assets)(?:\/|$)|\.(?:test|spec)\.|fixtures?\./i.test(p)).slice(0, 2500);
   const found = /* @__PURE__ */ new Set();
-  for (const path of paths) {
-    const source = await files.read(path, 2e5);
+  for (const path2 of paths) {
+    const source = await files.read(path2, 2e5);
     if (!source) continue;
     for (const p of products) if (p.pattern.test(source)) found.add(p.key);
   }
   const mapped = workflows.map((w) => {
     if (!w.tools.includes(google.id)) return w;
-    const [path, fn] = (w.entrypoint ?? "").split("#");
-    return { w, path, fn };
+    const [path2, fn] = (w.entrypoint ?? "").split("#");
+    return { w, path: path2, fn };
   });
   const finalWorkflows = [];
   let unresolved = false;
@@ -818,17 +970,17 @@ async function projectProducts(cwd, data, base) {
       finalWorkflows.push(value);
       continue;
     }
-    const { w, path, fn } = value;
-    const source = path ? await files.read(path, 2e5) : void 0;
+    const { w, path: path2, fn } = value;
+    const source = path2 ? await files.read(path2, 2e5) : void 0;
     const entry = source && fn ? exportedEntrypoints(source).find((e) => e.name === fn) : void 0;
     const body2 = source && entry ? source.split("\n").slice(entry.startLine - 1, entry.endLine).join("\n") : fn ? "" : source ?? "";
-    const matches = products.filter((p) => found.has(p.key) && p.pattern.test(body2)).map((p) => google.id + ":" + p.key);
-    if (!matches.length) {
+    const matches2 = products.filter((p) => found.has(p.key) && p.pattern.test(body2)).map((p) => google.id + ":" + p.key);
+    if (!matches2.length) {
       unresolved = true;
       finalWorkflows.push(w);
       continue;
     }
-    finalWorkflows.push({ ...w, tools: [...new Set(w.tools.flatMap((id) => id === google.id ? matches : [id]))], steps: w.steps.flatMap((s) => s.tool === google.id ? matches.map((tool) => ({ ...s, tool })) : [s]) });
+    finalWorkflows.push({ ...w, tools: [...new Set(w.tools.flatMap((id) => id === google.id ? matches2 : [id]))], steps: w.steps.flatMap((s) => s.tool === google.id ? matches2.map((tool) => ({ ...s, tool })) : [s]) });
   }
   const productTools = products.filter((p) => found.has(p.key)).map((p) => ({ ...google, id: google.id + ":" + p.key, title: p.title }));
   return discoveryTransfer({ ...data, tools: [...tools.filter((t) => t.id !== google.id || unresolved || !productTools.length).map((t) => t.id === google.id ? { ...t, title: "Google API (unspecified)" } : t), ...productTools], workflows: finalWorkflows });
@@ -840,6 +992,7 @@ var init_project_products = __esm({
     init_entrypoints();
     init_catalog();
     init_dashboard_transfer();
+    init_store();
   }
 });
 
@@ -861,8 +1014,8 @@ var init_sanitize = __esm({
 });
 
 // src/commands/dashboard.ts
-import { cp, mkdir, readFile as readFile5, writeFile } from "fs/promises";
-import { basename, join as join5 } from "path";
+import { cp, mkdir as mkdir4, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
+import { basename, join as join9 } from "path";
 import { fileURLToPath } from "url";
 function dashboardInventory(cwd, inventory) {
   return JSON.parse(sanitizeOutput(JSON.stringify({
@@ -898,8 +1051,8 @@ __export(session_exports, {
   writeSessionTask: () => writeSessionTask
 });
 import { spawn as spawn2, spawnSync } from "child_process";
-import { writeFile as writeFile2, readFile as readFile6 } from "fs/promises";
-import { join as join6 } from "path";
+import { writeFile as writeFile6, readFile as readFile9 } from "fs/promises";
+import { join as join10 } from "path";
 function sessionTask() {
   return `# Prepare this repository for AgentTwin
 
@@ -924,30 +1077,30 @@ function installedOpenCode() {
   return spawnSync("opencode", ["--version"], { stdio: "ignore", timeout: 5e3 }).status === 0;
 }
 async function writeSessionTask(cwd) {
-  const path = join6(cwd, ".agenttwin/AGENT-TASK.md");
-  await writeFile2(path, sessionTask(), "utf8");
-  return path;
+  const path2 = join10(cwd, ".agenttwin/AGENT-TASK.md");
+  await writeFile6(path2, sessionTask(), "utf8");
+  return path2;
 }
 async function launchSession(cwd) {
   if (!installedOpenCode()) throw new Error("OpenCode is not installed. Open .agenttwin/AGENT-TASK.md with your coding agent, or install OpenCode and retry init --agent opencode.");
   const prompt = "Read .agenttwin/AGENT-TASK.md and follow it to discover and prepare this project for AgentTwin. Start by analyzing the repository and presenting workflow findings and missing execution requirements.";
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve4, reject) => {
     const child = spawn2("opencode", ["--prompt", prompt], { cwd, stdio: "inherit", shell: false });
     child.once("error", reject);
-    child.once("exit", (code, signal) => code === 0 ? resolve3() : reject(new Error(`Coding session ended ${signal || `with exit code ${code}`}. Discovery files remain available.`)));
+    child.once("exit", (code, signal) => code === 0 ? resolve4() : reject(new Error(`Coding session ended ${signal || `with exit code ${code}`}. Discovery files remain available.`)));
   });
 }
 async function loadDashboardDiscovery(cwd, inventory) {
   let previousHead;
   try {
-    previousHead = JSON.parse(await readFile6(join6(cwd, ".agenttwin/git.json"), "utf8")).head;
+    previousHead = JSON.parse(await readFile9(join10(cwd, ".agenttwin/git.json"), "utf8")).head;
   } catch {
   }
   const git = await captureGit(cwd, previousHead);
   const base = discoveryTransfer({ ...dashboardInventory(cwd, inventory), ...git ? { git } : {} });
   let raw;
   try {
-    raw = await readFile6(join6(cwd, ".agenttwin/agent-discovery.json"), "utf8");
+    raw = await readFile9(join10(cwd, ".agenttwin/agent-discovery.json"), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return projectProducts(cwd, base, base);
     throw error;
@@ -973,13 +1126,206 @@ var init_session = __esm({
   }
 });
 
+// src/runtime/workspace-profile.ts
+function validateWorkspaceProfile(input) {
+  const allowed = ["name", "workspace", "company", "website", "role", "teamSize", "useCase", "complete"];
+  if (Object.keys(input).some((key) => !allowed.includes(key))) throw new Error("Unexpected profile field.");
+  const text = (key, max, required = false) => {
+    const value = input[key] === void 0 ? "" : input[key];
+    if (typeof value !== "string" || value.trim().length > max || /[\u0000-\u001f\u007f]/.test(value) || required && !value.trim()) throw new Error(`Enter a valid ${key}.`);
+    return value.trim();
+  };
+  const name = text("name", 100, true), workspace = text("workspace", 100, true);
+  const website = text("website", 254);
+  if (website) {
+    let url;
+    try {
+      url = new URL(website);
+    } catch {
+      throw new Error("Enter a full company website URL.");
+    }
+    if (!["https:", "http:"].includes(url.protocol) || url.username || url.password) throw new Error("Enter a public company website URL.");
+  }
+  const teamSize = text("teamSize", 20);
+  if (!["", "1", "2\u201310", "11\u201350", "51\u2013200", "201\u20131000", "1000+"].includes(teamSize)) throw new Error("Choose a team size.");
+  if (input.complete !== void 0 && typeof input.complete !== "boolean") throw new Error("Invalid completion state.");
+  return { name, workspace, complete: input.complete === true, context: { company: text("company", 100), website, role: text("role", 100), teamSize, useCase: text("useCase", 500) } };
+}
+
+// src/runtime/email-verification.ts
+import { createHmac, randomBytes, randomInt, timingSafeEqual } from "crypto";
+function normalizedEmail(value) {
+  const email = typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (email.length > 254 || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) throw new Error("Enter a valid email address.");
+  return email;
+}
+function createEmailVerification(options, secret) {
+  const hash3 = (value) => createHmac("sha256", secret).update(value).digest("hex");
+  const matches2 = (value, expected) => {
+    const a = Buffer.from(hash3(value), "hex"), b = Buffer.from(expected, "hex");
+    return a.length === b.length && timingSafeEqual(a, b);
+  };
+  return {
+    enabled: !!options,
+    challenge(email, origin) {
+      const id = randomBytes(24).toString("hex"), binding = randomBytes(32).toString("hex");
+      const code = String(randomInt(0, 1e8)).padStart(8, "0");
+      const challenge = { email, origin, binding: hash3(binding), codeHash: hash3(id + ":" + code), expires: Date.now() + 10 * 6e4, attempts: 0, sentAt: Date.now() };
+      return { id, binding, code, challenge };
+    },
+    bound(challenge, binding, origin) {
+      return !!challenge && challenge.expires > Date.now() && challenge.origin === origin && matches2(binding, challenge.binding);
+    },
+    verify(id, challenge, code) {
+      if (challenge.verified || challenge.attempts >= 5 || challenge.expires <= Date.now()) return false;
+      challenge.attempts++;
+      if (typeof code !== "string" || !/^\d{8}$/.test(code) || !matches2(id + ":" + code, challenge.codeHash)) return false;
+      challenge.verified = true;
+      return true;
+    },
+    async deliver(email, code, id) {
+      if (!options) throw new Error("email_not_configured");
+      const response = await fetch("https://api.resend.com/emails", {
+        method: "POST",
+        headers: { authorization: "Bearer " + options.apiKey, "content-type": "application/json", "Idempotency-Key": "agenttwin-login-" + id },
+        body: JSON.stringify({ from: options.from, to: [email], subject: "Your AgentTwin verification code", text: `Your AgentTwin verification code is ${code}.
+
+It expires in 10 minutes. Do not share this code. If you did not request it, ignore this email.` }),
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (!response.ok) throw new Error("email_delivery_failed");
+    }
+  };
+}
+
+// src/runtime/social-auth.ts
+import * as oidc from "openid-client";
+import { randomBytes as randomBytes2, createHash, timingSafeEqual as timingSafeEqual2 } from "crypto";
+var hash = (value) => createHash("sha256").update(value).digest();
+var validUrl = (value) => {
+  const url = new URL(value);
+  if (url.username || url.password || url.search || url.hash || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1"].includes(url.hostname))) throw new Error("Authentication URLs must use HTTPS (or local HTTP).");
+  return url;
+};
+function createSocialAuth(options) {
+  const base = options ? validUrl(options.publicUrl) : void 0;
+  if (base && base.pathname !== "/") throw new Error("Authentication public URL must be an origin.");
+  if (options?.sso) validUrl(options.sso.issuer);
+  const transactions = /* @__PURE__ */ new Map();
+  const configs = /* @__PURE__ */ new Map();
+  const enabled = (provider) => !!options?.[provider];
+  const callback = (provider) => new URL("/v1/auth/oauth/" + provider + "/callback", base).href;
+  const config = (provider) => {
+    let pending = configs.get(provider);
+    if (!pending) {
+      const credentials2 = options[provider];
+      const issuer = provider === "google" ? "https://accounts.google.com" : options.sso.issuer;
+      pending = oidc.discovery(new URL(issuer), credentials2.clientId, credentials2.clientSecret, void 0, { timeout: 10, execute: [oidc.enableNonRepudiationChecks] });
+      configs.set(provider, pending);
+      void pending.catch(() => configs.delete(provider));
+    }
+    return pending;
+  };
+  return {
+    providers: () => ["google", "github", "sso"].map((id) => ({ id, enabled: enabled(id) })),
+    async begin(provider, origin, signup, onboarding) {
+      if (!enabled(provider)) throw new Error("provider_not_configured");
+      for (const [key, value] of transactions) if (value.expires < Date.now()) transactions.delete(key);
+      if (transactions.size >= 1e3) throw new Error("auth_busy");
+      const state = oidc.randomState(), verifier = oidc.randomPKCECodeVerifier(), nonce = oidc.randomNonce(), binding = randomBytes2(32).toString("hex");
+      const challenge = await oidc.calculatePKCECodeChallenge(verifier);
+      let url;
+      const parameters = { redirect_uri: callback(provider), state, code_challenge: challenge, code_challenge_method: "S256" };
+      if (provider === "github") {
+        url = new URL("https://github.com/login/oauth/authorize");
+        Object.entries({ ...parameters, client_id: options.github.clientId, scope: "read:user user:email" }).forEach(([key, value]) => url.searchParams.set(key, value));
+      } else url = oidc.buildAuthorizationUrl(await config(provider), { ...parameters, nonce, scope: "openid email profile" });
+      if (transactions.size >= 1e3) throw new Error("auth_busy");
+      transactions.set(state, { provider, origin, signup, onboarding, verifier, nonce, binding: hash(binding).toString("hex"), expires: Date.now() + 6e5 });
+      return { url: url.href, binding, secure: base.protocol === "https:" };
+    },
+    // Bind the state to this browser before exchanging any provider code. Consume once.
+    take(provider, query, cookie) {
+      if (query.getAll("state").length !== 1) throw new Error("invalid_state");
+      const state = query.get("state"), transaction = transactions.get(state);
+      if (!transaction || transaction.provider !== provider || transaction.expires < Date.now() || !timingSafeEqual2(hash(cookie), Buffer.from(transaction.binding, "hex"))) throw new Error("invalid_state");
+      transactions.delete(state);
+      return transaction;
+    },
+    async finish(transaction, query) {
+      const provider = transaction.provider;
+      let subject, email, verified, name, issuer;
+      if (provider === "github") {
+        if (query.get("error") || query.getAll("code").length !== 1) throw new Error("authorization_failed");
+        const response = await fetch("https://github.com/login/oauth/access_token", { method: "POST", headers: { accept: "application/json", "content-type": "application/x-www-form-urlencoded" }, body: new URLSearchParams({ client_id: options.github.clientId, client_secret: options.github.clientSecret, code: query.get("code"), redirect_uri: callback(provider), code_verifier: transaction.verifier }), signal: AbortSignal.timeout(1e4) });
+        const token = await response.json();
+        if (!response.ok || !token.access_token || token.token_type?.toLowerCase() !== "bearer") throw new Error("authorization_failed");
+        const headers = { authorization: "Bearer " + token.access_token, accept: "application/vnd.github+json", "user-agent": "AgentTwin", "X-GitHub-Api-Version": "2022-11-28" };
+        const [user, addresses] = await Promise.all([fetch("https://api.github.com/user", { headers, signal: AbortSignal.timeout(1e4) }), fetch("https://api.github.com/user/emails", { headers, signal: AbortSignal.timeout(1e4) })]);
+        if (!user.ok || !addresses.ok) throw new Error("authorization_failed");
+        const profile = await user.json();
+        const emails = await addresses.json();
+        const address = emails.find((item) => item.primary && item.verified);
+        if (!Number.isSafeInteger(profile.id) || profile.id <= 0) throw new Error("authorization_failed");
+        subject = String(profile.id);
+        issuer = "https://github.com";
+        email = address?.email;
+        verified = address?.verified;
+        name = profile.name || profile.login;
+      } else {
+        const configuration = await config(provider);
+        const currentUrl = new URL(callback(provider));
+        currentUrl.search = query.toString();
+        const tokens = await oidc.authorizationCodeGrant(configuration, currentUrl, { pkceCodeVerifier: transaction.verifier, expectedState: query.get("state"), expectedNonce: transaction.nonce, idTokenExpected: true });
+        const claims = tokens.claims();
+        if (!claims) throw new Error("authorization_failed");
+        subject = claims.sub;
+        issuer = claims.iss;
+        email = claims.email;
+        verified = claims.email_verified;
+        name = claims.name;
+      }
+      if (verified !== true || typeof email !== "string" || email.length > 254 || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) throw new Error("verified_email_required");
+      return { provider, issuer, subject, email: email.trim().toLowerCase(), name: (typeof name === "string" && name.trim() ? name.trim() : email.split("@")[0]).slice(0, 100) };
+    }
+  };
+}
+
+// src/runtime/auth.ts
+import { randomBytes as randomBytes3, scrypt, timingSafeEqual as timingSafeEqual3, createHash as createHash2 } from "crypto";
+var digest = (value) => createHash2("sha256").update(value).digest("hex");
+var derive = (password, salt) => new Promise((resolve4, reject) => scrypt(password, salt, 64, { N: 131072, r: 8, p: 1, maxmem: 160 * 1024 * 1024 }, (error, key) => error ? reject(error) : resolve4(key)));
+async function passwordHash(password) {
+  const salt = randomBytes3(16).toString("hex");
+  return `${salt}:${(await derive(password, salt)).toString("hex")}`;
+}
+async function passwordMatches(password, stored) {
+  const [salt, key] = stored.split(":");
+  const actual = await derive(password, salt);
+  const expected = Buffer.from(key, "hex");
+  return expected.length === actual.length && timingSafeEqual3(expected, actual);
+}
+function credentials(input) {
+  if (!input || typeof input !== "object") throw new Error("Enter your email and password.");
+  const data = input;
+  const email = typeof data.email === "string" ? data.email.trim().toLowerCase() : "";
+  const password = typeof data.password === "string" ? data.password : "";
+  if (email.length > 254 || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) || password.length < 12 || password.length > 128) throw new Error("Use a valid email and a password with 12\u2013128 characters.");
+  return { email, password };
+}
+var challengeStore = (map, key, value, ttlMs) => {
+  map[key] = { value, expires: Date.now() + ttlMs };
+  for (const [k, v] of Object.entries(map)) if (v.expires < Date.now()) delete map[k];
+};
+
 // src/runtime/gateway.ts
 init_dashboard_transfer();
+import { generateRegistrationOptions, verifyRegistrationResponse, generateAuthenticationOptions, verifyAuthenticationResponse } from "@simplewebauthn/server";
 import { createServer as createServer2 } from "http";
-import { createHash as createHash2, randomBytes as randomBytes3, randomUUID as randomUUID2, timingSafeEqual } from "crypto";
-import { mkdir as mkdir3, readFile as readFile8, writeFile as writeFile4, rename, mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
-import { resolve as resolve2, join as join8, dirname as dirname2, extname } from "path";
-import { tmpdir as tmpdir2 } from "os";
+import { createHash as createHash5, randomBytes as randomBytes6, randomUUID as randomUUID2, timingSafeEqual as timingSafeEqual4 } from "crypto";
+import { mkdir as mkdir6, readFile as readFile11, writeFile as writeFile8, rename, mkdtemp as mkdtemp3, rm as rm4 } from "fs/promises";
+import { resolve as resolve3, join as join12, dirname as dirname2, extname } from "path";
+import { tmpdir as tmpdir3 } from "os";
 
 // src/runtime/transcription.ts
 var transcriptionConfiguration = () => ({ available: Boolean(process.env.OPENAI_API_KEY), model: "gpt-4o-mini-transcribe" });
@@ -1055,7 +1401,7 @@ function parseWorld(value) {
     if (!object(service) || typeof service.name !== "string" || !namePattern.test(service.name) || services.has(service.name)) invalid("service names must be unique lowercase identifiers");
     const item = service;
     if (!Array.isArray(item.collections) || !item.collections.length || item.collections.length > 20) invalid("each service needs 1\u201320 collections");
-    if (item.adapter !== void 0 && !["json-collection", "slack"].includes(String(item.adapter))) invalid("unsupported service adapter");
+    if (item.adapter !== void 0 && !["json-collection", "slack", "stripe"].includes(String(item.adapter))) invalid("unsupported service adapter");
     const paths = /* @__PURE__ */ new Set();
     for (const entry of item.collections) {
       if (!object(entry) || typeof entry.path !== "string" || !/^\/[a-zA-Z0-9_/-]+$/.test(entry.path) || entry.path.includes("//") || paths.has(entry.path)) invalid("collection paths must be unique absolute HTTP paths");
@@ -1064,6 +1410,7 @@ function parseWorld(value) {
       paths.add(collection.path);
     }
     if (item.adapter === "slack" && (!paths.has("/messages") || !paths.has("/channels") || paths.size !== 2)) invalid("slack adapter requires /messages and /channels collections");
+    if (item.adapter === "stripe" && (!paths.has("/v1/customers") || !paths.has("/v1/payment_intents") || paths.size !== 2)) invalid("stripe adapter requires /v1/customers and /v1/payment_intents collections");
     services.set(item.name, paths);
   }
   const known = (entry) => typeof entry.service === "string" && typeof entry.path === "string" && services.get(entry.service)?.has(entry.path);
@@ -1071,6 +1418,19 @@ function parseWorld(value) {
   for (const assertion of v.assertions) {
     if (!object(assertion) || !known(assertion) || !Number.isSafeInteger(assertion.count) || Number(assertion.count) < 0 || assertion.where !== void 0 && !object(assertion.where)) invalid("assertions need an existing service/path, nonnegative count, and optional where object");
   }
+  const policyIds = /* @__PURE__ */ new Set();
+  for (const field of ["forbiddenEffects", "preservedState"]) {
+    if (v[field] === void 0) continue;
+    if (!Array.isArray(v[field]) || v[field].length > 100) invalid(`${field} must contain at most 100 checks`);
+    for (const entry of v[field]) {
+      if (!object(entry) || typeof entry.id !== "string" || !namePattern.test(entry.id) || policyIds.has(entry.id) || !known(entry) || entry.where !== void 0 && !object(entry.where)) invalid(`${field} requires unique ids, known collections and an optional where object`);
+      const item = entry;
+      if (field === "forbiddenEffects" && !["write", "read", "replay"].includes(String(item.operation))) invalid("forbiddenEffects operation must be write, read or replay");
+      if (Object.keys(item).some((k) => !["id", "service", "path", "where", ...field === "forbiddenEffects" ? ["operation"] : []].includes(k))) invalid(`unknown ${field} field`);
+      policyIds.add(item.id);
+    }
+  }
+  if (v.scenario !== void 0 && (!object(v.scenario) || typeof v.scenario.id !== "string" || !namePattern.test(v.scenario.id) || !Number.isSafeInteger(v.scenario.version) || Number(v.scenario.version) < 1 || typeof v.scenario.digest !== "string" || !/^[a-f0-9]{64}$/.test(v.scenario.digest) || Object.keys(v.scenario).some((k) => !["id", "version", "digest"].includes(k)))) invalid("scenario requires id, positive version and SHA-256 digest");
   if (v.postgres !== void 0) {
     if (!object(v.postgres) || v.postgres.seedFile !== void 0 && !v.files.includes(String(v.postgres.seedFile)) || !Array.isArray(v.postgres.assertions) || !v.postgres.assertions.length || v.postgres.assertions.length > 100) invalid("postgres requires assertions and seedFile must be listed in files");
     for (const a of v.postgres.assertions) {
@@ -1084,7 +1444,29 @@ function parseWorld(value) {
     }
   }
   if (v.fault !== void 0 && (!object(v.fault) || !known(v.fault) || v.fault.type !== "timeout-after-write" || !Number.isInteger(v.fault.delayMs) || Number(v.fault.delayMs) < 1 || Number(v.fault.delayMs) > 1e4)) invalid("fault requires an existing service/path and delayMs 1\u201310000");
-  const keys = ["schema", "name", "workflowId", "files", "command", "timeoutSeconds", "services", "assertions", "postgres", "redis", "fault"];
+  if (v.browser !== void 0) {
+    if (!object(v.browser) || typeof v.browser.baseUrl !== "string") invalid("browser requires baseUrl");
+    const browser = v.browser;
+    let u;
+    try {
+      u = new URL(String(v.browser.baseUrl));
+    } catch {
+      invalid("browser baseUrl must be a loopback HTTP URL");
+    }
+    if (u.protocol !== "http:" || u.hostname !== "127.0.0.1" || !u.port || u.username || u.password || u.pathname !== "/" || u.search || u.hash) invalid("browser baseUrl must be http://127.0.0.1:<port>");
+    if (!Array.isArray(browser.steps) || !browser.steps.length || browser.steps.length > 100 || Object.keys(browser).some((k) => !["baseUrl", "steps"].includes(k))) invalid("browser needs 1\u2013100 steps");
+    for (const raw of browser.steps) {
+      const step = raw;
+      if (!object(step) || !["goto", "click", "fill", "expectText"].includes(String(step.action))) invalid("unsupported browser action");
+      if (step.action === "goto") {
+        if (typeof step.path !== "string" || !step.path.startsWith("/") || step.path.startsWith("//") || step.path.includes("\\") || Object.keys(step).some((k) => !["action", "path"].includes(k))) invalid("goto requires a relative application path");
+      } else {
+        if (typeof step.selector !== "string" || !step.selector || step.action === "fill" && typeof step.value !== "string" || step.action === "expectText" && typeof step.text !== "string" || Object.keys(step).some((k) => !["action", "selector", ...step.action === "fill" ? ["value"] : step.action === "expectText" ? ["text"] : []].includes(k))) invalid("invalid browser selector/action parameters");
+      }
+    }
+  }
+  if (v.background !== void 0 && (!object(v.background) || !known(v.background) || !Number.isSafeInteger(v.background.count) || Number(v.background.count) < 0 || !Number.isInteger(v.background.timeoutMs) || Number(v.background.timeoutMs) < 1 || Number(v.background.timeoutMs) > Number(v.timeoutSeconds) * 1e3 || v.background.where !== void 0 && !object(v.background.where) || Object.keys(v.background).some((k) => !["service", "path", "count", "where", "timeoutMs"].includes(k)))) invalid("background requires a known collection, expected count, optional where, and bounded timeoutMs");
+  const keys = ["schema", "name", "workflowId", "files", "command", "timeoutSeconds", "browser", "background", "services", "assertions", "forbiddenEffects", "preservedState", "scenario", "postgres", "redis", "fault"];
   if (Object.keys(v).some((k) => !keys.includes(k))) invalid("unknown world field");
   return v;
 }
@@ -1101,9 +1483,18 @@ function portableLocalReceipt(value) {
   const uuid = (v) => typeof v === "string" && /^[a-f0-9-]{36}$/.test(v);
   if (!r || r.schema !== "agenttwin/run-v1" || r.runtime !== "local" || !uuid(r.runId) || typeof r.name !== "string" || !/^[a-z][a-z0-9_]{0,39}$/.test(r.name) || typeof r.project !== "string" || r.project.length > 240 || /[\x00-\x1f]/.test(r.project) || !["passed", "failed", "error", "incomplete"].includes(r.status) || typeof r.createdAt !== "string" || !Number.isFinite(Date.parse(r.createdAt)) || !Number.isFinite(r.durationMs) || r.durationMs < 0 || !r.application || !Array.isArray(r.application.command) || r.application.command[0] !== "node" || r.application.command.some((v) => typeof v !== "string") || !Array.isArray(r.assertions) || !r.assertions.length || r.assertions.length > 100 || r.assertions.some((a) => typeof a.service !== "string" || typeof a.path !== "string" || typeof a.passed !== "boolean" || !Number.isSafeInteger(a.count) || a.count < 0 || !Number.isSafeInteger(a.actual) || a.actual < 0 || a.passed !== (a.count === a.actual)) || !Array.isArray(r.events) || r.events.length > 5e4 || !r.finalState || typeof r.finalState !== "object" || !r.initialState || typeof r.initialState !== "object" || !r.sourceDigests || typeof r.sourceDigests !== "object" || !/^[a-f0-9]{64}$/.test(r.specDigest)) throw new Error("Invalid CLI receipt");
   if (r.status === "passed" && (r.application.exitCode !== 0 || r.application.timedOut || r.assertions.some((a) => !a.passed) || r.unsupported?.length || r.fault && !r.fault.triggered)) throw new Error("Passed receipt contradicts recorded evidence");
-  if (Array.isArray(r.sourceDigests) || Object.keys(r.sourceDigests).length > 100 || Object.entries(r.sourceDigests).some(([path, digest]) => path.startsWith("/") || path.split("/").includes("..") || typeof digest !== "string" || !/^[a-f0-9]{64}$/.test(digest)) || Object.values(r.finalState).some((paths) => !paths || typeof paths !== "object" || Array.isArray(paths) || Object.values(paths).some((rows) => !Array.isArray(rows))) || typeof r.application.stdout !== "string" || typeof r.application.stderr !== "string" || r.application.stdout.length > 65536 || r.application.stderr.length > 65536 || r.events.some((e) => !e || !Number.isSafeInteger(e.sequence) || typeof e.service !== "string" || typeof e.operation !== "string" || typeof e.path !== "string" || typeof e.detail !== "string")) throw new Error("Invalid CLI evidence fields");
+  if (r.browser !== void 0) {
+    const b = r.browser;
+    if (!b || b.engine !== "playwright-chromium" || typeof b.passed !== "boolean" || !Array.isArray(b.steps) || b.steps.length > 100 || b.steps.some((step) => !step || !["goto", "click", "fill", "expectText"].includes(step.action) || typeof step.passed !== "boolean") || b.error !== void 0 && (typeof b.error !== "string" || b.error.length > 4096) || b.screenshot !== void 0 && (!b.screenshot || b.screenshot.mimeType !== "image/jpeg" || typeof b.screenshot.base64 !== "string" || b.screenshot.base64.length > 14e5 || !/^[A-Za-z0-9+/]*={0,2}$/.test(b.screenshot.base64) || Buffer.from(b.screenshot.base64, "base64").toString("base64") !== b.screenshot.base64) || r.status === "passed" && (!b.passed || b.steps.some((step) => !step.passed))) throw new Error("Invalid or contradictory browser evidence");
+  }
+  if (r.background !== void 0 && (!r.background || typeof r.background.service !== "string" || typeof r.background.path !== "string" || !Number.isSafeInteger(r.background.count) || !Number.isSafeInteger(r.background.actual) || r.background.actual < 0 || r.background.count < 0 || typeof r.background.passed !== "boolean" || r.background.passed !== (r.background.count === r.background.actual) || r.status === "passed" && !r.background.passed)) throw new Error("Invalid or contradictory background evidence");
+  if (r.executionError !== void 0 && (typeof r.executionError !== "string" || r.executionError.length > 4096 || r.status === "passed")) throw new Error("Invalid execution error evidence");
+  if (r.evaluation !== void 0 && (!r.evaluation || r.evaluation.schema !== "agenttwin/evaluation-v1" || !["passed", "failed", "unsafe"].includes(r.evaluation.outcome) || typeof r.evaluation.taskPassed !== "boolean" || typeof r.evaluation.safe !== "boolean" || !Array.isArray(r.evaluation.checks) || r.evaluation.checks.length > 300 || r.evaluation.checks.some((c) => !c || typeof c.id !== "string" || typeof c.passed !== "boolean" || !["required-outcome", "forbidden-effect", "preserved-state"].includes(c.kind)) || r.status === "passed" && (r.evaluation.outcome !== "passed" || !r.evaluation.safe || !r.evaluation.taskPassed || r.evaluation.checks.some((c) => !c.passed)))) throw new Error("Invalid or contradictory state evaluation");
+  if (Array.isArray(r.sourceDigests) || Object.keys(r.sourceDigests).length > 100 || Object.entries(r.sourceDigests).some(([path2, digest2]) => path2.startsWith("/") || path2.split("/").includes("..") || typeof digest2 !== "string" || !/^[a-f0-9]{64}$/.test(digest2)) || Object.values(r.finalState).some((paths) => !paths || typeof paths !== "object" || Array.isArray(paths) || Object.values(paths).some((rows) => !Array.isArray(rows))) || typeof r.application.stdout !== "string" || typeof r.application.stderr !== "string" || r.application.stdout.length > 65536 || r.application.stderr.length > 65536 || r.events.some((e) => !e || !Number.isSafeInteger(e.sequence) || typeof e.service !== "string" || typeof e.operation !== "string" || typeof e.path !== "string" || typeof e.detail !== "string")) throw new Error("Invalid CLI evidence fields");
+  if (r.events.some((e) => e.source !== void 0 && (!e.source || e.source.provenance !== "application-reported" || typeof e.source.file !== "string" || !Object.hasOwn(r.sourceDigests, e.source.file) || !Number.isSafeInteger(e.source.line) || e.source.line < 1 || e.source.line > 1e6 || !Number.isSafeInteger(e.source.column) || e.source.column < 1 || e.source.column > 1e6))) throw new Error("Invalid reported source evidence");
+  if (r.sourceDirectory !== void 0 && (typeof r.sourceDirectory !== "string" || r.sourceDirectory.length > 1024 || r.sourceDirectory.startsWith("/") || r.sourceDirectory.includes("\\") || r.sourceDirectory.split("/").includes("..") || /[\x00-\x1f]/.test(r.sourceDirectory))) throw new Error("Invalid source directory");
   const git = validateGit(r.git);
-  const fields = ["schema", "runId", "name", "workflowId", "project", "createdAt", "durationMs", "status", "application", "assertions", "infrastructureAssertions", "fault", "initialState", "finalState", "events", "unsupported", "coverage", "sourceDigests", "specDigest"];
+  const fields = ["schema", "runId", "name", "workflowId", "project", "createdAt", "durationMs", "status", "application", "assertions", "infrastructureAssertions", "fault", "initialState", "finalState", "events", "unsupported", "coverage", "sourceDigests", "sourceDirectory", "specDigest", "evaluation", "contracts", "scenario", "worldId", "browser", "background", "executionError"];
   const result = Object.fromEntries(fields.filter((k) => r[k] !== void 0).map((k) => [k, r[k]]));
   Object.assign(result, { runtime: "local", provenance: "CLI-reported execution; not independently attested", isolation: { kind: "process", network: "host network; not isolated", rootFilesystem: "host-accessible" }, ...git ? { git } : {} });
   if (Buffer.byteLength(JSON.stringify(result)) > 2 * 1024 * 1024) throw new Error("CLI receipt exceeds 2 MiB");
@@ -1111,15 +1502,30 @@ function portableLocalReceipt(value) {
 }
 
 // src/commands/run.ts
-import { mkdtemp, mkdir as mkdir2, readFile as readFile7, writeFile as writeFile3, realpath, lstat, rm, copyFile } from "fs/promises";
-import { tmpdir } from "os";
-import { basename as basename2, dirname, isAbsolute, join as join7, relative as relative2, resolve, sep as sep2 } from "path";
+import { mkdtemp as mkdtemp2, mkdir as mkdir5, readFile as readFile10, writeFile as writeFile7, realpath as realpath2, lstat, rm as rm3, copyFile } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, dirname, isAbsolute, join as join11, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { createHash, randomUUID } from "crypto";
+import { createHash as createHash4, randomUUID } from "crypto";
 
-// src/runtime/remote.ts
-import { readFile as readFile2 } from "fs/promises";
+// src/runtime/credentials.ts
+import { homedir } from "os";
 import { join as join2 } from "path";
+import { readFile as readFile2, mkdir, writeFile, chmod, rm } from "fs/promises";
+var path = () => join2(homedir(), ".agenttwin", "credentials.json");
+async function savedConnection() {
+  try {
+    const data = JSON.parse(await readFile2(path(), "utf8"));
+    return typeof data.base === "string" && /^at_user_[a-f0-9]{64}$/.test(data.token) ? data : null;
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw new Error("Cannot read saved login. Run npx agenttwin login again.");
+  }
+}
+
+// src/runtime/remote.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
 
 // src/lib/exit.ts
 var EXIT = {
@@ -1153,11 +1559,12 @@ function apiBase(value) {
   return value.replace(/\/$/, "");
 }
 async function executeRemote(stage, spec, log, metadata = {}) {
-  const base = apiBase(process.env.AGENTTWIN_API_URL ?? "");
-  const token = process.env.AGENTTWIN_TOKEN;
-  if (!token) throw new CliError("AGENTTWIN_TOKEN is not configured", { code: EXIT.BLOCKED });
+  const saved = await savedConnection();
+  const base = apiBase(process.env.AGENTTWIN_API_URL || saved?.base || "https://api.agenttwin.si");
+  const token = process.env.AGENTTWIN_TOKEN || saved?.token;
+  if (!token) throw new CliError("Sign in first with npx agenttwin login", { code: EXIT.BLOCKED });
   const files = /* @__PURE__ */ Object.create(null);
-  for (const file of spec.files) files[file] = (await readFile2(join2(stage, "app", file))).toString("base64");
+  for (const file of spec.files) files[file] = (await readFile3(join3(stage, "app", file))).toString("base64");
   const headers = { authorization: `Bearer ${token}`, "content-type": "application/json" };
   const response = await fetch(`${base}/v1/runs`, { method: "POST", headers, body: JSON.stringify({ spec, files, ...metadata }), redirect: "error", signal: AbortSignal.timeout(15e3) });
   if (!response.ok) throw new CliError(`AgentTwin API rejected run (${response.status}): ${await response.text()}`, { code: response.status === 401 || response.status === 429 ? EXIT.BLOCKED : EXIT.ERROR });
@@ -1174,17 +1581,184 @@ async function executeRemote(stage, spec, log, metadata = {}) {
       return state.receipt;
     }
     if (["error", "cancelled"].includes(state.status)) throw new CliError(state.error ?? "Hosted runtime failed");
-    await new Promise((resolve3) => setTimeout(resolve3, 1e3));
+    await new Promise((resolve4) => setTimeout(resolve4, 1e3));
   }
   throw new CliError(`Timed out waiting for hosted run ${job.id}; inspect this run in the API before retrying`);
 }
 
+// src/runtime/browser-execution.ts
+import { chromium } from "playwright";
+import { isDeepStrictEqual } from "util";
+async function browserExecution(spec, world, signal) {
+  signal?.throwIfAborted();
+  const recipe = spec.browser;
+  const browser = await chromium.launch({ headless: true, timeout: spec.timeoutSeconds * 1e3, ...process.env.AGENTTWIN_CHROMIUM_EXECUTABLE_PATH ? { executablePath: process.env.AGENTTWIN_CHROMIUM_EXECUTABLE_PATH } : {} });
+  const abort = () => {
+    void browser.close().catch(() => {
+    });
+  };
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    signal?.throwIfAborted();
+    const context = await browser.newContext({ serviceWorkers: "block", viewport: { width: 1280, height: 720 } });
+    const origins = /* @__PURE__ */ new Set([new URL(recipe.baseUrl).origin, ...Object.values(world.credentials).map((c) => new URL(c.endpoint).origin)]);
+    const blocked = /* @__PURE__ */ new Set();
+    await context.route("**/*", (route) => {
+      const origin = new URL(route.request().url()).origin;
+      if (origins.has(origin)) return route.continue();
+      if (blocked.size < 100) blocked.add(origin);
+      return route.abort("blockedbyclient");
+    });
+    const page = await context.newPage();
+    page.setDefaultTimeout(Math.min(spec.timeoutSeconds * 500, 1e4));
+    const deadline = Date.now() + Math.min(spec.timeoutSeconds * 1e3, 1e4);
+    while (true) {
+      signal?.throwIfAborted();
+      try {
+        const r = await fetch(recipe.baseUrl, { signal: AbortSignal.timeout(300) });
+        if (r.ok) break;
+      } catch {
+      }
+      if (Date.now() > deadline) throw new Error("Application browser readiness timed out");
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    const steps = [];
+    let error;
+    for (const step of recipe.steps) {
+      signal?.throwIfAborted();
+      try {
+        if (step.action === "goto") await page.goto(new URL(step.path, recipe.baseUrl).href);
+        else if (step.action === "click") await page.locator(step.selector).click();
+        else if (step.action === "fill") await page.locator(step.selector).fill(step.value);
+        else await page.locator(step.selector).filter({ hasText: step.text }).waitFor({ state: "visible" });
+        steps.push({ action: step.action, passed: true });
+      } catch (cause) {
+        error = cause instanceof Error ? cause.message : String(cause);
+        for (const s of recipe.steps) if (s.action === "fill" && s.value) error = error.split(s.value).join("[input]");
+        steps.push({ action: step.action, passed: false });
+        break;
+      }
+    }
+    let screenshot;
+    try {
+      const bytes = await page.screenshot({ type: "jpeg", quality: 65 });
+      if (bytes.length <= 768 * 1024) screenshot = { mimeType: "image/jpeg", base64: bytes.toString("base64") };
+    } catch {
+    }
+    for (const origin of blocked) world.unsupported.push(`browser: blocked unmodeled request origin ${origin}`);
+    return { engine: "playwright-chromium", steps, passed: !error, error, blockedOrigins: [...blocked], screenshot };
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    await browser.close();
+  }
+}
+async function waitBackground(spec, world, signal) {
+  const check = spec.background, deadline = Date.now() + check.timeoutMs;
+  while (true) {
+    signal?.throwIfAborted();
+    const actual = world.state[check.service][check.path].filter((row) => !check.where || Object.entries(check.where).every(([k, v]) => isDeepStrictEqual(row[k], v))).length;
+    if (actual === check.count) return { ...check, actual, passed: true };
+    if (Date.now() >= deadline) return { ...check, actual, passed: false };
+    await new Promise((r) => setTimeout(r, 25));
+  }
+}
+
+// src/runtime/request-source.ts
+import { mkdtemp, writeFile as writeFile2, rm as rm2, realpath } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join4, resolve } from "path";
+function parseRequestSource(raw, spec) {
+  if (typeof raw !== "string" || raw.length > 1024) return;
+  try {
+    const source = JSON.parse(raw);
+    if (!source || typeof source.file !== "string" || !spec.files.includes(source.file) || !Number.isSafeInteger(source.line) || source.line < 1 || source.line > 1e6 || !Number.isSafeInteger(source.column) || source.column < 1 || source.column > 1e6) return;
+    return { file: source.file, line: source.line, column: source.column, provenance: "application-reported" };
+  } catch {
+    return;
+  }
+}
+async function createRequestSourceHook(app, spec, credentials2) {
+  const dir = await mkdtemp(join4(tmpdir(), "agenttwin-source-hook-"));
+  const path2 = join4(dir, "hook.cjs");
+  const config = { root: await realpath(resolve(app)), files: spec.files, origins: Object.values(credentials2).map((c) => new URL(c.endpoint).origin) };
+  const hook = `const config=${JSON.stringify(config)};
+` + String.raw`
+const http=require('node:http'),https=require('node:https'),path=require('node:path'),{fileURLToPath}=require('node:url');
+const origins=new Set(config.origins),files=new Set(config.files);
+function source(){for(const frame of new Error().stack.split('\n').slice(2)){const match=frame.match(/(?:\(|\s)(file:\/\/[^\s)]+|\/[^\s)]+):(\d+):(\d+)\)?$/);if(!match)continue;let file;try{file=match[1].startsWith('file:')?fileURLToPath(match[1]):match[1];}catch{continue;}file=path.relative(config.root,file);if(files.has(file))return JSON.stringify({file,line:Number(match[2]),column:Number(match[3])});}}
+const originalFetch=globalThis.fetch;
+if(originalFetch)globalThis.fetch=function(input,init){let url;try{url=new URL(typeof input==='string'||input instanceof URL?input:input.url);}catch{return originalFetch(input,init);}if(!origins.has(url.origin))return originalFetch(input,init);const location=source();if(!location)return originalFetch(input,init);const headers=new Headers(init?.headers??input?.headers);headers.set('x-agenttwin-source',location);return originalFetch(input,{...init,headers});};
+for(const mod of [http,https])for(const method of ['request','get']){const original=mod[method];mod[method]=function(...args){let options,url,index;try{if(typeof args[0]==='string'||args[0] instanceof URL){url=new URL(args[0]);index=1;options=args[1]&&typeof args[1]==='object'?args[1]:{};}else{index=0;options=args[0]||{};url=new URL((options.protocol||(mod===https?'https:':'http:'))+'//'+(options.hostname||options.host||'localhost')+(options.port?':'+options.port:''));}}catch{return original.apply(this,args);}if(!origins.has(url.origin))return original.apply(this,args);const location=source();if(!location)return original.apply(this,args);const headers=Array.isArray(options.headers)?[...options.headers,'x-agenttwin-source',location]:{...options.headers,'x-agenttwin-source':location};const updated={...options,headers};if(index===1&&typeof args[1]==='function')args.splice(1,0,updated);else args[index]=updated;return original.apply(this,args);};}
+require('node:module').syncBuiltinESMExports();
+`;
+  await writeFile2(path2, hook, { mode: 384 });
+  return { path: path2, close: () => rm2(dir, { recursive: true, force: true }) };
+}
+
 // src/runtime/local.ts
 import { spawn } from "child_process";
 
 // src/runtime/http-world.ts
 import { createServer } from "http";
-import { randomBytes } from "crypto";
+import { randomBytes as randomBytes4 } from "crypto";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/runtime/stripe-adapter.ts
+function stripeOperation(method, path2, params, data, sequence) {
+  const error = (status, code, message, param) => ({ status, body: { error: { type: "invalid_request_error", code, message, ...param ? { param } : {} } } });
+  const match = /^\/v1\/(customers|payment_intents)(?:\/([^/]+))?(?:\/(confirm))?$/.exec(path2);
+  if (!match || !["GET", "POST"].includes(method)) return void 0;
+  const [, resource, id, action] = match, collection = `/v1/${resource}`, rows = data[collection];
+  const allowed = method === "GET" ? id ? [] : ["limit", "starting_after"] : resource === "customers" && !id ? ["email", "name", "description"] : resource === "payment_intents" && !id ? ["amount", "currency", "customer", "payment_method", "confirm"] : action === "confirm" ? ["payment_method"] : void 0;
+  if (!allowed || resource === "customers" && action || resource === "payment_intents" && method === "GET" && !id) return void 0;
+  if (Object.keys(params).some((k) => !allowed.includes(k))) return void 0;
+  if (method === "GET" && !id) {
+    const limit = params.limit === void 0 ? 10 : Number(params.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) return { ...error(400, "parameter_invalid_integer", "limit must be 1\u2013100", "limit"), collection };
+    const ordered = [...rows].reverse();
+    const index = params.starting_after === void 0 ? -1 : ordered.findIndex((r) => r.id === params.starting_after);
+    if (params.starting_after !== void 0 && index === -1) return { ...error(400, "resource_missing", "No such starting_after customer", "starting_after"), collection };
+    const page = ordered.slice(index + 1, index + 1 + limit);
+    return { status: 200, body: { object: "list", data: page, has_more: ordered.length > index + 1 + limit, url: collection }, collection, operation: "read" };
+  }
+  const row = id ? rows.find((r) => r.id === id) : void 0;
+  if (id && !row) return { ...error(404, "resource_missing", `No such ${resource}: '${id}'`), collection };
+  if (method === "GET") return { status: 200, body: row, collection, operation: "read" };
+  if (action === "confirm") {
+    if (row.status === "succeeded") return { status: 200, body: row, collection, operation: "replay" };
+    const payment = params.payment_method ?? row.payment_method;
+    if (payment !== "pm_card_visa" && payment !== "pm_card_chargeDeclined") return { ...error(400, "parameter_invalid", "Only pm_card_visa and pm_card_chargeDeclined are supported", "payment_method"), collection };
+    row.payment_method = payment;
+    row.status = payment === "pm_card_visa" ? "succeeded" : "requires_payment_method";
+    row.last_payment_error = payment === "pm_card_chargeDeclined" ? { code: "card_declined", decline_code: "generic_decline", message: "Your card was declined." } : null;
+    return { status: payment === "pm_card_chargeDeclined" ? 402 : 200, body: payment === "pm_card_chargeDeclined" ? { error: { type: "card_error", code: "card_declined", decline_code: "generic_decline", message: "Your card was declined.", payment_intent: structuredClone(row) } } : row, collection, record: structuredClone(row), operation: "write" };
+  }
+  const prefix = resource === "customers" ? "cus" : "pi";
+  let suffix = sequence;
+  while (rows.some((r) => r.id === `${prefix}_at_${suffix}`)) suffix++;
+  const created = { id: `${prefix}_at_${suffix}`, object: resource === "customers" ? "customer" : "payment_intent", created: 17e8, livemode: false };
+  if (resource === "customers") {
+    if (params.email !== void 0 && typeof params.email !== "string") return { ...error(400, "parameter_invalid", "email must be a string", "email"), collection };
+    Object.assign(created, { email: null, name: null, description: null, ...params });
+  } else {
+    const amount = Number(params.amount);
+    if (!Number.isSafeInteger(amount) || amount < 1) return { ...error(400, "parameter_invalid_integer", "amount must be a positive integer", "amount"), collection };
+    if (typeof params.currency !== "string" || !/^[a-z]{3}$/.test(params.currency)) return { ...error(400, "parameter_invalid", "currency must be a lowercase three-letter code", "currency"), collection };
+    if (params.customer && !data["/v1/customers"].some((r) => r.id === params.customer)) return { ...error(400, "resource_missing", "No such customer", "customer"), collection };
+    if (params.payment_method !== void 0 && !["pm_card_visa", "pm_card_chargeDeclined"].includes(String(params.payment_method))) return { ...error(400, "parameter_invalid", "Unsupported test payment method", "payment_method"), collection };
+    if (params.confirm !== void 0 && !["true", "false", true, false].includes(params.confirm)) return { ...error(400, "parameter_invalid", "confirm must be boolean", "confirm"), collection };
+    const confirm = params.confirm === "true" || params.confirm === true;
+    if (confirm && !params.payment_method) return { ...error(400, "parameter_missing", "Missing payment_method", "payment_method"), collection };
+    Object.assign(created, { amount, currency: params.currency, customer: params.customer ?? null, payment_method: params.payment_method ?? null, status: confirm && params.payment_method === "pm_card_visa" ? "succeeded" : !confirm && params.payment_method ? "requires_confirmation" : "requires_payment_method", last_payment_error: confirm && params.payment_method === "pm_card_chargeDeclined" ? { code: "card_declined", message: "Your card was declined." } : null });
+  }
+  if (rows.length >= 1e4) return { ...error(429, "world_capacity", "World record capacity reached"), collection };
+  rows.push(created);
+  const declined = resource === "payment_intents" && (params.confirm === "true" || params.confirm === true) && params.payment_method === "pm_card_chargeDeclined";
+  return { status: declined ? 402 : 200, body: declined ? { error: { type: "card_error", code: "card_declined", decline_code: "generic_decline", message: "Your card was declined.", payment_intent: structuredClone(created) } } : created, collection, record: structuredClone(created), operation: "write" };
+}
+
+// src/runtime/http-world.ts
 var HttpWorld = class {
   constructor(spec) {
     this.spec = spec;
@@ -1197,21 +1771,32 @@ var HttpWorld = class {
   servers = [];
   timers = /* @__PURE__ */ new Set();
   fired = false;
-  record(service, operation, path, detail) {
+  epoch = 0;
+  replayKeys = /* @__PURE__ */ new Map();
+  sourceContext = new AsyncLocalStorage();
+  record(service, operation, path2, detail, record) {
     if (this.events.length >= 5e4) return;
-    this.events.push({ sequence: this.events.length + 1, service, operation, path, detail });
+    const source = this.sourceContext.getStore();
+    this.events.push({ sequence: this.events.length + 1, service, operation, path: path2, detail, ...record ? { record: structuredClone(record) } : {}, ...source ? { source } : {} });
+  }
+  rejectUnsupported(service, method, path2, detail) {
+    this.unsupported.push(`${service}: ${method} ${path2}: ${detail}`);
+    this.record(service, "unsupported", path2, detail);
   }
   async start() {
+    if (this.servers.length) throw new Error("World is already started");
     for (const service of this.spec.services) {
-      const token = `at_world_${randomBytes(24).toString("hex")}`;
+      const token = `at_world_${randomBytes4(24).toString("hex")}`;
       const data = /* @__PURE__ */ Object.create(null);
       this.state[service.name] = data;
       for (const c of service.collections) data[c.path] = structuredClone(c.seed);
       const keys = /* @__PURE__ */ new Map();
-      const server = createServer(async (req, res) => {
+      this.replayKeys.set(service.name, keys);
+      const server = createServer((req, res) => this.sourceContext.run(parseRequestSource(req.headers["x-agenttwin-source"], this.spec), async () => {
+        const epoch = this.epoch;
         const send2 = (code, body2) => {
           if (!res.destroyed) {
-            res.writeHead(code, { "content-type": "application/json" });
+            res.writeHead(code, { "content-type": "application/json", ...code === 501 ? { "X-AgentTwin-Unsupported": "true" } : {} });
             res.end(JSON.stringify(body2));
           }
         };
@@ -1226,9 +1811,9 @@ var HttpWorld = class {
             return;
           }
           const url = new URL(req.url ?? "/", "http://localhost");
-          let path = url.pathname;
+          let path2 = url.pathname;
           const slack = service.adapter === "slack";
-          const slackMethod = path.replace(/^\/api\//, "");
+          const slackMethod = path2.replace(/^\/api\//, "");
           let payload;
           if (req.method === "POST") {
             const chunks = [];
@@ -1244,7 +1829,7 @@ var HttpWorld = class {
             const text = Buffer.concat(chunks).toString("utf8");
             let parsed;
             try {
-              parsed = slack && req.headers["content-type"]?.startsWith("application/x-www-form-urlencoded") ? Object.fromEntries(new URLSearchParams(text)) : JSON.parse(text);
+              parsed = (slack || service.adapter === "stripe") && req.headers["content-type"]?.startsWith("application/x-www-form-urlencoded") ? Object.fromEntries(new URLSearchParams(text)) : JSON.parse(text);
             } catch {
               send2(400, { error: "expected_json_object" });
               return;
@@ -1255,36 +1840,75 @@ var HttpWorld = class {
             }
             payload = parsed;
           }
+          if (epoch !== this.epoch) {
+            send2(409, { error: "world_reset" });
+            return;
+          }
+          if (service.adapter === "stripe") {
+            const params = payload ?? Object.fromEntries(url.searchParams);
+            const keyHeader2 = req.headers["idempotency-key"];
+            const key2 = req.method === "POST" && typeof keyHeader2 === "string" ? `${path2}:${keyHeader2}` : void 0;
+            const signature2 = JSON.stringify(params);
+            const previous2 = key2 ? keys.get(key2) : void 0;
+            if (previous2) {
+              if (previous2.body !== signature2) {
+                send2(400, { error: { type: "idempotency_error", message: "Keys for idempotent requests can only be used with the same parameters" } });
+                return;
+              }
+              this.record(service.name, "replay", path2, "same-key response replay", previous2.record);
+              send2(200, previous2.record);
+              return;
+            }
+            const result = stripeOperation(req.method ?? "", path2, params, data, this.events.length + 1);
+            if (!result) {
+              this.rejectUnsupported(service.name, req.method ?? "", path2, "unsupported Stripe operation or parameters");
+              send2(501, { error: { type: "invalid_request_error", code: "unsupported_operation", message: "Outside the verified AgentTwin Stripe subset" }, forwardedToProduction: false });
+              return;
+            }
+            if (result.operation) this.record(service.name, result.operation, result.collection, path2, "record" in result ? result.record : result.body);
+            if (key2 && result.status === 200) keys.set(key2, { body: signature2, record: structuredClone(result.body) });
+            const fault2 = this.spec.fault;
+            if (!this.fired && result.operation === "write" && fault2?.service === service.name && fault2.path === result.collection) {
+              this.fired = true;
+              this.record(service.name, "fault", result.collection, `write committed; response delayed ${fault2.delayMs}ms`);
+              const timer = setTimeout(() => {
+                this.timers.delete(timer);
+                send2(result.status, result.body);
+              }, fault2.delayMs);
+              this.timers.add(timer);
+            } else send2(result.status, result.body);
+            return;
+          }
           if (slack) {
             const params = payload ?? Object.fromEntries(url.searchParams);
             const allowed = slackMethod === "chat.postMessage" ? ["channel", "text"] : slackMethod === "conversations.history" ? ["channel"] : [];
             if (Object.keys(params).some((k) => !allowed.includes(k))) {
-              this.unsupported.push(`${service.name}: unsupported parameters for ${slackMethod}`);
+              this.rejectUnsupported(service.name, req.method ?? "", url.pathname, `unsupported parameters for ${slackMethod}`);
               send2(501, { ok: false, error: "unsupported_parameters", forwardedToProduction: false });
               return;
             }
-            if (slackMethod === "chat.postMessage" && req.method === "POST") path = "/messages";
-            else if (slackMethod === "conversations.history" && ["GET", "POST"].includes(req.method ?? "")) path = "/messages";
-            else if (slackMethod === "conversations.list" && ["GET", "POST"].includes(req.method ?? "")) path = "/channels";
+            if (slackMethod === "chat.postMessage" && req.method === "POST") path2 = "/messages";
+            else if (slackMethod === "conversations.history" && ["GET", "POST"].includes(req.method ?? "")) path2 = "/messages";
+            else if (slackMethod === "conversations.list" && ["GET", "POST"].includes(req.method ?? "")) path2 = "/channels";
             else {
-              this.unsupported.push(`${service.name}: ${req.method} ${url.pathname}`);
-              send2(501, { ok: false, error: "unsupported_operation" });
+              this.rejectUnsupported(service.name, req.method ?? "", url.pathname, "unsupported operation");
+              send2(501, { ok: false, error: "unsupported_operation", forwardedToProduction: false });
               return;
             }
           }
-          if (!Object.hasOwn(data, path) || !["GET", "POST"].includes(req.method ?? "")) {
-            this.unsupported.push(`${service.name}: ${req.method} ${path}`);
+          if (!Object.hasOwn(data, path2) || !["GET", "POST"].includes(req.method ?? "")) {
+            this.rejectUnsupported(service.name, req.method ?? "", path2, "unsupported operation");
             send2(501, { error: "unsupported_operation", forwardedToProduction: false });
             return;
           }
           if (req.method === "GET" || slack && slackMethod !== "chat.postMessage") {
-            this.record(service.name, "read", path, `${data[path].length} records`);
-            if (slack && path === "/channels") send2(200, { ok: true, channels: data[path], response_metadata: { next_cursor: "" } });
+            this.record(service.name, "read", path2, `${data[path2].length} records`);
+            if (slack && path2 === "/channels") send2(200, { ok: true, channels: data[path2], response_metadata: { next_cursor: "" } });
             else if (slack) {
               const channel = payload?.channel ?? url.searchParams.get("channel");
               if (!data["/channels"].some((c) => c.id === channel)) send2(200, { ok: false, error: "channel_not_found" });
-              else send2(200, { ok: true, messages: data[path].filter((m) => m.channel === channel), has_more: false });
-            } else send2(200, { data: data[path] });
+              else send2(200, { ok: true, messages: data[path2].filter((m) => m.channel === channel), has_more: false });
+            } else send2(200, { data: data[path2] });
             return;
           }
           const body2 = payload;
@@ -1299,12 +1923,12 @@ var HttpWorld = class {
               return;
             }
           }
-          if (data[path].length >= 1e4 || this.events.length >= 5e4) {
+          if (data[path2].length >= 1e4 || this.events.length >= 5e4) {
             send2(429, { error: "world_capacity" });
             return;
           }
           const keyHeader = slack ? void 0 : req.headers["idempotency-key"];
-          const key = typeof keyHeader === "string" ? `${path}:${keyHeader}` : void 0;
+          const key = typeof keyHeader === "string" ? `${path2}:${keyHeader}` : void 0;
           const signature = JSON.stringify(body2);
           const previous = key ? keys.get(key) : void 0;
           if (previous) {
@@ -1312,22 +1936,22 @@ var HttpWorld = class {
               send2(409, { error: "idempotency_conflict" });
               return;
             }
-            this.record(service.name, "replay", path, "same-key response replay");
+            this.record(service.name, "replay", path2, "same-key response replay", previous.record);
             send2(200, previous.record);
             return;
           }
-          let index = data[path].length + 1;
-          while (data[path].some((r) => r.id === `${service.name}_${index}`)) index++;
+          let index = data[path2].length + 1;
+          while (data[path2].some((r) => r.id === `${service.name}_${index}`)) index++;
           const row = { ...body2, id: `${service.name}_${index}` };
           if (slack) row.ts = `${index}.000001`;
           const reply = slack ? { ok: true, channel: row.channel, ts: row.ts, message: row } : row;
-          data[path].push(row);
+          data[path2].push(row);
           if (key) keys.set(key, { body: signature, record: row });
-          this.record(service.name, "write", path, String(row.id));
+          this.record(service.name, "write", path2, String(row.id), row);
           const fault = this.spec.fault;
-          if (!this.fired && fault?.service === service.name && fault.path === path) {
+          if (!this.fired && fault?.service === service.name && fault.path === path2) {
             this.fired = true;
-            this.record(service.name, "fault", path, `write committed; response delayed ${fault.delayMs}ms`);
+            this.record(service.name, "fault", path2, `write committed; response delayed ${fault.delayMs}ms`);
             const timer = setTimeout(() => {
               this.timers.delete(timer);
               send2(slack ? 200 : 201, reply);
@@ -1337,11 +1961,11 @@ var HttpWorld = class {
         } catch {
           send2(500, { error: "world_request_error" });
         }
-      });
+      }));
       server.requestTimeout = 1e4;
-      await new Promise((resolve3, reject) => {
+      await new Promise((resolve4, reject) => {
         server.once("error", reject);
-        server.listen(0, "127.0.0.1", resolve3);
+        server.listen(0, "127.0.0.1", resolve4);
       });
       this.servers.push(server);
       this.credentials[service.name] = { endpoint: `http://127.0.0.1:${server.address().port}`, token };
@@ -1350,37 +1974,121 @@ var HttpWorld = class {
   }
   assertions() {
     return this.spec.assertions.map((a) => {
-      const rows = this.state[a.service][a.path].filter((row) => !a.where || Object.entries(a.where).every(([k, v]) => JSON.stringify(row[k]) === JSON.stringify(v)));
+      const rows = this.state[a.service][a.path].filter((row) => !a.where || Object.entries(a.where).every(([k, v]) => isDeepStrictEqual2(row[k], v)));
       return { ...a, actual: rows.length, passed: rows.length === a.count };
     });
   }
   get faultTriggered() {
     return this.fired;
   }
+  snapshot() {
+    return structuredClone(this.state);
+  }
+  quiesce() {
+    this.epoch++;
+    for (const server of this.servers) server.closeAllConnections();
+    for (const timer of this.timers) clearTimeout(timer);
+    this.timers.clear();
+  }
+  reset() {
+    this.quiesce();
+    for (const service of this.spec.services) {
+      for (const collection of service.collections) this.state[service.name][collection.path] = structuredClone(collection.seed);
+      this.replayKeys.get(service.name)?.clear();
+    }
+    this.events.length = 0;
+    this.unsupported.length = 0;
+    this.fired = false;
+    return this.snapshot();
+  }
   async close() {
+    this.epoch++;
     for (const timer of this.timers) clearTimeout(timer);
     this.timers.clear();
-    await Promise.all(this.servers.map((server) => new Promise((resolve3) => {
-      server.close(() => resolve3());
+    await Promise.all(this.servers.map((server) => new Promise((resolve4) => {
+      server.close(() => resolve4());
       server.closeAllConnections();
     })));
+    this.servers.length = 0;
   }
 };
 
+// src/runtime/evaluation.ts
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
+var matches = (row, where) => !where || Object.entries(where).every(([k, v]) => isDeepStrictEqual3(row[k], v));
+function evaluateState(spec, initial, final, events) {
+  const checks = spec.assertions.map((a, index) => {
+    const before = initial[a.service]?.[a.path];
+    const after = final[a.service]?.[a.path];
+    const actual = after?.filter((row) => matches(row, a.where)).length;
+    return {
+      id: `assertion_${index + 1}`,
+      kind: "required-outcome",
+      service: a.service,
+      path: a.path,
+      passed: actual === a.count,
+      expected: a.count,
+      actual: actual ?? null,
+      evidence: {
+        initial: `/initialState/${escape(a.service)}/${escape(a.path)}`,
+        final: `/finalState/${escape(a.service)}/${escape(a.path)}`,
+        beforeCount: before?.filter((row) => matches(row, a.where)).length ?? null,
+        eventSequences: events.filter((e) => e.service === a.service && e.path === a.path).map((e) => e.sequence)
+      }
+    };
+  });
+  const forbidden = (spec.forbiddenEffects ?? []).map((policy) => {
+    const hits = events.filter((e) => e.service === policy.service && e.path === policy.path && e.operation === policy.operation && (!policy.where || e.record !== void 0 && matches(e.record, policy.where)));
+    const unknown = events.some((e) => e.service === policy.service && e.path === policy.path && e.operation === policy.operation && policy.where && !e.record);
+    return {
+      id: policy.id,
+      kind: "forbidden-effect",
+      service: policy.service,
+      path: policy.path,
+      passed: hits.length === 0 && !unknown,
+      expected: 0,
+      actual: hits.length,
+      evidence: { eventSequences: hits.map((e) => e.sequence), evidenceGap: unknown }
+    };
+  });
+  const preserved = (spec.preservedState ?? []).map((policy) => {
+    const before = initial[policy.service]?.[policy.path];
+    const after = final[policy.service]?.[policy.path];
+    const passed = !!before && !!after && isDeepStrictEqual3(before.filter((row) => matches(row, policy.where)), after.filter((row) => matches(row, policy.where)));
+    return {
+      id: policy.id,
+      kind: "preserved-state",
+      service: policy.service,
+      path: policy.path,
+      passed,
+      expected: "unchanged",
+      actual: passed ? "unchanged" : "changed or missing",
+      evidence: { initial: `/initialState/${escape(policy.service)}/${escape(policy.path)}`, final: `/finalState/${escape(policy.service)}/${escape(policy.path)}` }
+    };
+  });
+  const taskPassed = checks.every((c) => c.passed);
+  const safe = [...forbidden, ...preserved].every((c) => c.passed);
+  return { schema: "agenttwin/evaluation-v1", outcome: !safe ? "unsafe" : taskPassed ? "passed" : "failed", taskPassed, safe, checks: [...checks, ...forbidden, ...preserved] };
+}
+var escape = (value) => value.replace(/~/g, "~0").replace(/\//g, "~1");
+
 // src/runtime/local.ts
-async function executeLocal(app, spec, signal) {
+init_contracts();
+async function executeLocal(app, spec, signal, existingWorld) {
   if (spec.postgres || spec.redis) throw new Error("This world needs PostgreSQL or Redis. Use --runtime hosted or --runtime e2b, or prepare a workflow using HTTP twins only. No local containers are started.");
   signal?.throwIfAborted();
-  const world = new HttpWorld(spec), started = Date.now();
+  const world = existingWorld ?? new HttpWorld(spec), started = Date.now();
   try {
-    const credentials = await world.start();
+    const credentials2 = existingWorld ? world.credentials : await world.start();
+    const initialState = world.snapshot();
     const env = { PATH: process.env.PATH ?? "", NODE_ENV: "test" };
-    for (const [name, c] of Object.entries(credentials)) {
+    for (const [name, c] of Object.entries(credentials2)) {
       env[`AGENTTWIN_${name.toUpperCase()}_URL`] = c.endpoint;
       env[`AGENTTWIN_${name.toUpperCase()}_TOKEN`] = c.token;
     }
     let stdout = "", stderr = "", timedOut = false;
-    const child = spawn(process.execPath, spec.command.slice(1), { cwd: app, env, stdio: ["ignore", "pipe", "pipe"], detached: process.platform !== "win32" });
+    const hook = await createRequestSourceHook(app, spec, credentials2);
+    const child = spawn(process.execPath, ["--require", hook.path, ...spec.command.slice(1)], { cwd: app, env, stdio: ["ignore", "pipe", "pipe"], detached: process.platform !== "win32" });
     child.stdout.on("data", (b) => {
       stdout = (stdout + b.toString()).slice(-65536);
     });
@@ -1395,31 +2103,61 @@ async function executeLocal(app, spec, signal) {
         }
       }
     };
-    const abort = () => kill();
+    const executionAbort = new AbortController();
+    const abort = () => {
+      executionAbort.abort();
+      kill();
+    };
     signal?.addEventListener("abort", abort, { once: true });
     const timer = setTimeout(() => {
       timedOut = true;
+      executionAbort.abort();
       kill();
     }, spec.timeoutSeconds * 1e3);
-    const exitCode = await new Promise((resolve3, reject) => {
+    const completion = new Promise((resolve4, reject) => {
       child.once("error", reject);
-      child.once("close", resolve3);
-    }).finally(() => {
+      child.once("close", resolve4);
+    });
+    let browser, background, executionError;
+    let exitCode;
+    try {
+      if (spec.browser || spec.background) {
+        const work = (async () => {
+          if (spec.browser) browser = await browserExecution(spec, world, executionAbort.signal);
+          if (spec.background) background = await waitBackground(spec, world, executionAbort.signal);
+          return 0;
+        })();
+        exitCode = await Promise.race([work, completion.then((code) => {
+          if (!spec.browser && code === 0) return work;
+          throw new Error(`Application exited before browser/background completion (${code})`);
+        })]);
+      } else exitCode = await completion;
+    } catch (error) {
+      executionError = error instanceof Error ? error.message : String(error);
+      exitCode = 1;
+    } finally {
+      executionAbort.abort();
       clearTimeout(timer);
       signal?.removeEventListener("abort", abort);
       kill();
-    });
+      await completion.catch(() => {
+      });
+      await hook.close();
+    }
     signal?.throwIfAborted();
-    await world.close();
-    for (const c of Object.values(credentials)) {
+    if (existingWorld) world.quiesce();
+    else await world.close();
+    for (const c of Object.values(credentials2)) {
       stdout = stdout.split(c.token).join("[test-token]");
       stderr = stderr.split(c.token).join("[test-token]");
     }
     const assertions = world.assertions();
-    const status = world.unsupported.length || spec.fault && !world.faultTriggered ? "incomplete" : timedOut || exitCode !== 0 ? "error" : assertions.every((a) => a.passed) ? "passed" : "failed";
-    return { schema: "agenttwin/run-v1", name: spec.name, workflowId: spec.workflowId, status, application: { command: spec.command, exitCode, timedOut, stdout, stderr }, assertions, infrastructureAssertions: [], fault: spec.fault ? { ...spec.fault, triggered: world.faultTriggered } : null, initialState: Object.fromEntries(spec.services.map((s) => [s.name, Object.fromEntries(s.collections.map((c) => [c.path, c.seed]))])), finalState: world.state, events: world.events, unsupported: world.unsupported, durationMs: Date.now() - started, coverage: "CLI Node execution with fresh in-process HTTP collections and bounded Slack operations. Not a VM or network/filesystem isolation boundary. No production environment variables inherited; reviewed code can still access the host filesystem and network.", isolation: { kind: "process", productionCredentialsInherited: false, network: "host network; not isolated", rootFilesystem: "host-accessible; explicit files staged in temporary directory" } };
+    const evaluation = evaluateState(spec, initialState, world.state, world.events);
+    const status = world.unsupported.length || spec.fault && !world.faultTriggered ? "incomplete" : timedOut || exitCode !== 0 ? "error" : background?.passed === false || browser?.passed === false ? "failed" : evaluation.outcome === "passed" ? "passed" : "failed";
+    return { schema: "agenttwin/run-v1", name: spec.name, workflowId: spec.workflowId, status, browser, background, executionError, application: { command: spec.command, exitCode, timedOut, stdout, stderr }, assertions, evaluation, contracts: operationMatrix(spec), scenario: spec.scenario, infrastructureAssertions: [], fault: spec.fault ? { ...spec.fault, triggered: world.faultTriggered } : null, initialState, finalState: world.snapshot(), events: structuredClone(world.events), unsupported: [...world.unsupported], durationMs: Date.now() - started, coverage: "CLI Node execution with fresh in-process HTTP collections and advertised provider subsets. Optional Chromium browser steps and bounded collection-state background completion. Not a VM or network/filesystem isolation boundary. No production environment variables inherited; reviewed code can still access the host filesystem and network.", isolation: { kind: "process", productionCredentialsInherited: false, network: "host network; not isolated", rootFilesystem: "host-accessible; explicit files staged in temporary directory" } };
   } finally {
-    await world.close();
+    if (existingWorld) world.quiesce();
+    else await world.close();
   }
 }
 
@@ -1428,17 +2166,18 @@ init_git();
 
 // src/runtime/e2b.ts
 import { Sandbox } from "e2b";
-import { readFile as readFile3 } from "fs/promises";
-import { randomBytes as randomBytes2 } from "crypto";
-import { homedir } from "os";
-import { join as join3 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { randomBytes as randomBytes5 } from "crypto";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
 async function executeE2B(stage, spec, log, signal) {
+  if (spec.browser || spec.background) throw new Error("Browser and background execution currently require --runtime local; hosted browser dependencies are not provisioned.");
   signal?.throwIfAborted();
   const apiKey = process.env.E2B_API_KEY;
   if (!apiKey) throw new CliError("E2B_API_KEY is not configured", { code: EXIT.BLOCKED, action: "Set E2B_API_KEY in your shell. It remains on the host and is never passed to the application." });
   let saved = {};
   try {
-    saved = JSON.parse(await readFile3(join3(homedir(), ".agenttwin/runtime.json"), "utf8"));
+    saved = JSON.parse(await readFile4(join5(homedir2(), ".agenttwin/runtime.json"), "utf8"));
   } catch {
   }
   const template = process.env.E2B_TEMPLATE_ID ?? saved.templateId;
@@ -1457,12 +2196,12 @@ async function executeE2B(stage, spec, log, signal) {
     signal?.throwIfAborted();
     await sandbox.commands.run("mkdir -p /input/app && chmod 755 /input /input/app", { user: "root" });
     for (const file of ["world.json", "worker.js", ...spec.files.map((f) => `app/${f}`)]) {
-      await sandbox.files.write(`/input/${file}`, new Uint8Array(await readFile3(join3(stage, file))).buffer, { user: "root" });
+      await sandbox.files.write(`/input/${file}`, new Uint8Array(await readFile4(join5(stage, file))).buffer, { user: "root" });
     }
     await sandbox.commands.run("chmod -R a+rX /input", { user: "root" });
     const runtimeEnv = {};
     if (spec.postgres) {
-      const password = randomBytes2(24).toString("hex");
+      const password = randomBytes5(24).toString("hex");
       secrets.push(password);
       await sandbox.commands.run("pg_ctlcluster --skip-systemctl-redirect 15 main start -o '-c ssl=off -c listen_addresses=127.0.0.1'", { user: "root" });
       await sandbox.files.write("/tmp/agenttwin-init.sql", `CREATE ROLE agenttwin LOGIN PASSWORD '${password}';
@@ -1476,7 +2215,7 @@ CREATE DATABASE agenttwin OWNER agenttwin;
       }
     }
     if (spec.redis) {
-      const password = randomBytes2(24).toString("hex");
+      const password = randomBytes5(24).toString("hex");
       secrets.push(password);
       await sandbox.files.write("/tmp/agenttwin-redis.conf", `bind 127.0.0.1
 port 6379
@@ -1515,70 +2254,131 @@ logfile /tmp/agenttwin-redis.log
   }
 }
 
+// src/runtime/scenarios.ts
+import { createHash as createHash3 } from "crypto";
+import { mkdir as mkdir2, readFile as readFile5, readdir as readdir2, writeFile as writeFile3 } from "fs/promises";
+import { join as join6 } from "path";
+import { isDeepStrictEqual as isDeepStrictEqual4 } from "util";
+var identifier = /^[a-z][a-z0-9_]{0,39}$/;
+var object2 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var sort = (v) => Array.isArray(v) ? v.map(sort) : object2(v) ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, sort(v[k])])) : v;
+var scenarioDigest = (scenario) => createHash3("sha256").update(JSON.stringify(sort(scenario))).digest("hex");
+function parseScenario(value) {
+  const fail = (detail) => {
+    throw new Error(`Invalid scenario: ${detail}`);
+  };
+  if (!object2(value) || value.schema !== "agenttwin/scenario-v1" || typeof value.id !== "string" || !identifier.test(value.id) || !Number.isSafeInteger(value.version) || Number(value.version) < 1 || typeof value.description !== "string" || value.description.length > 2e3 || !Array.isArray(value.services) || !Array.isArray(value.entities) || value.entities.length > 100 || Object.keys(value).some((k) => !["schema", "id", "version", "description", "services", "entities"].includes(k))) fail("schema, id, version, description, services and entities are required");
+  const scenario = value;
+  parseWorld({
+    schema: "agenttwin/world-v1",
+    name: scenario.id,
+    files: ["app.mjs"],
+    command: ["node", "app.mjs"],
+    timeoutSeconds: 1,
+    services: scenario.services,
+    assertions: [{ service: scenario.services[0]?.name, path: scenario.services[0]?.collections?.[0]?.path, count: 0 }]
+  });
+  const ids = /* @__PURE__ */ new Set();
+  for (const entity of scenario.entities) {
+    if (!object2(entity) || typeof entity.id !== "string" || !identifier.test(entity.id) || ids.has(entity.id) || !Array.isArray(entity.refs) || entity.refs.length < 2 || entity.refs.length > 20 || Object.keys(entity).some((k) => !["id", "refs"].includes(k))) fail("entities need unique ids and 2\u201320 cross-service references");
+    ids.add(entity.id);
+    const services = /* @__PURE__ */ new Set();
+    for (const ref of entity.refs) {
+      if (!object2(ref) || typeof ref.service !== "string" || typeof ref.path !== "string" || !object2(ref.where) || !Object.keys(ref.where).length || Object.keys(ref).some((k) => !["service", "path", "where"].includes(k))) fail("entity reference needs service, path and a nonempty where selector");
+      const rows = scenario.services.find((s) => s.name === ref.service)?.collections.find((c) => c.path === ref.path)?.seed;
+      if (!rows || rows.filter((row) => Object.entries(ref.where).every(([k, v]) => isDeepStrictEqual4(row[k], v))).length !== 1) fail(`entity ${entity.id} reference must resolve to exactly one seeded record`);
+      services.add(ref.service);
+    }
+    if (services.size < 2) fail(`entity ${entity.id} must link at least two services`);
+  }
+  return structuredClone(scenario);
+}
+function reference(ref) {
+  const match = /^([a-z][a-z0-9_]{0,39})@([1-9][0-9]*)$/.exec(ref);
+  if (!match || !Number.isSafeInteger(Number(match[2]))) throw new Error("Scenario reference must be id@version");
+  return { id: match[1], version: Number(match[2]) };
+}
+async function loadScenario(cwd, ref) {
+  const { id, version } = reference(ref);
+  const path2 = join6(cwd, ".agenttwin/scenarios", id, `${version}.json`);
+  const bytes = await readFile5(path2);
+  if (bytes.length > 2 * 1024 * 1024) throw new Error("Scenario exceeds 2 MiB");
+  const scenario = parseScenario(JSON.parse(bytes.toString()));
+  if (scenario.id !== id || scenario.version !== version) throw new Error("Scenario identity does not match its stored version");
+  return scenario;
+}
+function applyScenario(world, scenario) {
+  const shape = (services) => services.map((s) => ({ name: s.name, adapter: s.adapter ?? "json-collection", paths: s.collections.map((c) => c.path).sort() })).sort((a, b) => a.name.localeCompare(b.name));
+  if (!isDeepStrictEqual4(shape(world.services), shape(scenario.services))) throw new Error("Scenario services, adapters and collections must exactly match the world");
+  return parseWorld({ ...world, services: structuredClone(scenario.services), scenario: { id: scenario.id, version: scenario.version, digest: scenarioDigest(scenario) } });
+}
+
 // src/commands/run.ts
 async function stageApplication(root, files, destination) {
-  const canonicalRoot = await realpath(root);
+  const canonicalRoot = await realpath2(root);
   const digests = {};
   let bytes = 0;
   for (const file of files) {
     if (isAbsolute(file) || file.includes("\\") || file.split("/").some((p) => p === ".." || /^(\.env.*|\.git|\.ssh|\.aws|\.azure|\.config|\.npmrc|\.netrc|credentials.*)$/i.test(p)) || /\.(pem|key|p12|pfx)$/i.test(file)) throw new CliError(`Unsafe application file: ${file}`, { code: EXIT.USAGE });
-    const source = await realpath(resolve(canonicalRoot, file));
+    const source = await realpath2(resolve2(canonicalRoot, file));
     const rel = relative2(canonicalRoot, source);
-    if (rel.startsWith(`..${sep2}`) || rel === ".." || isAbsolute(rel) || source !== resolve(canonicalRoot, file) || !(await lstat(source)).isFile()) throw new CliError(`Files must be regular files within the project, without symlinks: ${file}`, { code: EXIT.USAGE });
-    const contents = await readFile7(source);
+    if (rel.startsWith(`..${sep2}`) || rel === ".." || isAbsolute(rel) || source !== resolve2(canonicalRoot, file) || !(await lstat(source)).isFile()) throw new CliError(`Files must be regular files within the project, without symlinks: ${file}`, { code: EXIT.USAGE });
+    const contents = await readFile10(source);
     bytes += contents.length;
     if (bytes > 20 * 1024 * 1024) throw new CliError("Application files exceed 20 MiB; supply a smaller built bundle", { code: EXIT.USAGE });
-    const target = join7(destination, file);
-    await mkdir2(dirname(target), { recursive: true });
-    await writeFile3(target, contents, { mode: 420 });
-    digests[file] = createHash("sha256").update(contents).digest("hex");
+    const target = join11(destination, file);
+    await mkdir5(dirname(target), { recursive: true });
+    await writeFile7(target, contents, { mode: 420 });
+    digests[file] = createHash4("sha256").update(contents).digest("hex");
   }
   return digests;
 }
 async function runWorld(cwd, opts) {
-  const file = resolve(cwd, opts.file ?? "agenttwin.world.json");
+  const file = resolve2(cwd, opts.file ?? "agenttwin.world.json");
   let spec;
   try {
-    spec = parseWorld(JSON.parse(await readFile7(file, "utf8")));
+    spec = parseWorld(JSON.parse(await readFile10(file, "utf8")));
   } catch (error) {
     throw new CliError(String(error), { code: EXIT.USAGE, action: "Create agenttwin.world.json; run agenttwin example --out ./agenttwin-example for a working example." });
   }
+  if (opts.scenario) spec = applyScenario(spec, await loadScenario(cwd, opts.scenario));
   if (spec.workflowId) {
     let inventory;
     try {
-      inventory = JSON.parse(await readFile7(join7(cwd, ".agenttwin/inventory.json"), "utf8"));
+      inventory = JSON.parse(await readFile10(join11(cwd, ".agenttwin/inventory.json"), "utf8"));
     } catch {
       throw new CliError("Linked workflow needs discovery inventory; run init first", { code: EXIT.BLOCKED });
     }
     if (!inventory.workflows?.some((w) => w.id === spec.workflowId)) {
       const { loadDashboardDiscovery: loadDashboardDiscovery2 } = await Promise.resolve().then(() => (init_session(), session_exports));
-      const discovery = await loadDashboardDiscovery2(cwd, inventory);
-      if (!discovery.workflows.some((w) => w.id === spec.workflowId)) throw new CliError("workflowId is absent from the current inventory", { code: EXIT.BLOCKED });
+      const discovery2 = await loadDashboardDiscovery2(cwd, inventory);
+      if (!discovery2.workflows.some((w) => w.id === spec.workflowId)) throw new CliError("workflowId is absent from the current inventory", { code: EXIT.BLOCKED });
     }
   }
   const runtime = opts.runtime ?? "local";
   if (!["local", "e2b", "hosted"].includes(runtime)) throw new CliError("runtime must be local, hosted or e2b", { code: EXIT.USAGE });
   if (runtime === "e2b" && !process.env.E2B_API_KEY) throw new CliError("E2B_API_KEY is not configured", { code: EXIT.BLOCKED, action: "Configure your E2B key in the shell; it will not be uploaded." });
-  const stage = await mkdtemp(join7(tmpdir(), "agenttwin-world-"));
+  const stage = await mkdtemp2(join11(tmpdir2(), "agenttwin-world-"));
   try {
-    const sourceDigests = await stageApplication(dirname(file), spec.files, join7(stage, "app"));
-    await writeFile3(join7(stage, "world.json"), JSON.stringify(spec), { mode: 420 });
+    const sourceDigests = await stageApplication(dirname(file), spec.files, join11(stage, "app"));
+    await writeFile7(join11(stage, "world.json"), JSON.stringify(spec), { mode: 420 });
     const git = await captureGit(cwd);
     let project;
     try {
-      project = JSON.parse(await readFile7(join7(cwd, ".agenttwin/inventory.json"), "utf8")).name ?? basename2(cwd);
+      project = JSON.parse(await readFile10(join11(cwd, ".agenttwin/inventory.json"), "utf8")).name ?? basename2(cwd);
     } catch {
     }
     if (runtime === "local") {
       opts.log("Testing through the CLI with in-process service twins. No cloud VM or containers.");
-      const report2 = await executeLocal(join7(stage, "app"), spec, opts.signal);
+      const report2 = await executeLocal(join11(stage, "app"), spec, opts.signal);
       const runId2 = randomUUID();
-      const receipt2 = { ...report2, runId: runId2, runtime, project, git, createdAt: (/* @__PURE__ */ new Date()).toISOString(), sourceDigests, specDigest: createHash("sha256").update(JSON.stringify(spec)).digest("hex"), provenance: "CLI-reported execution" };
-      const out2 = resolve(cwd, opts.out ?? `.agenttwin/runs/${runId2}`);
-      await mkdir2(out2, { recursive: true });
-      const evidencePath = join7(out2, "run.json"), reportPath = join7(out2, "report.md");
-      await writeFile3(evidencePath, JSON.stringify(receipt2, null, 2) + "\n", { mode: 384 });
-      await writeFile3(reportPath, `# ${spec.name}: ${receipt2.status}
+      const receipt2 = { ...report2, sourceDirectory: relative2(cwd, dirname(file)).split(sep2).join("/"), runId: runId2, runtime, project, git, createdAt: (/* @__PURE__ */ new Date()).toISOString(), sourceDigests, specDigest: createHash4("sha256").update(JSON.stringify(spec)).digest("hex"), provenance: "CLI-reported execution" };
+      const out2 = resolve2(cwd, opts.out ?? `.agenttwin/runs/${runId2}`);
+      await mkdir5(out2, { recursive: true });
+      const evidencePath = join11(out2, "run.json"), reportPath = join11(out2, "report.md");
+      await writeFile7(evidencePath, JSON.stringify(receipt2, null, 2) + "\n", { mode: 384 });
+      await writeFile7(join11(out2, "world.json"), JSON.stringify(spec, null, 2) + "\n", { mode: 384 });
+      await writeFile7(reportPath, `# ${spec.name}: ${receipt2.status}
 
 Runner: CLI
 Git: ${git?.head ?? "unavailable"}
@@ -1586,20 +2386,20 @@ Git: ${git?.head ?? "unavailable"}
 ` + receipt2.assertions.map((a) => `- ${a.passed ? "PASS" : "FAIL"} ${a.service}${a.path}: expected ${a.count}, observed ${a.actual}`).join("\n") + "\n\nSee run.json for activities, fault and initial/final state.\n");
       return { ...receipt2, reportPath, evidencePath };
     }
-    const worker = join7(dirname(fileURLToPath2(import.meta.url)), "worker.js");
-    await copyFile(worker, join7(stage, "worker.js"));
+    const worker = join11(dirname(fileURLToPath2(import.meta.url)), "worker.js");
+    await copyFile(worker, join11(stage, "worker.js"));
     if (runtime === "hosted") {
       const receipt2 = await executeRemote(stage, spec, opts.log, { git, project });
       if (receipt2.schema !== "agenttwin/run-v1" || typeof receipt2.runId !== "string" || !/^[a-f0-9-]{36}$/.test(receipt2.runId) || !["passed", "failed", "error", "incomplete"].includes(String(receipt2.status))) throw new CliError("Invalid hosted receipt");
-      const expectedSpec = createHash("sha256").update(JSON.stringify(spec)).digest("hex");
+      const expectedSpec = createHash4("sha256").update(JSON.stringify(spec)).digest("hex");
       const reportedSources = receipt2.sourceDigests;
-      if (receipt2.specDigest !== expectedSpec || !reportedSources || Object.keys(reportedSources).length !== Object.keys(sourceDigests).length || Object.entries(sourceDigests).some(([path, digest]) => reportedSources[path] !== digest)) throw new CliError("Hosted receipt does not match the submitted source/specification");
-      const out2 = resolve(cwd, opts.out ?? `.agenttwin/runs/${receipt2.runId}`);
-      await mkdir2(out2, { recursive: true });
-      const evidencePath = join7(out2, "run.json");
-      const reportPath = join7(out2, "report.md");
-      await writeFile3(evidencePath, JSON.stringify(receipt2, null, 2) + "\n", { mode: 384 });
-      await writeFile3(reportPath, `# ${spec.name}: ${receipt2.status}
+      if (receipt2.specDigest !== expectedSpec || !reportedSources || Object.keys(reportedSources).length !== Object.keys(sourceDigests).length || Object.entries(sourceDigests).some(([path2, digest2]) => reportedSources[path2] !== digest2)) throw new CliError("Hosted receipt does not match the submitted source/specification");
+      const out2 = resolve2(cwd, opts.out ?? `.agenttwin/runs/${receipt2.runId}`);
+      await mkdir5(out2, { recursive: true });
+      const evidencePath = join11(out2, "run.json");
+      const reportPath = join11(out2, "report.md");
+      await writeFile7(evidencePath, JSON.stringify(receipt2, null, 2) + "\n", { mode: 384 });
+      await writeFile7(reportPath, `# ${spec.name}: ${receipt2.status}
 
 Run: ${receipt2.runId}
 
@@ -1629,26 +2429,26 @@ See run.json for assertions, service state, application output and isolation met
       image,
       templateBuildId,
       sourceDigests,
-      specDigest: createHash("sha256").update(JSON.stringify(spec)).digest("hex"),
+      specDigest: createHash4("sha256").update(JSON.stringify(spec)).digest("hex"),
       isolation
     };
-    const out = resolve(cwd, opts.out ?? `.agenttwin/runs/${runId}`);
-    await mkdir2(out, { recursive: true });
-    await writeFile3(join7(out, "run.json"), JSON.stringify(receipt, null, 2) + "\n", { mode: 384 });
-    await writeFile3(join7(out, "world.json"), JSON.stringify(spec, null, 2) + "\n", { mode: 384 });
+    const out = resolve2(cwd, opts.out ?? `.agenttwin/runs/${runId}`);
+    await mkdir5(out, { recursive: true });
+    await writeFile7(join11(out, "run.json"), JSON.stringify(receipt, null, 2) + "\n", { mode: 384 });
+    await writeFile7(join11(out, "world.json"), JSON.stringify(spec, null, 2) + "\n", { mode: 384 });
     const summary = [`# ${spec.name}: ${report.status}`, "", `Run: ${runId}`, `Image: ${image}`, "", "## Assertions", "", ...report.assertions.map((a) => `- ${a.passed ? "PASS" : "FAIL"} ${a.service}${a.path}: expected ${a.count}, observed ${a.actual}`), "", "## Infrastructure assertions", "", ...(report.infrastructureAssertions ?? []).map((a) => `- ${a.passed ? "PASS" : "FAIL"} ${a.service}: ${JSON.stringify(a.actual)}`), "", "## Coverage", "", report.coverage, "", "External networking disabled. Only explicitly listed source files were uploaded. New state and tokens are created for each run.", "", "See run.json for application output, faults, events, and initial/final state.", ""].join("\n");
-    await writeFile3(join7(out, "report.md"), summary);
-    return { ...receipt, reportPath: join7(out, "report.md"), evidencePath: join7(out, "run.json") };
+    await writeFile7(join11(out, "report.md"), summary);
+    return { ...receipt, reportPath: join11(out, "report.md"), evidencePath: join11(out, "run.json") };
   } finally {
-    await rm(stage, { recursive: true, force: true });
+    await rm3(stage, { recursive: true, force: true });
   }
 }
 
 // src/runtime/gateway.ts
-var hash = (value) => createHash2("sha256").update(value).digest("hex");
-function uploadPath(path) {
-  if (!path || path.startsWith("/") || path.includes("\\") || path.includes("\0") || path.split("/").some((p) => !p || p === "." || p === ".." || /^(\.env.*|\.git|\.ssh|\.aws|\.azure|\.config|\.npmrc|\.netrc|credentials.*)$/i.test(p)) || /\.(pem|key|p12|pfx)$/i.test(path)) throw new Error("Unsafe uploaded file path");
-  return path;
+var hash2 = (value) => createHash5("sha256").update(value).digest("hex");
+function uploadPath(path2) {
+  if (!path2 || path2.startsWith("/") || path2.includes("\\") || path2.includes("\0") || path2.split("/").some((p) => !p || p === "." || p === ".." || /^(\.env.*|\.git|\.ssh|\.aws|\.azure|\.config|\.npmrc|\.netrc|credentials.*)$/i.test(p)) || /\.(pem|key|p12|pfx)$/i.test(path2)) throw new Error("Unsafe uploaded file path");
+  return path2;
 }
 async function body(req, limit = 28 * 1024 * 1024) {
   const chunks = [];
@@ -1661,30 +2461,44 @@ async function body(req, limit = 28 * 1024 * 1024) {
   return JSON.parse(Buffer.concat(chunks).toString("utf8"));
 }
 function send(res, code, value) {
-  res.writeHead(code, { "content-type": "application/json", "cache-control": "no-store" });
+  res.writeHead(code, {
+    "content-type": "application/json",
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff",
+    "referrer-policy": "no-referrer",
+    "x-frame-options": "DENY",
+    "content-security-policy": "default-src 'none'; frame-ancestors 'none'"
+  });
   res.end(JSON.stringify(value));
 }
 function equal(a, b) {
-  const x = Buffer.from(hash(a)), y = Buffer.from(hash(b));
-  return timingSafeEqual(x, y);
+  const x = Buffer.from(hash2(a)), y = Buffer.from(hash2(b));
+  return timingSafeEqual4(x, y);
 }
 async function startGateway(opts) {
   if (opts.adminToken.length < 40) throw new Error("AGENTTWIN_ADMIN_TOKEN must have at least 40 characters");
+  const socialAuth = createSocialAuth(opts.socialAuth);
+  const emailVerification = createEmailVerification(opts.emailVerification, opts.adminToken);
   const allowedOrigins = new Set(opts.allowedOrigins ?? []);
   for (const origin of allowedOrigins) {
     const u = new URL(origin);
     if (u.origin !== origin || u.protocol !== "https:" && !(u.protocol === "http:" && ["127.0.0.1", "localhost"].includes(u.hostname))) throw new Error("Invalid dashboard origin");
   }
+  const verificationUrl = opts.verificationUrl ?? "https://agenttwin.si/onboarding/";
+  if (opts.verificationUrl) {
+    const target = new URL(verificationUrl);
+    if (!allowedOrigins.has(target.origin) || target.pathname !== "/onboarding/" || target.search || target.hash || target.username || target.password) throw new Error("Invalid device verification URL");
+  }
   const controllers = /* @__PURE__ */ new Map();
   const chatTasks = /* @__PURE__ */ new Set();
   const chatControllers = /* @__PURE__ */ new Map();
   const voiceControllers = /* @__PURE__ */ new Map();
-  const directory = resolve2(opts.directory);
-  await mkdir3(directory, { recursive: true, mode: 448 });
-  const storePath = join8(directory, "state.json");
+  const directory = resolve3(opts.directory);
+  await mkdir6(directory, { recursive: true, mode: 448 });
+  const storePath2 = join12(directory, "state.json");
   let store;
   try {
-    store = JSON.parse(await readFile8(storePath, "utf8"));
+    store = JSON.parse(await readFile11(storePath2, "utf8"));
     if (store.schema !== "agenttwin/gateway-v1") throw new Error("Invalid store");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
@@ -1699,9 +2513,9 @@ async function startGateway(opts) {
   const save = () => {
     const snapshot = JSON.stringify(store);
     writes = writes.then(async () => {
-      const path = join8(directory, `state-${randomUUID2()}.tmp`);
-      await writeFile4(path, snapshot, { mode: 384 });
-      await rename(path, storePath);
+      const path2 = join12(directory, `state-${randomUUID2()}.tmp`);
+      await writeFile8(path2, snapshot, { mode: 384 });
+      await rename(path2, storePath2);
     }).catch((error) => {
       storageHealthy = false;
       throw error;
@@ -1734,16 +2548,16 @@ async function startGateway(opts) {
           if (!store.accounts.some((a) => a.id === item.job.accountId && a.active)) throw new Error("Account revoked before execution");
           item.job.status = "running";
           await save();
-          workspace = await mkdtemp2(join8(tmpdir2(), "agenttwin-api-run-"));
+          workspace = await mkdtemp3(join12(tmpdir3(), "agenttwin-api-run-"));
           for (const [file, encoded] of Object.entries(item.files)) {
-            const destination = join8(workspace, uploadPath(file));
-            await mkdir3(dirname2(destination), { recursive: true });
-            await writeFile4(destination, Buffer.from(encoded, "base64"), { mode: 384 });
+            const destination = join12(workspace, uploadPath(file));
+            await mkdir6(dirname2(destination), { recursive: true });
+            await writeFile8(destination, Buffer.from(encoded, "base64"), { mode: 384 });
           }
-          await writeFile4(join8(workspace, "agenttwin.world.json"), JSON.stringify(item.spec));
+          await writeFile8(join12(workspace, "agenttwin.world.json"), JSON.stringify(item.spec));
           if (item.spec.workflowId) {
-            await mkdir3(join8(workspace, ".agenttwin"));
-            await writeFile4(join8(workspace, ".agenttwin/inventory.json"), JSON.stringify({ workflows: [{ id: item.spec.workflowId }] }));
+            await mkdir6(join12(workspace, ".agenttwin"));
+            await writeFile8(join12(workspace, ".agenttwin/inventory.json"), JSON.stringify({ workflows: [{ id: item.spec.workflowId }] }));
           }
           const receipt = await runWorld(workspace, { runtime: "e2b", signal: controllers.get(item.job.id)?.signal, log: () => {
           } });
@@ -1757,7 +2571,7 @@ async function startGateway(opts) {
           item.job.error = message.split(process.env.E2B_API_KEY ?? "\0").join("[redacted]").replace(/(?:postgresql|redis):\/\/[^\s]+/g, "[test-connection]").slice(0, 2e3);
         } finally {
           try {
-            if (workspace) await rm2(workspace, { recursive: true, force: true });
+            if (workspace) await rm4(workspace, { recursive: true, force: true });
             await save();
           } finally {
             controllers.delete(item.job.id);
@@ -1771,24 +2585,29 @@ async function startGateway(opts) {
       });
     }
   }
+  const authAttempts = /* @__PURE__ */ new Map();
+  const passkeyChallenges = {};
+  const devices = /* @__PURE__ */ new Map();
+  let hashing = 0;
+  const dummyPassword = randomBytes6(16).toString("hex") + ":" + randomBytes6(64).toString("hex");
   const server = createServer2(async (req, res) => {
     try {
       const requestUrl = new URL(req.url ?? "/", "http://localhost");
-      const path = requestUrl.pathname;
-      if (opts.dashboardDirectory && req.method === "GET" && (path === "/dashboard" || path.startsWith("/dashboard/"))) {
-        if (path === "/dashboard") {
+      const path2 = requestUrl.pathname;
+      if (opts.dashboardDirectory && req.method === "GET" && (path2 === "/dashboard" || path2.startsWith("/dashboard/"))) {
+        if (path2 === "/dashboard") {
           res.writeHead(302, { location: "/dashboard/" });
           res.end();
           return;
         }
-        const relative3 = decodeURIComponent(path.slice("/dashboard/".length)) || "index.html";
-        const root = resolve2(opts.dashboardDirectory), file = resolve2(root, relative3);
+        const relative3 = decodeURIComponent(path2.slice("/dashboard/".length)) || "index.html";
+        const root = resolve3(opts.dashboardDirectory), file = resolve3(root, relative3);
         if (!file.startsWith(root + "/") || relative3 !== "index.html" && !relative3.startsWith("assets/")) {
           send(res, 404, { error: "not_found" });
           return;
         }
         try {
-          const bytes = await readFile8(file);
+          const bytes = await readFile11(file);
           const types = { ".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8", ".css": "text/css; charset=utf-8", ".json": "application/json", ".svg": "image/svg+xml", ".png": "image/png", ".jpg": "image/jpeg", ".ico": "image/x-icon", ".woff2": "font/woff2" };
           res.writeHead(200, { "content-type": types[extname(file)] ?? "application/octet-stream", "cache-control": "no-store", "x-content-type-options": "nosniff", "referrer-policy": "no-referrer" });
           res.end(bytes);
@@ -1805,6 +2624,7 @@ async function startGateway(opts) {
         }
         res.setHeader("Access-Control-Allow-Origin", origin);
         res.setHeader("Vary", "Origin");
+        res.setHeader("Access-Control-Allow-Credentials", "true");
         if (req.method === "OPTIONS") {
           res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
           res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
@@ -1814,7 +2634,7 @@ async function startGateway(opts) {
           return;
         }
       }
-      if (path === "/healthz" && req.method === "GET") {
+      if (path2 === "/healthz" && req.method === "GET") {
         send(res, 200, { status: stopping ? "stopping" : "ok" });
         return;
       }
@@ -1823,8 +2643,402 @@ async function startGateway(opts) {
         return;
       }
       const token = req.headers.authorization?.replace(/^Bearer /, "") ?? "";
+      const cookieToken = req.headers.cookie?.split(";").map((v) => v.trim()).find((v) => v.startsWith("at_session="))?.slice(11) ?? "";
+      const session = store.sessions?.find((s) => s.hash === digest(cookieToken) && s.expires > Date.now());
+      if (cookieToken && !token && !["GET", "HEAD", "OPTIONS"].includes(req.method ?? "") && (!origin || !allowedOrigins.has(origin))) {
+        send(res, 403, { error: "origin_required" });
+        return;
+      }
+      const setCookie = (value, age) => {
+        const local = opts.host === "127.0.0.1" || opts.host === "localhost";
+        res.setHeader("Set-Cookie", `at_session=${value}; Path=/; HttpOnly; Max-Age=${age}; SameSite=${local ? "Lax" : "None"}${local ? "" : "; Secure"}`);
+      };
+      const profile = (a) => ({ accountId: a.id, email: a.identity?.email, name: a.identity?.name ?? a.label, workspace: a.label, workspaceProfile: a.workspaceProfile, passwordEnabled: !!a.identity?.passwordHash, passwordSetupAllowed: !a.identity?.passwordHash && !!a.externalIdentities?.some((i) => i.provider === "google") });
+      if (path2 === "/v1/dev/workspace" && req.method === "GET" && opts.localDevelopment && ["127.0.0.1", "localhost"].includes(opts.host ?? "") && verificationUrl === "http://localhost:3000/onboarding/") {
+        send(res, 200, { schema: "agenttwin/local-workspace-v1", dashboard: verificationUrl });
+        return;
+      }
+      if (path2 === "/v1/auth/providers" && req.method === "GET") {
+        send(res, 200, { providers: socialAuth.providers(), emailVerification: emailVerification.enabled });
+        return;
+      }
+      const emailCookie = req.headers.cookie?.split(";").map((value) => value.trim()).find((value) => value.startsWith("at_email="))?.slice(9) ?? "";
+      const [emailChallengeId, emailBinding] = emailCookie.split(".");
+      const emailGrant = store.emailChallenges?.[emailChallengeId ?? ""];
+      const setEmailCookie = (value, age) => {
+        const local = opts.host === "127.0.0.1" || opts.host === "localhost";
+        return `at_email=${value}; Path=/v1/auth/; HttpOnly; Max-Age=${age}; SameSite=${local ? "Lax" : "None"}${local ? "" : "; Secure"}`;
+      };
+      if (path2 === "/v1/auth/email/start" && req.method === "POST") {
+        if (!origin || !allowedOrigins.has(origin)) {
+          send(res, 403, { error: "origin_required" });
+          return;
+        }
+        if (!emailVerification.enabled) {
+          send(res, 503, { error: "Email verification is not available yet. Please use Google sign-in." });
+          return;
+        }
+        let email;
+        try {
+          email = normalizedEmail((await body(req, 8192)).email);
+        } catch {
+          send(res, 400, { error: "Enter a valid email address." });
+          return;
+        }
+        store.emailChallenges ??= {};
+        for (const [id, challenge] of Object.entries(store.emailChallenges)) if (challenge.expires <= Date.now()) delete store.emailChallenges[id];
+        for (const [key, limit] of authAttempts) if (limit.until <= Date.now()) authAttempts.delete(key);
+        const keys = ["email-send:" + digest(email), "email-ip:" + digest(req.socket.remoteAddress ?? "unknown")];
+        if (Object.keys(store.emailChallenges).length >= 1e3 || authAttempts.size >= 1e4 || keys.some((key, index) => (authAttempts.get(key)?.count ?? 0) >= (index === 0 ? 5 : 20)) || Object.values(store.emailChallenges).some((challenge) => challenge.email === email && Date.now() - challenge.sentAt < 6e4)) {
+          send(res, 429, { error: "Please wait before requesting another code." });
+          return;
+        }
+        for (const key of keys) {
+          const limit = authAttempts.get(key) ?? { count: 0, until: Date.now() + 15 * 6e4 };
+          limit.count++;
+          authAttempts.set(key, limit);
+        }
+        const flow = emailVerification.challenge(email, origin);
+        for (const [id, challenge] of Object.entries(store.emailChallenges)) if (challenge.email === email) delete store.emailChallenges[id];
+        store.emailChallenges[flow.id] = flow.challenge;
+        await save();
+        try {
+          await emailVerification.deliver(email, flow.code, flow.id);
+        } catch {
+          delete store.emailChallenges[flow.id];
+          await save();
+          send(res, 503, { error: "Could not send your verification code. Please try again shortly." });
+          return;
+        }
+        res.setHeader("Set-Cookie", setEmailCookie(flow.id + "." + flow.binding, 600));
+        send(res, 200, { sent: true, expiresIn: 600, retryAfter: 60 });
+        return;
+      }
+      if (path2 === "/v1/auth/email/verify" && req.method === "POST") {
+        if (!origin || !allowedOrigins.has(origin)) {
+          send(res, 403, { error: "origin_required" });
+          return;
+        }
+        if (!emailVerification.enabled || !emailVerification.bound(emailGrant, emailBinding ?? "", origin)) {
+          send(res, 400, { error: "Verification expired. Request a new code." });
+          return;
+        }
+        const input = await body(req, 8192);
+        const valid = emailVerification.verify(emailChallengeId, emailGrant, input.code);
+        await save();
+        if (!valid) {
+          send(res, 400, { error: "The code is incorrect or expired. Request a new code after five unsuccessful attempts." });
+          return;
+        }
+        send(res, 200, { verified: true });
+        return;
+      }
+      const oauthStart = path2.match(/^\/v1\/auth\/oauth\/(google|github|sso)\/start$/);
+      if (oauthStart && req.method === "POST") {
+        if (!origin || !allowedOrigins.has(origin)) {
+          send(res, 403, { error: "origin_required" });
+          return;
+        }
+        const key = "oauth:" + (req.socket.remoteAddress ?? "unknown");
+        for (const [k, value] of authAttempts) if (value.until < Date.now()) authAttempts.delete(k);
+        const limit = authAttempts.get(key) ?? { count: 0, until: Date.now() + 6e5 };
+        if (limit.count >= 20 || authAttempts.size >= 1e4) {
+          send(res, 429, { error: "Too many attempts. Try again shortly." });
+          return;
+        }
+        limit.count++;
+        authAttempts.set(key, limit);
+        const input = await body(req, 8192);
+        try {
+          const result = await socialAuth.begin(oauthStart[1], origin, input.signup === true, input.onboarding === true);
+          res.setHeader("Set-Cookie", `at_oauth=${result.binding}; Path=/v1/auth/oauth/; HttpOnly; Max-Age=600; SameSite=Lax${result.secure ? "; Secure" : ""}`);
+          send(res, 200, { url: result.url });
+        } catch (error) {
+          send(res, 503, { error: error instanceof Error && error.message === "provider_not_configured" ? "This sign-in provider has not been configured yet. Use email to continue." : "Could not start provider sign-in. Please try again." });
+        }
+        return;
+      }
+      const oauthCallback = path2.match(/^\/v1\/auth\/oauth\/(google|github|sso)\/callback$/);
+      if (oauthCallback && req.method === "GET") {
+        const binding = req.headers.cookie?.split(";").map((v) => v.trim()).find((v) => v.startsWith("at_oauth="))?.slice(9) ?? "";
+        let transaction;
+        try {
+          transaction = socialAuth.take(oauthCallback[1], requestUrl.searchParams, binding);
+        } catch {
+          send(res, 400, { error: "Sign-in expired or belongs to another browser. Start again from the login page." });
+          return;
+        }
+        const secure = opts.socialAuth?.publicUrl.startsWith("https:");
+        const clearBinding = `at_oauth=; Path=/v1/auth/oauth/; HttpOnly; Max-Age=0; SameSite=Lax${secure ? "; Secure" : ""}`;
+        const redirect = (path3) => {
+          res.writeHead(303, { Location: transaction.origin + path3, "Cache-Control": "no-store", "Referrer-Policy": "no-referrer" });
+          res.end();
+        };
+        res.setHeader("Set-Cookie", clearBinding);
+        try {
+          const identity = await socialAuth.finish(transaction, requestUrl.searchParams);
+          let owner = store.accounts.find((a) => a.externalIdentities?.some((i) => i.provider === identity.provider && i.issuer === identity.issuer && i.subject === identity.subject));
+          let created = false;
+          if (!owner) {
+            if (store.accounts.some((a) => a.identity?.email === identity.email)) {
+              redirect((transaction.signup ? "/signup/" : "/login/") + "?auth_error=existing_account");
+              return;
+            }
+            if (store.accounts.length >= 1e4) throw new Error("account_capacity");
+            owner = { id: randomUUID2(), tokenHash: hash2(randomBytes6(32).toString("hex")), label: identity.name + "'s workspace", active: true, usageDay: "", runs: 0, identity: { email: identity.email, name: identity.name }, externalIdentities: [{ provider: identity.provider, issuer: identity.issuer, subject: identity.subject }] };
+            store.accounts.push(owner);
+            created = true;
+          }
+          if (!owner.active) throw new Error("account_inactive");
+          const secret = randomBytes6(32).toString("hex");
+          store.sessions = (store.sessions ?? []).filter((s) => s.expires > Date.now());
+          const owned = store.sessions.filter((s) => s.accountId === owner.id);
+          if (owned.length >= 10) store.sessions = store.sessions.filter((s) => s !== owned[0]);
+          store.sessions.push({ accountId: owner.id, hash: digest(secret), expires: Date.now() + 7 * 864e5, authenticatedAt: Date.now(), method: identity.provider });
+          await save();
+          setCookie(secret, 7 * 86400);
+          res.setHeader("Set-Cookie", [String(res.getHeader("Set-Cookie")), clearBinding]);
+          redirect(created || transaction.signup || transaction.onboarding ? "/onboarding/" : "/dashboard/#home");
+        } catch (error) {
+          const reason = error instanceof Error && error.message === "verified_email_required" ? "verified_email" : "provider_failed";
+          redirect((transaction.signup ? "/signup/" : "/login/") + "?auth_error=" + reason);
+        }
+        return;
+      }
+      if (path2 === "/v1/auth/device" && req.method === "POST") {
+        for (const [k, v] of devices) if (v.expires < Date.now()) devices.delete(k);
+        if (devices.size >= 100) {
+          send(res, 429, { error: "Try again shortly." });
+          return;
+        }
+        const secret = randomBytes6(32).toString("hex"), code = randomBytes6(5).toString("hex").toUpperCase();
+        devices.set(digest(secret), { code, expires: Date.now() + 6e5, lastPoll: 0 });
+        send(res, 200, { deviceCode: secret, userCode: code, verificationUrl, expiresIn: 600 });
+        return;
+      }
+      if (path2 === "/v1/auth/passkey/options" && req.method === "POST") {
+        if (!origin || !allowedOrigins.has(origin)) {
+          send(res, 403, { error: "origin_required" });
+          return;
+        }
+        if (!session) {
+          send(res, 401, { error: "unauthorized" });
+          return;
+        }
+        const owner = store.accounts.find((a) => a.id === session.accountId && a.active);
+        if (!owner) {
+          send(res, 401, { error: "unauthorized" });
+          return;
+        }
+        const rpID = requestUrl.hostname === "localhost" || requestUrl.hostname === "127.0.0.1" ? "localhost" : new URL(origin).hostname;
+        const options = await generateRegistrationOptions({ rpName: "AgentTwin", rpID, userName: owner.identity?.email ?? owner.label, userDisplayName: owner.identity?.name ?? owner.label, excludeCredentials: (owner.passkeys ?? []).map((k) => ({ id: k.id })) });
+        const challengeId = randomBytes6(16).toString("hex");
+        challengeStore(passkeyChallenges, challengeId, options.challenge, 12e4);
+        send(res, 200, { options, challengeId });
+        return;
+      }
+      if (path2 === "/v1/auth/passkey/register" && req.method === "POST") {
+        if (!origin || !allowedOrigins.has(origin)) {
+          send(res, 403, { error: "origin_required" });
+          return;
+        }
+        if (!session) {
+          send(res, 401, { error: "unauthorized" });
+          return;
+        }
+        const owner = store.accounts.find((a) => a.id === session.accountId && a.active);
+        if (!owner) {
+          send(res, 401, { error: "unauthorized" });
+          return;
+        }
+        const input = await body(req, 65536);
+        const stored = passkeyChallenges[String(input.challengeId)];
+        if (!stored) {
+          send(res, 400, { error: "Registration expired. Try again." });
+          return;
+        }
+        delete passkeyChallenges[String(input.challengeId)];
+        const rpID = requestUrl.hostname === "localhost" || requestUrl.hostname === "127.0.0.1" ? "localhost" : new URL(origin).hostname;
+        const verification = await verifyRegistrationResponse({ response: input.credential, expectedChallenge: stored.value, expectedOrigin: origin, expectedRPID: rpID, requireUserVerification: false });
+        if (!verification.verified || !verification.registrationInfo) {
+          send(res, 400, { error: "Passkey could not be verified. Try again." });
+          return;
+        }
+        const { credential } = verification.registrationInfo;
+        owner.passkeys = [...(owner.passkeys ?? []).filter((k) => k.id !== credential.id), { id: credential.id, publicKey: Buffer.from(credential.publicKey).toString("base64url"), counter: credential.counter, deviceType: verification.registrationInfo.credentialDeviceType, backedUp: verification.registrationInfo.credentialBackedUp, createdAt: (/* @__PURE__ */ new Date()).toISOString() }].slice(-10);
+        await save();
+        send(res, 200, { registered: true });
+        return;
+      }
+      if (path2 === "/v1/auth/passkey/auth/options" && req.method === "POST") {
+        if (!origin || !allowedOrigins.has(origin)) {
+          send(res, 403, { error: "origin_required" });
+          return;
+        }
+        const input = await body(req, 8192);
+        const credentialId = typeof input.credentialId === "string" ? input.credentialId.slice(0, 1024) : "";
+        const owner = credentialId ? store.accounts.find((a) => a.active && (a.passkeys ?? []).some((k) => k.id === credentialId)) : void 0;
+        const options = await generateAuthenticationOptions({ rpID: requestUrl.hostname === "localhost" || requestUrl.hostname === "127.0.0.1" ? "localhost" : new URL(origin).hostname, allowCredentials: credentialId && owner ? [{ id: credentialId }] : void 0, userVerification: "preferred" });
+        const challengeId = randomBytes6(16).toString("hex");
+        challengeStore(passkeyChallenges, challengeId, options.challenge, 12e4);
+        send(res, 200, { options, challengeId });
+        return;
+      }
+      if (path2 === "/v1/auth/passkey/auth" && req.method === "POST") {
+        if (!origin || !allowedOrigins.has(origin)) {
+          send(res, 403, { error: "origin_required" });
+          return;
+        }
+        const input = await body(req, 65536);
+        const stored = passkeyChallenges[String(input.challengeId)];
+        if (!stored) {
+          send(res, 400, { error: "Login expired. Try again." });
+          return;
+        }
+        delete passkeyChallenges[String(input.challengeId)];
+        const credentialId = String(input.credential?.id ?? "");
+        const owner = store.accounts.find((a) => a.active && (a.passkeys ?? []).some((k) => k.id === credentialId));
+        if (!owner) {
+          send(res, 401, { error: "No account matches this passkey. Sign in with email first." });
+          return;
+        }
+        const key = owner.passkeys.find((k) => k.id === credentialId);
+        const rpID = requestUrl.hostname === "localhost" || requestUrl.hostname === "127.0.0.1" ? "localhost" : new URL(origin).hostname;
+        const verification = await verifyAuthenticationResponse({ response: input.credential, expectedChallenge: stored.value, expectedOrigin: origin, expectedRPID: rpID, credential: { id: key.id, publicKey: Buffer.from(key.publicKey, "base64url"), counter: key.counter, transports: void 0 }, requireUserVerification: false });
+        if (!verification.verified) {
+          send(res, 401, { error: "Passkey verification failed." });
+          return;
+        }
+        key.counter = verification.authenticationInfo.newCounter;
+        const secret = randomBytes6(32).toString("hex");
+        store.sessions = (store.sessions ?? []).filter((s) => s.expires > Date.now());
+        const owned = store.sessions.filter((s) => s.accountId === owner.id);
+        if (owned.length >= 10) store.sessions = store.sessions.filter((s) => s !== owned[0]);
+        store.sessions.push({ accountId: owner.id, hash: digest(secret), expires: Date.now() + 7 * 864e5 });
+        await save();
+        setCookie(secret, 7 * 86400);
+        send(res, 200, { user: profile(owner) });
+        return;
+      }
+      if (path2 === "/v1/auth/device/poll" && req.method === "POST") {
+        const input = await body(req, 8192);
+        const device = typeof input.deviceCode === "string" ? devices.get(digest(input.deviceCode)) : void 0;
+        if (!device || device.expires < Date.now()) {
+          send(res, 410, { error: "Pairing expired. Run agenttwin login again." });
+          return;
+        }
+        if (Date.now() - device.lastPoll < 4e3) {
+          send(res, 429, { error: "slow_down" });
+          return;
+        }
+        device.lastPoll = Date.now();
+        if (!storageHealthy) {
+          send(res, 503, { error: "storage_unavailable" });
+          return;
+        }
+        if (!device.token) {
+          send(res, 202, { pending: true });
+          return;
+        }
+        const owner = store.accounts.find((a) => a.id === device.accountId && a.active);
+        if (!owner) {
+          send(res, 401, { error: "unauthorized" });
+          return;
+        }
+        devices.delete(digest(input.deviceCode));
+        send(res, 200, { token: device.token, workspace: owner.label });
+        return;
+      }
+      if (["/v1/auth/signup", "/v1/auth/login"].includes(path2) && req.method === "POST") {
+        if (!origin || !allowedOrigins.has(origin)) {
+          send(res, 403, { error: "origin_required" });
+          return;
+        }
+        const key = req.socket.remoteAddress ?? "unknown";
+        for (const [k, v] of authAttempts) if (v.until < Date.now()) authAttempts.delete(k);
+        const limit = authAttempts.get(key) ?? { count: 0, until: Date.now() + 15 * 6e4 };
+        if (limit.count >= 120 || hashing >= 2 || authAttempts.size >= 1e4) {
+          send(res, 429, { error: "Too many attempts. Try again in 15 minutes." });
+          return;
+        }
+        limit.count++;
+        authAttempts.set(key, limit);
+        let input, parsed;
+        try {
+          input = await body(req, 8192);
+          parsed = credentials(input);
+        } catch {
+          send(res, 400, { error: "Use a valid email and a password with 12\u2013128 characters." });
+          return;
+        }
+        if (emailVerification.enabled && (!emailGrant?.verified || emailGrant.email !== parsed.email || !emailVerification.bound(emailGrant, emailBinding ?? "", origin))) {
+          send(res, 403, { error: "Verify your email with a one-time code before continuing.", code: "email_verification_required" });
+          return;
+        }
+        const emailKey = "email:" + digest(parsed.email);
+        const emailLimit = authAttempts.get(emailKey) ?? { count: 0, until: Date.now() + 15 * 6e4 };
+        if (emailLimit.count >= 10) {
+          send(res, 429, { error: "Too many attempts. Try again in 15 minutes." });
+          return;
+        }
+        emailLimit.count++;
+        authAttempts.set(emailKey, emailLimit);
+        hashing++;
+        try {
+          let a = store.accounts.find((a2) => a2.identity?.email === parsed.email);
+          if (path2.endsWith("/signup")) {
+            const name = typeof input.name === "string" ? input.name.trim() : "";
+            const workspace = typeof input.workspace === "string" ? input.workspace.trim() : "";
+            if (!name || name.length > 100 || !workspace || workspace.length > 100) {
+              send(res, 400, { error: "Enter your name and workspace name." });
+              return;
+            }
+            const encoded = await passwordHash(parsed.password);
+            if (emailVerification.enabled && (store.emailChallenges?.[emailChallengeId] !== emailGrant || !emailVerification.bound(emailGrant, emailBinding ?? "", origin))) {
+              send(res, 403, { error: "Email verification expired. Request a new code." });
+              return;
+            }
+            if (store.accounts.some((a2) => a2.identity?.email === parsed.email)) {
+              send(res, 409, { error: "Unable to create account. Try signing in instead." });
+              return;
+            }
+            if (store.accounts.length >= 1e4) {
+              send(res, 429, { error: "account_capacity" });
+              return;
+            }
+            a = { id: randomUUID2(), tokenHash: hash2(randomBytes6(32).toString("hex")), label: workspace, active: true, usageDay: "", runs: 0, identity: { email: parsed.email, name, passwordHash: encoded } };
+            store.accounts.push(a);
+          } else {
+            const matches2 = await passwordMatches(parsed.password, a?.identity?.passwordHash ?? dummyPassword);
+            if (!a?.active || !a.identity?.passwordHash || !matches2) {
+              send(res, 401, { error: "Email or password is incorrect." });
+              return;
+            }
+          }
+          const secret = randomBytes6(32).toString("hex");
+          store.sessions = (store.sessions ?? []).filter((s) => s.expires > Date.now());
+          const owned = store.sessions.filter((s) => s.accountId === a.id);
+          if (owned.length >= 10) store.sessions = store.sessions.filter((s) => s !== owned[0]);
+          if (emailVerification.enabled) {
+            if (store.emailChallenges?.[emailChallengeId] !== emailGrant || !emailVerification.bound(emailGrant, emailBinding ?? "", origin)) {
+              send(res, 403, { error: "Email verification expired. Request a new code." });
+              return;
+            }
+            delete store.emailChallenges[emailChallengeId];
+            a.identity.emailVerified = true;
+          }
+          store.sessions.push({ accountId: a.id, hash: digest(secret), expires: Date.now() + 7 * 864e5 });
+          await save();
+          setCookie(secret, 7 * 86400);
+          if (emailVerification.enabled) res.setHeader("Set-Cookie", [String(res.getHeader("Set-Cookie")), setEmailCookie("", 0)]);
+          send(res, 200, { user: profile(a) });
+          return;
+        } finally {
+          hashing--;
+        }
+      }
       const admin = equal(token, opts.adminToken);
-      if (path === "/v1/accounts" && req.method === "POST") {
+      if (path2 === "/v1/accounts" && req.method === "POST") {
         if (!admin) {
           send(res, 401, { error: "unauthorized" });
           return;
@@ -1834,8 +3048,8 @@ async function startGateway(opts) {
           send(res, 400, { error: "label_required" });
           return;
         }
-        const accessToken = `at_user_${randomBytes3(32).toString("hex")}`;
-        const account2 = { id: randomUUID2(), tokenHash: hash(accessToken), label: data.label, active: true, usageDay: "", runs: 0 };
+        const accessToken = `at_user_${randomBytes6(32).toString("hex")}`;
+        const account2 = { id: randomUUID2(), tokenHash: hash2(accessToken), label: data.label, active: true, usageDay: "", runs: 0 };
         if (store.accounts.length >= 1e4) {
           send(res, 429, { error: "account_capacity" });
           return;
@@ -1845,7 +3059,7 @@ async function startGateway(opts) {
         send(res, 201, { accountId: account2.id, token: accessToken });
         return;
       }
-      const revoke = path.match(/^\/v1\/accounts\/([a-f0-9-]{36})$/);
+      const revoke = path2.match(/^\/v1\/accounts\/([a-f0-9-]{36})$/);
       if (revoke && req.method === "DELETE") {
         if (!admin) {
           send(res, 401, { error: "unauthorized" });
@@ -1861,21 +3075,140 @@ async function startGateway(opts) {
         send(res, 200, { revoked: true });
         return;
       }
-      const account = store.accounts.find((a) => a.active && a.tokenHash === hash(token));
+      const account = store.accounts.find((a) => a.active && (token ? a.tokenHash === hash2(token) || a.cliTokens?.includes(hash2(token)) : a.id === session?.accountId));
       if (!account) {
         send(res, 401, { error: "unauthorized" });
         return;
       }
+      if (path2 === "/v1/auth/password" && req.method === "POST") {
+        if (token || !session || !account.identity || !origin || !allowedOrigins.has(origin)) {
+          send(res, 403, { error: "browser_session_required" });
+          return;
+        }
+        if (account.identity.passwordHash) {
+          send(res, 409, { error: "A password is already set. Use email and password to sign in." });
+          return;
+        }
+        const recentlyAuthenticated = () => session.method === "google" && typeof session.authenticatedAt === "number" && Date.now() - session.authenticatedAt >= 0 && Date.now() - session.authenticatedAt < 10 * 6e4;
+        if (!recentlyAuthenticated() || !account.externalIdentities?.some((i) => i.provider === "google")) {
+          send(res, 403, { error: "Sign in with Google again, then create your password within 10 minutes.", code: "reauthentication_required" });
+          return;
+        }
+        let parsed;
+        try {
+          const input = await body(req, 8192);
+          parsed = credentials({ email: account.identity.email, password: input.password });
+        } catch {
+          send(res, 400, { error: "Use a password with 12\u2013128 characters." });
+          return;
+        }
+        if (hashing >= 2) {
+          send(res, 429, { error: "Please try again shortly." });
+          return;
+        }
+        hashing++;
+        try {
+          const encoded = await passwordHash(parsed.password);
+          if (account.identity.passwordHash) {
+            send(res, 409, { error: "A password is already set." });
+            return;
+          }
+          if (!account.active || !store.sessions?.includes(session) || session.expires <= Date.now() || !recentlyAuthenticated()) {
+            send(res, 403, { error: "Sign in with Google again before creating a password.", code: "reauthentication_required" });
+            return;
+          }
+          const previousIdentity = account.identity, previousSessions = store.sessions;
+          const secret = randomBytes6(32).toString("hex");
+          account.identity = { ...account.identity, passwordHash: encoded };
+          store.sessions = [...store.sessions.filter((s) => s.accountId !== account.id), { accountId: account.id, hash: digest(secret), expires: Date.now() + 7 * 864e5 }];
+          try {
+            await save();
+          } catch (error) {
+            account.identity = previousIdentity;
+            store.sessions = previousSessions;
+            throw error;
+          }
+          setCookie(secret, 7 * 86400);
+          send(res, 200, { user: profile(account) });
+          return;
+        } finally {
+          hashing--;
+        }
+      }
+      if (path2 === "/v1/auth/token/revoke" && req.method === "POST") {
+        if (!token) {
+          send(res, 400, { error: "terminal_token_required" });
+          return;
+        }
+        account.cliTokens = (account.cliTokens ?? []).filter((t) => t !== hash2(token));
+        if (account.tokenHash === hash2(token)) account.tokenHash = hash2(randomBytes6(32).toString("hex"));
+        await save();
+        send(res, 200, { signedOut: true });
+        return;
+      }
+      if (path2 === "/v1/auth/device/approve" && req.method === "POST") {
+        const input = await body(req, 8192);
+        const code = typeof input.userCode === "string" ? input.userCode.trim().toUpperCase() : "";
+        const device = [...devices.values()].find((d) => d.code === code && d.expires > Date.now() && !d.accountId);
+        if (!device) {
+          send(res, 400, { error: "Code not found or expired. Run agenttwin login again." });
+          return;
+        }
+        const accessToken = `at_user_${randomBytes6(32).toString("hex")}`;
+        account.cliTokens = [...(account.cliTokens ?? []).slice(-9), hash2(accessToken)];
+        device.accountId = account.id;
+        await save();
+        device.token = accessToken;
+        send(res, 200, { connected: true, workspace: account.label });
+        return;
+      }
+      if (path2 === "/v1/auth/profile" && req.method === "POST") {
+        if (token || !session || !account.identity) {
+          send(res, 403, { error: "browser_session_required" });
+          return;
+        }
+        const input = await body(req, 8192);
+        let validated;
+        try {
+          validated = validateWorkspaceProfile(input);
+        } catch (error) {
+          send(res, 400, { error: error instanceof Error ? error.message : "Invalid profile." });
+          return;
+        }
+        const previous = { label: account.label, identity: account.identity, workspaceProfile: account.workspaceProfile };
+        account.label = validated.workspace;
+        account.identity = { ...account.identity, name: validated.name };
+        account.workspaceProfile = { ...validated.context, ...validated.complete ? { completedAt: (/* @__PURE__ */ new Date()).toISOString() } : account.workspaceProfile?.completedAt ? { completedAt: account.workspaceProfile.completedAt } : {} };
+        try {
+          await save();
+        } catch (error) {
+          Object.assign(account, previous);
+          throw error;
+        }
+        send(res, 200, { user: profile(account) });
+        return;
+      }
+      if (path2 === "/v1/auth/me" && req.method === "GET") {
+        send(res, 200, { user: profile(account) });
+        return;
+      }
+      if (path2 === "/v1/auth/logout" && req.method === "POST") {
+        store.sessions = (store.sessions ?? []).filter((s) => s !== session);
+        await save();
+        setCookie("", 0);
+        send(res, 200, { signedOut: true });
+        return;
+      }
       const projectInventories = [...store.projectDiscoveries?.[account.id] ?? []];
       const latestInventory = store.discoveries?.[account.id];
       if (latestInventory && !projectInventories.some((p) => p.name === latestInventory.name)) projectInventories.push(latestInventory);
       const requestedProject = requestUrl.searchParams.get("project");
       const selectedInventory = requestedProject === null ? latestInventory : projectInventories.find((p) => p.name === requestedProject);
-      if (path === "/v1/projects" && req.method === "GET") {
+      if (path2 === "/v1/projects" && req.method === "GET") {
         send(res, 200, { projects: projectInventories.map((p) => ({ name: p.name, tools: p.tools.length, workflows: p.workflows.length })), latest: latestInventory?.name ?? null });
         return;
       }
-      if (path === "/v1/discovery" && req.method === "GET") {
+      if (path2 === "/v1/discovery" && req.method === "GET") {
         if (requestedProject !== null && !selectedInventory) {
           send(res, 404, { error: "project_not_found" });
           return;
@@ -1883,7 +3216,7 @@ async function startGateway(opts) {
         send(res, 200, { inventory: selectedInventory ?? null });
         return;
       }
-      if (path === "/v1/discovery" && req.method === "POST") {
+      if (path2 === "/v1/discovery" && req.method === "POST") {
         if (stopping) {
           send(res, 503, { error: "stopping" });
           return;
@@ -1902,7 +3235,7 @@ async function startGateway(opts) {
         send(res, 200, { synced: true, tools: inventory.tools.length, workflows: inventory.workflows.length });
         return;
       }
-      if (path === "/v1/receipts" && req.method === "POST") {
+      if (path2 === "/v1/receipts" && req.method === "POST") {
         const receipt = portableLocalReceipt(await body(req));
         if (!projectInventories.some((p) => p.name === receipt.project)) {
           send(res, 409, { error: "sync_project_before_receipt" });
@@ -1929,11 +3262,11 @@ async function startGateway(opts) {
         send(res, 201, { id, synced: true });
         return;
       }
-      if (path === "/v1/runs" && req.method === "GET") {
-        send(res, 200, { jobs: store.jobs.filter((j) => j.accountId === account.id).sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt)).slice(0, 100).map(({ id, status, createdAt }) => ({ id, status, createdAt })) });
+      if (path2 === "/v1/runs" && req.method === "GET") {
+        send(res, 200, { jobs: store.jobs.filter((j) => j.accountId === account.id).sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt)).slice(0, 100).map((job) => ({ id: job.id, status: job.status, createdAt: job.createdAt, name: job.name ?? (typeof job.receipt?.name === "string" ? job.receipt.name : void 0), workflowId: job.workflowId ?? (typeof job.receipt?.workflowId === "string" ? job.receipt.workflowId : void 0), project: job.project ?? (typeof job.receipt?.project === "string" ? job.receipt.project : void 0) })) });
         return;
       }
-      if (path === "/v1/runs" && req.method === "POST") {
+      if (path2 === "/v1/runs" && req.method === "POST") {
         if (stopping) {
           send(res, 503, { error: "stopping" });
           return;
@@ -1957,6 +3290,10 @@ async function startGateway(opts) {
         }
         const input = await body(req);
         const spec = parseWorld(input.spec);
+        if (spec.browser || spec.background) {
+          send(res, 422, { error: "unsupported_runtime", message: "Browser recipes and background completion checks currently require the local runtime. No cloud job was queued." });
+          return;
+        }
         const git = validateGit(input.git);
         const project = input.project;
         if (project !== void 0 && (typeof project !== "string" || !projectInventories.some((p) => p.name === project))) {
@@ -1991,7 +3328,7 @@ async function startGateway(opts) {
           return;
         }
         store.jobs = store.jobs.filter((j) => Date.parse(j.createdAt) > Date.now() - 30 * 864e5);
-        const job = { id: randomUUID2(), accountId: account.id, status: "queued", createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+        const job = { id: randomUUID2(), accountId: account.id, status: "queued", createdAt: (/* @__PURE__ */ new Date()).toISOString(), name: spec.name, workflowId: spec.workflowId, project };
         account.runs++;
         store.jobs.push(job);
         await save();
@@ -2001,16 +3338,16 @@ async function startGateway(opts) {
         send(res, 202, { id: job.id, status: job.status });
         return;
       }
-      if ((path === "/v1/chat" || path === "/v1/workflows") && requestedProject !== null && !selectedInventory) {
+      if ((path2 === "/v1/chat" || path2 === "/v1/workflows") && requestedProject !== null && !selectedInventory) {
         send(res, 404, { error: "project_not_found" });
         return;
       }
-      if (path === "/v1/workflows" && req.method === "GET") {
+      if (path2 === "/v1/workflows" && req.method === "GET") {
         const project = selectedInventory?.name ?? null;
         send(res, 200, { project, workflows: (store.workflows ?? []).filter((w) => w.accountId === account.id && w.project === project) });
         return;
       }
-      if (path === "/v1/workflows" && req.method === "POST") {
+      if (path2 === "/v1/workflows" && req.method === "POST") {
         if (stopping) {
           send(res, 503, { error: "stopping" });
           return;
@@ -2054,13 +3391,13 @@ async function startGateway(opts) {
         send(res, 200, { workflow });
         return;
       }
-      if (path === "/v1/chat" && req.method === "GET") {
+      if (path2 === "/v1/chat" && req.method === "GET") {
         const project = selectedInventory?.name ?? null;
         const thread = store.chats?.find((t) => t.accountId === account.id && t.project === project);
         send(res, 200, { ...chatConfiguration(), transcription: transcriptionConfiguration(), project, thread: thread ?? null, busy: chatControllers.has(account.id) });
         return;
       }
-      if (path === "/v1/transcriptions" && req.method === "POST") {
+      if (path2 === "/v1/transcriptions" && req.method === "POST") {
         if (stopping) {
           send(res, 503, { error: "stopping" });
           return;
@@ -2116,7 +3453,7 @@ async function startGateway(opts) {
         }
         return;
       }
-      if (path === "/v1/chat" && req.method === "POST") {
+      if (path2 === "/v1/chat" && req.method === "POST") {
         if (stopping) {
           send(res, 503, { error: "stopping" });
           return;
@@ -2181,7 +3518,7 @@ async function startGateway(opts) {
         const controller = new AbortController();
         chatControllers.set(account.id, controller);
         const timeout = setTimeout(() => controller.abort(), 45e3);
-        const context = { project, discoveryDigest: inventory ? hash(JSON.stringify(inventory)) : null, jobId: job?.id ?? null };
+        const context = { project, discoveryDigest: inventory ? hash2(JSON.stringify(inventory)) : null, jobId: job?.id ?? null };
         thread.messages.push({ id: randomUUID2(), role: "user", content: input.content.trim(), requestId: input.requestId, createdAt: (/* @__PURE__ */ new Date()).toISOString(), context });
         try {
           await save();
@@ -2216,7 +3553,7 @@ async function startGateway(opts) {
         }
         return;
       }
-      const match = path.match(/^\/v1\/runs\/([a-f0-9-]{36})$/);
+      const match = path2.match(/^\/v1\/runs\/([a-f0-9-]{36})$/);
       if (match && req.method === "DELETE") {
         const job = store.jobs.find((j) => j.id === match[1] && j.accountId === account.id);
         if (!job) {
@@ -2260,6 +3597,7 @@ async function startGateway(opts) {
   });
   server.requestTimeout = 3e4;
   server.headersTimeout = 1e4;
+  server.maxHeadersCount = 64;
   await new Promise((done, reject) => {
     server.once("error", reject);
     server.listen(opts.port, opts.host ?? "127.0.0.1", done);