@voicelayer/sdk 0.1.2 → 0.1.4

package/dist/runtime/text-session.js

@@ -0,0 +1,4119 @@
+import { z } from 'zod';
+import OpenAI from 'openai';
+import 'quickjs-emscripten';
+import { setup } from 'xstate';
+import 'crypto';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/runtime/graph/graph-model.ts
+function buildGraphModel(program) {
+  return {
+    entry: program.entry,
+    node: (id) => program.nodes[id],
+    out: (id) => program.nodes[id]?.out ?? [],
+    selectByPort: (id, port) => {
+      const edges = program.nodes[id]?.out ?? [];
+      const byHandle = edges.find((e) => e.sourceHandle === port);
+      if (byHandle) return byHandle.to;
+      const byLabel = edges.find((e) => e.label === port);
+      return byLabel ? byLabel.to : null;
+    },
+    askNodeForSlot: (slot) => {
+      const want = slot.trim();
+      for (const node of Object.values(program.nodes)) {
+        if (node.type !== "ask") continue;
+        const s = typeof node.config.slot === "string" ? node.config.slot : node.id;
+        if (s.trim() === want) return node.id;
+      }
+      return void 0;
+    }
+  };
+}
+var init_graph_model = __esm({
+  "src/runtime/graph/graph-model.ts"() {
+  }
+});
+var init_primitive = __esm({
+  "../contracts/src/primitive.ts"() {
+  }
+});
+
+// ../contracts/src/events.ts
+var init_events = __esm({
+  "../contracts/src/events.ts"() {
+  }
+});
+
+// ../contracts/src/context.ts
+var init_context = __esm({
+  "../contracts/src/context.ts"() {
+  }
+});
+
+// ../contracts/src/errors.ts
+var init_errors = __esm({
+  "../contracts/src/errors.ts"() {
+  }
+});
+var init_ids = __esm({
+  "../contracts/src/ids.ts"() {
+  }
+});
+var FlowKind, FlowStatus, FlowNodeType, FlowNodePosition, FlowNode, FlowEdge, FlowGraph;
+var init_flow = __esm({
+  "../contracts/src/flow.ts"() {
+    FlowKind = z.enum(["conversation"]);
+    FlowStatus = z.enum(["draft", "published", "archived"]);
+    z.enum(["shared", "dedicated"]);
+    FlowNodeType = z.enum([
+      // Explicit entry marker — the interpreter starts here (falls back to the
+      // first indegree-0 node for older graphs without one).
+      "start",
+      "say",
+      "ask",
+      "confirm",
+      "tool",
+      "decision",
+      "handoff",
+      "end",
+      "trigger",
+      "gate",
+      "playbook",
+      "menu",
+      "code",
+      "set",
+      // Reusable component: runs another published flow inline.
+      "subflow",
+      // AI nodes (PRD P5).
+      "llm",
+      "rag",
+      "memory",
+      "classify",
+      // Agentic router: per-turn, selects 1-of-N skills by their plain-language
+      // descriptions and takes that port (the resident routing surface / hub).
+      "router",
+      // Canvas-only annotation (sticky note); excluded from compilation/runtime.
+      "note"
+    ]);
+    FlowNodePosition = z.object({
+      x: z.number(),
+      y: z.number()
+    });
+    FlowNode = z.object({
+      id: z.string().min(1).max(128),
+      type: FlowNodeType,
+      position: FlowNodePosition,
+      // Node-specific config. Generic on purpose — the per-type shape is validated
+      // by the runtime compiler that targets each plane, not by storage.
+      data: z.record(z.unknown()).default({})
+    });
+    FlowEdge = z.object({
+      id: z.string().min(1).max(128),
+      // Source / target node ids (must reference FlowNode.id values).
+      source: z.string().min(1).max(128),
+      target: z.string().min(1).max(128),
+      // React Flow handle ids for multi-port nodes (e.g. a decision's branches).
+      sourceHandle: z.string().max(128).optional(),
+      targetHandle: z.string().max(128).optional(),
+      // Optional label / branch condition — e.g. a normalized tool `result.kind`.
+      label: z.string().max(128).optional(),
+      condition: z.string().max(512).optional()
+    });
+    FlowGraph = z.object({
+      nodes: z.array(FlowNode).max(1e3).default([]),
+      edges: z.array(FlowEdge).max(2e3).default([])
+    });
+    z.object({
+      id: z.string().uuid(),
+      projectId: z.string().min(1),
+      name: z.string().min(1).max(200),
+      kind: FlowKind,
+      status: FlowStatus,
+      // The working/draft graph. Published versions snapshot this.
+      graph: FlowGraph,
+      // Latest published version number; null until first publish.
+      publishedVersion: z.number().int().min(1).nullable(),
+      createdAt: z.string().datetime(),
+      // Optimistic-lock token (mirrors AgentConfig.updatedAt).
+      updatedAt: z.string().datetime()
+    });
+    z.object({
+      id: z.string().uuid(),
+      flowId: z.string().uuid(),
+      projectId: z.string().min(1),
+      version: z.number().int().min(1),
+      kind: FlowKind,
+      // Frozen graph at publish time.
+      graph: FlowGraph,
+      // Optional human note describing the publish.
+      note: z.string().max(1e3).nullable(),
+      publishedByUserId: z.string().nullable(),
+      publishedAt: z.string().datetime()
+    });
+    z.object({
+      name: z.string().trim().min(1).max(200),
+      kind: FlowKind,
+      // Optional initial graph; defaults to empty.
+      graph: FlowGraph.optional()
+    });
+    z.object({
+      name: z.string().trim().min(1).max(200).optional(),
+      graph: FlowGraph.optional(),
+      // Framework is a reversible default-structure switch (Voiceflow parity):
+      // changing kind re-frames the palette/deployability but never touches the graph.
+      kind: FlowKind.optional()
+    }).refine((b) => b.name !== void 0 || b.graph !== void 0 || b.kind !== void 0, {
+      message: "provide at least one of `name`, `graph`, or `kind`"
+    });
+    z.object({
+      note: z.string().max(1e3).optional()
+    });
+  }
+});
+var FlowProgramEdge, FlowProgramNode, FlowProgramDiagnostics, FlowProgram;
+var init_flow_program = __esm({
+  "../contracts/src/flow-program.ts"() {
+    init_flow();
+    FlowProgramEdge = z.object({
+      to: z.string().min(1).max(128),
+      // Branch condition (e.g. `slot:Intent==billing`, `tool.lookup.ok`). Empty =
+      // default/fallthrough edge. Evaluated by the runtime's condition matcher.
+      condition: z.string().max(512).optional(),
+      // React Flow handle id for multi-branch nodes (decision/menu ports).
+      sourceHandle: z.string().max(128).optional(),
+      label: z.string().max(128).optional()
+    });
+    FlowProgramNode = z.object({
+      id: z.string().min(1).max(128),
+      type: FlowNodeType,
+      // Cleaned, per-type config (text / slot / ask / url / requiredFields / ...).
+      // Produced by compileFlowToProgram; read defensively by the executors.
+      config: z.record(z.unknown()),
+      // Outgoing edges in declaration order.
+      out: z.array(FlowProgramEdge).max(64)
+    });
+    FlowProgramDiagnostics = z.object({
+      // False if the graph contains a cycle (runtime still runs it, guarded by a
+      // per-call step/visit budget).
+      acyclic: z.boolean(),
+      // Edge ids whose source/target node was missing (skipped at compile).
+      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)
+    });
+    FlowProgram = z.object({
+      v: z.literal(1),
+      id: z.string().min(1).max(64),
+      // Entry node id(s) — nodes with no inbound edge (interpreter starts here).
+      entry: z.array(z.string().min(1).max(128)).max(64),
+      nodes: z.record(FlowProgramNode),
+      // Mirrors the flat completion gate so the same gate computation is reused.
+      completionGate: z.object({ requiredFields: z.array(z.string()).max(64) }),
+      diagnostics: FlowProgramDiagnostics.optional()
+    });
+  }
+});
+var AgentEnvironment, AgentStatus, AgentName, AgentVersion, AgentMetadata, AgentCapability, ReadinessReport, ProcessFieldDTO, ProcessTriggerDTO, ProcessToolDTO, ProcessSchemaDTO, AgentDTO;
+var init_agents = __esm({
+  "../contracts/src/agents.ts"() {
+    init_flow_program();
+    AgentEnvironment = z.enum(["dev", "stg", "prd"]);
+    AgentStatus = z.enum(["online", "offline", "degraded"]);
+    AgentName = z.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9-_]*$/, 'lowercase letters, digits, "-" or "_" only');
+    AgentVersion = z.string().min(1).max(64);
+    AgentMetadata = z.record(z.unknown());
+    AgentCapability = z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9-_:.]*$/, 'lowercase letters, digits, "-_:." only');
+    ReadinessReport = z.object({
+      probe: z.string().min(1).max(128),
+      ok: z.boolean(),
+      detail: z.string().max(512).optional()
+    });
+    ProcessFieldDTO = z.object({
+      name: z.string().min(1).max(64),
+      required: z.boolean(),
+      type: z.enum(["string", "string[]", "number", "boolean", "datetime", "email", "phone"]),
+      pattern: z.string().max(1024).optional(),
+      min: z.number().optional(),
+      max: z.number().optional(),
+      enum: z.array(z.string()).max(64).optional(),
+      ask: z.string().max(512).optional()
+    });
+    ProcessTriggerDTO = z.object({
+      name: z.string().min(1).max(64),
+      on: z.string().min(1).max(512),
+      then: z.string().min(1).max(1024),
+      onlyWhile: z.string().max(64).optional()
+    });
+    ProcessToolDTO = z.object({
+      name: z.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/, "snake_case"),
+      description: z.string().min(1).max(2e3),
+      // Shorthand input shape: field name → primitive type. The LLM fills these.
+      // Required (the compiler always provides it, possibly {}) to keep the schema's
+      // input/output types symmetric — a `.default()` here diverges them.
+      input: z.record(z.enum(["string", "number", "boolean"])),
+      url: z.string().url(),
+      method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+      headers: z.record(z.string().max(1024)).optional(),
+      auth: z.enum(["none", "connection"]),
+      connectionRef: z.string().max(128).optional()
+    });
+    ProcessSchemaDTO = z.object({
+      id: z.string().min(1).max(64),
+      // System-prompt fragments compiled from say/confirm nodes. The SDK bridge
+      // composes these into the agent's prompt.
+      prompts: z.array(z.object({ id: z.string().min(1).max(128), text: z.string().max(2e3) })).max(64).optional(),
+      fields: z.array(ProcessFieldDTO).max(64),
+      completionGate: z.object({
+        requiredFields: z.array(z.string()).max(64),
+        backendAck: z.object({
+          url: z.string().url(),
+          timeoutMs: z.number().int().positive()
+        }).optional()
+      }),
+      // Deterministic rails compiled from trigger/handoff/end nodes.
+      triggers: z.array(ProcessTriggerDTO).max(64).optional(),
+      // Default human destination for `then:'handoff'` rails.
+      handoff: z.object({
+        fallback: z.string().max(128).optional(),
+        routes: z.record(z.string().max(128)).optional()
+      }).optional(),
+      // Memory config compiled from a memory node (maps to AgentConfig.memory).
+      memory: z.object({
+        scope: z.enum(["call", "caller", "participant", "account", "platform"]).optional(),
+        retentionDays: z.number().int().positive().optional(),
+        piiFields: z.array(z.string().max(64)).max(64).optional()
+      }).optional(),
+      // Tool capabilities compiled from tool nodes (maps to AgentConfig.tools).
+      tools: z.array(ProcessToolDTO).max(32).optional(),
+      // Graph-preserving compiled program. When present and the flow-runtime graph
+      // mode is enabled, the worker executes this node-graph deterministically
+      // (the interpreter) instead of the flat goals+rails form above. Embedded here
+      // (not a new column) so the existing fetch path delivers it with no migration.
+      program: FlowProgram.optional()
+    });
+    z.object({
+      name: AgentName,
+      version: AgentVersion,
+      environment: AgentEnvironment,
+      // Initial status. Defaults to 'online'; SDK sends 'degraded' when any
+      // readiness probe failed but registration wasn't required-ready.
+      status: z.enum(["online", "degraded"]).optional(),
+      statusDetail: z.string().max(512).optional(),
+      capabilities: z.array(AgentCapability).max(64).optional(),
+      readiness: z.array(ReadinessReport).max(64).optional(),
+      metadata: AgentMetadata.optional(),
+      processSchema: ProcessSchemaDTO.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
+      // agent stays invisible to MCP; identity is purely in worker code.
+      mcpExposed: z.boolean().optional()
+    });
+    AgentDTO = z.object({
+      id: z.string().uuid(),
+      projectId: z.string(),
+      name: AgentName,
+      version: AgentVersion,
+      environment: AgentEnvironment,
+      status: AgentStatus,
+      statusDetail: z.string().nullable(),
+      capabilities: z.array(AgentCapability),
+      readiness: z.array(ReadinessReport),
+      lastSeenAt: z.string().datetime().nullable(),
+      metadata: AgentMetadata,
+      processSchema: ProcessSchemaDTO.nullable().optional(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    z.object({
+      processSchema: ProcessSchemaDTO.nullable()
+    });
+    z.object({
+      processSchema: ProcessSchemaDTO.nullable()
+    });
+    z.object({
+      agent: AgentDTO,
+      // Server-controlled cadence so we can tune without an SDK release.
+      heartbeatIntervalMs: z.number().int().positive()
+    });
+    z.object({
+      status: z.enum(["online", "degraded"]).optional(),
+      statusDetail: z.string().max(512).optional(),
+      metadata: AgentMetadata.optional()
+    });
+    z.object({
+      agent: AgentDTO,
+      heartbeatIntervalMs: z.number().int().positive()
+    });
+    z.object({
+      environment: AgentEnvironment.optional()
+    });
+    z.object({
+      agents: z.array(AgentDTO)
+    });
+    z.object({
+      ok: z.literal(true)
+    });
+  }
+});
+var ProcessLifecycleEvent, ProcessSnapshotPayload;
+var init_process_state = __esm({
+  "../contracts/src/process-state.ts"() {
+    ProcessLifecycleEvent = z.object({
+      id: z.string().min(1),
+      at: z.string().datetime(),
+      kind: z.string().min(1).max(80),
+      source: z.enum(["agent", "caller", "form", "platform"]),
+      data: z.record(z.string(), z.unknown())
+    });
+    ProcessSnapshotPayload = z.object({
+      schemaId: z.string(),
+      currentNode: z.string(),
+      fieldsCaptured: z.record(z.string(), z.unknown()),
+      backendAckReceived: z.boolean(),
+      backendAckReceivedAt: z.string().datetime().optional(),
+      // Optional for back-compat with publishers built before this field
+      // existed. The cold-path → SSE pipe is otherwise pass-through.
+      lifecycle: z.array(ProcessLifecycleEvent).optional()
+    });
+    z.object({
+      callId: z.string().min(1),
+      agentId: z.string().min(1).nullable(),
+      projectId: z.string().min(1),
+      ts: z.string().datetime(),
+      snapshot: ProcessSnapshotPayload
+    });
+  }
+});
+var GuidanceCommand, ConsultationPolicy;
+var init_consultation = __esm({
+  "../contracts/src/consultation.ts"() {
+    z.enum([
+      "consultation.requested",
+      "consultation.resolved"
+    ]);
+    z.object({
+      consultationId: z.string().uuid(),
+      // Free-form question. Generic on purpose — no vertical-specific fields.
+      question: z.string().min(1).max(2e3),
+      // Transcript context the agent felt was relevant when asking.
+      transcriptSnippet: z.string().max(4e3).optional(),
+      // Hint to the orchestrator about how aggressively to interrupt the human.
+      urgency: z.enum(["low", "normal", "high"]).default("normal"),
+      // Server-clamped to ConsultationPolicy.maxTimeoutMs and ProjectLimits.
+      timeoutMs: z.number().int().min(1e3).max(3e5)
+    });
+    z.object({
+      consultationId: z.string().uuid(),
+      // 'timeout' = per-consult cap. 'cumulative_cap' = call-wide ceiling.
+      // 'cancelled' = agent decided it no longer needed an answer.
+      resolution: z.enum(["guidance", "timeout", "cumulative_cap", "cancelled"]),
+      guidance: z.string().max(4e3).optional(),
+      // Wall-clock from requested-emit → resolved-emit. SLA tracking.
+      latencyMs: z.number().int().min(0)
+    });
+    GuidanceCommand = z.object({
+      kind: z.literal("guidance"),
+      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()
+    });
+    ConsultationPolicy = z.object({
+      enabled: z.boolean().default(true),
+      // Per-consult default. ProjectLimits.perCallMaxTimeoutMs clamps this.
+      defaultTimeoutMs: z.number().int().min(1e3).default(3e4),
+      maxTimeoutMs: z.number().int().min(1e3).default(3e4),
+      // Cumulative cap across the call. ProjectLimits clamps.
+      maxCumulativeHoldMs: z.number().int().min(1e3).default(12e4),
+      // Spoken when the agent emits consultation.requested.
+      holdPhrase: z.string().min(1).max(500).default("Let me check on that."),
+      // Spoken when a single consultation times out — the call continues.
+      fallbackPhrase: z.string().min(1).max(500).default("Sorry, I don't have that information right now."),
+      // Spoken when the cumulative cap fires — the call ends after this.
+      callEndFallback: z.string().min(1).max(500).default("I'm going to need someone to call you back. Thank you."),
+      // Optional per-urgency timeout override. Lets ops shorten 'high' urgency
+      // holds without lowering the default.
+      urgencyOverrides: z.object({
+        low: z.number().int().min(1e3).optional(),
+        normal: z.number().int().min(1e3).optional(),
+        high: z.number().int().min(1e3).optional()
+      }).optional()
+    });
+  }
+});
+var CallEventKind, SayCommand, HangupCommand, DtmfCommand, InstructCommand;
+var init_call_events = __esm({
+  "../contracts/src/call-events.ts"() {
+    init_consultation();
+    CallEventKind = z.enum([
+      "status.dialing",
+      "status.dispatched",
+      "status.ringing",
+      "status.answered",
+      "status.ended",
+      "transcript.partial",
+      "transcript.final",
+      "tts.spoken",
+      "cost.update",
+      // Consultation lifecycle — see packages/contracts/src/consultation.ts.
+      // Emitted by the agent's built-in `ask_host` tool. The dashboard and MCP
+      // host SSE clients filter on these to surface the "let me check" UX.
+      "consultation.requested",
+      "consultation.resolved",
+      // DTMF keypad events. `dtmf.received` fires when a remote participant
+      // presses a key on their leg; `dtmf.sent` fires when our agent (or a
+      // programmatic caller via /v1/calls/:id/dtmf) emits one outbound.
+      "dtmf.received",
+      "dtmf.sent"
+    ]);
+    z.object({
+      reason: z.string().optional(),
+      durationMs: z.number().int().min(0).optional(),
+      endedAt: z.string().datetime().optional()
+    });
+    z.object({
+      speaker: z.enum(["caller", "agent"]),
+      text: z.string(),
+      startMs: z.number().int().min(0),
+      endMs: z.number().int().min(0)
+    });
+    z.object({
+      text: z.string(),
+      // The MCP client sets this so it can correlate the spoken event to the
+      // call_say invocation that triggered it (used for "did my say actually go
+      // through" confirmation in the host chat).
+      correlationId: z.string().optional()
+    });
+    z.object({
+      digit: z.string().regex(/^[0-9*#A-D]$/),
+      code: z.number().int().min(0).max(15),
+      participantId: z.string().optional()
+    });
+    z.object({
+      totalUsd: z.string(),
+      breakdown: z.object({
+        llmUsd: z.string().optional(),
+        ttsUsd: z.string().optional(),
+        sttUsd: z.string().optional(),
+        telephonyUsd: z.string().optional()
+      }).optional()
+    });
+    z.object({
+      // Global bigserial assigned at insert. SSE clients use this as Last-Event-ID.
+      seq: z.number().int().min(0),
+      callId: z.string().uuid(),
+      projectId: z.string().min(1),
+      kind: CallEventKind,
+      payload: z.unknown(),
+      ts: z.string().datetime()
+    });
+    z.enum(["say", "hangup", "dtmf", "instruct", "guidance"]);
+    SayCommand = z.object({
+      kind: z.literal("say"),
+      text: z.string().min(1),
+      // 'interrupt' replaces any in-flight TTS; 'queue' waits for current to end.
+      mode: z.enum(["interrupt", "queue"]).default("interrupt"),
+      correlationId: z.string().optional()
+    });
+    HangupCommand = z.object({
+      kind: z.literal("hangup"),
+      reason: z.string().optional()
+    });
+    DtmfCommand = z.object({
+      kind: z.literal("dtmf"),
+      digits: z.string().regex(/^[0-9*#]+$/)
+    });
+    InstructCommand = z.object({
+      kind: z.literal("instruct"),
+      text: z.string().min(1)
+    });
+    z.discriminatedUnion("kind", [
+      SayCommand,
+      HangupCommand,
+      DtmfCommand,
+      InstructCommand,
+      GuidanceCommand
+    ]);
+  }
+});
+var VoiceConfig, ModelConfig, SttConfig, RealtimeConfig, PipelineMode, ToolBinding, ProcessFieldType, ProcessFieldSpec, ProcessCompleteWhen, ProcessBackendAckSpec, ProcessSpec, TriggerConditionSpec, TriggerActionSpec, TriggerSpec, RequiredInfoField, AgentConfig;
+var init_agent_config = __esm({
+  "../contracts/src/agent-config.ts"() {
+    init_consultation();
+    VoiceConfig = z.object({
+      // Finite, vetted list — platform-level enum.
+      provider: z.enum(["deepgram", "elevenlabs", "openai", "cartesia"]),
+      voiceId: z.string().min(1).max(128),
+      // TTS synthesis model (provider-specific, e.g. 'eleven_turbo_v2_5',
+      // 'sonic-2'). Optional — providers like Deepgram fold the voice into the
+      // model id (aura-2-harmonia-en) and ignore this.
+      model: z.string().min(1).max(128).optional(),
+      // Speed knob narrow to what every provider supports — keeps it portable.
+      rate: z.number().min(0.5).max(2).optional()
+    });
+    ModelConfig = z.object({
+      provider: z.enum(["openai", "anthropic", "gemini"]),
+      model: z.string().min(1).max(128),
+      temperature: z.number().min(0).max(2).optional(),
+      // Per-call ceiling. Distinct from project-level quota in ProjectLimits.
+      maxOutputTokens: z.number().int().min(1).max(32768).optional(),
+      // Advanced nucleus-sampling knob. Optional — most builders leave it unset
+      // and rely on temperature alone.
+      topP: z.number().min(0).max(1).optional()
+    });
+    SttConfig = z.object({
+      provider: z.enum(["deepgram", "cartesia", "assemblyai"]),
+      model: z.string().min(1).max(128).optional(),
+      // BCP-47; falls back to AgentConfig.language when unset.
+      language: z.string().min(2).max(16).optional(),
+      // End-of-turn confidence (higher = wait for more certainty before the agent
+      // takes its turn). The single biggest perceived-latency lever in voice.
+      endOfTurnConfidence: z.number().min(0).max(1).optional(),
+      // Hard cap (ms) on how long to wait for end-of-turn before responding.
+      endOfTurnTimeoutMs: z.number().int().min(100).max(5e3).optional(),
+      // Keyword boost list — bias transcription toward these terms.
+      keywords: z.array(z.string().min(1).max(64)).max(100).optional()
+    });
+    RealtimeConfig = z.object({
+      provider: z.enum(["openai", "google"]),
+      model: z.string().min(1).max(128),
+      // Provider-native voice id ('alloy', 'echo' for OpenAI; 'Aoede', 'Puck' for
+      // Gemini Live). Optional — provider default applies when unset.
+      voice: z.string().min(1).max(128).optional(),
+      temperature: z.number().min(0).max(2).optional()
+    });
+    PipelineMode = z.enum(["cascade", "realtime"]);
+    ToolBinding = z.object({
+      toolName: z.string().min(1).max(128),
+      // Per-agent override of the tool's default args (e.g. an API base URL).
+      // Generic Record on purpose — no vertical-specific shape.
+      defaultArgs: z.record(z.unknown()).optional()
+    });
+    ProcessFieldType = z.enum([
+      "string",
+      "string[]",
+      "number",
+      "boolean",
+      "datetime",
+      "email",
+      "phone"
+    ]);
+    ProcessFieldSpec = z.object({
+      type: ProcessFieldType,
+      required: z.boolean().optional(),
+      // Regex source string (not a RegExp object — JSON-safe). Applied to
+      // `string` and `string[]` items by the SDK at validation time.
+      pattern: z.string().max(500).optional(),
+      min: z.number().optional(),
+      max: z.number().optional(),
+      enum: z.array(z.string().min(1).max(200)).max(50).optional(),
+      // Override the auto-generated capture prompt.
+      ask: z.string().max(500).optional(),
+      // Override the field-extraction hint shown to the LLM.
+      extract: z.string().max(500).optional()
+    });
+    ProcessCompleteWhen = z.enum([
+      "all-required-captured",
+      "all-captured"
+    ]);
+    ProcessBackendAckSpec = z.object({
+      url: z.string().url(),
+      timeoutMs: z.number().int().min(100).max(6e4).optional(),
+      headers: z.record(z.string(), z.string()).optional()
+    });
+    ProcessSpec = z.object({
+      // Defaults to {} so LLM-authored plans can emit `process: { completeWhen }`
+      // without naming any structured fields. Downstream agent runtime handles
+      // empty maps as "no callee-side capture, only the completeWhen criterion."
+      collect: z.record(z.string().min(1).max(128), ProcessFieldSpec).default({}),
+      completeWhen: ProcessCompleteWhen.default("all-required-captured"),
+      backendAck: ProcessBackendAckSpec.optional()
+    });
+    TriggerConditionSpec = z.discriminatedUnion("kind", [
+      z.object({
+        kind: z.literal("regex"),
+        pattern: z.string().min(1).max(500),
+        flags: z.string().max(8).optional()
+      }),
+      z.object({
+        kind: z.literal("signal"),
+        name: z.string().min(1).max(128)
+      })
+    ]);
+    TriggerActionSpec = z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("handoff") }),
+      z.object({ kind: z.literal("endCall") }),
+      z.object({ kind: z.literal("say"), text: z.string().min(1).max(2e3) })
+    ]);
+    TriggerSpec = z.object({
+      on: TriggerConditionSpec,
+      then: TriggerActionSpec,
+      // If set, the trigger only fires while the named process field is uncaptured.
+      onlyWhile: z.string().min(1).max(128).optional()
+    });
+    RequiredInfoField = z.object({
+      name: z.string().min(1).max(64),
+      type: z.enum(["string", "string[]", "number", "boolean", "datetime", "email", "phone"]),
+      required: z.boolean(),
+      // The field's `ask` prompt — what the value represents / how to source it.
+      description: z.string().max(512).optional(),
+      // Constrained value set, when the field is an enum.
+      enum: z.array(z.string()).max(64).optional()
+    });
+    AgentConfig = z.object({
+      id: z.string().uuid(),
+      projectId: z.string().min(1),
+      // Human-readable label. No `agentType` enum on purpose.
+      name: z.string().min(1).max(128),
+      // Soft override of the worker's baked-in prompt. Absent → call_start
+      // uses the SDK worker's predefined prompt (the source of truth for
+      // pre-defined agents like FNOL). Present → it overrides the worker's
+      // prompt at call_start as a snapshot decision; mid-call edits are not
+      // honoured. Per-call override at call_start time is also allowed.
+      systemPrompt: z.string().max(64e3).optional(),
+      // Routing/decision layer (Voiceflow "Instructions"): plain-language guidance the
+      // agent reads to decide WHEN to do things (vs systemPrompt = WHO it is). Injected
+      // into the system prompt below the persona. Interpolated with {{ }} at runtime.
+      routingInstructions: z.string().max(32e3).optional(),
+      voice: VoiceConfig,
+      model: ModelConfig,
+      // STT for the cascade pipeline. Absent → SDK default (Deepgram nova-3).
+      stt: SttConfig.optional(),
+      // Pipeline mode. Defaults to 'cascade' so pre-existing rows (which have no
+      // mode column) behave exactly as before.
+      mode: PipelineMode.default("cascade"),
+      // Realtime / speech-to-speech model. Used when mode === 'realtime'; ignored
+      // otherwise. Optional in the schema so cascade-only agents omit it.
+      realtime: RealtimeConfig.optional(),
+      // BCP-47 string. Free-form so customers add locales without a release.
+      language: z.string().min(2).max(16).default("en-US"),
+      tools: z.array(ToolBinding).max(64).default([]),
+      consultation: ConsultationPolicy,
+      // Structured outcome — the data the agent collects on the call.
+      // Optional; absent means the call has no structured outcome.
+      process: ProcessSpec.optional(),
+      // Deterministic routes that fire BEFORE the LLM. Keyed by stable string
+      // ids (e.g. 'cancellation_fee', 'asked_for_card') so call_plan revisions
+      // can address a specific trigger.
+      triggers: z.record(z.string().min(1).max(128), TriggerSpec).optional(),
+      // Free-form labels — no semantic enums.
+      tags: z.array(z.string().max(64)).max(32).optional(),
+      // Bound brain connector (bring-your-own LLM). When set, the worker drives the
+      // LLM slot through the connector instead of a first-party model. Null/absent →
+      // first-party pipeline (unchanged default). See docs/specs/voice-brain-connector.
+      brainConnectorId: z.string().uuid().nullable().optional(),
+      // Provenance: 'sdk' (hand-coded defineAgent worker), 'flow' (canvas deploy),
+      // 'playbook' (agent-mode deploy), or 'connector' (brain-connector agent).
+      // DERIVED from the linked agents row's deploy tags (flowId / playbookId /
+      // connectorId in metadata) — not stored on agent_config, never PATCHed.
+      source: z.enum(["sdk", "flow", "playbook", "connector"]).optional(),
+      // True when the pipeline MODE is locked to code (genuine SDK agents only):
+      // the dashboard renders mode read-only and PATCH rejects a mode change.
+      // Derived; read-only. Flow/playbook/connector agents → false.
+      modeLocked: z.boolean().optional(),
+      // Inputs this agent needs to run a call, projected from its process schema.
+      // An MCP host reads these (via list_agents) to pre-fill known values as
+      // call_start metadata so the agent never re-asks. Empty when the agent
+      // collects nothing structured. DERIVED from the agents row; read-only.
+      requiredInfo: z.array(RequiredInfoField).max(64).default([]),
+      createdAt: z.string().datetime(),
+      // Optimistic-lock token. PATCH must echo this in If-Match.
+      updatedAt: z.string().datetime()
+    });
+  }
+});
+var PlanStatus, PlanCallee, PlanQuestion, PlanEscalation, DraftAgentConfig, CallPlan;
+var init_call_plan = __esm({
+  "../contracts/src/call-plan.ts"() {
+    init_agent_config();
+    PlanStatus = z.enum([
+      "drafting",
+      "clarifying",
+      "ready",
+      "committed",
+      "abandoned"
+    ]);
+    PlanCallee = z.object({
+      e164: z.string().min(2).optional(),
+      // may be unknown at intent time
+      displayName: z.string().max(200).optional(),
+      // What the host knows about who they're calling. e.g. "their dentist's
+      // billing office", "a hiring manager named Priya". Seeds tone/register
+      // and likely-triggers; not used to gate behaviour.
+      description: z.string().max(2e3).optional()
+    });
+    PlanQuestion = z.object({
+      id: z.string().min(1).max(128),
+      // stable across rounds; e.g. 'policy_number'
+      prompt: z.string().min(1).max(1e3),
+      // 'fact'     — the planner needs a piece of data (e.g. account #).
+      // 'decision' — the planner needs the host to pick an option/policy.
+      // 'auth'     — the planner is checking the host has authority to act.
+      kind: z.enum(["fact", "decision", "auth"]),
+      // For 'decision' questions only.
+      options: z.array(z.string().min(1).max(200)).max(20).optional(),
+      // True if the agent could ask the callee for this mid-call instead of
+      // demanding it from the host now. When true and the host can't answer,
+      // the planner promotes this to a draftConfig.process.collect field
+      // rather than blocking the call.
+      deferrableToCallee: z.boolean().default(false)
+    });
+    PlanEscalation = z.object({
+      // 'consult_host'    — ask the MCP host (default for plan-first calls).
+      // 'ask_callee'      — stay on the line and ask the caller.
+      // 'fallback_phrase' — read the agent's configured fallback line.
+      onUncertainty: z.enum(["consult_host", "ask_callee", "fallback_phrase"]).default("consult_host"),
+      // Hard cap on host consultations for this call. Independent of
+      // ConsultationPolicy time caps which still apply.
+      maxHostConsults: z.number().int().min(0).max(20).optional(),
+      // If host doesn't reply within this window, fall through to `secondary`.
+      // Server-clamps to ConsultationPolicy.maxTimeoutMs.
+      hostTimeoutMs: z.number().int().min(1e3).max(3e5).optional(),
+      secondary: z.enum(["ask_callee", "fallback_phrase"]).default("fallback_phrase")
+    });
+    DraftAgentConfig = AgentConfig.omit({
+      id: true,
+      projectId: true,
+      createdAt: true,
+      updatedAt: true
+    }).partial();
+    CallPlan = z.object({
+      planId: z.string().uuid(),
+      projectId: z.string().min(1),
+      status: PlanStatus,
+      // Why we're calling. One sentence, free-form. Kept verbatim from the
+      // host's original IntentRequest so we can replay planning. The refined
+      // version lives in draftConfig.systemPrompt.
+      objective: z.string().min(1).max(2e3),
+      callee: PlanCallee,
+      // The AgentConfig the planner is building. Grows across clarify rounds.
+      // At status='ready' this is a complete (modulo defaulted fields)
+      // AgentConfig override; at status='committed' it's the snapshot the
+      // call booted with.
+      draftConfig: DraftAgentConfig.default({}),
+      // Pre-call host-facing clarifications. When non-empty AND
+      // status='clarifying', the host must answer via call_clarify. When
+      // non-empty AND status='ready', the remaining questions were either
+      // deferred to callee (see unresolvedQuestions) or dropped after
+      // exhausting clarificationRounds — see changeSummary on each
+      // PlanResponse for what happened.
+      openQuestions: z.array(PlanQuestion).max(20).default([]),
+      // Snapshot of deferrableToCallee questions that the planner couldn't
+      // resolve and instead promoted to draftConfig.process.collect at
+      // commit time. Kept for audit + so the host can see what the agent
+      // will ask the callee.
+      unresolvedQuestions: z.array(PlanQuestion).max(20).default([]),
+      escalation: PlanEscalation,
+      // Round counter. Server enforces PlanLimits.maxClarificationRounds.
+      clarificationRounds: z.number().int().min(0).default(0),
+      // Set once `call_commit` succeeds. Links the plan to the call it
+      // created. Useful for the dashboard plan inspector.
+      committedCallId: z.string().uuid().optional(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    z.object({
+      objective: z.string().min(1).max(2e3),
+      callee: PlanCallee.optional(),
+      // Initial facts the host already has. Folded into draftConfig at the
+      // planner's discretion — typically inlined into systemPrompt or stored
+      // as process.collect default values.
+      knowns: z.record(z.string().min(1).max(128), z.string().max(4e3)).optional(),
+      // Hard constraints the planner must respect. e.g.
+      // ["never disclose the card CVV", "if asked for SSN, refuse politely"].
+      // Generate matching triggers + appear in systemPrompt as do-not-disclose
+      // rules.
+      constraints: z.array(z.string().min(1).max(500)).max(20).optional(),
+      // Per-call escalation overrides — merged with project defaults.
+      escalation: PlanEscalation.partial().optional(),
+      // Override the agent's default voice/model/language for this call. Most
+      // hosts won't set this; here for power users.
+      configOverrides: DraftAgentConfig.pick({
+        voice: true,
+        model: true,
+        language: true
+      }).optional()
+    });
+    z.object({
+      // Map question.id → answer text. For 'decision' questions the value
+      // should be one of `options`, but the server doesn't enforce strictly —
+      // the planner will re-ask if the answer is unrecognized.
+      answers: z.record(z.string().min(1).max(128), z.string().max(4e3)),
+      // The host can also push new facts that weren't asked for.
+      additionalKnowns: z.record(z.string().min(1).max(128), z.string().max(4e3)).optional()
+    });
+    z.object({
+      to: z.string().min(2),
+      // E.164
+      phoneNumberId: z.string().uuid(),
+      metadata: z.record(z.string().min(1).max(128), z.string().max(4e3)).optional(),
+      force: z.boolean().default(false)
+    });
+    z.object({
+      plan: CallPlan,
+      // Convenience: questions to answer next. Same as plan.openQuestions
+      // when status='clarifying'; empty otherwise.
+      questions: z.array(PlanQuestion),
+      // Human-readable summary of what changed in this round. Useful for the
+      // host's chat surface ("I added 3 facts and resolved 2 questions").
+      changeSummary: z.string().max(2e3).optional()
+    });
+    z.object({
+      callId: z.string().uuid(),
+      plan: CallPlan
+      // status will be 'committed'
+    });
+    z.object({
+      // After this many round-trips, the planner forces status='ready' and
+      // any remaining questions are marked deferrableToCallee or dropped.
+      maxClarificationRounds: z.number().int().min(1).default(3),
+      // How long an uncommitted plan lives before it's auto-abandoned. Lets
+      // the host build a plan in one session and commit it in another.
+      planTtlMs: z.number().int().min(6e4).default(36e5)
+      // 1h
+    });
+  }
+});
+var MemoryScope, MemoryRecord, RelevantContext, CallerDTO;
+var init_memory = __esm({
+  "../contracts/src/memory.ts"() {
+    MemoryScope = z.enum(["call", "caller", "account", "platform"]);
+    MemoryRecord = z.record(z.unknown());
+    RelevantContext = z.object({
+      call: MemoryRecord,
+      caller: MemoryRecord,
+      account: MemoryRecord,
+      platform: MemoryRecord
+    });
+    z.object({
+      callerId: z.string().min(1),
+      scopes: z.array(MemoryScope).optional()
+    });
+    z.object({
+      context: RelevantContext
+    });
+    z.object({
+      scope: MemoryScope,
+      callerId: z.string().min(1),
+      delta: MemoryRecord,
+      callId: z.string().optional()
+    });
+    z.object({
+      accepted: z.literal(true)
+    });
+    z.object({
+      callId: z.string().uuid(),
+      stage: z.string().min(1).max(64),
+      snapshot: MemoryRecord
+    });
+    z.object({
+      id: z.string().uuid()
+    });
+    z.object({
+      externalKey: z.string().min(1).max(256),
+      displayName: z.string().max(256).optional(),
+      identifiers: z.array(
+        z.object({
+          type: z.string().min(1).max(64),
+          value: z.string().min(1).max(256)
+        })
+      ).optional()
+    });
+    CallerDTO = z.object({
+      id: z.string().uuid(),
+      projectId: z.string(),
+      externalKey: z.string(),
+      displayName: z.string().nullable(),
+      metadata: MemoryRecord,
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    z.object({
+      caller: CallerDTO
+    });
+    z.object({
+      ok: z.literal(true),
+      scopesPurged: z.array(MemoryScope)
+    });
+  }
+});
+
+// ../contracts/src/participants.ts
+var init_participants = __esm({
+  "../contracts/src/participants.ts"() {
+  }
+});
+
+// ../contracts/src/forms.ts
+var init_forms = __esm({
+  "../contracts/src/forms.ts"() {
+  }
+});
+var ProviderKind, CatalogVoice, CatalogModel, CatalogProvider, CostEstimateAssumptions, CostEstimatePerMinute, CostEstimateBilledPerMinute;
+var init_model_catalog = __esm({
+  "../contracts/src/model-catalog.ts"() {
+    init_agent_config();
+    ProviderKind = z.enum(["llm", "stt", "tts", "realtime"]);
+    CatalogVoice = z.object({
+      id: z.string().min(1).max(128),
+      label: z.string().min(1).max(128),
+      // Optional sample for an in-picker preview button.
+      previewUrl: z.string().url().optional(),
+      // e.g. 'female', 'narration', 'en-US'.
+      tags: z.array(z.string().max(40)).max(12).optional()
+    });
+    CatalogModel = z.object({
+      id: z.string().min(1).max(128),
+      label: z.string().min(1).max(128),
+      // Pricing hints (USD) shown next to the option. Only the fields relevant to
+      // the provider kind are populated.
+      inputPerMillion: z.number().nonnegative().optional(),
+      // llm / realtime tokens
+      outputPerMillion: z.number().nonnegative().optional(),
+      perMillionChars: z.number().nonnegative().optional(),
+      // tts
+      perMinute: z.number().nonnegative().optional(),
+      // stt / realtime session
+      // Capability hints.
+      contextWindow: z.number().int().positive().optional(),
+      notes: z.string().max(200).optional()
+    });
+    CatalogProvider = z.object({
+      id: z.string().min(1).max(64),
+      // 'openai' | 'anthropic' | 'deepgram' | ...
+      label: z.string().min(1).max(64),
+      kind: ProviderKind,
+      models: z.array(CatalogModel).default([]),
+      // Populated for tts / realtime providers.
+      voices: z.array(CatalogVoice).optional(),
+      // Pre-selected when the provider is chosen.
+      defaultModel: z.string().max(128).optional()
+    });
+    z.object({
+      llm: z.array(CatalogProvider).default([]),
+      stt: z.array(CatalogProvider).default([]),
+      tts: z.array(CatalogProvider).default([]),
+      realtime: z.array(CatalogProvider).default([])
+    });
+    CostEstimateAssumptions = z.object({
+      callDurationSeconds: z.number().positive().max(7200).optional(),
+      llmInputTokensPerMin: z.number().nonnegative().max(1e6).optional(),
+      llmOutputTokensPerMin: z.number().nonnegative().max(1e6).optional(),
+      ttsCharsPerMin: z.number().nonnegative().max(1e6).optional(),
+      direction: z.enum(["inbound", "outbound"]).optional(),
+      includeTelephony: z.boolean().optional()
+    });
+    z.object({
+      mode: PipelineMode.default("cascade"),
+      model: ModelConfig.optional(),
+      // LLM (cascade)
+      voice: VoiceConfig.optional(),
+      // TTS (cascade)
+      stt: SttConfig.optional(),
+      // STT (cascade)
+      realtime: RealtimeConfig.optional(),
+      // realtime
+      assumptions: CostEstimateAssumptions.optional()
+    });
+    CostEstimatePerMinute = z.object({
+      llm: z.number().nonnegative(),
+      stt: z.number().nonnegative(),
+      tts: z.number().nonnegative(),
+      realtime: z.number().nonnegative(),
+      telephony: z.number().nonnegative(),
+      total: z.number().nonnegative()
+    });
+    CostEstimateBilledPerMinute = z.object({
+      platformFee: z.number().nonnegative(),
+      providerPassthrough: z.number().nonnegative(),
+      telephony: z.number().nonnegative(),
+      allIn: z.number().nonnegative()
+    });
+    z.object({
+      currency: z.literal("USD"),
+      perMinute: CostEstimatePerMinute,
+      // Present when the server could resolve the project's rate card.
+      billedPerMinute: CostEstimateBilledPerMinute.optional(),
+      // Rough voice-to-voice latency estimate for the chosen pipeline.
+      latencyMs: z.object({
+        estimate: z.number().nonnegative(),
+        realtime: z.boolean()
+      }),
+      // The assumptions actually used (after defaults) — drives the UI footnote.
+      assumptions: CostEstimateAssumptions.required()
+    });
+  }
+});
+var EvaluationMetric, EvaluationStatus, EvaluationOption, EvaluationInput;
+var init_evaluations = __esm({
+  "../contracts/src/evaluations.ts"() {
+    EvaluationMetric = z.enum(["rating", "binary", "options", "text"]);
+    EvaluationStatus = z.enum(["pending", "scored", "failed"]);
+    EvaluationOption = z.object({
+      value: z.string().min(1).max(64),
+      label: z.string().min(1).max(120),
+      description: z.string().max(400).optional()
+    });
+    z.object({
+      id: z.string().uuid(),
+      projectId: z.string(),
+      name: z.string().min(1).max(120),
+      criteria: z.string().max(4e3),
+      metric: EvaluationMetric,
+      model: z.string().min(1).max(128),
+      minValue: z.number().int().nullable(),
+      minLabel: z.string().nullable(),
+      maxValue: z.number().int().nullable(),
+      maxLabel: z.string().nullable(),
+      options: z.array(EvaluationOption),
+      enabled: z.boolean(),
+      isDefault: z.boolean(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    EvaluationInput = z.object({
+      name: z.string().min(1).max(120),
+      criteria: z.string().max(4e3).default(""),
+      metric: EvaluationMetric.default("rating"),
+      model: z.string().min(1).max(128).default("gpt-4o-mini"),
+      minValue: z.number().int().nullable().optional(),
+      minLabel: z.string().max(200).nullable().optional(),
+      maxValue: z.number().int().nullable().optional(),
+      maxLabel: z.string().max(200).nullable().optional(),
+      options: z.array(EvaluationOption).max(12).default([]),
+      enabled: z.boolean().default(true)
+    });
+    EvaluationInput.partial();
+    z.object({
+      id: z.string().uuid(),
+      callId: z.string().uuid(),
+      projectId: z.string(),
+      evaluationId: z.string().uuid(),
+      name: z.string(),
+      metric: EvaluationMetric,
+      status: EvaluationStatus,
+      valueNumber: z.number().nullable(),
+      valueBool: z.boolean().nullable(),
+      valueText: z.string().nullable(),
+      reasoning: z.string().nullable(),
+      model: z.string().nullable(),
+      costUsd: z.number().nullable(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    z.object({
+      status: EvaluationStatus,
+      valueNumber: z.number().nullable(),
+      valueBool: z.boolean().nullable(),
+      valueText: z.string().nullable(),
+      reasoning: z.string().nullable(),
+      costUsd: z.number().nullable(),
+      error: z.string().nullable()
+    });
+    z.object({
+      evaluationId: z.string().uuid(),
+      name: z.string(),
+      metric: EvaluationMetric,
+      scored: z.number(),
+      average: z.number().nullable(),
+      // rating
+      positiveRate: z.number().nullable(),
+      // binary (fraction true)
+      distribution: z.array(z.object({ value: z.string(), count: z.number() })),
+      // options/text
+      avgCostUsd: z.number().nullable()
+    });
+  }
+});
+var TestCheckType, TestRunStatus, TestCheckStatus, TestSuiteInput, TestRun, TestCheck;
+var init_tests = __esm({
+  "../contracts/src/tests.ts"() {
+    TestCheckType = z.enum(["response-judge", "routing", "tool-call"]);
+    TestRunStatus = z.enum(["pending", "scored", "failed"]);
+    TestCheckStatus = z.enum(["pass", "fail", "skipped"]);
+    z.object({
+      id: z.string().uuid(),
+      projectId: z.string(),
+      name: z.string().min(1).max(120),
+      description: z.string().max(4e3),
+      criteria: z.string().max(4e3),
+      enabled: z.boolean(),
+      isDefault: z.boolean(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    TestSuiteInput = z.object({
+      name: z.string().min(1).max(120),
+      description: z.string().max(4e3).default(""),
+      criteria: z.string().max(4e3).default(""),
+      enabled: z.boolean().default(true)
+    });
+    TestSuiteInput.partial();
+    TestRun = z.object({
+      id: z.string().uuid(),
+      projectId: z.string(),
+      testSuiteId: z.string().uuid(),
+      callId: z.string().uuid(),
+      name: z.string(),
+      status: TestRunStatus,
+      reasoning: z.string().nullable(),
+      model: z.string().nullable(),
+      costUsd: z.number().nullable(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    TestCheck = z.object({
+      id: z.string().uuid(),
+      projectId: z.string(),
+      testRunId: z.string().uuid(),
+      checkType: TestCheckType,
+      turnIndex: z.number().int(),
+      status: TestCheckStatus,
+      input: z.unknown().nullable(),
+      output: z.unknown().nullable(),
+      reasoning: z.string().nullable(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    TestRun.extend({
+      checks: z.array(TestCheck)
+    });
+    z.object({
+      status: TestRunStatus,
+      reasoning: z.string().nullable(),
+      costUsd: z.number().nullable(),
+      checks: z.array(
+        z.object({
+          checkType: TestCheckType,
+          turnIndex: z.number().int(),
+          status: TestCheckStatus,
+          reasoning: z.string().nullable()
+        })
+      ),
+      error: z.string().nullable()
+    });
+    z.object({
+      testSuiteId: z.string().uuid(),
+      name: z.string(),
+      runs: z.number(),
+      passed: z.number(),
+      failed: z.number(),
+      passRate: z.number().nullable(),
+      avgCostUsd: z.number().nullable()
+    });
+  }
+});
+var CallThumb;
+var init_call_review = __esm({
+  "../contracts/src/call-review.ts"() {
+    CallThumb = z.enum(["up", "down"]);
+    z.object({
+      callId: z.string().uuid(),
+      projectId: z.string(),
+      thumb: CallThumb.nullable(),
+      note: z.string().nullable(),
+      reviewed: z.boolean(),
+      reviewedBy: z.string().nullable(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    z.object({
+      thumb: CallThumb.nullable().optional(),
+      note: z.string().max(2e3).nullable().optional(),
+      reviewed: z.boolean().optional()
+    });
+  }
+});
+var ToolExposure;
+var init_agent_tools = __esm({
+  "../contracts/src/agent-tools.ts"() {
+    ToolExposure = z.enum(["agent", "mcp"]);
+    z.object({
+      name: z.string().min(1).max(64).regex(/^[a-z][a-z0-9_]*$/, "snake_case"),
+      // The string that routes the LLM/orchestrator to invoke this tool.
+      description: z.string().min(1).max(2e3),
+      // Zod serialized to JSON Schema at registration time. Persisted as
+      // JSON Schema; SDK and dashboard rehydrate to Zod when needed.
+      inputSchema: z.record(z.unknown()),
+      // When present, the runtime validates the handler's return value.
+      outputSchema: z.record(z.unknown()).optional(),
+      exposedVia: z.array(ToolExposure).min(1),
+      // ── Tool/Plugin SDK (PRD P0.2). All optional for back-compat. ──
+      // Latency class (PRD §4.6.3). Runtime defaults to 'in_call' when omitted.
+      mode: z.enum(["in_call", "async_only"]).optional(),
+      // Hard timeout for an in-call tool (ms).
+      timeoutMs: z.number().int().min(50).max(6e4).optional(),
+      // 'connection' resolves a credential from the vault by `connectionRef`.
+      auth: z.enum(["none", "connection"]).optional(),
+      connectionRef: z.string().max(128).optional(),
+      // Retry policy for safe/async verbs.
+      retry: z.object({
+        maxAttempts: z.number().int().min(1).max(5),
+        backoffMs: z.number().int().min(0).max(6e4)
+      }).optional(),
+      // Normalized result kinds the flow/decision layer branches on (result.kind).
+      resultKinds: z.array(z.string().min(1).max(64)).max(24).optional(),
+      // Free-form dashboard metadata (icon, group, etc.). No `category` enum.
+      metadata: z.record(z.unknown()).optional()
+    });
+  }
+});
+var TranscriptTurn, ConsultationAudit, ToolCallAudit, McpInteractionAudit;
+var init_call_result = __esm({
+  "../contracts/src/call-result.ts"() {
+    TranscriptTurn = z.object({
+      speaker: z.enum(["caller", "agent"]),
+      text: z.string(),
+      startMs: z.number().int().min(0),
+      endMs: z.number().int().min(0)
+    });
+    ConsultationAudit = z.object({
+      consultationId: z.string().uuid(),
+      question: z.string(),
+      resolution: z.enum(["guidance", "timeout", "cumulative_cap", "cancelled"]),
+      guidance: z.string().optional(),
+      requestedAt: z.string().datetime(),
+      resolvedAt: z.string().datetime(),
+      latencyMs: z.number().int().min(0)
+    });
+    ToolCallAudit = z.object({
+      toolName: z.string(),
+      // Verbatim args the LLM produced. May contain PII — see open question O2
+      // in docs/architecture/contracts-design.md §5.
+      args: z.record(z.unknown()),
+      result: z.unknown(),
+      startedAt: z.string().datetime(),
+      durationMs: z.number().int().min(0),
+      ok: z.boolean(),
+      errorMessage: z.string().optional()
+    });
+    McpInteractionAudit = z.object({
+      // One of the four runtime tools — closed set, no growth allowed.
+      tool: z.enum(["call_say", "call_send_guidance", "call_inject_context", "call_instruct"]),
+      // Args verbatim — see open question O2.
+      args: z.record(z.unknown()),
+      ts: z.string().datetime(),
+      // Attribution. The API key that drove the orchestrator session.
+      apiKeyId: z.string()
+    });
+    z.object({
+      callId: z.string().uuid(),
+      status: z.enum(["completed", "failed"]),
+      startedAt: z.string().datetime(),
+      endedAt: z.string().datetime(),
+      durationMs: z.number().int().min(0),
+      transcript: z.array(TranscriptTurn),
+      // Whatever the agent's process-schema captured. No prescribed shape.
+      structuredOutputs: z.record(z.unknown()).optional(),
+      recordingUrl: z.string().url().optional(),
+      cost: z.object({
+        totalUsd: z.string(),
+        breakdown: z.record(z.string()).optional()
+      }),
+      consultations: z.array(ConsultationAudit),
+      toolCalls: z.array(ToolCallAudit),
+      mcpInteractions: z.array(McpInteractionAudit)
+    });
+  }
+});
+var PhoneNumberStatus, PhoneNumberProvider, PhoneNumberCapabilities, PhoneNumberRecord;
+var init_numbers = __esm({
+  "../contracts/src/numbers.ts"() {
+    PhoneNumberStatus = z.enum([
+      "pending",
+      "active",
+      "releasing",
+      "released",
+      "failed"
+    ]);
+    PhoneNumberProvider = z.enum(["twilio", "telnyx", "plivo"]);
+    PhoneNumberCapabilities = z.object({
+      voice: z.boolean().optional(),
+      sms: z.boolean().optional(),
+      mms: z.boolean().optional(),
+      fax: z.boolean().optional()
+    });
+    PhoneNumberRecord = z.object({
+      id: z.string().uuid(),
+      projectId: z.string(),
+      e164: z.string().regex(/^\+[1-9]\d{1,14}$/),
+      provider: PhoneNumberProvider,
+      // Carrier-side identifiers — sensitive, stripped from PublicPhoneNumber.
+      providerSid: z.string(),
+      providerTrunkSid: z.string().nullable(),
+      voiceRouteId: z.string().nullable(),
+      voiceRouteTrunkId: z.string().nullable(),
+      agentId: z.string().uuid().nullable(),
+      // Environments pin (draft/live). null = no pin → live (today's behaviour).
+      agentConfigEnv: z.enum(["draft", "live"]).nullable(),
+      status: PhoneNumberStatus,
+      friendlyName: z.string().nullable(),
+      region: z.string().nullable(),
+      capabilities: PhoneNumberCapabilities,
+      providerMetadata: z.record(z.unknown()),
+      purchaseIdempotencyKey: z.string().nullable().optional(),
+      purchasedAt: z.string().datetime().nullable(),
+      releasedAt: z.string().datetime().nullable(),
+      createdByUserId: z.string().nullable(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    PhoneNumberRecord.omit({
+      providerSid: true,
+      providerTrunkSid: true,
+      providerMetadata: true,
+      purchaseIdempotencyKey: true
+    });
+    z.object({
+      phoneNumberId: z.string().uuid(),
+      // null detaches.
+      agentId: z.string().uuid().nullable()
+    });
+  }
+});
+var init_project_limits = __esm({
+  "../contracts/src/project-limits.ts"() {
+    z.object({
+      consultation: z.object({
+        // Ceiling for ConsultationPolicy.maxTimeoutMs. Project default 90_000.
+        perCallMaxTimeoutMs: z.number().int().min(1e3).default(9e4),
+        // Ceiling for ConsultationPolicy.maxCumulativeHoldMs. Default 300_000.
+        perCallMaxCumulativeMs: z.number().int().min(1e3).default(3e5)
+      })
+    });
+  }
+});
+
+// ../contracts/src/flow-ports.ts
+var INCOMPLETE_PORT_ID;
+var init_flow_ports = __esm({
+  "../contracts/src/flow-ports.ts"() {
+    INCOMPLETE_PORT_ID = "incomplete";
+  }
+});
+var FlowIssueSeverity, FlowIssue;
+var init_flow_validate = __esm({
+  "../contracts/src/flow-validate.ts"() {
+    init_flow_ports();
+    FlowIssueSeverity = z.enum(["error", "warning"]);
+    FlowIssue = z.object({
+      code: z.string().max(64),
+      severity: FlowIssueSeverity,
+      message: z.string().max(500),
+      nodeId: z.string().max(128).optional(),
+      edgeId: z.string().max(128).optional()
+    });
+    z.object({
+      valid: z.boolean(),
+      issues: z.array(FlowIssue).max(256)
+    });
+  }
+});
+
+// ../contracts/src/flow-builtins.ts
+var init_flow_builtins = __esm({
+  "../contracts/src/flow-builtins.ts"() {
+  }
+});
+var ComplianceRule, ComplianceDecision, ComplianceConfig;
+var init_compliance = __esm({
+  "../contracts/src/compliance.ts"() {
+    ComplianceRule = z.enum(["dnc", "consent", "quiet_hours", "frequency_cap"]);
+    ComplianceDecision = z.enum(["allowed", "blocked"]);
+    ComplianceConfig = z.object({
+      // Local calling window for the CALLED party — TCPA default 8am–9pm.
+      quietHoursStartHour: z.number().int().min(0).max(23).default(8),
+      quietHoursEndHour: z.number().int().min(1).max(24).default(21),
+      enforceDnc: z.boolean().default(true),
+      enforceQuietHours: z.boolean().default(true),
+      // Max dial attempts to one number per rolling 24h. 0 = unlimited.
+      maxAttemptsPerDay: z.number().int().min(0).default(0),
+      // Require a recorded consent flag before dialing.
+      requireConsent: z.boolean().default(false),
+      // Fallback IANA tz when the number's region can't be resolved.
+      fallbackTimeZone: z.string().min(1).default("America/New_York")
+    });
+    z.object({
+      phoneE164: z.string().regex(/^\+[1-9]\d{1,14}$/, "must be E.164"),
+      // ISO instant the check is evaluated at (defaults to now server-side).
+      now: z.string().datetime().optional(),
+      // Override the resolved timezone (else derived from the number's area code).
+      timeZone: z.string().optional(),
+      // Recent attempt count in the last 24h (for the frequency cap), if known.
+      recentAttempts: z.number().int().min(0).optional(),
+      // Whether consent is on file (for requireConsent).
+      hasConsent: z.boolean().optional()
+    });
+    z.object({
+      decision: ComplianceDecision,
+      // The first rule that blocked, if any.
+      rule: ComplianceRule.nullable(),
+      reason: z.string().nullable()
+    });
+    z.object({
+      id: z.string().uuid(),
+      projectId: z.string().min(1),
+      phoneE164: z.string(),
+      reason: z.string().nullable(),
+      source: z.string().nullable(),
+      createdAt: z.string().datetime()
+    });
+    z.object({
+      id: z.string().uuid(),
+      projectId: z.string().min(1),
+      phoneE164: z.string(),
+      decision: ComplianceDecision,
+      rule: ComplianceRule.nullable(),
+      reason: z.string().nullable(),
+      checkedAt: z.string().datetime()
+    });
+    z.object({
+      phoneE164: z.string().regex(/^\+[1-9]\d{1,14}$/, "must be E.164"),
+      reason: z.string().max(500).optional(),
+      source: z.string().max(120).optional()
+    });
+    ComplianceConfig.partial();
+  }
+});
+var init_call_recording = __esm({
+  "../contracts/src/call-recording.ts"() {
+    z.object({
+      // When false, the call-event sink skips egress entirely — no recording is made.
+      recordingEnabled: z.boolean().default(true),
+      // Optional consent preamble the agent speaks first on every call. null/empty =
+      // no announcement. Capped so it stays a short notice, not a monologue.
+      consentAnnouncement: z.string().max(1e3).nullable().default(null)
+    });
+    z.object({
+      recordingEnabled: z.boolean().optional(),
+      consentAnnouncement: z.string().max(1e3).nullable().optional()
+    });
+  }
+});
+var OutboundAmdMode;
+var init_outbound = __esm({
+  "../contracts/src/outbound.ts"() {
+    OutboundAmdMode = z.enum(["off", "detect", "detectMessageEnd"]);
+    z.object({
+      // Callee in E.164 (e.g. +14155551234). call-router re-validates strictly.
+      to: z.string().regex(/^\+[1-9]\d{6,14}$/, "must be E.164, e.g. +14155551234"),
+      // Caller-id phone number (must belong to the calling project).
+      phoneNumberId: z.string().min(1),
+      // Optional agent override; falls back to the number's bound agent.
+      agentId: z.string().min(1).optional(),
+      // Template/context variables forwarded to the agent as dispatch metadata.
+      variables: z.record(z.string(), z.string()).optional(),
+      // Per-call AMD override; takes precedence over the agent's stored outbound.amd.
+      amd: OutboundAmdMode.optional()
+    });
+  }
+});
+var ConnectionAuthType, ConnectionStatus;
+var init_connection = __esm({
+  "../contracts/src/connection.ts"() {
+    ConnectionAuthType = z.enum(["oauth2", "api_key", "bearer", "basic", "none"]);
+    ConnectionStatus = z.enum(["active", "revoked", "error"]);
+    z.object({
+      v: z.number().int(),
+      iv: z.string(),
+      ct: z.string(),
+      tag: z.string()
+    });
+    z.object({
+      id: z.string().uuid(),
+      projectId: z.string().min(1),
+      name: z.string().min(1).max(128),
+      // Open string — customers name providers freely (e.g. 'google_calendar',
+      // 'salesforce', 'n8n', 'http').
+      provider: z.string().min(1).max(120),
+      authType: ConnectionAuthType,
+      status: ConnectionStatus,
+      // Non-secret metadata (scopes, account label, base URL, …).
+      metadata: z.record(z.unknown()),
+      expiresAt: z.string().datetime().nullable(),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    z.object({
+      name: z.string().trim().min(1).max(128),
+      provider: z.string().trim().min(1).max(120),
+      authType: ConnectionAuthType,
+      // The secret material to encrypt at rest. Never stored or returned in plaintext.
+      secret: z.string().min(1).max(8192),
+      metadata: z.record(z.unknown()).optional(),
+      expiresAt: z.string().datetime().optional()
+    });
+    z.object({
+      name: z.string().trim().min(1).max(128).optional(),
+      // New secret material — re-encrypted at rest; the old envelope is replaced.
+      secret: z.string().min(1).max(8192).optional(),
+      // Merged over the existing metadata (top-level keys win).
+      metadata: z.record(z.unknown()).optional()
+    }).refine((v) => v.name !== void 0 || v.secret !== void 0 || v.metadata !== void 0, {
+      message: "nothing to update"
+    });
+  }
+});
+var ConnectorMode, ConnectorStatus, ConnectorNormalize;
+var init_connector = __esm({
+  "../contracts/src/connector.ts"() {
+    ConnectorMode = z.enum(["tunnel", "direct"]);
+    ConnectorStatus = z.enum(["online", "degraded", "offline"]);
+    ConnectorNormalize = z.enum(["auto", "on", "off"]);
+    z.object({
+      id: z.string().uuid(),
+      projectId: z.string().min(1),
+      name: z.string().min(1).max(128),
+      mode: ConnectorMode,
+      // Tunnel mode: a short non-secret preview of the daemon token. Null for direct.
+      tokenPreview: z.string().nullable(),
+      // Direct mode: the connections-vault row holding the URL + key. Null for tunnel.
+      connectionId: z.string().uuid().nullable(),
+      // Upstream model id / alias. Null → the brain's own default.
+      defaultModel: z.string().nullable(),
+      normalize: ConnectorNormalize,
+      enabled: z.boolean(),
+      status: ConnectorStatus,
+      lastSeenAt: z.string().datetime().nullable(),
+      metadata: z.record(z.unknown()),
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    z.object({
+      name: z.string().trim().min(1).max(128),
+      mode: ConnectorMode,
+      // Required when mode === 'direct': the vault connection holding URL + key.
+      connectionId: z.string().uuid().optional(),
+      defaultModel: z.string().trim().min(1).max(200).optional(),
+      normalize: ConnectorNormalize.optional(),
+      metadata: z.record(z.unknown()).optional()
+    });
+    z.object({
+      name: z.string().trim().min(1).max(128).optional(),
+      connectionId: z.string().uuid().nullable().optional(),
+      defaultModel: z.string().trim().min(1).max(200).nullable().optional(),
+      normalize: ConnectorNormalize.optional(),
+      enabled: z.boolean().optional()
+    });
+  }
+});
+var BrainWireMessage, HelloFrame, PongFrame, RegisteredFrame, PingFrame, ShutdownFrame, BrainRequestFrame, BrainCancelFrame, BrainDeltaFrame, BrainDoneFrame, BrainErrorFrame;
+var init_connector_stream = __esm({
+  "../contracts/src/connector-stream.ts"() {
+    BrainWireMessage = z.object({
+      role: z.enum(["system", "user", "assistant"]),
+      content: z.string()
+    });
+    HelloFrame = z.object({
+      kind: z.literal("hello"),
+      token: z.string().min(1),
+      replicaId: z.string().min(1),
+      version: z.string().min(1),
+      caps: z.object({ streaming: z.boolean(), tools: z.boolean(), litellm: z.boolean() })
+    });
+    PongFrame = z.object({ kind: z.literal("pong"), ts: z.number().int() });
+    RegisteredFrame = z.object({
+      kind: z.literal("registered"),
+      connectorId: z.string().uuid(),
+      projectId: z.string().min(1)
+    });
+    PingFrame = z.object({ kind: z.literal("ping"), ts: z.number().int() });
+    ShutdownFrame = z.object({ kind: z.literal("shutdown"), reason: z.string().optional() });
+    BrainRequestFrame = z.object({
+      kind: z.literal("brain.request"),
+      streamId: z.string().min(1),
+      model: z.string().optional(),
+      temperature: z.number().optional(),
+      messages: z.array(BrainWireMessage)
+    });
+    BrainCancelFrame = z.object({
+      kind: z.literal("brain.cancel"),
+      streamId: z.string().min(1)
+    });
+    BrainDeltaFrame = z.object({
+      kind: z.literal("brain.delta"),
+      streamId: z.string().min(1),
+      content: z.string()
+    });
+    BrainDoneFrame = z.object({
+      kind: z.literal("brain.done"),
+      streamId: z.string().min(1),
+      finishReason: z.string()
+    });
+    BrainErrorFrame = z.object({
+      kind: z.literal("brain.error"),
+      streamId: z.string().min(1),
+      code: z.enum([
+        "upstream_timeout",
+        "upstream_error",
+        "bad_response",
+        "normalize_failed",
+        "unreachable"
+      ]),
+      message: z.string()
+    });
+    z.discriminatedUnion("kind", [
+      HelloFrame,
+      PongFrame,
+      BrainDeltaFrame,
+      BrainDoneFrame,
+      BrainErrorFrame
+    ]);
+    z.discriminatedUnion("kind", [
+      RegisteredFrame,
+      PingFrame,
+      ShutdownFrame,
+      BrainRequestFrame,
+      BrainCancelFrame
+    ]);
+  }
+});
+
+// ../contracts/src/flow-enrichment.ts
+var init_flow_enrichment = __esm({
+  "../contracts/src/flow-enrichment.ts"() {
+  }
+});
+
+// ../contracts/src/flow-compile.ts
+var init_flow_compile = __esm({
+  "../contracts/src/flow-compile.ts"() {
+    init_flow_enrichment();
+  }
+});
+var EnvironmentSpec;
+var init_environments = __esm({
+  "../contracts/src/environments.ts"() {
+    EnvironmentSpec = z.enum(["draft", "live"]);
+    z.object({
+      agentName: z.string().min(1),
+      draftPercent: z.number().int().min(0).max(100),
+      livePercent: z.number().int().min(0).max(100)
+    });
+    z.object({
+      draftPercent: z.number().int().min(0).max(100),
+      livePercent: z.number().int().min(0).max(100).optional()
+    }).refine(
+      (v) => v.livePercent === void 0 || v.draftPercent + v.livePercent === 100,
+      { message: "draftPercent + livePercent must equal 100" }
+    );
+    z.object({
+      env: EnvironmentSpec.nullable()
+    });
+  }
+});
+var VariableType, VariableScope, VariableName;
+var init_variables = __esm({
+  "../contracts/src/variables.ts"() {
+    VariableType = z.enum(["string", "number", "boolean", "json"]);
+    VariableScope = z.enum(["project", "user"]);
+    VariableName = z.string().min(1).max(64).regex(
+      /^[A-Za-z_][A-Za-z0-9_]*$/,
+      "must be a valid identifier (letters, digits, underscore; no leading digit)"
+    );
+    z.object({
+      id: z.string().uuid(),
+      projectId: z.string(),
+      name: VariableName,
+      type: VariableType,
+      // Stored as text; interpreted per `type`. null = no default (renders '').
+      defaultValue: z.string().nullable(),
+      description: z.string().max(280).nullable(),
+      scope: VariableScope,
+      createdAt: z.string().datetime(),
+      updatedAt: z.string().datetime()
+    });
+    z.object({
+      name: VariableName,
+      type: VariableType.default("string"),
+      defaultValue: z.string().nullable().optional(),
+      description: z.string().max(280).nullable().optional(),
+      scope: VariableScope.default("project")
+    });
+    z.object({
+      type: VariableType.optional(),
+      defaultValue: z.string().nullable().optional(),
+      description: z.string().max(280).nullable().optional(),
+      scope: VariableScope.optional()
+    }).refine((b) => Object.keys(b).length > 0, { message: "no fields to update" });
+  }
+});
+var PlaybookExitCondition;
+var init_playbooks = __esm({
+  "../contracts/src/playbooks.ts"() {
+    PlaybookExitCondition = z.object({
+      name: z.string().min(1).max(64),
+      description: z.string().max(2e3),
+      requiredVariables: z.array(z.string().min(1).max(64)).max(32)
+    });
+    z.object({
+      id: z.string(),
+      projectId: z.string(),
+      name: z.string().min(1).max(120),
+      // Routing signal — "what it does AND when to use it" (read by the agent router).
+      llmDescription: z.string().max(2e3),
+      instructions: z.string().max(2e4),
+      // Model overrides (null = inherit the agent's). Exactly 3 knobs, no top-p/penalties.
+      model: z.string().max(120).nullable(),
+      temperature: z.number().min(0).max(2).nullable(),
+      maxTokens: z.number().int().positive().max(32e3).nullable(),
+      // Registry HTTP tools (by name) this playbook may call. With tools the
+      // playbook runs as an agent loop (LLM-with-tools + structured exit).
+      tools: z.array(z.string().min(1).max(128)).max(64).default([]),
+      exitConditions: z.array(PlaybookExitCondition).max(24),
+      createdAt: z.string(),
+      updatedAt: z.string()
+    });
+    z.object({
+      name: z.string().min(1).max(120),
+      llmDescription: z.string().max(2e3).default(""),
+      instructions: z.string().max(2e4).default(""),
+      model: z.string().max(120).nullable().optional(),
+      temperature: z.number().min(0).max(2).nullable().optional(),
+      maxTokens: z.number().int().positive().max(32e3).nullable().optional(),
+      tools: z.array(z.string().min(1).max(128)).max(64).default([]),
+      exitConditions: z.array(PlaybookExitCondition).max(24).default([])
+    });
+    z.object({
+      name: z.string().min(1).max(120),
+      llmDescription: z.string().max(2e3),
+      instructions: z.string().max(2e4),
+      model: z.string().max(120).nullable(),
+      temperature: z.number().min(0).max(2).nullable(),
+      maxTokens: z.number().int().positive().max(32e3).nullable(),
+      tools: z.array(z.string().min(1).max(128)).max(64),
+      exitConditions: z.array(PlaybookExitCondition).max(24)
+    }).partial().refine((b) => Object.keys(b).length > 0, { message: "at least one field required" });
+  }
+});
+var PlaybookSnapshot;
+var init_playbook_versions = __esm({
+  "../contracts/src/playbook-versions.ts"() {
+    init_playbooks();
+    PlaybookSnapshot = z.object({
+      name: z.string().min(1).max(120),
+      llmDescription: z.string().max(2e3),
+      instructions: z.string().max(2e4),
+      model: z.string().max(120).nullable(),
+      temperature: z.number().min(0).max(2).nullable(),
+      maxTokens: z.number().int().positive().max(32e3).nullable(),
+      // Registry tool names frozen with the snapshot (default keeps old rows valid).
+      tools: z.array(z.string().min(1).max(128)).max(64).default([]),
+      exitConditions: z.array(PlaybookExitCondition).max(24)
+    });
+    z.object({
+      id: z.string(),
+      playbookId: z.string(),
+      projectId: z.string(),
+      version: z.number().int().min(1),
+      // Frozen playbook definition at publish time.
+      definition: PlaybookSnapshot,
+      note: z.string().max(1e3).nullable(),
+      publishedByUserId: z.string().nullable(),
+      publishedAt: z.string()
+    });
+    z.object({
+      note: z.string().max(1e3).optional()
+    });
+  }
+});
+
+// ../contracts/src/playbook-compile.ts
+var init_playbook_compile = __esm({
+  "../contracts/src/playbook-compile.ts"() {
+  }
+});
+
+// ../contracts/src/index.ts
+var init_src = __esm({
+  "../contracts/src/index.ts"() {
+    init_primitive();
+    init_events();
+    init_context();
+    init_errors();
+    init_ids();
+    init_agents();
+    init_process_state();
+    init_call_events();
+    init_call_plan();
+    init_memory();
+    init_participants();
+    init_forms();
+    init_consultation();
+    init_agent_config();
+    init_model_catalog();
+    init_evaluations();
+    init_tests();
+    init_call_review();
+    init_agent_tools();
+    init_call_result();
+    init_numbers();
+    init_project_limits();
+    init_flow();
+    init_flow_program();
+    init_flow_ports();
+    init_flow_validate();
+    init_flow_builtins();
+    init_compliance();
+    init_call_recording();
+    init_outbound();
+    init_connection();
+    init_connector();
+    init_connector_stream();
+    init_flow_compile();
+    init_flow_enrichment();
+    init_environments();
+    init_variables();
+    init_playbooks();
+    init_playbook_versions();
+    init_playbook_compile();
+  }
+});
+
+// src/runtime/graph/interpolate.ts
+function interpolate(template, scope) {
+  if (!template || template.indexOf("{{") === -1) return template;
+  return template.replace(TOKEN, (_match, expr) => {
+    const value = resolvePath(scope, expr.trim());
+    return value === void 0 || value === null ? "" : String(value);
+  });
+}
+function resolvePath(scope, path) {
+  const parts = path.split(".").map((p) => p.trim()).filter((p) => p.length > 0);
+  let current = scope;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object") return void 0;
+    const obj = current;
+    if (Object.prototype.hasOwnProperty.call(obj, part)) {
+      current = obj[part];
+      continue;
+    }
+    const tolerant = Object.keys(obj).find((k) => k.trim() === part);
+    if (tolerant === void 0) return void 0;
+    current = obj[tolerant];
+  }
+  return current;
+}
+function hasSlot(slots, name) {
+  const v = resolvePath(slots, name.trim());
+  return v !== void 0 && v !== null && v !== "";
+}
+var TOKEN;
+var init_interpolate = __esm({
+  "src/runtime/graph/interpolate.ts"() {
+    TOKEN = /\{\{\s*([^}]+?)\s*\}\}/g;
+  }
+});
+
+// src/runtime/graph/builtins.ts
+function buildBuiltinScope(deps) {
+  const call = deps.ctx.call;
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const today = nowIso.slice(0, 10);
+  const callerId = typeof call?.callerId === "string" ? call.callerId : "";
+  const agentName = deps.ctx.metadata?.["agentName"];
+  return {
+    caller_id: callerId,
+    from: callerId,
+    to: typeof call?.to === "string" ? call.to : "",
+    call_id: typeof call?.callId === "string" ? call.callId : "",
+    agent_name: typeof agentName === "string" ? agentName : "",
+    channel: "voice",
+    now: nowIso,
+    today,
+    vf_now: nowIso,
+    vf_today: today
+  };
+}
+var init_builtins = __esm({
+  "src/runtime/graph/builtins.ts"() {
+    init_src();
+  }
+});
+function defaultOpenAIOptions() {
+  if (!credential) return {};
+  return {
+    apiKey: credential.apiKey,
+    ...credential.baseURL ? { baseURL: credential.baseURL } : {}
+  };
+}
+function defaultOpenAI() {
+  return cached ??= new OpenAI(defaultOpenAIOptions());
+}
+function hasOpenAiKey() {
+  return credential !== null || Boolean(process.env["OPENAI_API_KEY"]);
+}
+var credential, cached;
+var init_openai_default = __esm({
+  "src/runtime/openai-default.ts"() {
+    credential = null;
+    cached = null;
+  }
+});
+
+// src/runtime/graph/embedder.ts
+function dotProduct(a, b) {
+  const n = Math.min(a.length, b.length);
+  let sum = 0;
+  for (let i = 0; i < n; i++) sum += a[i] * b[i];
+  return sum;
+}
+function createOpenAIEmbedder() {
+  const cache = /* @__PURE__ */ new Map();
+  const available = () => hasOpenAiKey();
+  function remember(key, vec) {
+    if (cache.size >= CACHE_MAX) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== void 0) cache.delete(oldest);
+    }
+    cache.set(key, vec);
+    return vec;
+  }
+  return {
+    get available() {
+      return available();
+    },
+    async embed(text) {
+      const key = text.trim();
+      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);
+      }
+    },
+    prewarm(text) {
+      void this.embed(text).catch(() => {
+      });
+    }
+  };
+}
+function getEmbedder() {
+  if (override) return override;
+  singleton ??= createOpenAIEmbedder();
+  return singleton;
+}
+var EMBED_MODEL, ROUTE_THRESHOLD, EMBED_TIMEOUT_MS, CACHE_MAX, singleton, override;
+var init_embedder = __esm({
+  "src/runtime/graph/embedder.ts"() {
+    init_openai_default();
+    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");
+    CACHE_MAX = 2e3;
+    singleton = null;
+    override = null;
+  }
+});
+
+// src/runtime/graph/conditions.ts
+async function selectEdge(edges, ctx) {
+  if (edges.length === 0) return null;
+  const conditional = edges.filter((e) => e.condition && e.condition.trim());
+  const fallthrough = edges.find((e) => (!e.condition || !e.condition.trim()) && !e.sourceHandle);
+  const nl = [];
+  for (const edge of conditional) {
+    const det = evaluateDeterministicCondition(edge.condition, ctx);
+    if (det === true) return edge.to;
+    if (det === void 0) nl.push(edge);
+  }
+  if (nl.length === 0) return fallthrough ? fallthrough.to : null;
+  const routed = await routeByEmbedding(nl, ctx);
+  if (routed) return routed;
+  for (const edge of nl) {
+    if (await evaluateCondition(edge.condition, ctx)) return edge.to;
+  }
+  return fallthrough ? fallthrough.to : null;
+}
+function evaluateDeterministicCondition(condition, ctx) {
+  const text = condition.trim();
+  if (!text) return true;
+  let anyOrTrue = false;
+  for (const orPart of splitTop(text, "||")) {
+    let allOk = true;
+    for (const atom of splitTop(orPart, "&&")) {
+      const det = evaluateDeterministic(atom.trim(), ctx);
+      if (det === void 0) return void 0;
+      if (!det) allOk = false;
+    }
+    if (allOk) anyOrTrue = true;
+  }
+  return anyOrTrue;
+}
+function isNaturalLanguageCondition(condition) {
+  return !!condition.trim() && evaluateDeterministicCondition(condition, { slots: {}, tools: {} }) === void 0;
+}
+async function routeByEmbedding(nl, ctx) {
+  const utterance = ctx.lastUtterance?.trim();
+  if (!utterance) return null;
+  const embedder = getEmbedder();
+  if (!embedder.available) return null;
+  const uvec = await embedder.embed(utterance);
+  if (!uvec) return null;
+  let best = null;
+  for (const edge of nl) {
+    const cvec = await embedder.embed(edge.condition);
+    if (!cvec) continue;
+    const score = dotProduct(uvec, cvec);
+    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)) });
+    return best.to;
+  }
+  return null;
+}
+async function evaluateCondition(condition, ctx) {
+  const text = condition.trim();
+  if (!text) return true;
+  for (const orPart of splitTop(text, "||")) {
+    const ands = splitTop(orPart, "&&");
+    let allOk = true;
+    for (const atom of ands) {
+      const det = evaluateDeterministic(atom.trim(), ctx);
+      const ok = det === void 0 ? await judge(atom.trim(), ctx) : det;
+      if (!ok) {
+        allOk = false;
+        break;
+      }
+    }
+    if (allOk) return true;
+  }
+  return false;
+}
+function splitTop(text, op) {
+  return text.split(op);
+}
+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*(.*)$/);
+  if (toolMatch) {
+    const [, id, path, op, rawVal] = toolMatch;
+    const result = ctx.tools[id];
+    if (result === void 0) return false;
+    if (!path || path === "ok") {
+      const ok = result.ok === true || result.kind === "ok";
+      return op === "!=" ? !ok : ok;
+    }
+    const actual = resolvePath(result, path);
+    if (!op) return actual !== void 0 && actual !== null && actual !== "";
+    const eq = String(actual ?? "").toLowerCase() === (rawVal ?? "").trim().toLowerCase();
+    return op === "!=" ? !eq : eq;
+  }
+  const nodeMatch = atom.match(/^node:([A-Za-z0-9_-]+)(?:\.([\w.]+))?\s*(==|!=)?\s*(.*)$/);
+  if (nodeMatch) {
+    if (!ctx.nodeResults) return void 0;
+    const [, id, path, op, rawVal] = nodeMatch;
+    const result = ctx.nodeResults[id];
+    if (result === void 0) return void 0;
+    if (!path) return result !== null && result !== "" && result !== false;
+    const actual = resolvePath(result, path);
+    if (!op) return actual !== void 0 && actual !== null && actual !== "";
+    const eq = String(actual ?? "").toLowerCase() === (rawVal ?? "").trim().toLowerCase();
+    return op === "!=" ? !eq : eq;
+  }
+  const dtmfMatch = atom.match(/^dtmf:\s*(.+)$/i);
+  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
+  );
+  if (opMatch) {
+    const [, neg, nameRaw, op, valRaw] = opMatch;
+    const raw = resolvePath(ctx.slots, nameRaw.trim());
+    const value = String(raw ?? "").toLowerCase();
+    const target = valRaw.trim().toLowerCase();
+    const opKey = op.toLowerCase();
+    let res;
+    if (opKey === "contains") res = value.includes(target);
+    else if (opKey === "starts_with") res = value.startsWith(target);
+    else if (opKey === "greater_than" || opKey === ">" || opKey === ">=" || opKey === "less_than" || opKey === "<" || opKey === "<=") {
+      const a = Number(String(raw ?? "").replace(/[^0-9.+-]/g, ""));
+      const b = Number(valRaw.trim().replace(/[^0-9.+-]/g, ""));
+      if (Number.isNaN(a) || Number.isNaN(b)) res = false;
+      else if (opKey === "greater_than" || opKey === ">") res = a > b;
+      else if (opKey === ">=") res = a >= b;
+      else if (opKey === "less_than" || opKey === "<") res = a < b;
+      else res = a <= b;
+    } else if (opKey === "!=") res = value !== target;
+    else res = value === target;
+    return neg ? !res : res;
+  }
+  const slotPres = atom.match(/^(!?)\s*slot:(.+?)\s*(present|empty)?$/i);
+  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);
+  if (bare) {
+    const [, neg, name, kw] = bare;
+    const present = hasSlot(ctx.slots, name);
+    const res = (kw ?? "").toLowerCase() === "empty" ? !present : present;
+    return neg ? !res : res;
+  }
+  return void 0;
+}
+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("; ");
+  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 ?? ""}"`,
+    "Outcomes:",
+    list,
+    'Answer with ONLY the outcome number, or "none" if nothing clearly matches.'
+  ].join("\n");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), JUDGE_TIMEOUT_MS);
+  try {
+    const res = await defaultOpenAI().chat.completions.create(
+      {
+        model: process.env["VOICELAYER_JUDGE_MODEL"] ?? "gpt-4o-mini",
+        temperature: 0,
+        max_tokens: 4,
+        messages: [
+          { role: "system", content: 'Answer with only a number, or "none".' },
+          { role: "user", content: prompt }
+        ]
+      },
+      { signal: controller.signal }
+    );
+    const answer = (res.choices[0]?.message?.content ?? "").trim().toLowerCase();
+    const n = Number.parseInt(answer.replace(/[^0-9]/g, ""), 10);
+    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", {
+      err: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+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("; ");
+  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 ?? ""}"`,
+    `Condition: ${condition}`,
+    'Answer strictly "yes" or "no".'
+  ].join("\n");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), JUDGE_TIMEOUT_MS);
+  try {
+    const res = await defaultOpenAI().chat.completions.create(
+      {
+        model: process.env["VOICELAYER_JUDGE_MODEL"] ?? "gpt-4o-mini",
+        temperature: 0,
+        max_tokens: 2,
+        messages: [
+          { role: "system", content: 'Answer only "yes" or "no".' },
+          { role: "user", content: prompt }
+        ]
+      },
+      { signal: controller.signal }
+    );
+    return (res.choices[0]?.message?.content ?? "").trim().toLowerCase().startsWith("y");
+  } catch (err) {
+    console.warn("[graph] condition judge failed; treating as false", {
+      condition,
+      err: err instanceof Error ? err.message : String(err)
+    });
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var JUDGE_TIMEOUT_MS;
+var init_conditions = __esm({
+  "src/runtime/graph/conditions.ts"() {
+    init_openai_default();
+    init_interpolate();
+    init_embedder();
+    JUDGE_TIMEOUT_MS = 4e3;
+  }
+});
+
+// src/runtime/graph/branch-resolve.ts
+function branchOptionsOf(config) {
+  if (!Array.isArray(config.branches)) return [];
+  return config.branches.filter((b) => b && typeof b.id === "string" && typeof b.label === "string").map((b) => ({
+    id: b.id,
+    label: b.label,
+    ...typeof b.when === "string" && b.when.trim() ? { when: b.when } : {},
+    ...typeof b.digit === "string" && b.digit.trim() ? { digit: b.digit.trim() } : {},
+    ...typeof b.description === "string" && b.description.trim() ? { description: b.description } : {}
+  }));
+}
+async function resolveBranch(branches, ctx, opts) {
+  const candidates = branches.filter((b) => b.id !== ELSE_BRANCH_ID);
+  if (candidates.length === 0) return null;
+  const nl = [];
+  for (const b of candidates) {
+    if (b.when && b.when.trim()) {
+      const det = evaluateDeterministicCondition(b.when, ctx);
+      if (det === true) return b.id;
+      if (det === void 0) nl.push(b);
+    } else {
+      nl.push(b);
+    }
+  }
+  if (nl.length === 0) return null;
+  const utterance = ctx.lastUtterance?.trim();
+  if (utterance) {
+    const embedder = getEmbedder();
+    if (embedder.available) {
+      const uvec = await embedder.embed(utterance);
+      if (uvec) {
+        let best = null;
+        for (const b of nl) {
+          const bvec = await embedder.embed(b.when?.trim() || b.label);
+          if (!bvec) continue;
+          const score = dotProduct(uvec, bvec);
+          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)) });
+          return best.id;
+        }
+      }
+    }
+  }
+  return pickOption(
+    nl.map((b) => ({ id: b.id, text: b.when?.trim() || b.label })),
+    ctx,
+    opts?.hint
+  );
+}
+var ELSE_BRANCH_ID;
+var init_branch_resolve = __esm({
+  "src/runtime/graph/branch-resolve.ts"() {
+    init_conditions();
+    init_embedder();
+    ELSE_BRANCH_ID = "else";
+  }
+});
+
+// src/runtime/graph/drift.ts
+function adherenceOf(node) {
+  const a = node.config.adherence;
+  return a === "observe" || a === "enforce" ? a : "off";
+}
+async function similarity(reply, intent) {
+  const r = reply.trim();
+  const n = intent.trim();
+  if (!r || !n) return null;
+  const embedder = getEmbedder();
+  if (!embedder.available) return null;
+  const [rv, nv] = await Promise.all([embedder.embed(r), embedder.embed(n)]);
+  if (!rv || !nv) return null;
+  return dotProduct(rv, nv);
+}
+var DRIFT_THRESHOLD, MAX_DRIFT_RETRIES;
+var init_drift = __esm({
+  "src/runtime/graph/drift.ts"() {
+    init_embedder();
+    DRIFT_THRESHOLD = Number(process.env["VL_FLOW_DRIFT_THRESHOLD"] ?? "0.25");
+    MAX_DRIFT_RETRIES = Number(process.env["VL_FLOW_DRIFT_RETRIES"] ?? "1");
+  }
+});
+
+// src/define-tool.ts
+function defineTool(spec) {
+  return {
+    [spec.name]: {
+      description: spec.description,
+      input: spec.input,
+      run: spec.run,
+      ...spec.capability ? { capability: spec.capability } : {}
+    }
+  };
+}
+function httpTool(spec) {
+  const method = spec.method ?? "POST";
+  const fetchImpl = spec.fetchImpl ?? fetch;
+  return defineTool({
+    name: spec.name,
+    description: spec.description,
+    input: spec.input,
+    ...spec.capability ? { capability: spec.capability } : {},
+    run: async (input) => {
+      const bag = input ?? {};
+      const url = spec.url.replace(
+        /\{(\w+)\}/g,
+        (_m, key) => encodeURIComponent(String(bag[key] ?? ""))
+      );
+      const init = {
+        method,
+        headers: { "content-type": "application/json", ...spec.headers ?? {} },
+        ...method === "GET" ? {} : { body: JSON.stringify(spec.body ? spec.body(bag) : bag) }
+      };
+      const res = await fetchImpl(url, init);
+      const text = await res.text();
+      let data = text;
+      try {
+        data = JSON.parse(text);
+      } catch {
+      }
+      return { ok: res.ok, status: res.status, data };
+    }
+  });
+}
+var init_define_tool = __esm({
+  "src/define-tool.ts"() {
+  }
+});
+
+// src/runtime/graph/executors.ts
+function historyPolicyOf(node) {
+  const p = node.config.historyPolicy;
+  return p === "last-turn" || p === "slots-only" ? p : "full";
+}
+async function withHistory(deps, policy, gen) {
+  if (deps.history) await deps.history.withPolicy(policy, gen);
+  else await gen();
+}
+function scopeFor(state, deps) {
+  const slots = deps.processRt.getData();
+  return {
+    ...buildBuiltinScope(deps),
+    ...slots,
+    slots,
+    tool: state.toolResults,
+    node: state.nodeResults,
+    call: deps.ctx.call
+  };
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+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 } : {}
+  };
+}
+function deterministicEdgeTarget(edges, ctx) {
+  for (const e of edges) {
+    if (!e.condition || !e.condition.trim()) continue;
+    if (evaluateDeterministicCondition(e.condition, ctx) === true) return e.to;
+  }
+  return null;
+}
+async function speak(text, deps, opts) {
+  if (!text.trim()) return;
+  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 });
+    return;
+  }
+  const session = deps.ctx.livekit.session;
+  if (deps.realtime) {
+    await session.generateReply({
+      instructions: `Say the following line to the user, verbatim and in full \u2014 no additions, omissions, or rephrasing:
+
+${text}`
+    }).waitForPlayout();
+    console.log("[graph] 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 });
+}
+async function genReply(deps, instructions) {
+  if (deps.ctx.adapter) {
+    await deps.ctx.adapter.generateReply({ instructions });
+    return;
+  }
+  await deps.ctx.livekit.session.generateReply({ instructions }).waitForPlayout();
+}
+async function nextTurn(deps, reprompt) {
+  let reprompted = false;
+  for (; ; ) {
+    const evt = await deps.utterances.next({ timeoutMs: NO_INPUT_MS });
+    if (evt.kind === "hangup") return { result: { kind: "end" } };
+    if (evt.kind === "control") return { result: evt.result };
+    if (evt.kind === "timeout") {
+      if (!reprompted) {
+        reprompted = true;
+        deps.events.note("no_input.reprompt");
+        await speak(reprompt ?? "Sorry, are you still there?", deps);
+        continue;
+      }
+      deps.events.note("no_input.escalate");
+      return { result: { kind: "end" } };
+    }
+    if (evt.kind === "dtmf") return { text: evt.digit, dtmf: evt.digit };
+    return { text: evt.text };
+  }
+}
+function detectYesNo(text) {
+  const yes = YES_WORDS.test(text);
+  const no = NO_WORDS.test(text);
+  if (yes && !no) return "yes";
+  if (no && !yes) return "no";
+  return null;
+}
+function formatCollected(slots) {
+  return Object.entries(slots).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `${k.trim()}: ${String(v)}`).join("\n");
+}
+function round3(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+async function guardedGenerate(node, state, deps, instructions, intent) {
+  await genReply(deps, instructions);
+  const mode = adherenceOf(node);
+  if (mode === "off") return;
+  let sim = await similarity(deps.history?.lastAssistantText() ?? "", intent);
+  if (sim === null || sim >= DRIFT_THRESHOLD) return;
+  if (mode === "observe") {
+    deps.events.note("drift.observed", { node: node.id, score: round3(sim) });
+    return;
+  }
+  for (let attempt = 1; attempt <= MAX_DRIFT_RETRIES; attempt++) {
+    deps.events.note("drift.regenerate", { node: node.id, attempt, score: round3(sim) });
+    await genReply(
+      deps,
+      `${instructions}
+
+IMPORTANT: stay strictly on this task and do not go off-topic:
+${intent}`
+    );
+    sim = await similarity(deps.history?.lastAssistantText() ?? "", intent);
+    if (sim === null || sim >= DRIFT_THRESHOLD) return;
+  }
+  const fallback = str(node.config.fallback);
+  if (fallback) {
+    deps.events.note("drift.fallback_verbatim", { node: node.id });
+    await speak(interpolate(fallback, scopeFor(state, deps)), deps);
+  } else {
+    deps.events.note("drift.unresolved", { node: node.id });
+  }
+}
+function routeByPort(node, deps, port) {
+  return deps.model.selectByPort(node.id, port) !== null ? { kind: "take", port } : { kind: "advance" };
+}
+function menuDigitOf(b) {
+  if (b.digit && b.digit.trim()) return b.digit.trim();
+  const m = b.label.match(/^\s*([0-9*#])\b/);
+  return m ? m[1] : null;
+}
+function menuLabelOf(label) {
+  return label.replace(/^\s*[0-9*#]\s*[-—–:.]*\s*/, "").trim() || label.trim();
+}
+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_src();
+    init_interpolate();
+    init_builtins();
+    init_conditions();
+    init_branch_resolve();
+    init_drift();
+    init_define_tool();
+    ASK_MAX_CLARIFY = 4;
+    LLM_MAX_TURNS = 30;
+    HUB_MAX_TURNS = 500;
+    NO_INPUT_MS = Number(process.env["VL_FLOW_NO_INPUT_MS"] ?? "8000");
+    sayExecutor = async (node, state, deps) => {
+      await speak(interpolate(str(node.config.text), scopeFor(state, deps)), deps);
+      return { kind: "advance" };
+    };
+    YES_WORDS = /\b(yes|yeah|yep|yup|correct|right|exactly|sure|affirmative|that'?s right|sounds good|ok(?:ay)?)\b/i;
+    NO_WORDS = /\b(no|nope|nah|wrong|incorrect|negative|not right|that'?s not|change|actually)\b/i;
+    confirmExecutor = async (node, state, deps) => {
+      const text = interpolate(str(node.config.text), scopeFor(state, deps));
+      await speak(text || "Is that correct?", deps);
+      for (let attempt = 0; attempt < 2; attempt++) {
+        const t = await nextTurn(deps, text || "Is that correct?");
+        if ("result" in t) return t.result;
+        state.lastUtterance = t.text;
+        state.lastDtmf = t.dtmf;
+        let verdict = null;
+        if (t.dtmf === "1") verdict = "yes";
+        else if (t.dtmf === "2") verdict = "no";
+        else if (t.text.trim()) verdict = detectYesNo(t.text);
+        if (verdict === null && t.text.trim()) {
+          verdict = await resolveBranch(
+            [
+              { id: "yes", label: "The caller confirms \u2014 the detail is correct." },
+              { id: "no", label: "The caller says it is wrong or wants to change it." }
+            ],
+            evalCtxOf(state, deps)
+          );
+        }
+        if (verdict === "yes") {
+          deps.events.note("confirm.confirmed", { node: node.id });
+          return routeByPort(node, deps, "yes");
+        }
+        if (verdict === "no") {
+          deps.events.note("confirm.denied", { node: node.id });
+          return routeByPort(node, deps, "no");
+        }
+        if (attempt === 0) await speak("Sorry \u2014 is that correct? Yes or no.", deps);
+      }
+      deps.events.note("confirm.unresolved", { node: node.id });
+      return { kind: "advance" };
+    };
+    askExecutor = async (node, state, deps) => {
+      const slot = str(node.config.slot) || node.id;
+      const authoredSlot = slot === node.id ? "" : slot.trim();
+      const label = authoredSlot.replace(/[_-]+/g, " ");
+      if (hasSlot(deps.processRt.getData(), slot)) {
+        console.log("[graph] ask: slot already known, skipping", { slot: slot.trim() });
+        return { kind: "advance" };
+      }
+      const askText = interpolate(
+        str(node.config.ask) || (label ? `Could you tell me your ${label}?` : "Could you tell me a bit more about what you need?"),
+        scopeFor(state, deps)
+      );
+      await speak(askText, deps);
+      for (let turn = 0; turn < ASK_MAX_CLARIFY; turn++) {
+        const t = await nextTurn(deps, askText);
+        if ("result" in t) return t.result;
+        state.lastUtterance = t.text;
+        state.lastDtmf = t.dtmf;
+        if (hasSlot(deps.processRt.getData(), slot)) {
+          console.log("[graph] ask: captured", { slot: slot.trim() });
+          return { kind: "advance" };
+        }
+        console.log("[graph] ask: clarify", { slot: slot.trim(), turn });
+        await withHistory(
+          deps,
+          historyPolicyOf(node),
+          () => genReply(
+            deps,
+            `You are collecting "${label || "the detail just asked about"}" from the caller. They haven't yet given a clear, valid value. Acknowledge what they said, then briefly ask again for just that.`
+          )
+        );
+      }
+      deps.events.note("ask.unfilled", { slot: slot.trim() });
+      return { kind: "advance" };
+    };
+    gateExecutor = async (node, _state, deps) => {
+      const required = Array.isArray(node.config.requiredFields) ? node.config.requiredFields.filter((x) => typeof x === "string") : [];
+      const data = deps.processRt.getData();
+      const missing = required.filter((f) => !hasSlot(data, f));
+      if (missing.length === 0) return { kind: "advance" };
+      deps.events.note("gate.incomplete", { missing: missing.map((m) => m.trim()) });
+      return { kind: "advance" };
+    };
+    endExecutor = async (node, state, deps) => {
+      const msg = str(node.config.endMessage);
+      if (msg) await speak(interpolate(msg, scopeFor(state, deps)), deps);
+      return { kind: "end" };
+    };
+    handoffExecutor = async (node, _state, deps) => {
+      const cfg = node.config;
+      const target = str(cfg.to) || str(cfg.fallback);
+      if (!target) {
+        deps.events.note("handoff.no_target", { node: node.id });
+        return { kind: "advance" };
+      }
+      const reason = str(cfg.reason) || `flow:${node.id}`;
+      const mode = cfg.mode === "warm" || cfg.mode === "cold" ? cfg.mode : void 0;
+      deps.events.note("handoff.start", { node: node.id, to: target, ...mode ? { mode } : {} });
+      try {
+        await deps.ctx.handoff(target, { reason, ...mode ? { mode } : {} });
+      } catch (err) {
+        deps.events.note("handoff.failed", {
+          node: node.id,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      return { kind: "handoff", to: target };
+    };
+    llmExecutor = async (node, state, deps) => {
+      const out = deps.model.out(node.id);
+      const conditional = out.filter((e) => e.condition && e.condition.trim());
+      const terminal = out.length === 0;
+      const hub = node.config.hub === true;
+      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.";
+      for (let turn = 0; turn < maxTurns; turn++) {
+        const collected = formatCollected(deps.processRt.getData());
+        const parts = [base];
+        if (collected) parts.push(`Information collected so far:
+${collected}`);
+        if (state.lastUtterance) parts.push(`The caller just said: "${state.lastUtterance}"`);
+        await withHistory(
+          deps,
+          policy,
+          () => guardedGenerate(node, state, deps, parts.join("\n\n"), base)
+        );
+        if (!hub && !terminal && conditional.length === 0) return { kind: "advance" };
+        const t = await nextTurn(deps);
+        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
+          });
+          if (target) {
+            console.log("[graph] llm: transition", { node: node.id, to: target, hub });
+            return { kind: "goto", to: target };
+          }
+        }
+      }
+      console.log("[graph] llm: turn cap reached", { node: node.id, hub });
+      return terminal ? { kind: "end" } : { kind: "advance" };
+    };
+    toolExecutor = async (node, state, deps) => {
+      const cfg = node.config;
+      const name = str(cfg.name) || node.id;
+      const routeByOutcome = () => {
+        const ok = state.toolResults[node.id]?.ok === true;
+        return routeByPort(node, deps, ok ? "ok" : "fail");
+      };
+      const toolRef = str(cfg.toolRef);
+      const registry = deps.resolvers?.registryTools;
+      if (toolRef && registry) {
+        deps.events.note("tool.invoked", { node: node.id, name: toolRef, ref: true });
+        try {
+          const spec = (await registry.catalog()).find((t) => t.name === toolRef);
+          const slots2 = deps.processRt.getData();
+          const bag2 = {};
+          for (const field of Object.keys(spec?.input ?? {})) {
+            const v = resolvePath(slots2, field);
+            if (v !== void 0 && v !== null && v !== "") bag2[field] = v;
+          }
+          const result = await registry.run(toolRef, bag2);
+          state.toolResults[node.id] = result;
+          deps.events.note(result.ok ? "tool.succeeded" : "tool.errored", {
+            node: node.id,
+            name: toolRef,
+            status: result.status
+          });
+        } catch (err) {
+          state.toolResults[node.id] = {
+            ok: false,
+            status: 0,
+            data: { error: err instanceof Error ? err.message : String(err) }
+          };
+          deps.events.note("tool.errored", { node: node.id, name: toolRef });
+        }
+        return routeByOutcome();
+      }
+      if (toolRef && !registry) {
+        state.toolResults[node.id] = {
+          ok: false,
+          status: 0,
+          data: { kind: "unavailable", reason: "tool registry resolver not wired" }
+        };
+        deps.events.note("tool.unavailable", { node: node.id, name: toolRef });
+        return routeByOutcome();
+      }
+      const url = str(cfg.url);
+      if (!url) {
+        state.toolResults[node.id] = { ok: false, status: 0, data: null };
+        deps.events.note("tool.errored", { node: node.id, name, error: "no url" });
+        return routeByOutcome();
+      }
+      const inputSpec = cfg.input && typeof cfg.input === "object" ? cfg.input : {};
+      const slots = deps.processRt.getData();
+      const bag = {};
+      for (const field of Object.keys(inputSpec)) {
+        const v = resolvePath(slots, field);
+        if (v !== void 0 && v !== null && v !== "") bag[field] = v;
+      }
+      const cfgHeaders = cfg.headers && typeof cfg.headers === "object" ? cfg.headers : {};
+      const method = str(cfg.method) || "POST";
+      const auth = cfg.auth === "connection" ? "connection" : void 0;
+      const connectionRef = str(cfg.connectionRef);
+      deps.events.note("tool.invoked", { node: node.id, name });
+      const serverExec = deps.resolvers?.toolExecutor;
+      if (serverExec) {
+        try {
+          const result = await serverExec({
+            name,
+            url,
+            method,
+            ...Object.keys(cfgHeaders).length ? { headers: cfgHeaders } : {},
+            ...Object.keys(bag).length ? { input: bag } : {},
+            ...auth ? { auth } : {},
+            ...auth && connectionRef ? { connectionRef } : {}
+          });
+          state.toolResults[node.id] = result;
+          deps.events.note(result.ok ? "tool.succeeded" : "tool.errored", {
+            node: node.id,
+            name,
+            status: result.status
+          });
+        } catch (err) {
+          state.toolResults[node.id] = {
+            ok: false,
+            status: 0,
+            data: { error: err instanceof Error ? err.message : String(err) }
+          };
+          deps.events.note("tool.errored", { node: node.id, name });
+        }
+        return routeByOutcome();
+      }
+      let authHeaders = {};
+      if (auth === "connection") {
+        const resolver = deps.resolvers?.secrets;
+        const resolved = connectionRef && resolver ? await resolver(connectionRef) : null;
+        if (!resolved || !resolved.ok) {
+          state.toolResults[node.id] = {
+            ok: false,
+            status: 0,
+            data: {
+              kind: "unavailable",
+              reason: resolved && !resolved.ok ? resolved.reason : "connection-auth (vault resolver) not wired"
+            }
+          };
+          deps.events.note("tool.unavailable", { node: node.id, name });
+          return routeByOutcome();
+        }
+        authHeaders = resolved.headers;
+      }
+      const headers = { ...cfgHeaders, ...authHeaders };
+      try {
+        const def = httpTool({
+          name,
+          description: str(cfg.description) || name,
+          input: inputSpec,
+          url,
+          method,
+          ...Object.keys(headers).length ? { headers } : {}
+        });
+        const run = def[name]?.run;
+        const result = run ? await run(bag, deps.ctx) : { ok: false, status: 0, data: null };
+        state.toolResults[node.id] = result;
+        deps.events.note(result.ok ? "tool.succeeded" : "tool.errored", {
+          node: node.id,
+          name,
+          status: result.status
+        });
+      } catch (err) {
+        state.toolResults[node.id] = {
+          ok: false,
+          status: 0,
+          data: { error: err instanceof Error ? err.message : String(err) }
+        };
+        deps.events.note("tool.errored", { node: node.id, name });
+      }
+      return routeByOutcome();
+    };
+    ragExecutor = async (node, state, deps) => {
+      const cfg = node.config;
+      const resolver = deps.resolvers?.knowledge;
+      if (!resolver) {
+        state.nodeResults[node.id] = { found: false, count: 0, text: "", chunks: [] };
+        deps.events.note("rag.unavailable", { node: node.id });
+        return routeByPort(node, deps, "not_found");
+      }
+      const query = interpolate(str(cfg.query), scopeFor(state, deps)).trim() || (state.lastUtterance ?? "");
+      const limit = typeof cfg.topK === "number" ? cfg.topK : 3;
+      const minScore = typeof cfg.minScore === "number" ? cfg.minScore : void 0;
+      deps.events.note("rag.query", { node: node.id, chars: query.length, limit });
+      try {
+        const res = await resolver({ query, limit, ...minScore !== void 0 ? { minScore } : {} });
+        const text = res.chunks.map((c) => c.content).join("\n\n");
+        state.nodeResults[node.id] = {
+          found: res.found,
+          count: res.chunks.length,
+          text,
+          chunks: res.chunks
+        };
+        deps.events.note(res.found ? "rag.found" : "rag.not_found", {
+          node: node.id,
+          count: res.chunks.length
+        });
+        return routeByPort(node, deps, res.found ? "found" : "not_found");
+      } catch (err) {
+        state.nodeResults[node.id] = {
+          found: false,
+          count: 0,
+          text: "",
+          chunks: [],
+          error: err instanceof Error ? err.message : String(err)
+        };
+        deps.events.note("rag.errored", { node: node.id });
+        return routeByPort(node, deps, "not_found");
+      }
+    };
+    codeExecutor = async (node, state, deps) => {
+      const cfg = node.config;
+      const resolver = deps.resolvers?.code;
+      const expression = str(cfg.expression);
+      if (!resolver || !expression) {
+        state.nodeResults[node.id] = { ok: false, reason: resolver ? "no-expression" : "no-code-resolver" };
+        deps.events.note("code.unavailable", { node: node.id });
+        return { kind: "advance" };
+      }
+      deps.events.note("code.eval", { node: node.id });
+      try {
+        const res = await resolver({ expression, scope: scopeFor(state, deps) });
+        if (res.ok) {
+          state.nodeResults[node.id] = { ok: true, ...res.outputs };
+          deps.events.note("code.ok", { node: node.id });
+          return routeByPort(node, deps, res.next ?? "next");
+        }
+        state.nodeResults[node.id] = { ok: false, error: res.error };
+        deps.events.note("code.errored", { node: node.id });
+        return routeByPort(node, deps, "error");
+      } catch (err) {
+        state.nodeResults[node.id] = { ok: false, error: err instanceof Error ? err.message : String(err) };
+        deps.events.note("code.errored", { node: node.id });
+        return routeByPort(node, deps, "error");
+      }
+    };
+    decisionExecutor = async (node, state, deps) => {
+      const ctx = evalCtxOf(state, deps);
+      const det = deterministicEdgeTarget(deps.model.out(node.id), ctx);
+      if (det !== null) {
+        deps.events.note("decision.routed", { node: node.id, to: det });
+        return { kind: "goto", to: det };
+      }
+      const branches = branchOptionsOf(node.config);
+      if (branches.length === 0) return { kind: "advance" };
+      const choice = await resolveBranch(branches, ctx, { hint: str(node.config.condition) });
+      if (choice) {
+        state.nodeResults[node.id] = { choice };
+        deps.events.note("decision.routed", { node: node.id, choice });
+        return { kind: "take", port: choice };
+      }
+      if (branches.some((b) => b.id === ELSE_BRANCH_ID)) {
+        deps.events.note("decision.defaulted", { node: node.id });
+        return { kind: "take", port: ELSE_BRANCH_ID };
+      }
+      deps.events.note("decision.unresolved", { node: node.id });
+      return { kind: "advance" };
+    };
+    MENU_MAX_INPUTS = 3;
+    menuExecutor = async (node, state, deps) => {
+      const branches = branchOptionsOf(node.config);
+      const fallback = () => branches.some((b) => b.id === ELSE_BRANCH_ID) ? { kind: "take", port: ELSE_BRANCH_ID } : { kind: "advance" };
+      const keyed = branches.filter((b) => b.id !== ELSE_BRANCH_ID && menuDigitOf(b));
+      const synthesized = keyed.length ? `Please choose: ${keyed.map((b) => `press ${menuDigitOf(b)} for ${menuLabelOf(b.label)}`).join(", ")}.` : "";
+      const prompt = interpolate(str(node.config.prompt), scopeFor(state, deps)).trim() || synthesized;
+      await speak(prompt, deps);
+      if (branches.length === 0) return { kind: "advance" };
+      for (let attempt = 0; attempt < MENU_MAX_INPUTS; attempt++) {
+        const t = await nextTurn(deps, prompt);
+        if ("result" in t) return t.result;
+        state.lastUtterance = t.text;
+        state.lastDtmf = t.dtmf;
+        if (t.dtmf) {
+          const hit = branches.find((b) => b.id !== ELSE_BRANCH_ID && menuDigitOf(b) === t.dtmf);
+          if (hit) {
+            deps.events.note("menu.selected", { node: node.id, digit: t.dtmf, choice: hit.id });
+            return { kind: "take", port: hit.id };
+          }
+          deps.events.note("menu.invalid", { node: node.id, digit: t.dtmf });
+          await speak("Sorry, that's not one of the options.", deps);
+          continue;
+        }
+        if (t.text.trim()) {
+          const choice = await resolveBranch(branches, evalCtxOf(state, deps));
+          if (choice) {
+            deps.events.note("menu.selected", { node: node.id, choice });
+            return { kind: "take", port: choice };
+          }
+          await speak(prompt, deps);
+        }
+      }
+      deps.events.note("menu.unmatched", { node: node.id });
+      return fallback();
+    };
+    classifyExecutor = async (node, state, deps) => {
+      const cfg = node.config;
+      const resolver = deps.resolvers?.classify;
+      const branches = branchOptionsOf(cfg);
+      const options = branches.filter((b) => b.id !== ELSE_BRANCH_ID).map((b) => ({ id: b.id, label: b.label }));
+      const fallback = () => branches.some((b) => b.id === ELSE_BRANCH_ID) ? { kind: "take", port: ELSE_BRANCH_ID } : { kind: "advance" };
+      if (!resolver || options.length === 0) {
+        deps.events.note("classify.unavailable", { node: node.id });
+        return fallback();
+      }
+      deps.events.note("classify.start", { node: node.id, options: options.length });
+      try {
+        const choice = await resolver({
+          instructions: str(cfg.instructions),
+          options,
+          ...state.lastUtterance !== void 0 ? { lastUtterance: state.lastUtterance } : {},
+          slots: deps.processRt.getData()
+        });
+        if (!choice) {
+          deps.events.note("classify.undecided", { node: node.id });
+          return fallback();
+        }
+        state.nodeResults[node.id] = { choice };
+        deps.events.note("classify.chose", { node: node.id, choice });
+        return routeByPort(node, deps, choice);
+      } catch (err) {
+        deps.events.note("classify.errored", {
+          node: node.id,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return fallback();
+      }
+    };
+    routerExecutor = async (node, state, deps) => {
+      const resolver = deps.resolvers?.classify;
+      const branches = Array.isArray(node.config.branches) ? node.config.branches.filter((b) => b && typeof b.id === "string" && typeof b.label === "string").map((b) => ({
+        id: b.id,
+        // Match on the rich skill description when present; fall back to the label.
+        label: typeof b.description === "string" && b.description.trim() ? b.description : b.label
+      })) : [];
+      const options = branches.filter((b) => b.id !== ELSE_BRANCH_ID);
+      const fallback = () => branches.some((b) => b.id === ELSE_BRANCH_ID) ? { kind: "take", port: ELSE_BRANCH_ID } : { kind: "advance" };
+      if (!resolver || options.length === 0) {
+        deps.events.note("router.unavailable", { node: node.id });
+        return fallback();
+      }
+      deps.events.note("router.start", { node: node.id, skills: options.length });
+      try {
+        const choice = await resolver({
+          instructions: str(node.config.instructions),
+          options,
+          ...state.lastUtterance !== void 0 ? { lastUtterance: state.lastUtterance } : {},
+          slots: deps.processRt.getData()
+        });
+        if (!choice) {
+          deps.events.note("router.undecided", { node: node.id });
+          return fallback();
+        }
+        state.nodeResults[node.id] = { choice };
+        deps.events.note("router.routed", { node: node.id, choice });
+        return routeByPort(node, deps, choice);
+      } catch (err) {
+        deps.events.note("router.errored", {
+          node: node.id,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return fallback();
+      }
+    };
+    playbookExecutor = async (node, state, deps) => {
+      const cfg = node.config;
+      const out = deps.model.out(node.id);
+      const conditional = out.filter((e) => e.condition && e.condition.trim());
+      const terminal = out.length === 0;
+      const policy = historyPolicyOf(node);
+      const required = Array.isArray(cfg.requiredFields) ? cfg.requiredFields.filter((x) => typeof x === "string") : [];
+      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 temperature = typeof cfg.temperature === "number" ? cfg.temperature : void 0;
+      let libraryExits = [];
+      const ref = str(cfg.playbookRef);
+      if (ref && !cfg.pinned && deps.resolvers?.playbooks) {
+        const resolved = await deps.resolvers.playbooks(ref);
+        if (resolved) {
+          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 (temperature === void 0 && resolved.temperature !== void 0) temperature = resolved.temperature;
+          libraryExits = resolved.exits ?? [];
+        }
+      }
+      const branches = branchOptionsOf(cfg);
+      const base = interpolate(
+        [goal ? `Goal: ${goal}` : "", instr].filter(Boolean).join("\n\n"),
+        scopeFor(state, deps)
+      ) || "Help the caller accomplish their goal. Keep replies short and natural.";
+      const runner = deps.resolvers?.agentRunner;
+      const registry = deps.resolvers?.registryTools;
+      const useRunner = runner !== void 0 && (toolNames.length > 0 || cfg.agentLoop === true);
+      let agentTools = [];
+      if (useRunner && registry && toolNames.length > 0) {
+        try {
+          const catalog = await registry.catalog();
+          agentTools = catalog.filter((t) => toolNames.includes(t.name));
+          const missing = toolNames.filter((n) => !agentTools.some((t) => t.name === n));
+          if (missing.length) deps.events.note("playbook.tools_missing", { node: node.id, missing });
+        } catch {
+          deps.events.note("playbook.tools_missing", { node: node.id, missing: toolNames });
+        }
+      }
+      const exitOptions = branches.filter((b) => b.id !== ELSE_BRANCH_ID && b.id !== INCOMPLETE_PORT_ID).map((b) => ({
+        id: b.id,
+        description: libraryExits.find((e) => e.id === b.id)?.description ?? b.description ?? b.label
+      }));
+      const transcript = [];
+      for (let turn = 0; turn < LLM_MAX_TURNS; turn++) {
+        const collected = formatCollected(deps.processRt.getData());
+        const missingNow = required.filter((f) => !hasSlot(deps.processRt.getData(), f));
+        const parts = [base];
+        if (collected) parts.push(`Information collected so far:
+${collected}`);
+        if (missingNow.length) {
+          parts.push(
+            `You still need to collect: ${missingNow.map((m) => m.trim()).join(", ")}. Do not conclude until you have these.`
+          );
+        }
+        if (state.lastUtterance) parts.push(`The caller just said: "${state.lastUtterance}"`);
+        let ranAgentTurn = false;
+        let spokeThisTurn = false;
+        if (useRunner && runner) {
+          deps.busy?.begin();
+          let turnResult;
+          try {
+            turnResult = await runner({
+              instructions: parts.join("\n\n"),
+              transcript,
+              tools: agentTools,
+              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 } : {},
+              ...temperature !== void 0 ? { temperature } : {}
+            });
+          } finally {
+            deps.busy?.end();
+          }
+          if (turnResult) {
+            ranAgentTurn = true;
+            for (const call of turnResult.toolCalls) {
+              state.toolResults[call.name] = { ok: call.ok, status: call.status, data: call.data };
+              deps.events.note(call.ok ? "tool.succeeded" : "tool.errored", {
+                node: node.id,
+                name: call.name,
+                status: call.status,
+                agentLoop: true
+              });
+            }
+            if (turnResult.say) {
+              await speak(turnResult.say, deps, {
+                allowInterruptions: cfg.interruptible !== false
+              });
+              transcript.push({ role: "assistant", text: turnResult.say });
+              spokeThisTurn = true;
+            }
+            if (turnResult.exit) {
+              for (const [k, v] of Object.entries(turnResult.exit.vars)) {
+                deps.processRt.captureField(k, v);
+              }
+              const stillMissing2 = required.filter((f) => !hasSlot(deps.processRt.getData(), f));
+              if (stillMissing2.length > 0) {
+                deps.events.note("playbook.exit_blocked", {
+                  node: node.id,
+                  port: turnResult.exit.port,
+                  missing: stillMissing2.map((m) => m.trim())
+                });
+                parts.push(
+                  `You attempted to conclude, but these are still missing: ${stillMissing2.map((m) => m.trim()).join(", ")}. Continue the conversation and collect them.`
+                );
+              } else if (exitOptions.some((e) => e.id === turnResult.exit?.port) || deps.model.selectByPort(node.id, turnResult.exit.port) !== null) {
+                deps.events.note("playbook.exit", { node: node.id, port: turnResult.exit.port, structured: true });
+                return routeByPort(node, deps, turnResult.exit.port);
+              } else {
+                deps.events.note("playbook.exit_invalid_port", { node: node.id, port: turnResult.exit.port });
+              }
+            }
+          }
+        }
+        if (!ranAgentTurn || !spokeThisTurn) {
+          await withHistory(deps, policy, () => guardedGenerate(node, state, deps, parts.join("\n\n"), base));
+        }
+        const t = await nextTurn(deps);
+        if ("result" in t) return t.result;
+        state.lastUtterance = t.text;
+        state.lastDtmf = t.dtmf;
+        if (t.text.trim()) transcript.push({ role: "user", text: t.text });
+        const stillMissing = required.filter((f) => !hasSlot(deps.processRt.getData(), f));
+        if (stillMissing.length > 0) {
+          deps.events.note("playbook.gated", { node: node.id, missing: stillMissing.map((m) => m.trim()) });
+          continue;
+        }
+        const exitCtx = evalCtxOf(state, deps);
+        const det = deterministicEdgeTarget(out, exitCtx);
+        if (det !== null) {
+          deps.events.note("playbook.exit", { node: node.id, to: det });
+          return { kind: "goto", to: det };
+        }
+        if (useRunner) continue;
+        if (branches.length > 0) {
+          const choice = await resolveBranch(branches, exitCtx, { hint: goal || instr });
+          if (choice) {
+            deps.events.note("playbook.exit", { node: node.id, port: choice });
+            return { kind: "take", port: choice };
+          }
+          if (branches.some((b) => b.id === ELSE_BRANCH_ID)) {
+            deps.events.note("playbook.exit", { node: node.id, port: ELSE_BRANCH_ID });
+            return { kind: "take", port: ELSE_BRANCH_ID };
+          }
+        } else if (conditional.length > 0) {
+          const target = await selectEdge(out, exitCtx);
+          if (target) {
+            deps.events.note("playbook.exit", { node: node.id, to: target });
+            return { kind: "goto", to: target };
+          }
+        }
+      }
+      deps.events.note("playbook.turn_cap", { node: node.id });
+      const missingAtCap = required.filter((f) => !hasSlot(deps.processRt.getData(), f));
+      if (missingAtCap.length > 0) {
+        deps.events.note("playbook.incomplete", {
+          node: node.id,
+          missing: missingAtCap.map((m) => m.trim())
+        });
+        if (deps.model.selectByPort(node.id, INCOMPLETE_PORT_ID) !== null) {
+          return { kind: "take", port: INCOMPLETE_PORT_ID };
+        }
+        await speak(
+          interpolate(
+            str(cfg.incompleteMessage) || "I wasn't able to get everything we need on this call, so let me have someone follow up with you. Thanks for your time.",
+            scopeFor(state, deps)
+          ),
+          deps
+        );
+        return { kind: "end" };
+      }
+      return terminal ? { kind: "end" } : { kind: "advance" };
+    };
+    setExecutor = async (node, state, deps) => {
+      const assignments = Array.isArray(node.config.assignments) ? node.config.assignments : [];
+      let applied = 0;
+      for (const a of assignments) {
+        if (!a || typeof a.name !== "string" || !a.name.trim()) continue;
+        const value = interpolate(typeof a.value === "string" ? a.value : "", scopeFor(state, deps));
+        deps.processRt.captureField(a.name.trim(), value);
+        applied += 1;
+      }
+      deps.events.note("set.applied", { node: node.id, count: applied });
+      return { kind: "advance" };
+    };
+    MAX_SUBFLOW_DEPTH = 3;
+    subflowExecutor = async (node, _state, deps) => {
+      const ref = str(node.config.flowRef);
+      const depth = deps.depth ?? 0;
+      if (!ref || !deps.resolvers?.flows) {
+        deps.events.note("subflow.skipped", { node: node.id, reason: ref ? "no_resolver" : "no_ref" });
+        return { kind: "advance" };
+      }
+      if (depth >= MAX_SUBFLOW_DEPTH) {
+        deps.events.note("subflow.depth_capped", { node: node.id, depth });
+        return { kind: "advance" };
+      }
+      const program = await deps.resolvers.flows(ref);
+      if (!program) {
+        deps.events.note("subflow.unresolved", { node: node.id, ref });
+        return { kind: "advance" };
+      }
+      deps.events.note("subflow.enter", { node: node.id, ref, depth: depth + 1 });
+      const { runFlowGraph: runFlowGraph2 } = await Promise.resolve().then(() => (init_interpreter(), interpreter_exports));
+      const outcome = await runFlowGraph2(program, {
+        ctx: deps.ctx,
+        processRt: deps.processRt,
+        utterances: deps.utterances,
+        events: deps.events,
+        ...deps.history ? { history: deps.history } : {},
+        ...deps.realtime ? { realtime: true } : {},
+        ...deps.resolvers ? { resolvers: deps.resolvers } : {},
+        depth: depth + 1
+      });
+      deps.events.note("subflow.exit", { node: node.id, ref, outcome: outcome.kind });
+      if (outcome.kind === "ended" || outcome.kind === "hangup") return { kind: "end" };
+      if (outcome.kind === "handoff") return { kind: "handoff", to: outcome.to };
+      return { kind: "advance" };
+    };
+    passthroughExecutor = async () => ({
+      kind: "advance"
+    });
+    EXECUTORS = {
+      say: sayExecutor,
+      confirm: confirmExecutor,
+      ask: askExecutor,
+      gate: gateExecutor,
+      end: endExecutor,
+      handoff: handoffExecutor,
+      llm: llmExecutor,
+      tool: toolExecutor,
+      set: setExecutor,
+      subflow: subflowExecutor,
+      decision: decisionExecutor,
+      menu: menuExecutor,
+      // Agentic / data nodes — execute by default (no feature flag; the platform is
+      // pre-customer, so these ship on rather than dark). Each degrades to a recorded
+      // no-op when its resolver/config is absent, so they never throw.
+      rag: ragExecutor,
+      code: codeExecutor,
+      classify: classifyExecutor,
+      router: routerExecutor,
+      playbook: playbookExecutor
+      // start (explicit entry marker) and route (routing-plane legacy) have no
+      // executor — they pass through and the default edge / selectEdge routes.
+    };
+  }
+});
+
+// src/runtime/graph/interpreter.ts
+var interpreter_exports = {};
+__export(interpreter_exports, {
+  runFlowGraph: () => runFlowGraph
+});
+function pickEntry(model) {
+  return model.entry.length > 0 ? model.entry[0] : null;
+}
+async function selectNext(model, from, result, state, deps) {
+  if (result.kind === "goto") return result.to;
+  if (result.kind === "take") {
+    const target = model.selectByPort(from, result.port);
+    if (target !== null) return target;
+    const def = model.out(from).find((e) => (!e.condition || !e.condition.trim()) && !e.sourceHandle);
+    return def ? def.to : null;
+  }
+  return selectEdge(model.out(from), {
+    slots: deps.processRt.getData(),
+    tools: state.toolResults,
+    nodeResults: state.nodeResults,
+    ...state.lastUtterance !== void 0 ? { lastUtterance: state.lastUtterance } : {},
+    ...state.lastDtmf !== void 0 ? { lastDtmf: state.lastDtmf } : {}
+  });
+}
+async function runFlowGraph(program, deps) {
+  const model = buildGraphModel(program);
+  const maxNodeVisits = deps.maxNodeVisits ?? DEFAULT_MAX_NODE_VISITS;
+  const maxSteps = deps.maxSteps ?? DEFAULT_MAX_STEPS;
+  let cursor = pickEntry(model);
+  if (cursor === null) return { kind: "completed" };
+  const state = { toolResults: {}, nodeResults: {}, cursor };
+  const visits = /* @__PURE__ */ new Map();
+  let steps = 0;
+  while (cursor !== null) {
+    if (++steps > maxSteps) {
+      deps.events.note("flow.loop_guard_tripped", { reason: "max_steps", steps });
+      break;
+    }
+    const node = model.node(cursor);
+    if (!node) {
+      deps.events.note("flow.missing_node", { nodeId: cursor });
+      break;
+    }
+    const visit = (visits.get(cursor) ?? 0) + 1;
+    visits.set(cursor, visit);
+    const visitCap = node.config.hub === true ? HUB_MAX_NODE_VISITS : maxNodeVisits;
+    if (visit > visitCap) {
+      deps.events.note("flow.loop_guard_tripped", { reason: "max_node_visits", nodeId: cursor });
+      break;
+    }
+    state.cursor = cursor;
+    deps.events.enter(node.id, node.type);
+    console.log("[graph] enter", { node: node.id, type: node.type, step: steps });
+    const executor = EXECUTORS[node.type] ?? passthroughExecutor;
+    let result;
+    try {
+      result = await executor(node, state, {
+        ctx: deps.ctx,
+        processRt: deps.processRt,
+        utterances: deps.utterances,
+        events: deps.events,
+        model,
+        ...deps.history ? { history: deps.history } : {},
+        ...deps.realtime ? { realtime: true } : {},
+        ...deps.resolvers ? { resolvers: deps.resolvers } : {},
+        ...deps.depth !== void 0 ? { depth: deps.depth } : {},
+        ...deps.busy ? { busy: deps.busy } : {}
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (/AgentSession is not running|session is clos/i.test(message)) {
+        deps.events.note("node.session_closed", { nodeId: node.id });
+        return { kind: "ended", nodeId: node.id };
+      }
+      deps.events.note("node.errored", { nodeId: node.id, error: message });
+      const recovery = model.selectByPort(node.id, "error");
+      if (recovery !== null) {
+        deps.events.traverse(node.id, recovery);
+        cursor = recovery;
+        continue;
+      }
+      return { kind: "error", nodeId: node.id, message };
+    }
+    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);
+    if (next !== null) deps.events.traverse(cursor, next);
+    cursor = next;
+  }
+  return { kind: "completed" };
+}
+var DEFAULT_MAX_NODE_VISITS, DEFAULT_MAX_STEPS, HUB_MAX_NODE_VISITS;
+var init_interpreter = __esm({
+  "src/runtime/graph/interpreter.ts"() {
+    init_graph_model();
+    init_executors();
+    init_conditions();
+    DEFAULT_MAX_NODE_VISITS = 25;
+    DEFAULT_MAX_STEPS = 200;
+    HUB_MAX_NODE_VISITS = 200;
+  }
+});
+
+// src/runtime/graph/index.ts
+init_interpreter();
+
+// src/runtime/graph/utterances.ts
+var EVENT_UTTERANCE = "user_input_transcribed";
+var EVENT_CLOSE = "close";
+function createUtteranceStream(session, processRt, ctx, rails, prewarm, wantsDtmf) {
+  const queue = [];
+  let waiter = null;
+  let hung = false;
+  const deliver = (e) => {
+    if (hung && e.kind !== "hangup") return;
+    if (waiter) {
+      const resolve = waiter;
+      waiter = null;
+      resolve(e);
+    } else {
+      queue.push(e);
+    }
+  };
+  const onClose = () => {
+    hung = true;
+    if (waiter) {
+      const resolve = waiter;
+      waiter = null;
+      resolve({ kind: "hangup" });
+    }
+  };
+  const unsubs = [];
+  if (ctx.adapter) {
+    const a = ctx.adapter;
+    unsubs.push(
+      a.on("user_input", (e) => {
+        if (!e.isFinal || hung) return;
+        deliver({ kind: "utterance", text: e.transcript });
+      })
+    );
+    unsubs.push(a.once("close", onClose));
+    if (wantsDtmf) {
+      if (typeof ctx.onDtmf === "function") {
+        unsubs.push(
+          ctx.onDtmf((ev) => {
+            if (hung) return;
+            const digit = typeof ev?.digit === "string" ? ev.digit : "";
+            if (!digit) return;
+            deliver({ kind: "dtmf", digit });
+          })
+        );
+      } else {
+        unsubs.push(
+          a.on("dtmf", (e) => {
+            if (hung || !e.digit) return;
+            deliver({ kind: "dtmf", digit: e.digit });
+          })
+        );
+      }
+    }
+  } else {
+    const emitter = session;
+    const onUtterance = (payload) => {
+      const event = payload ?? {};
+      if (!event.isFinal || hung) return;
+      deliver({ kind: "utterance", text: typeof event.transcript === "string" ? event.transcript : "" });
+    };
+    emitter.on(EVENT_UTTERANCE, onUtterance);
+    emitter.on(EVENT_CLOSE, onClose);
+    unsubs.push(() => emitter.off(EVENT_UTTERANCE, onUtterance));
+    unsubs.push(() => emitter.off(EVENT_CLOSE, onClose));
+    if (wantsDtmf && typeof ctx.onDtmf === "function") {
+      const unsubDtmf = ctx.onDtmf((ev) => {
+        if (hung) return;
+        const digit = typeof ev?.digit === "string" ? ev.digit : "";
+        if (!digit) return;
+        deliver({ kind: "dtmf", digit });
+      });
+      unsubs.push(unsubDtmf);
+    }
+  }
+  function awaitRaw(timeoutMs) {
+    return new Promise((resolve) => {
+      let settled = false;
+      const timer = timeoutMs && timeoutMs > 0 ? setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        waiter = null;
+        resolve({ kind: "timeout" });
+      }, timeoutMs) : null;
+      waiter = (e) => {
+        if (settled) return;
+        settled = true;
+        if (timer) clearTimeout(timer);
+        resolve(e);
+      };
+    });
+  }
+  return {
+    async next(opts) {
+      for (; ; ) {
+        let raw;
+        if (queue.length > 0) {
+          raw = queue.shift();
+        } else if (hung) {
+          return { kind: "hangup" };
+        } else {
+          raw = await awaitRaw(opts?.timeoutMs);
+        }
+        if (raw.kind === "hangup") return { kind: "hangup" };
+        if (raw.kind === "timeout") return { kind: "timeout" };
+        if (raw.kind === "dtmf") return { kind: "dtmf", digit: raw.digit };
+        if (rails) {
+          const outcome = await rails.intercept(raw.text, ctx);
+          if (outcome.kind === "consumed") continue;
+          if (outcome.kind === "control") return { kind: "control", result: outcome.result };
+        }
+        if (prewarm) prewarm(raw.text);
+        try {
+          await processRt.ingest(raw.text, ctx);
+        } catch {
+        }
+        return { kind: "utterance", text: raw.text };
+      }
+    },
+    close() {
+      hung = true;
+      for (const u of unsubs) u();
+    }
+  };
+}
+
+// src/runtime/graph/history.ts
+function isConversational(it) {
+  return it.type === "message" && (it.role === "user" || it.role === "assistant");
+}
+function prune(items, policy) {
+  if (policy === "full") return items;
+  const persona = items.filter((it) => !isConversational(it));
+  if (policy === "slots-only") return persona;
+  for (let i = items.length - 1; i >= 0; i--) {
+    const it = items[i];
+    if (it.type === "message" && it.role === "user") return [...persona, it];
+  }
+  return persona;
+}
+function createHistoryController(agent) {
+  return {
+    lastAssistantText() {
+      if (!agent) return "";
+      try {
+        const items = agent.chatCtx.items;
+        for (let i = items.length - 1; i >= 0; i--) {
+          const it = items[i];
+          if (it.type === "message" && it.role === "assistant") return it.textContent ?? "";
+        }
+      } catch {
+      }
+      return "";
+    },
+    async withPolicy(policy, gen) {
+      if (policy === "full" || !agent) {
+        await gen();
+        return;
+      }
+      let saved;
+      try {
+        saved = agent.chatCtx.copy();
+        const next = agent.chatCtx.copy();
+        next.items = prune(next.items, policy);
+        await agent.updateChatCtx(next);
+      } catch (err) {
+        console.warn("[graph] historyPolicy prune failed; using full history", {
+          policy,
+          err: err instanceof Error ? err.message : String(err)
+        });
+        await gen();
+        return;
+      }
+      try {
+        await gen();
+      } finally {
+        try {
+          await agent.updateChatCtx(saved);
+        } catch (err) {
+          console.warn("[graph] historyPolicy restore failed", {
+            err: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }
+  };
+}
+
+// src/runtime/graph/index.ts
+init_embedder();
+init_conditions();
+init_interpreter();
+
+// src/runtime/graph/events.ts
+function createGraphEvents(processRt) {
+  let current = null;
+  return {
+    enter(nodeId, type) {
+      current = nodeId;
+      processRt.recordEvent({ kind: "node.entered", data: { nodeId, type } });
+    },
+    traverse(from, to, via) {
+      processRt.recordEvent({
+        kind: "edge.traversed",
+        data: { from, to, ...via ? { via } : {} }
+      });
+    },
+    note(kind, data) {
+      processRt.recordEvent({ kind, ...data ? { data } : {} });
+    },
+    currentNodeId() {
+      return current;
+    }
+  };
+}
+
+// src/runtime/graph/index.ts
+init_conditions();
+init_branch_resolve();
+init_embedder();
+
+// src/runtime/graph/agent-runner.ts
+init_openai_default();
+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");
+
+// src/runtime/graph/index.ts
+init_drift();
+init_interpolate();
+init_graph_model();
+
+// src/runtime/graph/resolvers.ts
+init_src();
+init_embedder();
+init_openai_default();
+Number(process.env["VL_FLOW_CODE_TIMEOUT_MS"] ?? "1000");
+Number(process.env["VL_FLOW_CODE_MEMORY_BYTES"] ?? String(16 * 1024 * 1024));
+
+// src/runtime/graph/index.ts
+init_builtins();
+async function runFlowProgram(program, ctx, opts) {
+  const embedder = getEmbedder();
+  const wantsRouting = embedder.available && Object.values(program.nodes).some(
+    (n) => n.out.some((e) => !!e.condition && isNaturalLanguageCondition(e.condition))
+  );
+  const prewarm = wantsRouting ? (text) => embedder.prewarm(text) : void 0;
+  const wantsDtmf = Object.values(program.nodes).some(
+    (n) => n.type === "menu" || n.out.some((e) => !!e.condition && e.condition.includes("dtmf:"))
+  );
+  const utterances = createUtteranceStream(
+    opts.session,
+    opts.processRt,
+    ctx,
+    opts.rails,
+    prewarm,
+    wantsDtmf
+  );
+  const history = createHistoryController(opts.agent ?? null);
+  try {
+    const outcome = await runFlowGraph(program, {
+      ctx,
+      processRt: opts.processRt,
+      utterances,
+      events: opts.events,
+      history,
+      ...opts.maxSteps !== void 0 ? { maxSteps: opts.maxSteps } : {},
+      ...opts.maxNodeVisits !== void 0 ? { maxNodeVisits: opts.maxNodeVisits } : {},
+      ...opts.realtime ? { realtime: true } : {},
+      ...opts.resolvers ? { resolvers: opts.resolvers } : {},
+      ...opts.busy ? { busy: opts.busy } : {}
+    });
+    console.log("[graph] outcome", outcome);
+    return outcome;
+  } finally {
+    utterances.close();
+  }
+}
+
+// src/runtime/process.ts
+init_openai_default();
+
+// ../primitives/process-schema/src/index.ts
+init_src();
+var PROCESS_LIFECYCLE_MAX_EVENTS = 100;
+setup({
+  types: {},
+  guards: {
+    allRequiredCaptured: ({ context }) => context.requiredFields.every((n) => context.fieldsCaptured.has(n)),
+    ackPending: ({ context }) => context.requiresAck && !context.backendAckReceived
+  },
+  actions: {
+    applyLoad: ({ context, event }) => {
+      if (event.type !== "LOAD") return;
+      context.requiredFields = event.requiredFields;
+      context.requiresAck = event.requiresAck;
+      context.fieldsCaptured = /* @__PURE__ */ new Map();
+      context.backendAckReceived = false;
+      context.backendAckReceivedAt = void 0;
+    },
+    applyCapture: ({ context, event }) => {
+      if (event.type !== "CAPTURE") return;
+      context.fieldsCaptured.set(event.name, event.value);
+    },
+    applyAck: ({ context, event }) => {
+      if (event.type !== "ACK") return;
+      context.backendAckReceived = true;
+      context.backendAckReceivedAt = event.receivedAt;
+    },
+    applyLifecycle: ({ context, event }) => {
+      if (event.type !== "EMIT_LIFECYCLE") return;
+      context.lifecycle.push(event.event);
+      if (context.lifecycle.length > PROCESS_LIFECYCLE_MAX_EVENTS) {
+        context.lifecycle.splice(
+          0,
+          context.lifecycle.length - PROCESS_LIFECYCLE_MAX_EVENTS
+        );
+      }
+    },
+    resetRuntime: ({ context }) => {
+      context.fieldsCaptured = /* @__PURE__ */ new Map();
+      context.backendAckReceived = false;
+      context.backendAckReceivedAt = void 0;
+      context.lifecycle = [];
+    }
+  }
+}).createMachine({
+  id: "process",
+  initial: "unloaded",
+  context: {
+    fieldsCaptured: /* @__PURE__ */ new Map(),
+    backendAckReceived: false,
+    backendAckReceivedAt: void 0,
+    requiredFields: [],
+    requiresAck: false,
+    lifecycle: []
+  },
+  // EMIT_LIFECYCLE is global — agents can record events in any state
+  // (unloaded through completed) without forcing a transition. Defined at the
+  // machine root so every state inherits it.
+  on: {
+    EMIT_LIFECYCLE: { actions: "applyLifecycle" }
+  },
+  states: {
+    unloaded: {
+      on: {
+        LOAD: { target: "collecting", actions: "applyLoad" }
+      }
+    },
+    collecting: {
+      always: [{ guard: "allRequiredCaptured", target: "awaiting_ack" }],
+      on: {
+        CAPTURE: { actions: "applyCapture" },
+        RESET: { actions: "resetRuntime", target: "collecting" },
+        LOAD: { target: "collecting", actions: "applyLoad" }
+      }
+    },
+    awaiting_ack: {
+      always: [{ guard: "ackPending", target: "awaiting_ack" }, { target: "ready_to_close" }],
+      on: {
+        ACK: { actions: "applyAck" },
+        CAPTURE: { actions: "applyCapture", target: "collecting" },
+        RESET: { actions: "resetRuntime", target: "collecting" },
+        LOAD: { target: "collecting", actions: "applyLoad" }
+      }
+    },
+    ready_to_close: {
+      on: {
+        COMPLETE: { target: "completed" },
+        CAPTURE: { actions: "applyCapture", target: "collecting" },
+        ACK: { actions: "applyAck" },
+        RESET: { actions: "resetRuntime", target: "collecting" },
+        LOAD: { target: "collecting", actions: "applyLoad" }
+      }
+    },
+    completed: {
+      type: "final"
+    }
+  }
+});
+
+// src/runtime/process.ts
+function createProcessRuntime(def) {
+  {
+    return {
+      augmentPrompt: (p) => p,
+      ingest: async () => {
+      },
+      getData: () => ({}),
+      isComplete: () => false,
+      captureField: () => false,
+      recordEvent: () => {
+      },
+      getSnapshot: () => null,
+      getSchema: () => null,
+      subscribe: () => () => {
+      }
+    };
+  }
+}
+
+// src/runtime/session-adapter.ts
+var LK_AGENT_STATE_MAP = {
+  initializing: "initializing",
+  idle: "idle",
+  listening: "listening",
+  thinking: "thinking",
+  speaking: "speaking"
+};
+var NON_BUSY_STATES = /* @__PURE__ */ new Set([
+  "idle",
+  "listening"
+]);
+function normalizeState(raw) {
+  return LK_AGENT_STATE_MAP[raw] ?? "thinking";
+}
+
+// src/runtime/session-adapter-text.ts
+function createTextSessionAdapter(transport) {
+  const listeners = /* @__PURE__ */ new Map();
+  let userInputListeners = 0;
+  let inboundActive = false;
+  let inboundSink = null;
+  let inboundEnd = null;
+  let currentState = "initializing";
+  let currentRaw = "initializing";
+  let closed = false;
+  const idleWaiters = /* @__PURE__ */ new Set();
+  const closeResolvers = /* @__PURE__ */ new Set();
+  function fire(event, payload) {
+    const set = listeners.get(event);
+    if (!set) return;
+    for (const handler of [...set]) handler(payload);
+  }
+  function releaseIdleWaiters(reason) {
+    for (const w of [...idleWaiters]) w(reason);
+    idleWaiters.clear();
+  }
+  function on(event, handler) {
+    if (event === "user_input" && inboundActive) {
+      throw new Error('on("user_input") is mutually exclusive with an active inbound() iterator');
+    }
+    let set = listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      listeners.set(event, set);
+    }
+    const erased = handler;
+    set.add(erased);
+    if (event === "user_input") userInputListeners += 1;
+    return () => {
+      if (set.delete(erased) && event === "user_input") userInputListeners -= 1;
+    };
+  }
+  function once(event, handler) {
+    const off = on(event, (payload) => {
+      off();
+      handler(payload);
+    });
+    return off;
+  }
+  function inbound(opts) {
+    if (userInputListeners > 0) {
+      throw new Error('inbound() is mutually exclusive with an on("user_input") listener');
+    }
+    if (inboundActive) throw new Error("inbound() iterator already active");
+    inboundActive = true;
+    const idleTimeoutMs = opts?.idleTimeoutMs;
+    const buffer = [];
+    let pending = null;
+    let finished = false;
+    let idleTimer = null;
+    const clearIdle = () => {
+      if (idleTimer !== null) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+    };
+    const armIdle = () => {
+      clearIdle();
+      if (typeof idleTimeoutMs === "number" && idleTimeoutMs > 0 && !finished) {
+        idleTimer = setTimeout(() => deliver({ kind: "timeout" }), idleTimeoutMs);
+      }
+    };
+    const deliver = (e) => {
+      if (finished) return;
+      if (e.kind === "partial") return;
+      if (pending) {
+        const p = pending;
+        pending = null;
+        p({ value: e, done: false });
+      } else {
+        buffer.push(e);
+      }
+      if (e.kind !== "timeout") armIdle();
+    };
+    const end = () => {
+      if (finished) return;
+      finished = true;
+      clearIdle();
+      if (pending) {
+        const p = pending;
+        pending = null;
+        p({ value: void 0, done: true });
+      }
+    };
+    const teardown = () => {
+      finished = true;
+      clearIdle();
+      if (inboundSink === deliver) inboundSink = null;
+      if (inboundEnd === end) inboundEnd = null;
+      inboundActive = false;
+    };
+    inboundSink = deliver;
+    inboundEnd = end;
+    if (closed) deliver({ kind: "hangup" });
+    armIdle();
+    return {
+      next() {
+        if (buffer.length > 0) {
+          const value = buffer.shift();
+          return Promise.resolve({ value, done: false });
+        }
+        if (finished) {
+          teardown();
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve) => {
+          pending = resolve;
+        });
+      },
+      return() {
+        teardown();
+        return Promise.resolve({ value: void 0, done: true });
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+  const capabilities = {
+    channel: "text",
+    usingRealtime: false,
+    hasStreamingTranscripts: false,
+    canBargeIn: false,
+    canReceiveDtmf: false,
+    canPublishDtmf: false,
+    canResolveSpeaker: true
+  };
+  const adapter = {
+    capabilities,
+    on,
+    once,
+    inbound,
+    get state() {
+      return currentState;
+    },
+    waitForIdle(timeoutMs) {
+      if (closed) return Promise.resolve("closed");
+      if (NON_BUSY_STATES.has(currentState)) return Promise.resolve("idle");
+      return new Promise((resolve) => {
+        let settled = false;
+        const w = (reason) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(t);
+          idleWaiters.delete(w);
+          resolve(reason);
+        };
+        const t = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          idleWaiters.delete(w);
+          resolve("timeout");
+        }, timeoutMs);
+        idleWaiters.add(w);
+      });
+    },
+    waitForClose() {
+      if (closed) return Promise.resolve();
+      return new Promise((resolve) => closeResolvers.add(resolve));
+    },
+    start() {
+      return Promise.resolve();
+    },
+    async say(text) {
+      fire("agent_turn", { text });
+      await transport.send(text);
+      return { interrupted: false };
+    },
+    async generateReply(opts) {
+      if (transport.generate) {
+        const text = await transport.generate(opts?.instructions);
+        if (text) {
+          fire("agent_turn", { text });
+          await transport.send(text);
+        }
+      }
+    },
+    interrupt() {
+      return Promise.resolve();
+    },
+    sendDtmf() {
+      return Promise.reject(new Error("sendDtmf unsupported on the text channel (canPublishDtmf=false)"));
+    },
+    endCall() {
+      return Promise.resolve({ torn: "agent", stranded: false });
+    },
+    dispose() {
+      if (inboundEnd) inboundEnd();
+      listeners.clear();
+      releaseIdleWaiters("closed");
+      closeResolvers.clear();
+    }
+  };
+  function setState(next) {
+    const raw = String(next);
+    const norm = normalizeState(raw);
+    const oldState = currentState;
+    const rawOld = currentRaw;
+    currentState = norm;
+    currentRaw = raw;
+    fire("state", { oldState, newState: norm, rawOldState: rawOld, rawNewState: raw });
+    if (NON_BUSY_STATES.has(norm)) releaseIdleWaiters("idle");
+  }
+  function push(text, opts) {
+    if (closed || text.length === 0) return;
+    const speakerId = opts?.speakerId ?? null;
+    fire("user_input", { transcript: text, isFinal: true, speakerId });
+    if (inboundSink) inboundSink({ kind: "final", text, speakerId, at: /* @__PURE__ */ new Date() });
+  }
+  function close() {
+    if (closed) return;
+    closed = true;
+    if (inboundSink) inboundSink({ kind: "hangup" });
+    if (inboundEnd) inboundEnd();
+    fire("close", void 0);
+    releaseIdleWaiters("closed");
+    for (const resolve of [...closeResolvers]) resolve();
+    closeResolvers.clear();
+  }
+  return { adapter, push, setState, close };
+}
+
+// src/runtime/text-session.ts
+function buildTextContext(adapter, call, processRt) {
+  return {
+    call: {
+      callId: call?.callId ?? "text-session",
+      callerId: "text",
+      to: null,
+      startedAt: /* @__PURE__ */ new Date(),
+      metadata: call?.metadata ?? {}
+    },
+    adapter,
+    connectors: {},
+    metadata: {},
+    recordEvent: (event) => processRt.recordEvent(event),
+    get process() {
+      return { data: processRt.getData(), complete: processRt.isComplete() };
+    },
+    // Voice-only escape hatch is absent on text; left undefined.
+    livekit: { session: {}, job: {} }
+  };
+}
+function runTextSession(opts) {
+  const processRt = opts.processRt ?? createProcessRuntime();
+  const handle = createTextSessionAdapter({
+    send: opts.onAgentText,
+    ...opts.generate ? { generate: opts.generate } : {}
+  });
+  const ctx = buildTextContext(handle.adapter, opts.call, processRt);
+  const base = createGraphEvents(processRt);
+  const onTrace = opts.onTrace;
+  const events = onTrace ? {
+    enter(nodeId, type) {
+      onTrace({ kind: "node.entered", data: { nodeId, type } });
+      base.enter(nodeId, type);
+    },
+    traverse(from, to, via) {
+      onTrace({ kind: "edge.traversed", data: { from, to, ...via ? { via } : {} } });
+      base.traverse(from, to, via);
+    },
+    note(kind, data) {
+      onTrace({ kind, data: data ?? {} });
+      base.note(kind, data);
+    },
+    currentNodeId: () => base.currentNodeId()
+  } : base;
+  const result = runFlowProgram(opts.program, ctx, {
+    processRt,
+    // createUtteranceStream prefers ctx.adapter; the session arg is unused here.
+    session: {},
+    events,
+    ...opts.maxSteps !== void 0 ? { maxSteps: opts.maxSteps } : {}
+  });
+  return {
+    sendUserMessage: (text) => handle.push(text),
+    result,
+    end: () => handle.close()
+  };
+}
+async function runTextTranscript(opts) {
+  const replies = [];
+  const trace = [];
+  const session = runTextSession({
+    program: opts.program,
+    onAgentText: (t) => void replies.push(t),
+    onTrace: (e) => void trace.push(e),
+    ...opts.processRt ? { processRt: opts.processRt } : {},
+    ...opts.generate ? { generate: opts.generate } : {},
+    ...opts.call ? { call: opts.call } : {},
+    ...opts.maxSteps !== void 0 ? { maxSteps: opts.maxSteps } : {}
+  });
+  for (const m of opts.messages) session.sendUserMessage(m);
+  session.end();
+  const outcome = await session.result;
+  return { replies, outcome, trace };
+}
+
+export { runTextSession, runTextTranscript };