@voicelayer/sdk 0.1.10 → 0.2.0

package/dist/runtime/text-session.js

@@ -1,5 +1,9 @@
 import { z } from 'zod';
 import OpenAI from 'openai';
+import { AsyncLocalStorage } from 'async_hooks';
+import 'dns';
+import 'net';
+import '@opentelemetry/api';
 import 'quickjs-emscripten';
 import { setup, createActor } from 'xstate';
 import { randomUUID } from 'crypto';
@@ -14,6 +18,18 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/runtime/graph/log.ts
+function graphLog(event, fields) {
+  console.log(`[graph] ${event}`, { ...fields, t: Date.now() });
+}
+function graphWarn(event, fields) {
+  console.warn(`[graph] ${event}`, { ...fields, t: Date.now() });
+}
+var init_log = __esm({
+  "src/runtime/graph/log.ts"() {
+  }
+});
+
 // src/runtime/graph/graph-model.ts
 function buildGraphModel(program) {
   return {
@@ -43,11 +59,100 @@ var init_graph_model = __esm({
   }
 });
 
+// ../contracts/src/effect-stack.ts
+var EffectStack;
+var init_effect_stack = __esm({
+  "../contracts/src/effect-stack.ts"() {
+    EffectStack = class {
+      #disposers = [];
+      #disposed = false;
+      #draining = false;
+      #drain = null;
+      #onError;
+      constructor(options = {}) {
+        this.#onError = options.onDisposeError ?? ((error) => {
+          console.error("[EffectStack] disposer threw during teardown", error);
+        });
+      }
+      /**
+       * Register an acquire's inverse. Returns a handle that reverts THIS effect
+       * early (at most once). The handle is a no-op after it has fired and after
+       * dispose() has already drained the disposer.
+       */
+      defer(disposer) {
+        if (this.#disposed && !this.#draining) {
+          const ran = this.#run(disposer);
+          return async () => {
+            await ran;
+          };
+        }
+        this.#disposers.push(disposer);
+        let fired = false;
+        return async () => {
+          if (fired) return;
+          fired = true;
+          const i = this.#disposers.lastIndexOf(disposer);
+          if (i < 0) return;
+          this.#disposers.splice(i, 1);
+          await this.#run(disposer);
+        };
+      }
+      /** Number of pending disposers. */
+      get size() {
+        return this.#disposers.length;
+      }
+      get disposed() {
+        return this.#disposed;
+      }
+      /**
+       * Run every pending disposer in LIFO order, each awaited before the next.
+       * Idempotent AND concurrency-safe (contract 3): overlapping calls all await
+       * the one in-flight drain. A disposer that registers another disposer during
+       * teardown is drained too, in LIFO position.
+       */
+      async dispose() {
+        return this.#drain ??= this.#runDrain();
+      }
+      async #runDrain() {
+        this.#disposed = true;
+        this.#draining = true;
+        try {
+          for (let next = this.#disposers.pop(); next !== void 0; next = this.#disposers.pop()) {
+            await this.#run(next);
+          }
+        } finally {
+          this.#draining = false;
+        }
+      }
+      /** Enables `await using stack = new EffectStack()` on hosts that support it. */
+      async [Symbol.asyncDispose]() {
+        await this.dispose();
+      }
+      async #run(disposer) {
+        try {
+          await disposer();
+        } catch (error) {
+          this.#onError(error);
+        }
+      }
+    };
+  }
+});
+
 // ../contracts/src/primitive.ts
 var BasePrimitive;
 var init_primitive = __esm({
   "../contracts/src/primitive.ts"() {
+    init_effect_stack();
     BasePrimitive = class {
+      /**
+       * Instance-lifetime effects. Subclasses that acquire a connection, queue, or
+       * timer in their constructor register its inverse here via
+       * `this.effects.defer(...)`; `[Symbol.asyncDispose]()` replays them LIFO. This
+       * is the structural fix for "a primitive that opens a resource cannot close
+       * it" (GROUNDING F1) — per-call resources still use onCallEnd.
+       */
+      effects = new EffectStack();
       async onError(err, _ctx) {
         return {
           kind: "fail",
@@ -81,6 +186,10 @@ var init_primitive = __esm({
         return () => {
         };
       }
+      /** Release instance-lifetime resources. Idempotent. */
+      async [Symbol.asyncDispose]() {
+        await this.effects.dispose();
+      }
     };
   }
 });
@@ -255,7 +364,13 @@ var init_flow_program = __esm({
       droppedEdges: z.array(z.string().max(128)).max(256),
       // Node ids needing external plumbing not wired yet (rag/classify/code) — the
       // interpreter passes through them.
-      unsupportedNodes: z.array(z.string().max(128)).max(256)
+      unsupportedNodes: z.array(z.string().max(128)).max(256),
+      // Port-less edges out of a conversational node (llm/ask/playbook) that carry
+      // a display `label` but no `condition` — compiled as the UNCONDITIONAL
+      // default (the label never routes). Mirrors validateFlowGraph's
+      // `edge_label_not_condition` warning. Optional: programs stored before this
+      // field existed must still pass the read-side parse.
+      labelOnlyEdges: z.array(z.string().max(128)).max(256).optional()
     });
     FlowProgram = z.object({
       v: z.literal(1),
@@ -372,6 +487,12 @@ var init_agents = __esm({
       readiness: z.array(ReadinessReport).max(64).optional(),
       metadata: AgentMetadata.optional(),
       processSchema: ProcessSchemaDTO.nullable().optional(),
+      // A code-first agent's base prompt (its instructions live in code, not the DB).
+      // Synced here so a generic worker can run it over text (P2). Omit for flow agents.
+      // Cap matches AgentConfig.systemPrompt (64k) so a large-but-valid prompt doesn't
+      // fail registration outright (which agent.ts swallows → agent runs but never
+      // registers/heartbeats).
+      prompt: z.string().max(64e3).nullable().optional(),
       // Opt into MCP exposure. When true the API upserts a matching agent_config
       // row keyed by (project_id, name, environment) so MCP / dashboard / REST
       // can list and inspect this agent's identity. When false / omitted, the
@@ -391,6 +512,13 @@ var init_agents = __esm({
       lastSeenAt: z.string().datetime().nullable(),
       metadata: AgentMetadata,
       processSchema: ProcessSchemaDTO.nullable().optional(),
+      // Whether this agent can run through the engine over text: a flow agent (its
+      // compiled graph rides in processSchema.program) OR a code-first agent whose
+      // base prompt was synced on register. Drives the dashboard's chat gate so it
+      // no longer hard-codes "flow only". Computed server-side; not stored. OPTIONAL
+      // on the wire so a new worker validating a response from an OLD api pod during
+      // a rolling deploy doesn't fail register/heartbeat on a missing field.
+      textRunnable: z.boolean().optional(),
       createdAt: z.string().datetime(),
       updatedAt: z.string().datetime()
     });
@@ -400,6 +528,9 @@ var init_agents = __esm({
     z.object({
       processSchema: ProcessSchemaDTO.nullable()
     });
+    z.object({
+      prompt: z.string().nullable()
+    });
     z.object({
       agent: AgentDTO,
       // Server-controlled cadence so we can tune without an SDK release.
@@ -486,7 +617,10 @@ var init_consultation = __esm({
       consultationId: z.string().uuid(),
       guidance: z.string().min(1).max(4e3),
       // Optional bridge phrase the agent may speak before delivering guidance.
-      resumePhrase: z.string().max(500).optional()
+      resumePhrase: z.string().max(500).optional(),
+      // G-5: the API's id for this command; the agent confirms it (CallControlAck). Optional so a command from an older
+      // API is still acted on (just not confirmed).
+      commandId: z.string().uuid().optional()
     });
     ConsultationPolicy = z.object({
       enabled: z.boolean().default(true),
@@ -511,7 +645,7 @@ var init_consultation = __esm({
     });
   }
 });
-var CallEventKind, OP_CALL_EVENT_KIND, OpCallEventKind, SayCommand, HangupCommand, DtmfCommand, InstructCommand;
+var CallEventKind, OP_CALL_EVENT_KIND, OpCallEventKind, commandId, SayCommand, HangupCommand, DtmfCommand, InstructCommand;
 var init_call_events = __esm({
   "../contracts/src/call-events.ts"() {
     init_consultation();
@@ -536,7 +670,7 @@ var init_call_events = __esm({
       "dtmf.received",
       "dtmf.sent"
     ]);
-    OP_CALL_EVENT_KIND = /^(tool|handoff|lookup|record|notify)\.[a-z0-9_]{1,48}(\.[a-z0-9_]{1,48})?$/;
+    OP_CALL_EVENT_KIND = /^(tool|handoff|lookup|record|notify|engine)\.[a-z0-9_]{1,48}(\.[a-z0-9_]{1,48})?$/;
     OpCallEventKind = z.string().regex(OP_CALL_EVENT_KIND);
     z.object({
       reason: z.string().optional(),
@@ -581,8 +715,10 @@ var init_call_events = __esm({
       ts: z.string().datetime()
     });
     z.enum(["say", "hangup", "dtmf", "instruct", "guidance"]);
+    commandId = z.string().uuid().optional();
     SayCommand = z.object({
       kind: z.literal("say"),
+      commandId,
       text: z.string().min(1),
       // 'interrupt' replaces any in-flight TTS; 'queue' waits for current to end.
       mode: z.enum(["interrupt", "queue"]).default("interrupt"),
@@ -590,14 +726,17 @@ var init_call_events = __esm({
     });
     HangupCommand = z.object({
       kind: z.literal("hangup"),
+      commandId,
       reason: z.string().optional()
     });
     DtmfCommand = z.object({
       kind: z.literal("dtmf"),
+      commandId,
       digits: z.string().regex(/^[0-9*#]+$/)
     });
     InstructCommand = z.object({
       kind: z.literal("instruct"),
+      commandId,
       text: z.string().min(1)
     });
     z.discriminatedUnion("kind", [
@@ -607,6 +746,14 @@ var init_call_events = __esm({
       InstructCommand,
       GuidanceCommand
     ]);
+    z.object({
+      commandId: z.string().uuid(),
+      outcome: z.enum(["applied", "refused", "failed"]),
+      // machine code: output_blocked · not_supported · unknown_consultation · no_consultation · invalid_command ·
+      // say_unavailable · dtmf_unavailable
+      code: z.string().max(64).optional(),
+      detail: z.string().max(500).optional()
+    });
   }
 });
 var VoiceConfig, ModelConfig, SttConfig, RealtimeConfig, PipelineMode, ToolBinding, ProcessFieldType, ProcessFieldSpec, ProcessCompleteWhen, ProcessBackendAckSpec, ProcessSpec, TriggerConditionSpec, TriggerActionSpec, TriggerSpec, RequiredInfoField, AgentConfig;
@@ -1022,6 +1169,113 @@ var init_forms = __esm({
   "../contracts/src/forms.ts"() {
   }
 });
+var AgentConfigVersionDTO, AgentConfigDiffField, AgentConfigChange;
+var init_agent_versions = __esm({
+  "../contracts/src/agent-versions.ts"() {
+    init_agent_config();
+    init_agents();
+    init_consultation();
+    z.object({
+      systemPrompt: z.string().max(64e3),
+      routingInstructions: z.string().max(32e3).nullable(),
+      voice: VoiceConfig,
+      model: ModelConfig,
+      stt: SttConfig.nullable(),
+      mode: PipelineMode,
+      realtime: RealtimeConfig.nullable(),
+      language: z.string().min(2).max(16),
+      tools: z.array(ToolBinding).max(64),
+      consultation: ConsultationPolicy,
+      tags: z.array(z.string().max(64)).max(32).nullable(),
+      brainConnectorId: z.string().uuid().nullable(),
+      flowVersion: z.number().int().nullable(),
+      processSchema: ProcessSchemaDTO.nullable()
+    });
+    z.enum(["published", "draft"]);
+    AgentConfigVersionDTO = z.object({
+      id: z.string().uuid(),
+      version: z.number().int().min(1),
+      createdAt: z.string().datetime(),
+      // 'user:<clerkId>' · 'api_key:<id>' · 'system:backfill' · 'system:deploy' · 'system:register'
+      createdBy: z.string().nullable(),
+      note: z.string().nullable(),
+      flowVersion: z.number().int().nullable(),
+      isPublished: z.boolean()
+    });
+    z.object({
+      versions: z.array(AgentConfigVersionDTO),
+      publishedVersion: z.number().int().min(1)
+    });
+    z.object({
+      note: z.string().trim().max(500).optional()
+    });
+    z.object({
+      version: AgentConfigVersionDTO
+    });
+    AgentConfigDiffField = z.enum([
+      "systemPrompt",
+      "routingInstructions",
+      "mode",
+      "model",
+      "voice",
+      "stt",
+      "realtime",
+      "language",
+      "tools",
+      "brainConnectorId",
+      "consultation",
+      "tags",
+      "flowVersion",
+      "processSchema"
+    ]);
+    AgentConfigChange = z.object({
+      field: AgentConfigDiffField,
+      label: z.string(),
+      /** The published value in plain words. */
+      from: z.string(),
+      /** The draft value in plain words. */
+      to: z.string(),
+      /** True for long text (prompts) — the sheet renders it in a scrollable block. */
+      longText: z.boolean()
+    });
+    z.object({
+      published: z.object({
+        version: z.number().int().min(1),
+        createdAt: z.string().datetime(),
+        note: z.string().nullable()
+      }),
+      hasChanges: z.boolean(),
+      changes: z.array(AgentConfigChange)
+    });
+  }
+});
+
+// ../contracts/src/providers.ts
+function providerIdentity(id) {
+  if (!id) return void 0;
+  return PROVIDERS[PROVIDER_ALIASES[id] ?? id];
+}
+function byokProviders() {
+  return Object.values(PROVIDERS).filter((p) => p.byok);
+}
+var PROVIDERS, PROVIDER_ALIASES;
+var init_providers = __esm({
+  "../contracts/src/providers.ts"() {
+    PROVIDERS = {
+      openai: { id: "openai", label: "OpenAI", capabilities: ["llm", "tts", "realtime"], byok: true, supportsBaseUrl: true, keyPlaceholder: "sk-..." },
+      anthropic: { id: "anthropic", label: "Anthropic", capabilities: ["llm"], byok: true, supportsBaseUrl: true, keyPlaceholder: "sk-ant-..." },
+      deepgram: { id: "deepgram", label: "Deepgram", capabilities: ["stt", "tts"], byok: true, supportsBaseUrl: false, keyPlaceholder: "Deepgram API key" },
+      elevenlabs: { id: "elevenlabs", label: "ElevenLabs", capabilities: ["tts"], byok: true, supportsBaseUrl: false, keyPlaceholder: "ElevenLabs API key" },
+      cartesia: { id: "cartesia", label: "Cartesia", capabilities: ["stt", "tts"], byok: true, supportsBaseUrl: false, keyPlaceholder: "Cartesia API key" },
+      assemblyai: { id: "assemblyai", label: "AssemblyAI", capabilities: ["stt"], byok: true, supportsBaseUrl: false, keyPlaceholder: "AssemblyAI API key" },
+      google: { id: "google", label: "Google (Gemini)", capabilities: ["llm", "realtime"], byok: true, supportsBaseUrl: false, keyPlaceholder: "AIza..." },
+      groq: { id: "groq", label: "Groq", capabilities: ["llm"], byok: true, supportsBaseUrl: true, keyPlaceholder: "gsk_..." },
+      // Runtime-only providers (no external key): local VAD.
+      silero: { id: "silero", label: "Silero", capabilities: ["vad"], byok: false, supportsBaseUrl: false }
+    };
+    PROVIDER_ALIASES = { gemini: "google" };
+  }
+});
 var ProviderKind, CatalogVoice, CatalogModel, CatalogProvider, CostEstimateAssumptions, CostEstimatePerMinute, CostEstimateBilledPerMinute;
 var init_model_catalog = __esm({
   "../contracts/src/model-catalog.ts"() {
@@ -1419,6 +1673,8 @@ var init_numbers = __esm({
       agentId: z.string().uuid().nullable(),
       // Environments pin (draft/live). null = no pin → live (today's behaviour).
       agentConfigEnv: z.enum(["draft", "live"]).nullable(),
+      // "Agent answers texts": the bound agent replies to inbound SMS (burn-down G-1). Off by default.
+      smsAgentReplies: z.boolean(),
       status: PhoneNumberStatus,
       friendlyName: z.string().nullable(),
       region: z.string().nullable(),
@@ -1442,6 +1698,7 @@ var init_numbers = __esm({
       // null detaches.
       agentId: z.string().uuid().nullable()
     });
+    z.object({ enabled: z.boolean() });
   }
 });
 var init_project_limits = __esm({
@@ -1548,6 +1805,12 @@ var init_compliance = __esm({
     ComplianceConfig.partial();
   }
 });
+
+// ../contracts/src/sms-keywords.ts
+var init_sms_keywords = __esm({
+  "../contracts/src/sms-keywords.ts"() {
+  }
+});
 var init_call_recording = __esm({
   "../contracts/src/call-recording.ts"() {
     z.object({
@@ -1584,10 +1847,16 @@ var init_outbound = __esm({
 var ConnectionAuthType, ConnectionStatus;
 var init_connection = __esm({
   "../contracts/src/connection.ts"() {
+    init_providers();
     ConnectionAuthType = z.enum(["oauth2", "api_key", "bearer", "basic", "none"]);
     ConnectionStatus = z.enum(["active", "revoked", "error"]);
     z.object({
       v: z.number().int(),
+      // Key id (short fingerprint) of the key that encrypted this envelope — lets the
+      // cipher pick the right key from its ring so CREDENTIAL_ENCRYPTION_KEY can rotate
+      // in-band (Tier-1 item 4). Optional/absent on legacy v1 envelopes, which decrypt
+      // with the designated legacy key.
+      kid: z.string().optional(),
       iv: z.string(),
       ct: z.string(),
       tag: z.string()
@@ -1625,6 +1894,218 @@ var init_connection = __esm({
     }).refine((v) => v.name !== void 0 || v.secret !== void 0 || v.metadata !== void 0, {
       message: "nothing to update"
     });
+    byokProviders().map((p) => ({
+      id: p.id,
+      label: p.label,
+      keyPlaceholder: p.keyPlaceholder ?? "",
+      supportsBaseUrl: p.supportsBaseUrl
+    }));
+  }
+});
+var E164, RoomPrefix, RecordingPrefix, Cidr, TelephonySettings, ProfileSource, EffectiveCallProfile;
+var init_telephony = __esm({
+  "../contracts/src/telephony.ts"() {
+    E164 = z.string().regex(/^\+[1-9]\d{6,14}$/, "must be E.164 (+15551234567)");
+    RoomPrefix = z.string().regex(/^[a-z0-9][a-z0-9-]{0,30}[a-z0-9-]?$/, "lowercase letters, digits, dashes; max 32");
+    RecordingPrefix = z.string().min(1).max(128).refine((v) => !v.startsWith("/") && !v.includes(".."), "relative key prefix only");
+    Cidr = z.string().regex(/^\d{1,3}(\.\d{1,3}){3}\/\d{1,2}$/, "must be IPv4 CIDR (a.b.c.d/nn)");
+    TelephonySettings = z.object({
+      outboundTrunkId: z.string().min(1).max(128).nullable().default(null),
+      defaultFromE164: E164.nullable().default(null),
+      roomPrefix: RoomPrefix.nullable().default(null),
+      sipAllowedCidrs: z.array(Cidr).max(32).nullable().default(null),
+      recordingPrefix: RecordingPrefix.nullable().default(null),
+      strictByok: z.boolean().default(false)
+    });
+    z.object({
+      outboundTrunkId: z.string().min(1).max(128).nullable().optional(),
+      defaultFromE164: E164.nullable().optional(),
+      roomPrefix: RoomPrefix.nullable().optional(),
+      sipAllowedCidrs: z.array(Cidr).max(32).nullable().optional(),
+      recordingPrefix: RecordingPrefix.nullable().optional(),
+      strictByok: z.boolean().optional()
+    }).refine((v) => Object.keys(v).length > 0, { message: "nothing to update" });
+    ProfileSource = z.enum(["org", "platform", "none"]);
+    EffectiveCallProfile = z.object({
+      projectId: z.string(),
+      outboundTrunkId: z.string().nullable(),
+      defaultFromE164: z.string().nullable(),
+      roomPrefix: z.string(),
+      sipAllowedCidrs: z.array(z.string()),
+      recordingPrefix: z.string(),
+      strictByok: z.boolean(),
+      sources: z.object({
+        outboundTrunkId: ProfileSource,
+        defaultFromE164: ProfileSource,
+        roomPrefix: ProfileSource,
+        sipAllowedCidrs: ProfileSource,
+        recordingPrefix: ProfileSource
+      })
+    });
+    z.object({
+      settings: TelephonySettings,
+      profile: EffectiveCallProfile
+    });
+  }
+});
+var SHORTENER_HOSTS, PLACEHOLDER_HOSTS, PublicUrl, A2pBusinessType, A2pBusinessInfo, A2pOptInType, A2pUseCase, A2pMessagingProfile, A2pState;
+var init_a2p = __esm({
+  "../contracts/src/a2p.ts"() {
+    SHORTENER_HOSTS = [
+      "bit.ly",
+      "tinyurl.com",
+      "t.co",
+      "goo.gl",
+      "ow.ly",
+      "is.gd",
+      "buff.ly",
+      "rebrand.ly",
+      "cutt.ly",
+      "shorturl.at",
+      "tiny.cc"
+    ];
+    PLACEHOLDER_HOSTS = ["acme.com", "example.com", "example.org", "test.com", "localhost"];
+    PublicUrl = z.string().url().refine((v) => v.startsWith("https://"), "must be https").refine((v) => {
+      try {
+        const host = new URL(v).hostname.toLowerCase().replace(/^www\./, "");
+        return !SHORTENER_HOSTS.includes(host);
+      } catch {
+        return false;
+      }
+    }, "public URL shorteners are rejected by carriers \u2014 use your own domain").refine((v) => {
+      try {
+        const host = new URL(v).hostname.toLowerCase().replace(/^www\./, "");
+        return !PLACEHOLDER_HOSTS.some((p) => host === p || host.endsWith(`.${p}`));
+      } catch {
+        return false;
+      }
+    }, "placeholder domain \u2014 reviewers will follow this link and reject the campaign");
+    A2pBusinessType = z.enum([
+      "Sole Proprietorship",
+      "Partnership",
+      "Corporation",
+      "Co-operative",
+      "Limited Liability Corporation",
+      "Non-profit Corporation"
+    ]);
+    A2pBusinessInfo = z.object({
+      legalName: z.string().trim().min(2).max(200),
+      /** EIN (US) or equivalent registration number. */
+      registrationNumber: z.string().trim().min(4).max(50),
+      businessType: A2pBusinessType,
+      /** Publicly reachable production site — not staging, not a 404. */
+      website: PublicUrl,
+      industry: z.string().trim().min(2).max(60),
+      address: z.object({
+        street: z.string().trim().min(2).max(200),
+        city: z.string().trim().min(1).max(100),
+        region: z.string().trim().min(1).max(100),
+        postalCode: z.string().trim().min(2).max(20),
+        isoCountry: z.string().trim().length(2)
+      }),
+      authorizedRep: z.object({
+        firstName: z.string().trim().min(1).max(100),
+        lastName: z.string().trim().min(1).max(100),
+        email: z.string().trim().email(),
+        phone: z.string().trim().regex(/^\+[1-9]\d{6,14}$/, "must be E.164"),
+        jobTitle: z.string().trim().min(2).max(100)
+      })
+    });
+    A2pOptInType = z.enum(["WEB_FORM", "PAPER_FORM", "VERBAL", "VIA_TEXT", "MOBILE_QR_CODE"]);
+    A2pUseCase = z.enum([
+      "MIXED",
+      "CUSTOMER_CARE",
+      "MARKETING",
+      "ACCOUNT_NOTIFICATION",
+      "2FA",
+      "DELIVERY_NOTIFICATION",
+      "HIGHER_EDUCATION",
+      "POLLING_VOTING",
+      "PUBLIC_SERVICE_ANNOUNCEMENT",
+      "LOW_VOLUME"
+    ]);
+    A2pMessagingProfile = z.object({
+      useCase: A2pUseCase,
+      /** Specific, not generic. "We send texts" gets rejected; describe the actual
+       *  messages and when they are sent. */
+      description: z.string().trim().min(40).max(4096),
+      /**
+       * The single most-rejected field. Must describe HOW people opt in, state the
+       * message frequency, include the "message and data rates may apply"
+       * disclosure, and link to publicly reachable evidence. Twilio's API bounds it
+       * to 40–2049 characters.
+       */
+      messageFlow: z.string().trim().min(40).max(2049),
+      optInType: A2pOptInType,
+      /** Publicly accessible screenshots/pages showing the opt-in. Reviewers open
+       *  these; anything behind a login fails. */
+      optInEvidenceUrls: z.array(PublicUrl).min(1).max(5),
+      /** Real messages the customer will send. Must reflect the declared use case
+       *  and carry opt-out language. */
+      messageSamples: z.array(z.string().trim().min(10).max(1024)).min(2).max(5),
+      privacyPolicyUrl: PublicUrl,
+      termsAndConditionsUrl: PublicUrl,
+      hasEmbeddedLinks: z.boolean().default(false),
+      hasEmbeddedPhone: z.boolean().default(false)
+    });
+    z.object({
+      business: A2pBusinessInfo,
+      messaging: A2pMessagingProfile,
+      /** Register against Twilio's mock endpoints — exercises the full pipeline
+       *  with no fees and no real carrier submission. Used in CI and staging. */
+      mock: z.boolean().default(false)
+    }).superRefine((v, ctx) => {
+      const flow = v.messaging.messageFlow.toLowerCase();
+      if (!/(msg|message)\s*(&|and)\s*data rates/.test(flow)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["messaging", "messageFlow"],
+          message: 'must include a "Message and data rates may apply" disclosure \u2014 carriers reject without it'
+        });
+      }
+      if (!/\d/.test(flow) || !/(msg|message|text)/.test(flow)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["messaging", "messageFlow"],
+          message: 'must state message frequency, e.g. "Up to 4 msgs/month"'
+        });
+      }
+      const hasOptOut = v.messaging.messageSamples.some((s) => /stop/i.test(s));
+      if (!hasOptOut) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["messaging", "messageSamples"],
+          message: 'at least one sample must include opt-out language (e.g. "Reply STOP to opt out")'
+        });
+      }
+    });
+    A2pState = z.enum([
+      "none",
+      "profile_pending",
+      "profile_approved",
+      "profile_failed",
+      "brand_pending",
+      "brand_approved",
+      "brand_failed",
+      "campaign_pending",
+      "messaging_ready",
+      "campaign_failed"
+    ]);
+    z.object({
+      state: A2pState,
+      customerProfileSid: z.string().nullable(),
+      trustProductSid: z.string().nullable(),
+      brandSid: z.string().nullable(),
+      messagingServiceSid: z.string().nullable(),
+      campaignSid: z.string().nullable(),
+      mock: z.boolean(),
+      /** Carrier/Twilio rejection details, surfaced verbatim so the customer can
+       *  fix the specific field rather than guess. */
+      failures: z.array(z.object({ code: z.number().nullable(), field: z.string().nullable(), message: z.string() })).default([]),
+      /** Plain-language next step for the dashboard. */
+      nextAction: z.string().nullable(),
+      updatedAt: z.string().nullable()
+    });
   }
 });
 var ConnectorMode, ConnectorStatus, ConnectorNormalize;
@@ -1752,6 +2233,7 @@ var init_flow_enrichment = __esm({
 var init_flow_compile = __esm({
   "../contracts/src/flow-compile.ts"() {
     init_flow_enrichment();
+    init_flow_validate();
   }
 });
 var EnvironmentSpec;
@@ -1896,6 +2378,1057 @@ var init_playbook_compile = __esm({
   "../contracts/src/playbook-compile.ts"() {
   }
 });
+var EngineSeamBinding, EnginePluginDTO;
+var init_engine = __esm({
+  "../contracts/src/engine.ts"() {
+    EngineSeamBinding = z.object({
+      key: z.string(),
+      bound: z.boolean()
+    });
+    EnginePluginDTO = z.object({
+      name: z.string(),
+      provides: z.array(EngineSeamBinding),
+      injects: z.array(z.string())
+    });
+    z.object({
+      plugins: z.array(EnginePluginDTO)
+    });
+  }
+});
+
+// ../contracts/src/identity.ts
+var init_identity = __esm({
+  "../contracts/src/identity.ts"() {
+  }
+});
+
+// ../contracts/src/interaction.ts
+var init_interaction = __esm({
+  "../contracts/src/interaction.ts"() {
+  }
+});
+
+// ../contracts/src/channel-connector/capability-state.ts
+var CONDITION_CLASSES, CONDITION_TYPES, SURFACES, TRANSPORT_KINDS, AGENT_INITIATION, TEMPLATE_REQUIREMENT, WINDOW_OUTSIDE, PEER_ID_SCOPES, RECEIPT_KINDS;
+var init_capability_state = __esm({
+  "../contracts/src/channel-connector/capability-state.ts"() {
+    CONDITION_CLASSES = ["authority", "operational", "observability"];
+    CONDITION_TYPES = [
+      { id: "CredentialsValid", defaultClass: "authority", summary: "credential lease resolves and is not expired/revoked" },
+      { id: "ProviderAccountGood", defaultClass: "authority", summary: "provider account / sender standing is not suspended or restricted" },
+      { id: "RegistrationApproved", defaultClass: "authority", summary: "required registration / approval is current" },
+      { id: "ResourceOwnershipConfirmed", defaultClass: "authority", summary: "the native object is confirmed to belong to this principal" },
+      { id: "InstallationPresent", defaultClass: "authority", summary: "the container installation exists and is not revoked" },
+      { id: "PermissionsHeld", defaultClass: "authority", summary: "required provider permissions/scopes/intents are held" },
+      { id: "ConsentResolved", defaultClass: "authority", summary: "consent verdict available (ch. 02; not_evaluated until it ships)" },
+      { id: "WindowOpen", defaultClass: "authority", summary: "the reply window for the peer is open" },
+      { id: "TemplateAvailable", defaultClass: "authority", summary: "an approved template exists for the operation" },
+      { id: "PeerReachable", defaultClass: "authority", summary: "the peer can be reached on this channel (e.g. RCS capability, not blocked)" },
+      { id: "WebhookRegistered", defaultClass: "operational", summary: "the provider has our ingress registered" },
+      { id: "InboundVerificationReady", defaultClass: "authority", summary: "the material the declared inbound-auth strategy needs (for the selected authorization method) resolves \u2014 REST auth alone never satisfies it (#306 L4)" },
+      { id: "WebhookHealthy", defaultClass: "operational", summary: "recent verified inbound / delivery health" },
+      { id: "TransportConnected", defaultClass: "operational", summary: "a transport lease is live (gateway / long-poll / pub-sub)" },
+      { id: "ReconcileFresh", defaultClass: "operational", summary: "the last reconcile is within its window" },
+      { id: "ProviderLatency", defaultClass: "observability", summary: "provider latency / error-rate telemetry" }
+    ];
+    new Set(CONDITION_TYPES.map((c) => c.id));
+    SURFACES = ["direct", "group", "channel", "thread", "broadcast"];
+    TRANSPORT_KINDS = ["webhook", "long_poll", "gateway", "pubsub", "http_interactions"];
+    AGENT_INITIATION = ["always", "installed_only", "opt_in_required", "template_only", "never"];
+    TEMPLATE_REQUIREMENT = ["never", "outside_window", "always"];
+    WINDOW_OUTSIDE = ["tagged_only", "template_only", "blocked"];
+    PEER_ID_SCOPES = ["global", "app_scoped", "workspace_scoped", "installation_scoped"];
+    RECEIPT_KINDS = ["sent", "delivered", "read", "failed"];
+  }
+});
+
+// ../contracts/src/channel-connector/channels.ts
+function baseline(channel, partial) {
+  return {
+    channel,
+    connector: null,
+    version: "1.0",
+    requiredPermissions: [],
+    registration: [],
+    readinessGates: [
+      { condition: "CredentialsValid", class: "authority", blocks: "*", ttlSec: 300 },
+      { condition: "ProviderAccountGood", class: "authority", blocks: "*", ttlSec: 3600 },
+      { condition: "WebhookHealthy", class: "operational", blocks: ["receive.message", "call.receive"], ttlSec: 900, evidence: "runtime" }
+    ],
+    ...partial
+  };
+}
+var TEXT_ONLY, RICH_MESSAGING, MESSAGE_CORE, CONTAINER_GATES, CHANNELS, CHANNEL_IDS;
+var init_channels = __esm({
+  "../contracts/src/channel-connector/channels.ts"() {
+    init_capability_state();
+    TEXT_ONLY = ["text"];
+    RICH_MESSAGING = ["text", "image", "audio", "video", "document", "location", "contact", "sticker", "reaction", "interactive", "template"];
+    MESSAGE_CORE = ["receive.message", "send.text", "send.media", "initiate.conversation", "reply.in_window"];
+    CONTAINER_GATES = [
+      { condition: "CredentialsValid", class: "authority", blocks: "*", ttlSec: 300 },
+      { condition: "InstallationPresent", class: "authority", blocks: "*", ttlSec: 3600 },
+      { condition: "PermissionsHeld", class: "authority", blocks: ["send.text", "send.media", "channel.post", "thread.reply", "group.post"], ttlSec: 3600 },
+      { condition: "WebhookHealthy", class: "operational", blocks: ["receive.message"], ttlSec: 900, evidence: "runtime" }
+    ];
+    CHANNELS = [
+      {
+        id: "sms",
+        displayName: "SMS",
+        addressSpace: "phone",
+        surfaces: ["direct"],
+        bindingCapabilities: ["sms"],
+        baseline: baseline("sms", {
+          operations: [...MESSAGE_CORE, "read.receipt"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "always", userInitiated: true, firstContactRule: "agent-initiated with registration (10DLC / TFV per country); STOP/HELP keywords mandatory" },
+          windows: [],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct"],
+          messageTypes: TEXT_ONLY,
+          // GSM-7 160/153, UCS-2 70/67 per segment (doc 01 §3); no body cap is a channel fact.
+          limits: { segments: true, note: "GSM-7 160/153 \xB7 UCS-2 70/67 per segment" },
+          receipts: ["sent", "delivered", "failed"],
+          edits: { edit: false, delete: false, reactions: false, commands: false },
+          transport: ["webhook"],
+          identity: { peerIdKind: "phone", peerIdScope: "global" },
+          registration: [{ kind: "campaign_vetting", blocks: ["send.text", "send.media", "initiate.conversation"] }]
+        })
+      },
+      {
+        id: "mms",
+        displayName: "MMS",
+        addressSpace: "phone",
+        surfaces: ["direct", "group"],
+        bindingCapabilities: ["mms"],
+        baseline: baseline("mms", {
+          operations: [...MESSAGE_CORE, "group.post"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "always", userInitiated: true, firstContactRule: "as SMS; carrier MMS size caps apply" },
+          windows: [],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct", "group"],
+          messageTypes: ["text", "image", "audio", "video", "document"],
+          limits: { mediaBytes: 1e6, note: "carrier MMS \u22480.6\u20131 MB (doc 01 \xA73)" },
+          receipts: ["sent", "delivered", "failed"],
+          edits: { edit: false, delete: false, reactions: false, commands: false },
+          transport: ["webhook"],
+          identity: { peerIdKind: "phone", peerIdScope: "global" },
+          registration: [{ kind: "campaign_vetting", blocks: ["send.text", "send.media", "initiate.conversation"] }]
+        })
+      },
+      {
+        id: "voice",
+        displayName: "Voice (PSTN)",
+        addressSpace: "phone",
+        surfaces: ["direct"],
+        bindingCapabilities: ["voice"],
+        baseline: baseline("voice", {
+          operations: ["call.receive", "call.place"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "always", userInitiated: true, firstContactRule: "agent-initiated; STIR/SHAKEN attestation; emergency addressing; trunk config" },
+          windows: [],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct"],
+          messageTypes: [],
+          limits: {},
+          receipts: [],
+          edits: { edit: false, delete: false, reactions: false, commands: false },
+          transport: ["webhook"],
+          identity: { peerIdKind: "phone", peerIdScope: "global" }
+        })
+      },
+      {
+        id: "whatsapp",
+        displayName: "WhatsApp",
+        addressSpace: "whatsapp",
+        surfaces: ["direct", "group"],
+        bindingCapabilities: ["whatsapp.message"],
+        baseline: baseline("whatsapp", {
+          operations: [...MESSAGE_CORE, "send.template", "send.interactive", "send.reaction", "read.receipt", "typing.indicate"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "template_only", userInitiated: true, firstContactRule: "user-initiated or a reviewed template outside the 24-h window; opt-in mandatory" },
+          windows: [{ kind: "reply", durationSec: 86400, opensOn: "inbound_message", outside: "template_only" }],
+          templates: { required: "outside_window", reviewed: true },
+          surfaces: ["direct", "group"],
+          messageTypes: RICH_MESSAGING,
+          limits: {
+            textChars: 4096,
+            mediaBytes: 1e8,
+            perSecond: 80,
+            formats: { audio: { mime: ["audio/ogg", "audio/mpeg", "audio/mp4", "audio/aac", "audio/amr"], variants: ["voice_note", "file"] } }
+          },
+          receipts: ["sent", "delivered", "read", "failed"],
+          edits: { edit: false, delete: false, reactions: true, commands: false },
+          transport: ["webhook"],
+          identity: { peerIdKind: "whatsapp", peerIdScope: "global" },
+          registration: [{ kind: "business_verification", blocks: ["initiate.conversation", "send.template"] }]
+        })
+      },
+      {
+        id: "instagram",
+        displayName: "Instagram DM",
+        addressSpace: "app",
+        surfaces: ["direct"],
+        bindingCapabilities: ["instagram.message"],
+        baseline: baseline("instagram", {
+          operations: ["receive.message", "send.text", "send.media", "send.reaction", "reply.in_window", "delete.message", "read.receipt"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "never", userInitiated: true, firstContactRule: "user-initiated only \u2014 the peer identifier exists only after the user messages or clicks" },
+          windows: [{ kind: "reply", durationSec: 86400, opensOn: "inbound_message", outside: "tagged_only" }],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct"],
+          messageTypes: ["text", "image", "audio", "video", "document", "sticker", "reaction", "interactive", "template"],
+          limits: { textBytes: 1e3, mediaBytes: 25e6 },
+          receipts: ["read"],
+          edits: { edit: false, delete: true, reactions: true, commands: false },
+          transport: ["webhook"],
+          // doc 07 §3: per person × professional account, stable across apps — the
+          // account scope is embedded in the normalized value, so the id is global.
+          identity: { peerIdKind: "meta_account_user", peerIdScope: "global" },
+          registration: [{ kind: "app_review", blocks: ["send.text", "send.media"] }]
+        })
+      },
+      {
+        id: "messenger",
+        displayName: "Messenger",
+        addressSpace: "app",
+        surfaces: ["direct"],
+        bindingCapabilities: ["messenger.message"],
+        baseline: baseline("messenger", {
+          operations: ["receive.message", "send.text", "send.media", "send.reaction", "reply.in_window", "edit.message", "read.receipt", "typing.indicate"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "never", userInitiated: true, firstContactRule: "as Instagram plus Get Started / link / ads entry points" },
+          windows: [{ kind: "reply", durationSec: 86400, opensOn: "inbound_message", outside: "tagged_only" }],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct"],
+          messageTypes: RICH_MESSAGING,
+          limits: { mediaBytes: 25e6 },
+          receipts: ["delivered", "read"],
+          edits: { edit: true, delete: false, reactions: true, commands: false },
+          transport: ["webhook"],
+          identity: { peerIdKind: "meta_account_user", peerIdScope: "global" },
+          registration: [{ kind: "app_review", blocks: ["send.text", "send.media"] }]
+        })
+      },
+      {
+        id: "telegram",
+        displayName: "Telegram",
+        addressSpace: "app",
+        surfaces: ["direct", "group", "channel", "thread"],
+        bindingCapabilities: ["telegram.message"],
+        baseline: baseline("telegram", {
+          operations: [...MESSAGE_CORE, "send.interactive", "send.reaction", "edit.message", "delete.message", "command.register", "group.post", "channel.post", "thread.reply"],
+          direction: { inbound: true, outbound: true },
+          // Plain bot: the user must start; no reply window. The business-account
+          // 24-h rule is an installation-level narrowing, not the channel ceiling.
+          initiation: { agentInitiated: "never", userInitiated: true, firstContactRule: "the user must start the bot (/start, deep link, group add) before it may message them" },
+          windows: [],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct", "group", "channel", "thread"],
+          messageTypes: ["text", "image", "audio", "video", "document", "location", "contact", "sticker", "reaction", "interactive", "poll"],
+          limits: { textChars: 4096, mediaBytes: 5e7, formats: { audio: { mime: ["audio/ogg", "audio/mpeg"], variants: ["voice_note", "file"] } } },
+          receipts: [],
+          edits: { edit: true, delete: true, reactions: true, commands: true },
+          transport: ["webhook", "long_poll"],
+          identity: { peerIdKind: "telegram_user", peerIdScope: "global" }
+        })
+      },
+      {
+        id: "discord",
+        displayName: "Discord",
+        addressSpace: "app",
+        surfaces: ["direct", "group", "channel", "thread"],
+        bindingCapabilities: ["discord.message", "discord.command"],
+        baseline: baseline("discord", {
+          // The channel exposes BOTH modes (doc 04 §1): text via `send.*`, realtime
+          // audio via `call.*`. Mode is per OPERATION — the channel id never implies it.
+          operations: [...MESSAGE_CORE, "send.interactive", "send.reaction", "edit.message", "delete.message", "command.register", "channel.post", "thread.reply", "call.receive", "call.place"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "installed_only", userInitiated: true, firstContactRule: "guild channels by permission; DMs need a mutual guild or a user install" },
+          windows: [],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct", "group", "channel", "thread"],
+          messageTypes: ["text", "image", "audio", "video", "document", "reaction", "interactive", "card", "poll"],
+          limits: { textChars: 2e3, mediaBytes: 10485760 },
+          receipts: [],
+          edits: { edit: true, delete: true, reactions: true, commands: true },
+          transport: ["gateway", "http_interactions"],
+          identity: { peerIdKind: "discord_user", peerIdScope: "global" },
+          readinessGates: [
+            { condition: "CredentialsValid", class: "authority", blocks: "*", ttlSec: 300 },
+            { condition: "InstallationPresent", class: "authority", blocks: "*", ttlSec: 3600 },
+            { condition: "PermissionsHeld", class: "authority", blocks: ["send.text", "send.media", "channel.post", "thread.reply", "call.receive", "call.place"], ttlSec: 3600 },
+            { condition: "TransportConnected", class: "operational", blocks: ["receive.message", "call.receive"], ttlSec: 120 }
+          ]
+        })
+      },
+      {
+        // G-3: the embeddable website chat widget. The widget key IS the identity and its evidence (a `web`-space Binding
+        // at `widget:<keyId>`, no provider connection), so no provider readiness gate applies. The agent only ever answers
+        // inside the visitor's own request — it never starts or pushes a message.
+        id: "web",
+        displayName: "Website chat",
+        addressSpace: "web",
+        surfaces: ["direct"],
+        bindingCapabilities: ["web.message"],
+        baseline: baseline("web", {
+          operations: ["receive.message", "reply.in_window"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "never", userInitiated: true, firstContactRule: "the visitor opens the widget and writes first" },
+          windows: [],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct"],
+          messageTypes: TEXT_ONLY,
+          limits: { textChars: 8e3 },
+          receipts: [],
+          edits: { edit: false, delete: false, reactions: false, commands: false },
+          transport: ["http_interactions"],
+          identity: { peerIdKind: "web_visitor", peerIdScope: "app_scoped" },
+          readinessGates: []
+        })
+      },
+      {
+        id: "slack",
+        displayName: "Slack",
+        addressSpace: "app",
+        surfaces: ["direct", "group", "channel", "thread"],
+        bindingCapabilities: ["slack.message"],
+        baseline: baseline("slack", {
+          operations: [...MESSAGE_CORE, "send.interactive", "send.reaction", "edit.message", "delete.message", "command.register", "channel.post", "thread.reply"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "installed_only", userInitiated: true, firstContactRule: "any channel the bot is in; DMs" },
+          windows: [],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct", "group", "channel", "thread"],
+          messageTypes: ["text", "image", "audio", "video", "document", "reaction", "interactive", "card"],
+          limits: { textChars: 4e3, note: "truncated at 40,000 (doc 01 \xA73)" },
+          receipts: [],
+          edits: { edit: true, delete: true, reactions: true, commands: true },
+          transport: ["webhook", "gateway"],
+          identity: { peerIdKind: "slack_user", peerIdScope: "workspace_scoped" },
+          readinessGates: CONTAINER_GATES
+        })
+      },
+      {
+        id: "teams",
+        displayName: "Microsoft Teams",
+        addressSpace: "app",
+        surfaces: ["direct", "group", "channel", "thread"],
+        bindingCapabilities: ["teams.message"],
+        baseline: baseline("teams", {
+          operations: [...MESSAGE_CORE, "send.interactive", "edit.message", "delete.message", "channel.post", "thread.reply", "read.receipt"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "installed_only", userInitiated: true, firstContactRule: "proactive send needs an installation in scope plus a conversation reference" },
+          windows: [],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct", "group", "channel", "thread"],
+          messageTypes: ["text", "image", "document", "card", "interactive", "reaction"],
+          limits: { textBytes: 102400, note: "message payload \u2264100 KB (doc 01 \xA73)" },
+          receipts: ["read"],
+          edits: { edit: true, delete: true, reactions: false, commands: false },
+          transport: ["webhook"],
+          identity: { peerIdKind: "teams_user", peerIdScope: "installation_scoped" },
+          readinessGates: CONTAINER_GATES
+        })
+      },
+      {
+        id: "rcs",
+        displayName: "RCS",
+        addressSpace: "rcs",
+        surfaces: ["direct"],
+        bindingCapabilities: ["rcs.message"],
+        baseline: baseline("rcs", {
+          operations: [...MESSAGE_CORE, "send.interactive", "read.receipt", "typing.indicate", "delete.message"],
+          direction: { inbound: true, outbound: true },
+          initiation: { agentInitiated: "opt_in_required", userInitiated: true, firstContactRule: "agent-initiated only with consent per AUP; STOP / UNSUBSCRIBE brand-wide" },
+          windows: [],
+          templates: { required: "never", reviewed: false },
+          surfaces: ["direct"],
+          messageTypes: ["text", "image", "audio", "video", "document", "card", "carousel", "interactive"],
+          limits: { textChars: 3072, mediaBytes: 104857600 },
+          receipts: ["delivered", "read"],
+          edits: { edit: false, delete: true, reactions: false, commands: false },
+          transport: ["webhook"],
+          identity: { peerIdKind: "phone", peerIdScope: "global" },
+          registration: [{ kind: "agent_launch", blocks: ["send.text", "send.media", "send.interactive", "initiate.conversation"] }],
+          readinessGates: [
+            { condition: "CredentialsValid", class: "authority", blocks: "*", ttlSec: 300 },
+            { condition: "RegistrationApproved", class: "authority", blocks: ["send.text", "send.media", "send.interactive", "initiate.conversation"], ttlSec: 86400 },
+            { condition: "PeerReachable", class: "authority", blocks: ["send.text", "send.media", "send.interactive", "initiate.conversation"], ttlSec: 86400 },
+            { condition: "WebhookHealthy", class: "operational", blocks: ["receive.message"], ttlSec: 900, evidence: "runtime" }
+          ]
+        })
+      }
+    ];
+    new Map(CHANNELS.map((c) => [c.id, c]));
+    CHANNEL_IDS = new Set(CHANNELS.map((c) => c.id));
+  }
+});
+
+// ../contracts/src/channel-connector/operations.ts
+var OPERATION_MODES, OPERATIONS, OPERATION_IDS;
+var init_operations = __esm({
+  "../contracts/src/channel-connector/operations.ts"() {
+    OPERATION_MODES = ["message", "realtime"];
+    OPERATIONS = [
+      { id: "receive.message", mode: "message", summary: "accept an inbound message" },
+      { id: "send.text", mode: "message", summary: "send a text message" },
+      { id: "send.media", mode: "message", summary: "send a message carrying a content item (image, audio, video, document)" },
+      { id: "send.template", mode: "message", summary: "send a reviewed template" },
+      { id: "send.interactive", mode: "message", summary: "send structured/interactive content" },
+      { id: "send.reaction", mode: "message", summary: "react to a message" },
+      { id: "edit.message", mode: "message", summary: "edit a sent message" },
+      { id: "delete.message", mode: "message", summary: "delete a sent message" },
+      { id: "initiate.conversation", mode: "message", summary: "first contact / outside any window" },
+      { id: "reply.in_window", mode: "message", summary: "reply inside an open window" },
+      { id: "call.receive", mode: "realtime", summary: "accept an inbound realtime session" },
+      { id: "call.place", mode: "realtime", summary: "place an outbound realtime session" },
+      { id: "read.receipt", mode: "message", summary: "mark a message as read" },
+      { id: "typing.indicate", mode: "message", summary: "typing indicator" },
+      { id: "command.register", mode: "message", summary: "register slash/bot commands" },
+      { id: "thread.reply", mode: "message", summary: "reply inside a thread" },
+      { id: "group.post", mode: "message", summary: "post to a group surface" },
+      { id: "channel.post", mode: "message", summary: "post to a channel surface" }
+    ];
+    new Map(
+      OPERATIONS.map((op) => [op.id, op])
+    );
+    OPERATION_IDS = new Set(OPERATIONS.map((op) => op.id));
+  }
+});
+
+// ../contracts/src/channel-connector/ids.ts
+var A2_SHIPPED_ROOTS, A2_PLATFORM_ROOTS, NAMESPACE_RE, SEMVER_RE;
+var init_ids2 = __esm({
+  "../contracts/src/channel-connector/ids.ts"() {
+    init_channels();
+    init_operations();
+    A2_SHIPPED_ROOTS = [
+      "llm",
+      "conversation",
+      "channels",
+      "tools",
+      "guard",
+      "store",
+      "compliance",
+      "carriers",
+      "agents",
+      "agentRun",
+      "telemetry"
+    ];
+    A2_PLATFORM_ROOTS = [
+      ...A2_SHIPPED_ROOTS,
+      "policy",
+      "identity",
+      "binding",
+      "provider",
+      "workflow",
+      "session",
+      "engine",
+      "message",
+      "connector",
+      "communication",
+      "event",
+      "reach",
+      "handler",
+      "plugin",
+      "scope",
+      "snapshot"
+    ];
+    /* @__PURE__ */ new Set([
+      ...A2_PLATFORM_ROOTS,
+      ...[...OPERATION_IDS].map((id) => id.split(".")[0]),
+      ...CHANNEL_IDS
+    ]);
+    NAMESPACE_RE = /^[a-z0-9]+\.[a-z0-9]+$/;
+    SEMVER_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/;
+  }
+});
+function parseContentRef(ref) {
+  const m = CONTENT_REF_RE.exec(ref);
+  return m ? { principalId: m[1], contentId: m[2] } : null;
+}
+function isContentRef(value) {
+  return typeof value === "string" && CONTENT_REF_RE.test(value);
+}
+function looksLikeProviderLocator(value) {
+  return /^(https?:\/\/|s3:\/\/|gs:\/\/)/i.test(value) || value.includes("?") || value.includes("://");
+}
+var MODALITY_KINDS, STRUCTURED_KINDS, CONTENT_KINDS, LOSSINESS, CONTENT_REF_RE, MessageContentProvenance, noLocator, MessageContentMetadata, contentRefSchema, OriginalMessageContent, DerivedMessageContent;
+var init_content_kinds = __esm({
+  "../contracts/src/channel-connector/content-kinds.ts"() {
+    MODALITY_KINDS = ["text", "image", "audio", "video", "document"];
+    STRUCTURED_KINDS = [
+      "location",
+      "contact",
+      "sticker",
+      "reaction",
+      "interactive",
+      "card",
+      "carousel",
+      "poll",
+      "template"
+    ];
+    CONTENT_KINDS = [...MODALITY_KINDS, ...STRUCTURED_KINDS];
+    new Set(CONTENT_KINDS);
+    LOSSINESS = ["lossless", "lossy", "semantic"];
+    CONTENT_REF_RE = /^content:([A-Za-z0-9_-]+)\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/;
+    MessageContentProvenance = z.object({
+      /** The connector that produced the item (A7 id). */
+      connector: z.string(),
+      /** The provider-native identifier — reconciliation only; never agent-facing. */
+      providerRef: z.string().optional(),
+      receivedAt: z.string().datetime().optional()
+    }).strict();
+    noLocator = (label) => z.string().refine((v) => !looksLikeProviderLocator(v), { message: `${label} must not carry a provider locator \u2014 provider ids live in provenance.providerRef only` });
+    MessageContentMetadata = z.object({
+      bytes: z.number().int().nonnegative().optional(),
+      durationMs: z.number().int().nonnegative().optional(),
+      width: z.number().int().positive().optional(),
+      height: z.number().int().positive().optional(),
+      filename: noLocator("metadata.filename").optional(),
+      caption: noLocator("metadata.caption").optional(),
+      /** e.g. `voice_note` for audio. */
+      variant: z.string().regex(/^[a-z0-9_]+$/).optional(),
+      language: z.string().max(16).optional()
+    }).strict();
+    contentRefSchema = z.string().refine(isContentRef, {
+      message: "ref must be an opaque platform content reference `content:<principal>/<uuid>`"
+    });
+    OriginalMessageContent = z.object({
+      kind: z.enum(CONTENT_KINDS),
+      /** MIME type or registry format id. */
+      format: z.string().min(1),
+      ref: contentRefSchema,
+      metadata: MessageContentMetadata.default({}),
+      provenance: MessageContentProvenance,
+      /** Inline text for `text` kind only (the ref still names the stored item). */
+      text: z.string().optional()
+    }).strict().refine((item) => item.text === void 0 || item.kind === "text", { message: "inline text is only valid on kind=text" });
+    DerivedMessageContent = OriginalMessageContent.innerType().extend({
+      derivedFrom: contentRefSchema,
+      /** The transform capability id (registry or extension id). */
+      transform: z.string().min(1),
+      /** A7 actor ref of the producer. */
+      producer: z.string().min(1),
+      lossiness: z.enum(LOSSINESS)
+    }).strict().refine((item) => item.text === void 0 || item.kind === "text", { message: "inline text is only valid on kind=text" }).refine((item) => parseContentRef(item.derivedFrom)?.principalId === parseContentRef(item.ref)?.principalId, {
+      message: "a derived item must derive from content of the same principal"
+    });
+    z.union([DerivedMessageContent, OriginalMessageContent]);
+  }
+});
+var STEP_KINDS, OWNERSHIP_MODES, WorkflowStep, ConnectorWorkflow;
+var init_onboarding = __esm({
+  "../contracts/src/channel-connector/onboarding.ts"() {
+    STEP_KINDS = [
+      "FORM",
+      "SECRET",
+      "OAUTH",
+      "APP_INSTALL",
+      "RESOURCE_SELECT",
+      "RESOURCE_CREATE",
+      "REGISTER",
+      "SUBMIT_APPROVAL",
+      "WAIT",
+      "ACTION_REQUIRED",
+      "GATEWAY_CONNECT",
+      "PROBE",
+      "ACTIVATE"
+    ];
+    OWNERSHIP_MODES = ["platform_managed", "customer_owned"];
+    new Set(OWNERSHIP_MODES);
+    new Set(STEP_KINDS);
+    WorkflowStep = z.object({
+      id: z.string().min(1),
+      kind: z.enum(STEP_KINDS),
+      title: z.string().min(1),
+      /** JSON Schema for FORM/SECRET inputs — schema-driven, no connector UI code. */
+      schema: z.record(z.unknown()).optional(),
+      /** Credential role for SECRET/OAUTH outputs. */
+      role: z.string().optional(),
+      approvalKind: z.string().optional(),
+      resourceKind: z.string().optional(),
+      mode: z.string().optional(),
+      dependsOn: z.array(z.string()).default([]),
+      optional: z.boolean().default(false),
+      /**
+       * Ownership modes this step applies to (absent = all). A REQUIRED step out of the run's mode is ownership-skipped
+       * (`OUT_OF_MODE`), which is distinct from `optional` — the engine must skip it regardless of `optional` (#306 §9).
+       */
+      ownership: z.array(z.enum(OWNERSHIP_MODES)).optional(),
+      repeatable: z.boolean().default(false),
+      producesChannels: z.array(z.string()).default([])
+    }).strict();
+    ConnectorWorkflow = z.object({
+      version: z.string().min(1),
+      steps: z.array(WorkflowStep).min(1),
+      /** What ACTIVATE requires (condition type ids). */
+      activationGates: z.array(z.string()),
+      /** The single step that re-establishes credentials. */
+      reauth: z.object({ stepId: z.string() }).strict(),
+      /** Steps that adopt existing resources on transfer / reconnect. */
+      relink: z.object({ stepIds: z.array(z.string()) }).strict()
+    }).strict();
+  }
+});
+var EXCLUSIVITY, TIMEOUT_EFFECTS, RECONCILE_BY, ABSENCE_PROOF_METHODS, DUPLICATE_COSTS, RESOURCE_KIND_RE, ResourceKindDeclaration;
+var init_external_resources = __esm({
+  "../contracts/src/channel-connector/external-resources.ts"() {
+    init_ids2();
+    EXCLUSIVITY = ["exclusive", "per_connection", "shared"];
+    TIMEOUT_EFFECTS = ["UNKNOWN", "NO_EFFECT", "PROVIDER_ACCEPTS", "PROVIDER_REJECTS"];
+    RECONCILE_BY = ["provider_ref", "correlation_tag", "listing", "none"];
+    ABSENCE_PROOF_METHODS = ["provider_ref", "correlation_tag", "listing"];
+    DUPLICATE_COSTS = ["low", "high"];
+    RESOURCE_KIND_RE = /^[a-z0-9]+(\.[a-z0-9_]+)+$/;
+    ResourceKindDeclaration = z.object({
+      kind: z.string().regex(RESOURCE_KIND_RE, "resource kind must be a namespaced dotted id"),
+      /** Customer-facing name of the kind (presentation only; the connector owns its provider vocabulary). */
+      label: z.string().min(1).optional(),
+      parentKinds: z.array(z.string()).default([]),
+      /** Channels this kind enables (registry ids), if any. */
+      channels: z.array(z.string()).default([]),
+      /** An installation target (guild, workspace, tenant, business account). */
+      isContainer: z.boolean().default(false),
+      /** A channel identity (sender). */
+      isSender: z.boolean().default(false),
+      isRegulatory: z.boolean().default(false),
+      exclusivity: z.enum(EXCLUSIVITY),
+      /** Provider-side sharing cap, manifest DATA never a core constant (e.g. Meta WABA = 2). */
+      maxHolders: z.number().int().positive().optional(),
+      /** doc 06 `reconcile { by, absenceProof?, duplicateCost }`. */
+      reconcile: z.object({
+        by: z.enum(RECONCILE_BY),
+        absenceProof: z.object({ minAgeSec: z.number().int().nonnegative(), method: z.enum(ABSENCE_PROOF_METHODS) }).strict().optional(),
+        duplicateCost: z.enum(DUPLICATE_COSTS)
+      }).strict(),
+      /** doc 06 `release { destructive }`. */
+      release: z.object({ destructive: z.boolean() }).strict().default({ destructive: false }),
+      /** Timeout semantics for the effect that creates this kind (D-23). */
+      createTimeoutEffect: z.enum(TIMEOUT_EFFECTS).default("UNKNOWN")
+    }).strict().superRefine((decl, ctx) => {
+      if (decl.isContainer && decl.exclusivity === "exclusive") {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: `container kind ${decl.kind} cannot be exclusive` });
+      }
+      if (decl.maxHolders !== void 0 && decl.exclusivity === "exclusive" && decl.maxHolders !== 1) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: `exclusive kind ${decl.kind} cannot declare maxHolders > 1` });
+      }
+      if (decl.exclusivity === "shared" && (decl.isSender || decl.isContainer)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: `shared kind ${decl.kind} is referenced by value and cannot be a sender or container` });
+      }
+      if (decl.reconcile.absenceProof && decl.reconcile.by === "none") {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: `kind ${decl.kind}: absenceProof needs a reconcile method other than none` });
+      }
+    });
+  }
+});
+
+// ../contracts/src/channel-connector/approvals.ts
+var APPROVAL_KINDS;
+var init_approvals = __esm({
+  "../contracts/src/channel-connector/approvals.ts"() {
+    APPROVAL_KINDS = [
+      "business_verification",
+      "campaign_vetting",
+      "toll_free_verification",
+      "app_review",
+      "privileged_permission_review",
+      "admin_consent",
+      "display_name_review",
+      "template_review",
+      "agent_launch",
+      "brand_verification"
+    ];
+    new Set(APPROVAL_KINDS);
+  }
+});
+var DEPLOYMENT_MODELS, CREDENTIAL_STRENGTHS, CREDENTIAL_ROLES, INSTALLATION_KINDS, AUTHORIZATION_METHODS, AUTHORIZATION_CAPABILITIES, AuthorizationMethodDeclaration, INBOUND_AUTH_AVAILABILITY, InboundAuthMethodDeclaration, MutationApprovalDeclaration, ReadinessGateSchema, FormatsSchema, LimitsSchema, DescriptorOverride, DecisionRequestDeclaration;
+var init_manifest = __esm({
+  "../contracts/src/channel-connector/manifest.ts"() {
+    init_identity();
+    init_approvals();
+    init_capability_state();
+    init_channels();
+    init_content_kinds();
+    init_external_resources();
+    init_ids2();
+    init_onboarding();
+    init_operations();
+    init_onboarding();
+    DEPLOYMENT_MODELS = ["per_tenant_app", "platform_app", "both"];
+    CREDENTIAL_STRENGTHS = ["ephemeral", "brokered", "exported_static"];
+    CREDENTIAL_ROLES = ["primary", "signing", "webhook", "refresh", "app_signing", "oauth_client", "partner"];
+    INSTALLATION_KINDS = ["guild", "user", "workspace", "org", "tenant", "team", "business_account", "chat"];
+    new Set(INSTALLATION_KINDS);
+    z.string().regex(/^cred:[a-z0-9_-]+\/[^\s]+$/, "A5 credential ref `cred:<store>/<path>`");
+    AUTHORIZATION_METHODS = ["oauth", "api_key", "api_secret", "account_token", "bot_token", "delegated_app", "installation_token", "certificate", "other"];
+    AUTHORIZATION_CAPABILITIES = ["discover", "provision", "send", "receive", "manage_resources", "manage_compliance", "manage_webhooks", "manage_installations", "manage_accounts"];
+    AuthorizationMethodDeclaration = z.object({
+      id: z.string().min(1),
+      method: z.enum(AUTHORIZATION_METHODS),
+      credentialRoles: z.array(z.enum(CREDENTIAL_ROLES)).min(1),
+      capabilities: z.array(z.enum(AUTHORIZATION_CAPABILITIES)).default([]),
+      scope: z.enum(["account", "container"]).optional()
+    }).strict();
+    INBOUND_AUTH_AVAILABILITY = ["ga", "beta", "private_beta", "unavailable"];
+    InboundAuthMethodDeclaration = z.object({
+      id: z.string().min(1),
+      verifier: z.string().min(1),
+      credentialRole: z.enum(CREDENTIAL_ROLES),
+      compatibleWith: z.array(z.object({ authMethodId: z.string().min(1), reusesAuthCredential: z.boolean() }).strict()).default([]),
+      availability: z.enum(INBOUND_AUTH_AVAILABILITY).default("ga")
+    }).strict();
+    MutationApprovalDeclaration = z.object({
+      effect: z.string().min(1),
+      approval: z.enum(["explicit", "implicit"]),
+      capturePriorState: z.boolean().default(false)
+    }).strict();
+    ReadinessGateSchema = z.object({
+      condition: z.string().min(1),
+      class: z.enum(CONDITION_CLASSES),
+      blocks: z.union([z.literal("*"), z.array(z.string())]),
+      ttlSec: z.number().int().nonnegative(),
+      evidence: z.enum(["configuration", "runtime"]).optional()
+    }).strict();
+    FormatsSchema = z.record(
+      z.enum(CONTENT_KINDS),
+      z.object({ mime: z.array(z.string()).optional(), variants: z.array(z.string()).optional() }).strict()
+    );
+    LimitsSchema = z.object({
+      textChars: z.number().int().positive().optional(),
+      textBytes: z.number().int().positive().optional(),
+      mediaBytes: z.number().int().positive().optional(),
+      segments: z.boolean().optional(),
+      perSecond: z.number().positive().optional(),
+      perRecipientPerSecond: z.number().positive().optional(),
+      formats: FormatsSchema.optional(),
+      note: z.string().optional()
+    }).strict();
+    DescriptorOverride = z.object({
+      version: z.string().min(1).optional(),
+      operations: z.array(z.string()).optional(),
+      direction: z.object({ inbound: z.boolean(), outbound: z.boolean() }).strict().optional(),
+      initiation: z.object({ agentInitiated: z.enum(AGENT_INITIATION), userInitiated: z.boolean(), firstContactRule: z.string() }).strict().optional(),
+      windows: z.array(
+        z.object({
+          kind: z.literal("reply"),
+          durationSec: z.number().int().positive(),
+          opensOn: z.enum(["inbound_message", "user_action"]),
+          outside: z.enum(WINDOW_OUTSIDE)
+        }).strict()
+      ).optional(),
+      templates: z.object({ required: z.enum(TEMPLATE_REQUIREMENT), reviewed: z.boolean(), categories: z.array(z.string()).optional() }).strict().optional(),
+      surfaces: z.array(z.enum(SURFACES)).optional(),
+      messageTypes: z.array(z.enum(CONTENT_KINDS)).optional(),
+      limits: LimitsSchema.optional(),
+      receipts: z.array(z.enum(RECEIPT_KINDS)).optional(),
+      edits: z.object({ edit: z.boolean(), delete: z.boolean(), reactions: z.boolean(), commands: z.boolean() }).strict().optional(),
+      transport: z.array(z.enum(TRANSPORT_KINDS)).optional(),
+      identity: z.object({ peerIdKind: z.string(), peerIdScope: z.enum(PEER_ID_SCOPES) }).strict().optional(),
+      requiredPermissions: z.array(z.string()).optional(),
+      registration: z.array(z.object({ kind: z.string(), blocks: z.array(z.string()) }).strict()).optional(),
+      readinessGates: z.array(ReadinessGateSchema).optional()
+    }).strict();
+    DecisionRequestDeclaration = z.object({
+      kind: z.string().min(1),
+      responseDeadlineSec: z.number().int().positive(),
+      /** The provider's law when we stay silent. */
+      defaultOutcome: z.enum(TIMEOUT_EFFECTS)
+    }).strict();
+    z.object({
+      /** A7 `<publisher>/<name>`. */
+      id: z.string().min(3),
+      /** A7: semver. */
+      version: z.string().regex(SEMVER_RE, "A7: plugin versions are semver"),
+      displayName: z.string().min(1),
+      publisher: z.string().min(1),
+      /** A STABLE https URL of the provider's own console (the `provider_console` remediation carries it); absent ⇒ remediation has no link. */
+      consoleUrl: z.string().url().optional(),
+      /** The publisher's reverse-domain namespace (`com.acme`) under which every contributed extension id must sit; verified in ch. 05 (D-9). Absent for first-party connectors, which use registry ids only. */
+      namespace: z.string().regex(NAMESPACE_RE, "namespace must be <root>.<label>").optional(),
+      deployment: z.enum(DEPLOYMENT_MODELS),
+      credentialStrength: z.enum(CREDENTIAL_STRENGTHS),
+      /** Roles this connector's connections store refs under. */
+      credentialRoles: z.array(z.enum(CREDENTIAL_ROLES)).default(["primary"]),
+      /** Channels served, each with its descriptor diff over the baseline. */
+      channels: z.array(z.object({ channel: z.string().min(1), descriptor: DescriptorOverride.default({}) }).strict()).min(1),
+      /** Operations the connector implements (registry ids or its own extension ops). */
+      operations: z.array(z.string()).min(1),
+      /** Extension operations this connector defines — each MUST declare a mode. */
+      extensionOperations: z.array(z.object({ id: z.string(), mode: z.enum(OPERATION_MODES), summary: z.string() }).strict()).default([]),
+      onboarding: ConnectorWorkflow,
+      resourceKinds: z.array(ResourceKindDeclaration).default([]),
+      installationKinds: z.array(z.string()).default([]),
+      transports: z.array(z.enum(TRANSPORT_KINDS)).min(1),
+      /** doc 05 §2: transports the provider makes mutually exclusive (e.g. webhook vs long_poll). */
+      transportsExclusive: z.array(z.array(z.enum(TRANSPORT_KINDS)).min(2)).default([]),
+      /** Verifier id the ingress runs before parsing; required with the `webhook` transport. */
+      webhookVerifier: z.string().min(1).optional(),
+      /** Reconcile handler ids by resource kind (doc 02). */
+      reconcilers: z.array(z.object({ resourceKind: z.string(), handler: z.string().min(1) }).strict()).default([]),
+      /** Inbound decision requests with provider-defined defaults (D-23). */
+      decisionRequests: z.array(DecisionRequestDeclaration).default([]),
+      /** Identifier kinds contributed to the ch. 00 B-1 vocabulary. */
+      identifierKinds: z.array(z.string()).default([]),
+      /** Approval kinds used (registry or extension ids). */
+      approvalKinds: z.array(z.string()).default([]),
+      /** Attribution key names used under `platform_app` (doc 08 §4a step 3). */
+      attributionKeys: z.array(z.string()).default([]),
+      /** Quarantine window for PENDING_ATTRIBUTION (D-21), seconds. */
+      pendingAttributionTtlSec: z.number().int().positive().default(7 * 86400),
+      metadata: z.record(z.unknown()).default({}),
+      /** Which relationship ownerships this connector serves (#306 §A/C1). A managed-capable connector MUST declare it explicitly; the default serves only the common OAuth-BYO connector. */
+      ownershipModes: z.array(z.enum(OWNERSHIP_MODES)).min(1).default(["customer_owned"]),
+      /** Authorization methods the connector supports (#306 §4/C3). */
+      authorizationMethods: z.array(AuthorizationMethodDeclaration).default([]),
+      /** Inbound-event authentication strategies (#306 §4/C4); `webhookVerifier` is the single-strategy shorthand, normalized by `resolveInboundAuthMethods`. */
+      inboundAuthMethods: z.array(InboundAuthMethodDeclaration).default([]),
+      /** Provider effects that require an explicit decision, keyed on stable effect ids (#306 L5/C5). */
+      mutationApprovals: z.array(MutationApprovalDeclaration).default([])
+    }).strict();
+  }
+});
+
+// ../contracts/src/channel-connector/index.ts
+var init_channel_connector = __esm({
+  "../contracts/src/channel-connector/index.ts"() {
+    init_ids2();
+    init_operations();
+    init_content_kinds();
+    init_capability_state();
+    init_onboarding();
+    init_external_resources();
+    init_approvals();
+    init_channels();
+    init_manifest();
+  }
+});
+function isSafeMonitoringHref(href) {
+  if (href !== href.trim() || UNSAFE_CHARS.test(href) || href.includes("\\") || /%2e|%2f|%5c|%25/i.test(href)) return false;
+  if (href.startsWith("/")) {
+    if (href.startsWith("//")) return false;
+    try {
+      const u = new URL(href, "https://dashboard.invalid");
+      return u.origin === "https://dashboard.invalid" && u.pathname.startsWith("/dashboard/") && u.pathname + u.search + u.hash === href;
+    } catch {
+      return false;
+    }
+  }
+  if (!href.startsWith("https://")) return false;
+  try {
+    const u = new URL(href);
+    return u.protocol === "https:" && !u.username && !u.password && Boolean(u.hostname);
+  } catch {
+    return false;
+  }
+}
+var Label, Short, Body, Iso, MonitoringAuthor, MonitoringTone, UNSAFE_CHARS, MonitoringBlock, PresentedCommunication, MonitoringChannelId, MonitoringChannelRef, MonitoredPeer, MonitoredConversationSummary, MonitoredCommunication, MonitoringUnlinkedHistory, MONITORING_DIRECTIONS, MONITORING_STATES, MONITORING_MAX_ID_FILTERS, MONITORING_MAX_CHANNEL_FILTERS;
+var init_monitoring = __esm({
+  "../contracts/src/monitoring.ts"() {
+    Label = z.string().trim().min(1).max(60);
+    Short = z.string().max(300);
+    Body = z.string().max(4e3);
+    Iso = z.string().datetime();
+    MonitoringAuthor = z.enum(["peer", "agent", "system"]);
+    MonitoringTone = z.enum(["ok", "warn", "bad", "info", "neutral"]);
+    UNSAFE_CHARS = /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u180e\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff\u{e0000}-\u{e007f}]/u;
+    new RegExp(UNSAFE_CHARS.source, "gu");
+    MonitoringBlock = z.discriminatedUnion("type", [
+      /** One line of the conversation: what was said, by whom. */
+      z.object({ type: z.literal("message"), author: MonitoringAuthor, text: Body, at: Iso.optional() }).strict(),
+      /** Channel facts worth seeing at a glance (Discord server/channel, SMS from/to, call duration). */
+      z.object({ type: z.literal("facts"), items: z.array(z.object({ label: Label, value: Short }).strict()).min(1).max(12) }).strict(),
+      /** The communication's state in words, with a tone. */
+      z.object({ type: z.literal("status"), label: Label, tone: MonitoringTone }).strict(),
+      /** Somewhere to go: the provider's own view of it (https) or a deeper dashboard page. */
+      z.object({ type: z.literal("link"), label: Label, href: z.string().max(2e3).refine(isSafeMonitoringHref, "href must be https or a /dashboard/ path") }).strict(),
+      /** A dated lifecycle fact (sent, delivered, answered, ended). */
+      z.object({ type: z.literal("event"), label: z.string().trim().min(1).max(120), at: Iso }).strict(),
+      /** A spoken exchange, turn by turn. */
+      z.object({
+        type: z.literal("transcript"),
+        turns: z.array(z.object({ author: MonitoringAuthor, text: Body, offsetMs: z.number().int().nonnegative().optional() }).strict()).max(500)
+      }).strict()
+    ]);
+    PresentedCommunication = z.object({
+      /** One line for lists ("Asked: What is 2 + 2?"). */
+      summary: z.string().max(140).optional(),
+      /**
+       * Something new starts at this communication — e.g. the agent began a fresh session with no memory of what came
+       * before. The page draws a labelled divider before it. Additive to v1: a reader that ignores it loses nothing else.
+       */
+      boundary: z.object({ label: z.string().trim().min(1).max(80) }).strict().optional(),
+      blocks: z.array(MonitoringBlock).max(50)
+    }).strict();
+    MonitoringChannelId = z.string().regex(/^[a-z][a-z0-9_.-]{0,39}$/);
+    MonitoringChannelRef = z.object({ id: z.string(), label: z.string() }).strict();
+    MonitoredPeer = z.object({
+      kind: z.string().nullable(),
+      address: z.string().nullable(),
+      /** From the channel's presenter (`describePeer`); null when it has no better name than the address. */
+      displayName: z.string().nullable()
+    }).strict();
+    MonitoredConversationSummary = z.object({
+      id: z.string().uuid(),
+      status: z.string(),
+      openedAt: z.string(),
+      lastActivityAt: z.string(),
+      agent: z.object({ id: z.string(), name: z.string() }).strict().nullable(),
+      peer: MonitoredPeer,
+      channels: z.array(MonitoringChannelRef),
+      communications: z.number().int().nonnegative(),
+      /** The latest INBOUND communication's one-liner (else the latest), as its channel presents it. */
+      summary: z.string().nullable(),
+      /** Something in it failed (a message not delivered, a call that failed). */
+      failed: z.boolean(),
+      /** A call in it is still in progress. */
+      live: z.boolean()
+    }).strict();
+    MonitoredCommunication = z.object({
+      id: z.string().uuid(),
+      type: z.string(),
+      channel: MonitoringChannelRef,
+      direction: z.string(),
+      status: z.string(),
+      startedAt: z.string(),
+      endedAt: z.string().nullable(),
+      /** Which presenter shaped it (`vl/discord`, `vl/sms`, `generic`), for support. */
+      presenter: z.string(),
+      presented: PresentedCommunication
+    }).strict();
+    MonitoringUnlinkedHistory = z.object({ calls: z.boolean(), messages: z.boolean() }).strict();
+    z.object({
+      blocksVersion: z.number().int(),
+      scope: z.string(),
+      conversations: z.array(MonitoredConversationSummary),
+      /** Opaque; pass back as `cursor` for the next (older) page. Null on the last page. */
+      nextCursor: z.string().nullable(),
+      /** History from before a channel was linked to the ledger (not shown here, 🔒 control-plane F8/F12). */
+      unlinkedHistory: MonitoringUnlinkedHistory
+    }).strict();
+    z.object({
+      blocksVersion: z.number().int(),
+      scope: z.string(),
+      conversation: MonitoredConversationSummary,
+      /** Oldest first. The page holds the LATEST communications; `earlierCursor` fetches the ones before them. */
+      communications: z.array(MonitoredCommunication),
+      earlierCursor: z.string().nullable()
+    }).strict();
+    z.object({
+      scope: z.string(),
+      /** Channels a presenter currently shows, named by that presenter. */
+      channels: z.array(MonitoringChannelRef),
+      /** The Lines (numbers, bots) conversations in this scope arrived on. */
+      lines: z.array(z.object({ id: z.string().uuid(), label: z.string() }).strict())
+    }).strict();
+    MONITORING_DIRECTIONS = ["inbound", "outbound"];
+    MONITORING_STATES = ["live", "failed", "ok"];
+    MONITORING_MAX_ID_FILTERS = 50;
+    MONITORING_MAX_CHANNEL_FILTERS = 20;
+    z.object({
+      scope: z.enum(["env:dev", "env:stg", "env:prd"]).optional(),
+      limit: z.coerce.number().int().min(1).max(100).optional(),
+      cursor: z.string().max(200).optional(),
+      from: z.string().datetime().optional(),
+      to: z.string().datetime().optional(),
+      channel: z.array(MonitoringChannelId).max(MONITORING_MAX_CHANNEL_FILTERS).optional(),
+      direction: z.array(z.enum(MONITORING_DIRECTIONS)).max(2).optional(),
+      line: z.array(z.string().uuid()).max(MONITORING_MAX_ID_FILTERS).optional(),
+      agent: z.array(z.string().uuid()).max(MONITORING_MAX_ID_FILTERS).optional(),
+      status: z.array(z.enum(MONITORING_STATES)).max(3).optional(),
+      customer: z.string().trim().max(100).optional()
+    }).strict();
+  }
+});
+var WalletRefusalCode, WalletMode, WalletInvoiceStatus, WalletInvoice, WalletEntryKind, WalletEntry, TOPUP_MIN_USD, TOPUP_MAX_USD;
+var init_wallet = __esm({
+  "../contracts/src/wallet.ts"() {
+    WalletRefusalCode = z.enum([
+      // Prepaid balance (or an invoiced credit limit) cannot cover the action.
+      "insufficient_balance",
+      // The wallet is frozen after a card dispute, until an operator unfreezes it.
+      "account_frozen",
+      // An invoice is unpaid past its 7 days' grace (B-19): new calls, messages and answers are refused; inbound calls are
+      // still answered. Paying the invoice restores the workspace.
+      "account_suspended",
+      // The action's reservation already closed (e.g. a call ended or expired) — it cannot be re-admitted.
+      "hold_closed"
+    ]);
+    z.object({
+      error: WalletRefusalCode,
+      code: WalletRefusalCode,
+      availableUsd: z.string(),
+      needUsd: z.string(),
+      message: z.string()
+    });
+    WalletMode = z.enum(["prepaid", "invoiced"]);
+    z.object({
+      mode: WalletMode,
+      status: z.enum(["active", "frozen"]),
+      // Decimal strings, six places (the ledger's micro-dollar precision).
+      balanceUsd: z.string(),
+      // Reserved for calls in progress.
+      heldUsd: z.string(),
+      // balance − held (+ credit limit when invoiced); null = unlimited.
+      availableUsd: z.string().nullable(),
+      creditLimitUsd: z.string().nullable(),
+      // A card saved by the first top-up — what auto top-up charges.
+      cardOnFile: z.boolean(),
+      autoTopup: z.object({ enabled: z.boolean(), thresholdUsd: z.string(), amountUsd: z.string() }),
+      // B-19: 'past_due' = an invoice is overdue (a pay-now banner); 'suspended' = paused for it (or by an operator).
+      standing: z.enum(["good", "past_due", "suspended"]),
+      // Why it is suspended: an invoice unpaid past grace (paying restores it) or an operator (only support lifts it).
+      suspension: z.enum(["unpaid_invoice", "operator"]).nullable(),
+      // The oldest overdue invoice, when there is one.
+      overdueInvoice: z.object({ amountUsd: z.string(), dueAt: z.string(), payUrl: z.string().nullable() }).nullable(),
+      // Invoiced wallets: what the next invoice holds so far (charges since the last invoice); null when prepaid.
+      uninvoicedUsd: z.string().nullable()
+    });
+    WalletInvoiceStatus = z.enum(["draft", "open", "paid", "void", "uncollectible"]);
+    WalletInvoice = z.object({
+      id: z.string(),
+      // 'final' = issued when the workspace moved to prepaid.
+      kind: z.enum(["monthly", "final"]),
+      periodStart: z.string(),
+      periodEnd: z.string(),
+      amountUsd: z.string(),
+      status: WalletInvoiceStatus,
+      issuedAt: z.string().nullable(),
+      dueAt: z.string().nullable(),
+      paidAt: z.string().nullable(),
+      // Stripe's hosted page to view and pay it (null until issued).
+      payUrl: z.string().nullable()
+    });
+    z.object({ invoices: z.array(WalletInvoice) });
+    WalletEntryKind = z.enum(["grant", "topup", "usage", "refund", "refund_reversal", "dispute", "dispute_reinstated", "adjustment", "invoice_payment"]);
+    WalletEntry = z.object({
+      id: z.string(),
+      kind: WalletEntryKind,
+      // Signed: a credit is positive, a debit negative.
+      amountUsd: z.string(),
+      balanceAfterUsd: z.string(),
+      // The usage row a debit charged (usage entries only).
+      usageEventId: z.string().nullable(),
+      note: z.string().nullable(),
+      createdAt: z.string()
+    });
+    z.object({
+      entries: z.array(WalletEntry),
+      // Pass as `before` for the next (older) page; null when there is none.
+      nextBefore: z.string().nullable()
+    });
+    TOPUP_MIN_USD = 10;
+    TOPUP_MAX_USD = 500;
+    z.object({ amountUsd: z.number().int().min(TOPUP_MIN_USD).max(TOPUP_MAX_USD) });
+    z.object({
+      enabled: z.boolean(),
+      thresholdUsd: z.number().min(1).max(TOPUP_MAX_USD),
+      amountUsd: z.number().int().min(TOPUP_MIN_USD).max(TOPUP_MAX_USD)
+    });
+  }
+});
 
 // ../contracts/src/index.ts
 var init_src = __esm({
@@ -1914,6 +3447,8 @@ var init_src = __esm({
     init_forms();
     init_consultation();
     init_agent_config();
+    init_agent_versions();
+    init_providers();
     init_model_catalog();
     init_evaluations();
     init_tests();
@@ -1928,9 +3463,12 @@ var init_src = __esm({
     init_flow_validate();
     init_flow_builtins();
     init_compliance();
+    init_sms_keywords();
     init_call_recording();
     init_outbound();
     init_connection();
+    init_telephony();
+    init_a2p();
     init_connector();
     init_connector_stream();
     init_flow_compile();
@@ -1940,20 +3478,27 @@ var init_src = __esm({
     init_playbooks();
     init_playbook_versions();
     init_playbook_compile();
+    init_effect_stack();
+    init_engine();
+    init_identity();
+    init_interaction();
+    init_channel_connector();
+    init_monitoring();
+    init_wallet();
   }
 });
 
 // src/runtime/graph/interpolate.ts
-function interpolate(template, scope) {
+function interpolate(template, scope2) {
   if (!template || template.indexOf("{{") === -1) return template;
   return template.replace(TOKEN, (_match, expr) => {
-    const value = resolvePath(scope, expr.trim());
+    const value = resolvePath(scope2, expr.trim());
     return value === void 0 || value === null ? "" : String(value);
   });
 }
-function resolvePath(scope, path) {
+function resolvePath(scope2, path) {
   const parts = path.split(".").map((p) => p.trim()).filter((p) => p.length > 0);
-  let current = scope;
+  let current = scope2;
   for (const part of parts) {
     if (current === null || typeof current !== "object") return void 0;
     const obj = current;
@@ -2003,6 +3548,20 @@ var init_builtins = __esm({
     init_src();
   }
 });
+function createChatClient(config = {}) {
+  return new OpenAI({
+    ...config.apiKey ? { apiKey: config.apiKey } : {},
+    ...config.baseURL ? { baseURL: config.baseURL } : {},
+    ...config.timeoutMs ? { timeout: config.timeoutMs } : {}
+  });
+}
+var init_dist = __esm({
+  "../llm-client/dist/index.js"() {
+  }
+});
+function runWithOpenAIScope(client, fn) {
+  return scope.run(client, fn);
+}
 function defaultOpenAIOptions() {
   if (!credential) return {};
   return {
@@ -2010,17 +3569,283 @@ function defaultOpenAIOptions() {
     ...credential.baseURL ? { baseURL: credential.baseURL } : {}
   };
 }
+function internalChatClient(opts) {
+  const cred = defaultOpenAIOptions();
+  return createChatClient({
+    ...cred.apiKey ? { apiKey: cred.apiKey } : {},
+    ...cred.baseURL ? { baseURL: cred.baseURL } : {},
+    ...{}
+  });
+}
 function defaultOpenAI() {
-  return cached ??= new OpenAI(defaultOpenAIOptions());
+  return scope.getStore() ?? (cached ??= internalChatClient());
 }
 function hasOpenAiKey() {
-  return credential !== null || Boolean(process.env["OPENAI_API_KEY"]);
+  return scope.getStore() !== void 0 || credential !== null || Boolean(process.env["OPENAI_API_KEY"]);
 }
-var credential, cached;
+var credential, cached, scope;
 var init_openai_default = __esm({
   "src/runtime/openai-default.ts"() {
+    init_dist();
     credential = null;
     cached = null;
+    scope = new AsyncLocalStorage();
+  }
+});
+var init_ssrf = __esm({
+  "src/brain/ssrf.ts"() {
+  }
+});
+
+// src/brain/serialize.ts
+var init_serialize = __esm({
+  "src/brain/serialize.ts"() {
+  }
+});
+
+// src/brain/transport-callback.ts
+var init_transport_callback = __esm({
+  "src/brain/transport-callback.ts"() {
+    init_serialize();
+  }
+});
+
+// src/brain/connector-llm.ts
+var init_connector_llm = __esm({
+  "src/brain/connector-llm.ts"() {
+    init_serialize();
+  }
+});
+var init_wrap = __esm({
+  "src/providers/wrap.ts"() {
+  }
+});
+
+// src/providers/index.ts
+async function importOptional(spec, hint) {
+  try {
+    return await import(spec);
+  } catch {
+    throw new Error(`${hint}: "${spec}" is not installed. Add it with: pnpm add ${spec}`);
+  }
+}
+function withCreds(opts, creds2) {
+  if (creds2?.apiKey) opts["apiKey"] = creds2.apiKey;
+  if (creds2?.baseURL) opts["baseURL"] = creds2.baseURL;
+  return opts;
+}
+var deepgram, openai, anthropic, cartesia, elevenlabs, assemblyai, google, silero;
+var init_providers2 = __esm({
+  "src/providers/index.ts"() {
+    init_ssrf();
+    init_transport_callback();
+    init_connector_llm();
+    init_wrap();
+    deepgram = {
+      stt(options = {}) {
+        return async () => {
+          const dg = await importOptional("@voicelayer/agents-plugin-deepgram", "deepgram.stt");
+          return new dg.STT(
+            withCreds(
+              { model: options.model ?? "nova-3", language: options.language ?? "en-US" },
+              options
+            )
+          );
+        };
+      },
+      tts(options = {}) {
+        return async () => {
+          const dg = await importOptional("@voicelayer/agents-plugin-deepgram", "deepgram.tts");
+          return new dg.TTS(
+            withCreds({ model: options.model ?? "aura-2-harmonia-en" }, options)
+          );
+        };
+      }
+    };
+    openai = {
+      llm(options = {}) {
+        return async () => {
+          const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.llm");
+          return new oa.LLM(
+            withCreds({ model: options.model ?? "gpt-4o-mini" }, options)
+          );
+        };
+      },
+      tts(options = {}) {
+        return async () => {
+          const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.tts");
+          const opts = { model: options.model ?? "tts-1" };
+          if (options.voice) opts["voice"] = options.voice;
+          if (options.instructions) opts["instructions"] = options.instructions;
+          return new oa.TTS(withCreds(opts, options));
+        };
+      },
+      // Speech-to-speech via the OpenAI Realtime API. Returns a RealtimeProvider
+      // that the SDK uses in place of the stt/llm/tts pipeline.
+      realtime(options = {}) {
+        return async () => {
+          const oa = await importOptional("@voicelayer/agents-plugin-openai", "openai.realtime");
+          const opts = {};
+          if (options.model) opts["model"] = options.model;
+          if (options.voice) opts["voice"] = options.voice;
+          return new oa.realtime.RealtimeModel(withCreds(opts, options));
+        };
+      }
+    };
+    anthropic = {
+      llm(options = {}) {
+        return async () => {
+          const an = await importOptional("@livekit/agents-plugin-anthropic", "anthropic.llm");
+          return new an.LLM(
+            withCreds({ model: options.model ?? "claude-sonnet-4" }, options)
+          );
+        };
+      }
+    };
+    cartesia = {
+      tts(options = {}) {
+        return async () => {
+          const ct = await importOptional("@voicelayer/agents-plugin-cartesia", "cartesia.tts");
+          return new ct.TTS(options);
+        };
+      },
+      stt(options = {}) {
+        return async () => {
+          const ct = await importOptional("@voicelayer/agents-plugin-cartesia", "cartesia.stt");
+          const opts = {};
+          if (options.model) opts["model"] = options.model;
+          if (options.language) opts["language"] = options.language;
+          return new ct.STT(withCreds(opts, options));
+        };
+      }
+    };
+    elevenlabs = {
+      tts(options = {}) {
+        return async () => {
+          const el = await importOptional("@voicelayer/agents-plugin-elevenlabs", "elevenlabs.tts");
+          const opts = {};
+          if (options.voice) opts["voiceId"] = options.voice;
+          if (options.model) opts["model"] = options.model;
+          return new el.TTS(withCreds(opts, options));
+        };
+      }
+    };
+    assemblyai = {
+      stt(options = {}) {
+        return async () => {
+          const aai = await importOptional("@voicelayer/agents-plugin-assemblyai", "assemblyai.stt");
+          const opts = {};
+          if (options.language) opts["language"] = options.language;
+          return new aai.STT(withCreds(opts, options));
+        };
+      }
+    };
+    google = {
+      llm(options = {}) {
+        return async () => {
+          const g = await importOptional("@voicelayer/agents-plugin-google", "google.llm");
+          return new g.LLM(
+            withCreds({ model: options.model ?? "gemini-2.0-flash" }, options)
+          );
+        };
+      },
+      realtime(options = {}) {
+        return async () => {
+          const g = await importOptional("@voicelayer/agents-plugin-google", "google.realtime");
+          const opts = {};
+          if (options.model) opts["model"] = options.model;
+          if (options.voice) opts["voice"] = options.voice;
+          return new g.beta.realtime.RealtimeModel(withCreds(opts, options));
+        };
+      }
+    };
+    silero = {
+      vad() {
+        return async () => {
+          const sil = await importOptional("@voicelayer/agents-plugin-silero", "silero.vad");
+          return await sil.VAD.load();
+        };
+      }
+    };
+  }
+});
+
+// src/providers/registry.ts
+function entry(id, bits) {
+  const identity = providerIdentity(id);
+  if (!identity) throw new Error(`PROVIDER_REGISTRY: no provider identity in contracts for '${id}'`);
+  return { name: identity.id, capabilities: identity.capabilities, ...bits };
+}
+var model, lang, voice, creds;
+var init_registry = __esm({
+  "src/providers/registry.ts"() {
+    init_providers2();
+    init_src();
+    model = (o) => o.model ? { model: o.model } : {};
+    lang = (o) => o.language ? { language: o.language } : {};
+    voice = (o) => o.voice ? { voice: o.voice } : {};
+    creds = (o) => o.creds ?? {};
+    ({
+      deepgram: entry("deepgram", {
+        failureClass: "vendor-api",
+        engines: ["livekit"],
+        stt: (o) => deepgram.stt({ ...model(o), ...lang(o), ...creds(o) }),
+        // Deepgram folds the voice into the model id (aura-2-<name>-en): wire config
+        // passes a voice, code config passes a model — both land as `model`.
+        tts: (o) => {
+          const m = o.voice ?? o.model;
+          return deepgram.tts({ ...m ? { model: m } : {}, ...creds(o) });
+        }
+      }),
+      openai: entry("openai", {
+        failureClass: "vendor-api",
+        engines: ["livekit", "text"],
+        llm: (o) => openai.llm({ ...model(o), ...creds(o) }),
+        tts: (o) => openai.tts({ ...voice(o), ...model(o), ...creds(o) }),
+        realtime: (o) => openai.realtime({ ...model(o), ...voice(o), ...creds(o) })
+      }),
+      anthropic: entry("anthropic", {
+        failureClass: "vendor-api",
+        engines: ["livekit", "text"],
+        llm: (o) => anthropic.llm({ ...model(o), ...creds(o) })
+      }),
+      google: entry("google", {
+        failureClass: "vendor-api",
+        engines: ["livekit", "text"],
+        llm: (o) => google.llm({ ...model(o), ...creds(o) }),
+        realtime: (o) => google.realtime({ ...model(o), ...voice(o), ...creds(o) })
+      }),
+      cartesia: entry("cartesia", {
+        failureClass: "vendor-api",
+        engines: ["livekit"],
+        stt: (o) => cartesia.stt({ ...model(o), ...lang(o), ...creds(o) }),
+        tts: (o) => cartesia.tts({ ...voice(o), ...model(o), ...creds(o) })
+      }),
+      elevenlabs: entry("elevenlabs", {
+        failureClass: "vendor-api",
+        engines: ["livekit"],
+        tts: (o) => elevenlabs.tts({ ...voice(o), ...model(o), ...creds(o) })
+      }),
+      assemblyai: entry("assemblyai", {
+        failureClass: "vendor-api",
+        engines: ["livekit"],
+        stt: (o) => assemblyai.stt({ ...lang(o), ...creds(o) })
+        // no model knob
+      }),
+      silero: entry("silero", {
+        failureClass: "local",
+        engines: ["livekit"],
+        vad: () => silero.vad()
+      })
+    });
+  }
+});
+
+// src/providers/llm.ts
+var init_llm = __esm({
+  "src/providers/llm.ts"() {
+    init_openai_default();
+    init_registry();
   }
 });
 
@@ -2033,6 +3858,7 @@ function dotProduct(a, b) {
 }
 function createOpenAIEmbedder() {
   const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
   const available = () => hasOpenAiKey();
   function remember(key, vec) {
     if (cache.size >= CACHE_MAX) {
@@ -2051,24 +3877,31 @@ function createOpenAIEmbedder() {
       if (!available() || !key) return null;
       const hit = cache.get(key);
       if (hit) return hit;
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), EMBED_TIMEOUT_MS);
-      try {
-        const res = await defaultOpenAI().embeddings.create(
-          { model: EMBED_MODEL, input: key },
-          { signal: controller.signal }
-        );
-        const vec = res.data[0]?.embedding;
-        if (!Array.isArray(vec)) return null;
-        return remember(key, vec);
-      } catch (err) {
-        console.warn("[graph] embed failed; router will fall back to judge", {
-          err: err instanceof Error ? err.message : String(err)
-        });
-        return null;
-      } finally {
-        clearTimeout(timer);
-      }
+      const pending = inflight.get(key);
+      if (pending) return pending;
+      const request = (async () => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), EMBED_TIMEOUT_MS);
+        try {
+          const res = await defaultOpenAI().embeddings.create(
+            { model: EMBED_MODEL, input: key },
+            { signal: controller.signal }
+          );
+          const vec = res.data[0]?.embedding;
+          if (!Array.isArray(vec)) return null;
+          return remember(key, vec);
+        } catch (err) {
+          graphWarn("embed failed; router will fall back to judge", {
+            err: err instanceof Error ? err.message : String(err)
+          });
+          return null;
+        } finally {
+          clearTimeout(timer);
+          inflight.delete(key);
+        }
+      })();
+      inflight.set(key, request);
+      return request;
     },
     prewarm(text) {
       void this.embed(text).catch(() => {
@@ -2084,7 +3917,8 @@ function getEmbedder() {
 var EMBED_MODEL, ROUTE_THRESHOLD, EMBED_TIMEOUT_MS, CACHE_MAX, singleton, override;
 var init_embedder = __esm({
   "src/runtime/graph/embedder.ts"() {
-    init_openai_default();
+    init_log();
+    init_llm();
     EMBED_MODEL = process.env["VOICELAYER_EMBED_MODEL"] ?? "text-embedding-3-small";
     ROUTE_THRESHOLD = Number(process.env["VL_FLOW_ROUTE_THRESHOLD"] ?? "0.62");
     EMBED_TIMEOUT_MS = Number(process.env["VL_FLOW_EMBED_TIMEOUT_MS"] ?? "2500");
@@ -2146,7 +3980,7 @@ async function routeByEmbedding(nl, ctx) {
     if (!best || score > best.score) best = { to: edge.to, score };
   }
   if (best && best.score >= ROUTE_THRESHOLD) {
-    console.log("[graph] route: embedding", { to: best.to, score: Number(best.score.toFixed(3)) });
+    graphLog("route: embedding", { to: best.to, score: Number(best.score.toFixed(3)) });
     return best.to;
   }
   return null;
@@ -2172,11 +4006,21 @@ async function evaluateCondition(condition, ctx) {
 function splitTop(text, op) {
   return text.split(op);
 }
+function conditionReadsSlots(condition) {
+  const text = condition.trim();
+  if (!text) return false;
+  return splitTop(text, "||").flatMap((part) => splitTop(part, "&&")).map((atom) => atom.trim()).some((atom) => {
+    const lower = atom.toLowerCase();
+    if (lower === "true" || lower === "always" || lower === "false" || lower === "never") return false;
+    if (TOOL_ATOM.test(atom) || NODE_ATOM.test(atom) || DTMF_ATOM.test(atom)) return false;
+    return OP_ATOM.test(atom) || SLOT_PRESENCE_ATOM.test(atom) || BARE_ATOM.test(atom);
+  });
+}
 function evaluateDeterministic(atom, ctx) {
   const lower = atom.toLowerCase();
   if (lower === "true" || lower === "always") return true;
   if (lower === "false" || lower === "never") return false;
-  const toolMatch = atom.match(/^tool[.:]([A-Za-z0-9_-]+)(?:\.([\w.]+))?\s*(==|!=)?\s*(.*)$/);
+  const toolMatch = atom.match(TOOL_ATOM);
   if (toolMatch) {
     const [, id, path, op, rawVal] = toolMatch;
     const result = ctx.tools[id];
@@ -2190,7 +4034,7 @@ function evaluateDeterministic(atom, ctx) {
     const eq = String(actual ?? "").toLowerCase() === (rawVal ?? "").trim().toLowerCase();
     return op === "!=" ? !eq : eq;
   }
-  const nodeMatch = atom.match(/^node:([A-Za-z0-9_-]+)(?:\.([\w.]+))?\s*(==|!=)?\s*(.*)$/);
+  const nodeMatch = atom.match(NODE_ATOM);
   if (nodeMatch) {
     if (!ctx.nodeResults) return void 0;
     const [, id, path, op, rawVal] = nodeMatch;
@@ -2202,14 +4046,12 @@ function evaluateDeterministic(atom, ctx) {
     const eq = String(actual ?? "").toLowerCase() === (rawVal ?? "").trim().toLowerCase();
     return op === "!=" ? !eq : eq;
   }
-  const dtmfMatch = atom.match(/^dtmf:\s*(.+)$/i);
+  const dtmfMatch = atom.match(DTMF_ATOM);
   if (dtmfMatch) {
     if (ctx.lastDtmf === void 0) return void 0;
     return ctx.lastDtmf === dtmfMatch[1].trim();
   }
-  const opMatch = atom.match(
-    /^(!?)\s*(?:slot:)?(.+?)\s*(==|!=|=|contains|starts_with|greater_than|less_than|>=|<=|>|<)\s*(.+)$/i
-  );
+  const opMatch = atom.match(OP_ATOM);
   if (opMatch) {
     const [, neg, nameRaw, op, valRaw] = opMatch;
     const raw = resolvePath(ctx.slots, nameRaw.trim());
@@ -2231,14 +4073,14 @@ function evaluateDeterministic(atom, ctx) {
     else res = value === target;
     return neg ? !res : res;
   }
-  const slotPres = atom.match(/^(!?)\s*slot:(.+?)\s*(present|empty)?$/i);
+  const slotPres = atom.match(SLOT_PRESENCE_ATOM);
   if (slotPres) {
     const [, neg, nameRaw, kw] = slotPres;
     const present = hasSlot(ctx.slots, nameRaw.trim());
     const res = (kw ?? "").toLowerCase() === "empty" ? !present : present;
     return neg ? !res : res;
   }
-  const bare = atom.match(/^(!?)\s*([\w.-]+)\s*(present|empty)?$/i);
+  const bare = atom.match(BARE_ATOM);
   if (bare) {
     const [, neg, name, kw] = bare;
     const present = hasSlot(ctx.slots, name);
@@ -2249,13 +4091,27 @@ function evaluateDeterministic(atom, ctx) {
 }
 async function pickOption(options, ctx, hint) {
   if (options.length === 0) return null;
-  const collected = Object.entries(ctx.slots).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `${k.trim()}: ${String(v)}`).join("; ");
+  return judgeSettled(ctx, (collected) => pickWith(options, collected, ctx.lastUtterance, hint));
+}
+function collectedOf(slots) {
+  return Object.entries(slots).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `${k.trim()}: ${String(v)}`).join("; ");
+}
+async function judgeSettled(ctx, run) {
+  const before = collectedOf(ctx.slots);
+  if (!ctx.settle) return run(before);
+  const [speculative, fresh] = await Promise.all([run(before), ctx.settle()]);
+  const after = collectedOf(fresh);
+  if (after === before) return speculative;
+  graphLog("judge: capture changed context; re-judging");
+  return run(after);
+}
+async function pickWith(options, collected, lastUtterance, hint) {
   const list = options.map((o, i) => `${i + 1}. ${o.text}`).join("\n");
   const prompt = [
     "Pick which outcome best matches the current state of this voice conversation.",
     ...hint && hint.trim() ? [`What decides the path: ${hint.trim()}`] : [],
     `Information collected: ${collected || "(none)"}`,
-    `The caller most recently said: "${ctx.lastUtterance ?? ""}"`,
+    `The caller most recently said: "${lastUtterance ?? ""}"`,
     "Outcomes:",
     list,
     'Answer with ONLY the outcome number, or "none" if nothing clearly matches.'
@@ -2280,7 +4136,7 @@ async function pickOption(options, ctx, hint) {
     if (!Number.isInteger(n) || n < 1 || n > options.length) return null;
     return options[n - 1]?.id ?? null;
   } catch (err) {
-    console.warn("[graph] option pick failed; treating as undecided", {
+    graphWarn("option pick failed; treating as undecided", {
       err: err instanceof Error ? err.message : String(err)
     });
     return null;
@@ -2289,12 +4145,18 @@ async function pickOption(options, ctx, hint) {
   }
 }
 async function judge(condition, ctx) {
-  const collected = Object.entries(ctx.slots).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `${k.trim()}: ${String(v)}`).join("; ");
+  return judgeSettled(ctx, (collected) => judgeWith(condition, collected, ctx.lastUtterance));
+}
+async function judgeWith(condition, collected, lastUtterance) {
   const prompt = [
     "You judge whether a condition about an ongoing voice conversation is currently TRUE.",
     `Information collected: ${collected || "(none)"}`,
-    `The caller most recently said: "${ctx.lastUtterance ?? ""}"`,
+    `The caller most recently said: "${lastUtterance ?? ""}"`,
     `Condition: ${condition}`,
+    // Observed live: "Keystone Arena." (a site name) was judged to satisfy
+    // "caller described a network problem". The judge must not fill in what
+    // the caller probably meant — only what they actually said counts.
+    'Judge only from what the caller actually said and the information collected \u2014 never infer or assume what they probably meant. If what they said does not itself establish the condition, answer "no".',
     'Answer strictly "yes" or "no".'
   ].join("\n");
   const controller = new AbortController();
@@ -2314,7 +4176,7 @@ async function judge(condition, ctx) {
     );
     return (res.choices[0]?.message?.content ?? "").trim().toLowerCase().startsWith("y");
   } catch (err) {
-    console.warn("[graph] condition judge failed; treating as false", {
+    graphWarn("condition judge failed; treating as false", {
       condition,
       err: err instanceof Error ? err.message : String(err)
     });
@@ -2323,13 +4185,20 @@ async function judge(condition, ctx) {
     clearTimeout(timer);
   }
 }
-var JUDGE_TIMEOUT_MS;
+var JUDGE_TIMEOUT_MS, TOOL_ATOM, NODE_ATOM, DTMF_ATOM, OP_ATOM, SLOT_PRESENCE_ATOM, BARE_ATOM;
 var init_conditions = __esm({
   "src/runtime/graph/conditions.ts"() {
-    init_openai_default();
+    init_log();
+    init_llm();
     init_interpolate();
     init_embedder();
     JUDGE_TIMEOUT_MS = 4e3;
+    TOOL_ATOM = /^tool[.:]([A-Za-z0-9_-]+)(?:\.([\w.]+))?\s*(==|!=)?\s*(.*)$/;
+    NODE_ATOM = /^node:([A-Za-z0-9_-]+)(?:\.([\w.]+))?\s*(==|!=)?\s*(.*)$/;
+    DTMF_ATOM = /^dtmf:\s*(.+)$/i;
+    OP_ATOM = /^(!?)\s*(?:slot:)?(.+?)\s*(==|!=|=|contains|starts_with|greater_than|less_than|>=|<=|>|<)\s*(.+)$/i;
+    SLOT_PRESENCE_ATOM = /^(!?)\s*slot:(.+?)\s*(present|empty)?$/i;
+    BARE_ATOM = /^(!?)\s*([\w.-]+)\s*(present|empty)?$/i;
   }
 });
 
@@ -2372,7 +4241,7 @@ async function resolveBranch(branches, ctx, opts) {
           if (!best || score > best.score) best = { id: b.id, score };
         }
         if (best && best.score >= ROUTE_THRESHOLD) {
-          console.log("[graph] branch: embedding", { id: best.id, score: Number(best.score.toFixed(3)) });
+          graphLog("branch: embedding", { id: best.id, score: Number(best.score.toFixed(3)) });
           return best.id;
         }
       }
@@ -2387,6 +4256,7 @@ async function resolveBranch(branches, ctx, opts) {
 var ELSE_BRANCH_ID;
 var init_branch_resolve = __esm({
   "src/runtime/graph/branch-resolve.ts"() {
+    init_log();
     init_conditions();
     init_embedder();
     ELSE_BRANCH_ID = "else";
@@ -2486,13 +4356,18 @@ function scopeFor(state, deps) {
 function str(value) {
   return typeof value === "string" ? value : "";
 }
+async function settledSlots(deps) {
+  await deps.utterances.settle?.();
+  return deps.processRt.getData();
+}
 function evalCtxOf(state, deps) {
   return {
     slots: deps.processRt.getData(),
     tools: state.toolResults,
     nodeResults: state.nodeResults,
     ...state.lastUtterance !== void 0 ? { lastUtterance: state.lastUtterance } : {},
-    ...state.lastDtmf !== void 0 ? { lastDtmf: state.lastDtmf } : {}
+    ...state.lastDtmf !== void 0 ? { lastDtmf: state.lastDtmf } : {},
+    settle: () => settledSlots(deps)
   };
 }
 function deterministicEdgeTarget(edges, ctx) {
@@ -2507,7 +4382,7 @@ async function speak(text, deps, opts) {
   const allowInterruptions = opts?.allowInterruptions === true;
   if (deps.ctx.adapter) {
     const r = await deps.ctx.adapter.say(text, { allowInterruptions });
-    console.log("[graph] said", { chars: text.length, interrupted: r.interrupted });
+    graphLog("said", { chars: text.length, interrupted: r.interrupted });
     return;
   }
   const session = deps.ctx.livekit.session;
@@ -2517,12 +4392,12 @@ async function speak(text, deps, opts) {
 
 ${text}`
     }).waitForPlayout();
-    console.log("[graph] said (realtime)", { chars: text.length });
+    graphLog("said (realtime)", { chars: text.length });
     return;
   }
   const handle = session.say(text, { allowInterruptions });
   await handle.waitForPlayout();
-  console.log("[graph] said", { chars: text.length, interrupted: handle.interrupted });
+  graphLog("said", { chars: text.length, interrupted: handle.interrupted });
 }
 async function genReply(deps, instructions) {
   if (deps.ctx.adapter) {
@@ -2531,10 +4406,13 @@ async function genReply(deps, instructions) {
   }
   await deps.ctx.livekit.session.generateReply({ instructions }).waitForPlayout();
 }
-async function nextTurn(deps, reprompt) {
+async function nextTurn(deps, reprompt, opts) {
   let reprompted = false;
   for (; ; ) {
-    const evt = await deps.utterances.next({ timeoutMs: NO_INPUT_MS });
+    const evt = await deps.utterances.next({
+      timeoutMs: NO_INPUT_MS,
+      ...opts?.deferCapture ? { deferCapture: true } : {}
+    });
     if (evt.kind === "hangup") return { result: { kind: "end" } };
     if (evt.kind === "control") return { result: evt.result };
     if (evt.kind === "timeout") {
@@ -2608,6 +4486,7 @@ function menuLabelOf(label) {
 var ASK_MAX_CLARIFY, LLM_MAX_TURNS, HUB_MAX_TURNS, NO_INPUT_MS, sayExecutor, YES_WORDS, NO_WORDS, confirmExecutor, askExecutor, gateExecutor, endExecutor, handoffExecutor, llmExecutor, toolExecutor, ragExecutor, codeExecutor, decisionExecutor, MENU_MAX_INPUTS, menuExecutor, classifyExecutor, routerExecutor, playbookExecutor, setExecutor, MAX_SUBFLOW_DEPTH, subflowExecutor, passthroughExecutor, EXECUTORS;
 var init_executors = __esm({
   "src/runtime/graph/executors.ts"() {
+    init_log();
     init_src();
     init_interpolate();
     init_builtins();
@@ -2740,6 +4619,7 @@ var init_executors = __esm({
       const policy = historyPolicyOf(node);
       const maxTurns = hub ? HUB_MAX_TURNS : LLM_MAX_TURNS;
       const base = interpolate(str(node.config.instructions), scopeFor(state, deps)) || "Help the caller using everything collected so far. Keep replies short and natural.";
+      const deferCapture = !conditional.some((e) => conditionReadsSlots(e.condition));
       for (let turn = 0; turn < maxTurns; turn++) {
         const collected = formatCollected(deps.processRt.getData());
         const parts = [base];
@@ -2752,25 +4632,19 @@ ${collected}`);
           () => guardedGenerate(node, state, deps, parts.join("\n\n"), base)
         );
         if (!hub && !terminal && conditional.length === 0) return { kind: "advance" };
-        const t = await nextTurn(deps);
+        const t = await nextTurn(deps, void 0, { deferCapture });
         if ("result" in t) return t.result;
         state.lastUtterance = t.text;
         state.lastDtmf = t.dtmf;
         if (conditional.length > 0) {
-          const target = await selectEdge(out, {
-            slots: deps.processRt.getData(),
-            tools: state.toolResults,
-            nodeResults: state.nodeResults,
-            lastDtmf: state.lastDtmf,
-            lastUtterance: state.lastUtterance
-          });
+          const target = await selectEdge(out, evalCtxOf(state, deps));
           if (target) {
-            console.log("[graph] llm: transition", { node: node.id, to: target, hub });
+            graphLog("llm: transition", { node: node.id, to: target, hub });
             return { kind: "goto", to: target };
           }
         }
       }
-      console.log("[graph] llm: turn cap reached", { node: node.id, hub });
+      graphLog("llm: turn cap reached", { node: node.id, hub });
       return terminal ? { kind: "end" } : { kind: "advance" };
     };
     toolExecutor = async (node, state, deps) => {
@@ -3129,7 +5003,7 @@ ${collected}`);
       const goal = str(cfg.goal);
       let instr = str(cfg.instructions);
       const toolNames = Array.isArray(cfg.tools) ? cfg.tools.filter((x) => typeof x === "string" && x.length > 0) : [];
-      let model = str(cfg.model) || void 0;
+      let model2 = str(cfg.model) || void 0;
       let temperature = typeof cfg.temperature === "number" ? cfg.temperature : void 0;
       let libraryExits = [];
       const ref = str(cfg.playbookRef);
@@ -3139,7 +5013,7 @@ ${collected}`);
           if (!instr) instr = resolved.instructions;
           for (const f of resolved.requiredFields) if (!required.includes(f)) required.push(f);
           for (const t of resolved.tools ?? []) if (!toolNames.includes(t)) toolNames.push(t);
-          if (!model && resolved.model) model = resolved.model;
+          if (!model2 && resolved.model) model2 = resolved.model;
           if (temperature === void 0 && resolved.temperature !== void 0) temperature = resolved.temperature;
           libraryExits = resolved.exits ?? [];
         }
@@ -3193,7 +5067,7 @@ ${collected}`);
               exits: exitOptions,
               captureVars: required,
               runTool: (name, args) => registry ? registry.run(name, args) : Promise.resolve({ ok: false, status: 0, data: { error: "no tool registry" } }),
-              ...model ? { model } : {},
+              ...model2 ? { model: model2 } : {},
               ...temperature !== void 0 ? { temperature } : {}
             });
           } finally {
@@ -3386,18 +5260,18 @@ var interpreter_exports = {};
 __export(interpreter_exports, {
   runFlowGraph: () => runFlowGraph
 });
-function pickEntry(model) {
-  return model.entry.length > 0 ? model.entry[0] : null;
+function pickEntry(model2) {
+  return model2.entry.length > 0 ? model2.entry[0] : null;
 }
-async function selectNext(model, from, result, state, deps) {
+async function selectNext(model2, from, result, state, deps) {
   if (result.kind === "goto") return result.to;
   if (result.kind === "take") {
-    const target = model.selectByPort(from, result.port);
+    const target = model2.selectByPort(from, result.port);
     if (target !== null) return target;
-    const def = model.out(from).find((e) => (!e.condition || !e.condition.trim()) && !e.sourceHandle);
+    const def = model2.out(from).find((e) => (!e.condition || !e.condition.trim()) && !e.sourceHandle);
     return def ? def.to : null;
   }
-  return selectEdge(model.out(from), {
+  return selectEdge(model2.out(from), {
     slots: deps.processRt.getData(),
     tools: state.toolResults,
     nodeResults: state.nodeResults,
@@ -3406,10 +5280,10 @@ async function selectNext(model, from, result, state, deps) {
   });
 }
 async function runFlowGraph(program, deps) {
-  const model = buildGraphModel(program);
+  const model2 = buildGraphModel(program);
   const maxNodeVisits = deps.maxNodeVisits ?? DEFAULT_MAX_NODE_VISITS;
   const maxSteps = deps.maxSteps ?? DEFAULT_MAX_STEPS;
-  let cursor = pickEntry(model);
+  let cursor = pickEntry(model2);
   if (cursor === null) return { kind: "completed" };
   const state = { toolResults: {}, nodeResults: {}, cursor };
   const visits = /* @__PURE__ */ new Map();
@@ -3419,7 +5293,7 @@ async function runFlowGraph(program, deps) {
       deps.events.note("flow.loop_guard_tripped", { reason: "max_steps", steps });
       break;
     }
-    const node = model.node(cursor);
+    const node = model2.node(cursor);
     if (!node) {
       deps.events.note("flow.missing_node", { nodeId: cursor });
       break;
@@ -3433,7 +5307,7 @@ async function runFlowGraph(program, deps) {
     }
     state.cursor = cursor;
     deps.events.enter(node.id, node.type);
-    console.log("[graph] enter", { node: node.id, type: node.type, step: steps });
+    graphLog("enter", { node: node.id, type: node.type, step: steps });
     const executor = EXECUTORS[node.type] ?? passthroughExecutor;
     let result;
     try {
@@ -3442,7 +5316,7 @@ async function runFlowGraph(program, deps) {
         processRt: deps.processRt,
         utterances: deps.utterances,
         events: deps.events,
-        model,
+        model: model2,
         ...deps.history ? { history: deps.history } : {},
         ...deps.realtime ? { realtime: true } : {},
         ...deps.resolvers ? { resolvers: deps.resolvers } : {},
@@ -3456,17 +5330,19 @@ async function runFlowGraph(program, deps) {
         return { kind: "ended", nodeId: node.id };
       }
       deps.events.note("node.errored", { nodeId: node.id, error: message });
-      const recovery = model.selectByPort(node.id, "error");
+      const recovery = model2.selectByPort(node.id, "error");
       if (recovery !== null) {
         deps.events.traverse(node.id, recovery);
         cursor = recovery;
         continue;
       }
       return { kind: "error", nodeId: node.id, message };
+    } finally {
+      await deps.utterances.settle?.();
     }
     if (result.kind === "end") return { kind: "ended", nodeId: node.id };
     if (result.kind === "handoff") return { kind: "handoff", to: result.to };
-    const next = await selectNext(model, cursor, result, state, deps);
+    const next = await selectNext(model2, cursor, result, state, deps);
     if (next !== null) deps.events.traverse(cursor, next);
     cursor = next;
   }
@@ -3475,6 +5351,7 @@ async function runFlowGraph(program, deps) {
 var DEFAULT_MAX_NODE_VISITS, DEFAULT_MAX_STEPS, HUB_MAX_NODE_VISITS;
 var init_interpreter = __esm({
   "src/runtime/graph/interpreter.ts"() {
+    init_log();
     init_graph_model();
     init_executors();
     init_conditions();
@@ -3485,15 +5362,33 @@ var init_interpreter = __esm({
 });
 
 // src/runtime/graph/index.ts
+init_log();
 init_interpreter();
 
 // src/runtime/graph/utterances.ts
+init_log();
 var EVENT_UTTERANCE = "user_input_transcribed";
 var EVENT_CLOSE = "close";
-function createUtteranceStream(session, processRt, ctx, rails, prewarm, wantsDtmf) {
+var DEFAULT_MIN_DELAY_MS = 600;
+var DEFAULT_MAX_DELAY_MS = 3e3;
+var VAD_SILENCE_MS = 550;
+var STT_LAG_MS = 400;
+function createUtteranceStream(session, processRt, ctx, rails, prewarm, wantsDtmf, onAwaitInput, endpointing) {
   const queue = [];
   let waiter = null;
   let hung = false;
+  let pending = null;
+  const capture = async (text, deferred) => {
+    const t0 = Date.now();
+    try {
+      await processRt.ingest(text, ctx);
+    } catch {
+    }
+    if (deferred) graphLog("capture", { deferred: true, ms: Date.now() - t0 });
+  };
+  const settle = async () => {
+    if (pending) await pending;
+  };
   const deliver = (e) => {
     if (hung && e.kind !== "hangup") return;
     if (waiter) {
@@ -3514,13 +5409,72 @@ function createUtteranceStream(session, processRt, ctx, rails, prewarm, wantsDtm
   };
   const unsubs = [];
   if (ctx.adapter) {
+    let onSettle2 = function() {
+      settle2 = null;
+      settleDue = Number.POSITIVE_INFINITY;
+      const idle = Date.now() - lastActivity;
+      if (speaking && idle < minDelay + STT_LAG_MS) settleAt(minDelay + STT_LAG_MS - idle);
+      else flush();
+    };
     const a = ctx.adapter;
+    const voice2 = a.capabilities?.channel === "voice";
+    const minDelay = Math.max(0, endpointing?.minDelay ?? DEFAULT_MIN_DELAY_MS);
+    const maxDelay = Math.max(minDelay, endpointing?.maxDelay ?? DEFAULT_MAX_DELAY_MS);
+    const parts = [];
+    let speaking = false;
+    let lastActivity = 0;
+    let settle2 = null;
+    let settleDue = Number.POSITIVE_INFINITY;
+    let cap = null;
+    const clearTimers = () => {
+      if (settle2) clearTimeout(settle2);
+      if (cap) clearTimeout(cap);
+      settle2 = null;
+      cap = null;
+      settleDue = Number.POSITIVE_INFINITY;
+    };
+    const flush = () => {
+      clearTimers();
+      const text = parts.splice(0).join(" ").trim();
+      if (!text) return;
+      graphLog("turn", { chars: text.length, quietMs: Date.now() - lastActivity, vadSpeaking: speaking });
+      deliver({ kind: "utterance", text });
+    };
+    const settleAt = (ms) => {
+      if (settle2) clearTimeout(settle2);
+      const wait = Math.max(0, ms);
+      settleDue = Date.now() + wait;
+      settle2 = setTimeout(onSettle2, wait);
+    };
     unsubs.push(
       a.on("user_input", (e) => {
-        if (!e.isFinal || hung) return;
-        deliver({ kind: "utterance", text: e.transcript });
+        if (hung) return;
+        lastActivity = Date.now();
+        if (!e.isFinal) {
+          if (parts.length > 0) settleAt(minDelay);
+          return;
+        }
+        const text = e.transcript.trim();
+        if (!text) return;
+        if (!voice2 || minDelay === 0) {
+          deliver({ kind: "utterance", text });
+          return;
+        }
+        parts.push(text);
+        if (cap) clearTimeout(cap);
+        cap = setTimeout(flush, maxDelay);
+        settleAt(minDelay);
+      })
+    );
+    unsubs.push(
+      a.on("user_state", (e) => {
+        speaking = e.speaking;
+        if (speaking || parts.length === 0) return;
+        const due = e.at - VAD_SILENCE_MS + minDelay;
+        if (due < settleDue) settleAt(due - Date.now());
       })
     );
+    unsubs.push(clearTimers);
     unsubs.push(a.once("close", onClose));
     if (wantsDtmf) {
       if (typeof ctx.onDtmf === "function") {
@@ -3588,10 +5542,12 @@ function createUtteranceStream(session, processRt, ctx, rails, prewarm, wantsDtm
         } else if (hung) {
           return { kind: "hangup" };
         } else {
+          if (onAwaitInput) onAwaitInput();
           raw = await awaitRaw(opts?.timeoutMs);
         }
         if (raw.kind === "hangup") return { kind: "hangup" };
         if (raw.kind === "timeout") return { kind: "timeout" };
+        await settle();
         if (raw.kind === "dtmf") return { kind: "dtmf", digit: raw.digit };
         if (rails) {
           const outcome = await rails.intercept(raw.text, ctx);
@@ -3599,13 +5555,18 @@ function createUtteranceStream(session, processRt, ctx, rails, prewarm, wantsDtm
           if (outcome.kind === "control") return { kind: "control", result: outcome.result };
         }
         if (prewarm) prewarm(raw.text);
-        try {
-          await processRt.ingest(raw.text, ctx);
-        } catch {
+        if (opts?.deferCapture) {
+          const run = capture(raw.text, true).then(() => {
+            if (pending === run) pending = null;
+          });
+          pending = run;
+          return { kind: "utterance", text: raw.text };
         }
+        await capture(raw.text, false);
         return { kind: "utterance", text: raw.text };
       }
     },
+    settle,
     close() {
       hung = true;
       for (const u of unsubs) u();
@@ -3614,6 +5575,7 @@ function createUtteranceStream(session, processRt, ctx, rails, prewarm, wantsDtm
 }
 
 // src/runtime/graph/history.ts
+init_log();
 function isConversational(it) {
   return it.type === "message" && (it.role === "user" || it.role === "assistant");
 }
@@ -3653,7 +5615,7 @@ function createHistoryController(agent) {
         next.items = prune(next.items, policy);
         await agent.updateChatCtx(next);
       } catch (err) {
-        console.warn("[graph] historyPolicy prune failed; using full history", {
+        graphWarn("historyPolicy prune failed; using full history", {
           policy,
           err: err instanceof Error ? err.message : String(err)
         });
@@ -3666,7 +5628,7 @@ function createHistoryController(agent) {
         try {
           await agent.updateChatCtx(saved);
         } catch (err) {
-          console.warn("[graph] historyPolicy restore failed", {
+          graphWarn("historyPolicy restore failed", {
             err: err instanceof Error ? err.message : String(err)
           });
         }
@@ -3703,13 +5665,17 @@ function createGraphEvents(processRt) {
   };
 }
 
+// src/runtime/graph/rails.ts
+init_log();
+
 // src/runtime/graph/index.ts
 init_conditions();
 init_branch_resolve();
 init_embedder();
 
 // src/runtime/graph/agent-runner.ts
-init_openai_default();
+init_log();
+init_llm();
 process.env["VOICELAYER_LLM_MODEL"] ?? process.env["OPENAI_LLM_MODEL"] ?? "gpt-4o";
 Number(process.env["VL_FLOW_AGENT_TURN_TIMEOUT_MS"] ?? "30000");
 Number(process.env["VL_FLOW_AGENT_MAX_TOOL_CALLS"] ?? "5");
@@ -3722,7 +5688,7 @@ init_graph_model();
 // src/runtime/graph/resolvers.ts
 init_src();
 init_embedder();
-init_openai_default();
+init_llm();
 Number(process.env["VL_FLOW_CODE_TIMEOUT_MS"] ?? "1000");
 Number(process.env["VL_FLOW_CODE_MEMORY_BYTES"] ?? String(16 * 1024 * 1024));
 
@@ -3743,7 +5709,9 @@ async function runFlowProgram(program, ctx, opts) {
     ctx,
     opts.rails,
     prewarm,
-    wantsDtmf
+    wantsDtmf,
+    opts.onAwaitInput,
+    opts.speech?.endpointing
   );
   const history = createHistoryController(opts.agent ?? null);
   try {
@@ -3759,15 +5727,16 @@ async function runFlowProgram(program, ctx, opts) {
       ...opts.resolvers ? { resolvers: opts.resolvers } : {},
       ...opts.busy ? { busy: opts.busy } : {}
     });
-    console.log("[graph] outcome", outcome);
+    graphLog("outcome", outcome);
     return outcome;
   } finally {
+    await utterances.settle?.();
     utterances.close();
   }
 }
 
 // src/runtime/process.ts
-init_openai_default();
+init_llm();
 
 // ../primitives/process-schema/src/index.ts
 init_src();
@@ -4663,6 +6632,10 @@ function createTextSessionAdapter(transport) {
       await transport.send(text);
       return { interrupted: false };
     },
+    async enqueueSay(text) {
+      fire("agent_turn", { text });
+      await transport.send(text);
+    },
     async generateReply(opts) {
       if (transport.generate) {
         const text = await transport.generate(opts?.instructions);
@@ -4741,6 +6714,7 @@ function processSchemaToDefinition(schema) {
 }
 
 // src/runtime/text-session.ts
+init_openai_default();
 function buildTextContext(adapter, call, processRt) {
   return {
     call: {
@@ -4802,7 +6776,8 @@ function runTextSession(opts) {
     // createUtteranceStream prefers ctx.adapter; the session arg is unused here.
     session: {},
     events,
-    ...opts.maxSteps !== void 0 ? { maxSteps: opts.maxSteps } : {}
+    ...opts.maxSteps !== void 0 ? { maxSteps: opts.maxSteps } : {},
+    ...opts.onAwaitInput ? { onAwaitInput: opts.onAwaitInput } : {}
   });
   return {
     sendUserMessage: (text) => handle.push(text),
@@ -4848,12 +6823,12 @@ function definitionFor(opts) {
 }
 async function runTextTranscript(opts) {
   const replies = [];
-  const trace = [];
+  const trace2 = [];
   const processRt = opts.processRt ?? createProcessRuntime(definitionFor(opts));
   const session = runTextSession({
     program: opts.program,
     onAgentText: (t) => void replies.push(t),
-    onTrace: (e) => void trace.push(e),
+    onTrace: (e) => void trace2.push(e),
     ...processRt ? { processRt } : {},
     ...opts.generate ? { generate: opts.generate } : {},
     ...opts.call ? { call: opts.call } : {},
@@ -4862,7 +6837,57 @@ async function runTextTranscript(opts) {
   for (const m of opts.messages) session.sendUserMessage(m);
   session.end();
   const outcome = await session.result;
-  return { replies, outcome, trace };
+  return { replies, outcome, trace: trace2 };
+}
+function runLiveTextConversation(opts) {
+  let buffer = [];
+  let settle = null;
+  let parkedPending = false;
+  let ended = false;
+  let outcome;
+  const signal = () => {
+    if (settle) {
+      const s = settle;
+      settle = null;
+      s();
+    } else {
+      parkedPending = true;
+    }
+  };
+  const processRt = opts.processRt ?? createProcessRuntime(definitionFor({ program: opts.program, ...opts.schema ? { schema: opts.schema } : {}, messages: [] }));
+  const session = runTextSession({
+    ...opts,
+    processRt,
+    onAgentText: (t) => {
+      buffer.push(t);
+      return opts.onAgentText?.(t);
+    },
+    onAwaitInput: signal
+  });
+  void session.result.then((o) => {
+    outcome = o;
+    ended = true;
+    signal();
+  });
+  const collect = async () => {
+    if (!parkedPending) await new Promise((res) => settle = res);
+    parkedPending = false;
+    const replies = buffer.slice();
+    buffer = [];
+    return { replies, done: ended, ...ended && outcome ? { outcome } : {} };
+  };
+  return {
+    start: () => collect(),
+    async turn(text) {
+      if (ended) return { replies: [], done: true, ...outcome ? { outcome } : {} };
+      session.sendUserMessage(text);
+      return collect();
+    },
+    async end() {
+      session.end();
+      return session.result;
+    }
+  };
 }
 
-export { runTextSession, runTextTranscript };
+export { runLiveTextConversation, runTextSession, runTextTranscript, runWithOpenAIScope };