wunderland 0.72.1 → 0.81.0

package/dist/autonomy/jobs/index.js

@@ -1,2 +1,14 @@
-export {};
+// @ts-nocheck
+/**
+ * @file index.ts
+ * @description Jobs system exports - agent-centric job evaluation, bidding, execution, and lifecycle management
+ */
+export { JobEvaluator } from './JobEvaluator.js';
+export { JobScanner } from './JobScanner.js';
+export { JobMemoryService, jobOutcomeToMemoryEntry } from './JobMemoryService.js';
+export { createAgentJobState, recordJobEvaluation, recordJobOutcome, incrementWorkload, decrementWorkload, calculateCapacity, } from './AgentJobState.js';
+export { QualityChecker } from './QualityChecker.js';
+export { DeliverableManager } from './DeliverableManager.js';
+export { JobExecutor } from './JobExecutor.js';
+export { BidLifecycleManager } from './BidLifecycleManager.js';
 //# sourceMappingURL=index.js.map

package/dist/autonomy/jobs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/autonomy/jobs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/autonomy/jobs/index.ts"],"names":[],"mappings":"AAAA,cAAc;AACd;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/autonomy/orchestration/index.d.ts

@@ -1,2 +1,3 @@
-export {};
+export { schemaFromYaml, type YamlFieldDef } from './yaml-schema.js';
+export { compileWorkflowYaml, compileMissionYaml } from './yaml-compiler.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/autonomy/orchestration/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/autonomy/orchestration/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/autonomy/orchestration/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/autonomy/orchestration/index.js

@@ -1,2 +1,4 @@
-export {};
+// @ts-nocheck
+export { schemaFromYaml } from './yaml-schema.js';
+export { compileWorkflowYaml, compileMissionYaml } from './yaml-compiler.js';
 //# sourceMappingURL=index.js.map

package/dist/autonomy/orchestration/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/autonomy/orchestration/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/autonomy/orchestration/index.ts"],"names":[],"mappings":"AAAA,cAAc;AACd,OAAO,EAAE,cAAc,EAAqB,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/autonomy/orchestration/llm-plan-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-plan-generator.d.ts","sourceRoot":"","sources":["../../../src/autonomy/orchestration/llm-plan-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAEjE;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAE5D,MAAM,WAAW,sBAAsB;IACrC,4FAA4F;IAC5F,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,SAAS,EAAE,SAAS,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAuCD,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AA0CD;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,UAAU,CAAC,CAgBvF"}

package/dist/autonomy/orchestration/llm-plan-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-plan-generator.js","sourceRoot":"","sources":["../../../src/autonomy/orchestration/llm-plan-generator.ts"],"names":[],"mappings":"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"}

package/dist/autonomy/orchestration/mission-tools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parse ONLY the `tools:` allowlist from a mission YAML.
+ *
+ * @param content Raw YAML mission document.
+ * @returns The pack-id list, `undefined` when omitted (meaning "use the default
+ *   curated set"), or `[]` for an explicit empty list.
+ * @throws If `tools:` is present but is not a list.
+ */
+export declare function parseMissionTools(content: string): string[] | undefined;
+//# sourceMappingURL=mission-tools.d.ts.map

package/dist/autonomy/orchestration/mission-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mission-tools.d.ts","sourceRoot":"","sources":["../../../src/autonomy/orchestration/mission-tools.ts"],"names":[],"mappings":"AAeA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAOvE"}

package/dist/autonomy/orchestration/mission-tools.js

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Mission `tools:` allowlist parsing.
+ *
+ * Kept in its own module (no `@framers/agentos` imports) so the CLI can scope a
+ * mission's tool set without pulling in the full compiler — and so the logic is
+ * unit-testable in isolation.
+ *
+ * `mission run` previously ignored a mission's `tools:` field, loading every
+ * curated tool with blanket auto-approval (Codex spec review F1). This is the
+ * surgical parse the CLI uses to scope the runtime before graph execution.
+ *
+ * @module wunderland/autonomy/orchestration/mission-tools
+ */
+import yaml from 'yaml';
+/**
+ * Parse ONLY the `tools:` allowlist from a mission YAML.
+ *
+ * @param content Raw YAML mission document.
+ * @returns The pack-id list, `undefined` when omitted (meaning "use the default
+ *   curated set"), or `[]` for an explicit empty list.
+ * @throws If `tools:` is present but is not a list.
+ */
+export function parseMissionTools(content) {
+    const doc = yaml.parse(content);
+    if (!doc || !('tools' in doc) || doc.tools == null)
+        return undefined;
+    if (!Array.isArray(doc.tools)) {
+        throw new Error('mission `tools:` must be a list of curated tool/pack ids');
+    }
+    return doc.tools.map((t) => String(t));
+}
+//# sourceMappingURL=mission-tools.js.map

package/dist/autonomy/orchestration/mission-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mission-tools.js","sourceRoot":"","sources":["../../../src/autonomy/orchestration/mission-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAe;IAC/C,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAA+B,CAAC;IAC9D,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,OAAO,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,KAAK,IAAI,IAAI;QAAE,OAAO,SAAS,CAAC;IACrE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;IAC9E,CAAC;IACD,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAU,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAClD,CAAC"}

package/dist/autonomy/orchestration/yaml-compiler.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @file yaml-compiler.ts
+ * @description Compiles YAML workflow and mission definitions to AgentOS execution graphs.
+ *
+ * This module bridges YAML-authored automation blueprints and the AgentOS fluent builder
+ * API. It parses a YAML string, validates the top-level structure, maps each declared step
+ * to the correct node factory (`toolNode`, `gmiNode`, or `humanNode`), and delegates the
+ * final compilation to the appropriate builder.
+ *
+ * Two entry points are exported:
+ * - {@link compileWorkflowYaml} — deterministic, acyclic workflow (sequential/branching).
+ * - {@link compileMissionYaml}  — goal-oriented mission with a planner strategy.
+ *
+ * @example Workflow YAML shape:
+ * ```yaml
+ * name: summarise
+ * steps:
+ *   - id: fetch
+ *     tool: web_fetch
+ *   - id: summarise
+ *     gmi:
+ *       instructions: Summarise the fetched content.
+ * ```
+ *
+ * @example Mission YAML shape:
+ * ```yaml
+ * name: research
+ * goal: Research {{topic}} and return a concise summary
+ * planner:
+ *   strategy: linear
+ *   maxSteps: 6
+ * ```
+ */
+/**
+ * Parses a YAML string describing a workflow and compiles it to a `CompiledWorkflow`.
+ *
+ * The YAML document must contain:
+ * - `name` (string) — workflow identifier.
+ * - `steps` (array)  — ordered list of step definitions.
+ *
+ * Each step requires an `id` and exactly one of `tool`, `gmi`, `human`, or `voice`.  A step
+ * may also carry a `condition` (string expression) and `routes` (map of route key → step) to
+ * declare a conditional branch.
+ *
+ * An optional top-level `transport` field configures the I/O layer used to drive the whole
+ * workflow.  When `transport.type` is `'voice'`, the workflow is intended to be executed inside
+ * a phone call or real-time voice session; every node receives input from STT and delivers
+ * output to TTS via a {@link VoiceTransportAdapter}.
+ *
+ * @param yamlContent - Raw YAML string to parse and compile.
+ * @returns A `CompiledWorkflow` ready to be invoked or streamed.
+ *          The compiled graph carries `transport` metadata at `compiled._transport` when
+ *          a transport block is present in the YAML.
+ *
+ * @throws {Error} When required fields are missing or a step has an invalid shape.
+ *
+ * @example Basic workflow
+ * ```yaml
+ * name: fetch-and-summarise
+ * steps:
+ *   - id: fetch
+ *     tool: web_fetch
+ *   - id: summarise
+ *     gmi:
+ *       instructions: Summarise the fetched content in 3 sentences.
+ * ```
+ *
+ * @example Voice transport workflow
+ * ```yaml
+ * name: phone-intake
+ * transport:
+ *   type: voice
+ *   stt: deepgram
+ *   tts: elevenlabs
+ *   bargeIn: hard-cut
+ * steps:
+ *   - id: greet
+ *     voice:
+ *       mode: conversation
+ *       maxTurns: 1
+ *   - id: collect-info
+ *     voice:
+ *       mode: conversation
+ *       exitOn: keyword
+ *       exitKeywords: [confirmed, done]
+ * ```
+ */
+export declare function compileWorkflowYaml(yamlContent: string): any;
+export { parseMissionTools } from './mission-tools.js';
+/**
+ * Parses a YAML string describing a mission and compiles it to a `CompiledMission`.
+ *
+ * The YAML document must contain:
+ * - `name`    — mission identifier.
+ * - `goal`    — goal prompt template (supports `{{variable}}` placeholders).
+ * - `planner` — object with at least `strategy` (`linear` | `tree` | `react`).
+ *
+ * @param yamlContent - Raw YAML string to parse and compile.
+ * @returns A `CompiledMission` with `invoke()`, `stream()`, `resume()`, and `explain()`.
+ *
+ * @throws {Error} When required fields (`name`, `goal`, `planner`) are missing.
+ *
+ * @example
+ * ```yaml
+ * name: research
+ * goal: Research {{topic}} and produce a concise summary
+ * planner:
+ *   strategy: linear
+ *   maxSteps: 6
+ * ```
+ */
+/**
+ * Optional dependencies for the LLM-driven planner mode (`planner.style:
+ * 'llm'`). When the YAML opts into LLM planning, callers MUST supply
+ * `llmCaller` here — the compiler issues exactly one completion call,
+ * caches the result by goal, and validates the returned step list before
+ * passing it through agentos's `plannerConfig.plan` field.
+ */
+export interface CompileMissionYamlOptions {
+    llmCaller?: (prompt: string) => Promise<string>;
+}
+export declare function compileMissionYaml(yamlContent: string): any;
+export declare function compileMissionYaml(yamlContent: string, opts: CompileMissionYamlOptions): Promise<any>;
+//# sourceMappingURL=yaml-compiler.d.ts.map

package/dist/autonomy/orchestration/yaml-compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-compiler.d.ts","sourceRoot":"","sources":["../../../src/autonomy/orchestration/yaml-compiler.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AA6UH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG,CAiD5D;AAqED,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACjD;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG,CAAC;AAC7D,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC"}

package/dist/autonomy/orchestration/yaml-compiler.js

@@ -0,0 +1,435 @@
+// @ts-nocheck
+/**
+ * @file yaml-compiler.ts
+ * @description Compiles YAML workflow and mission definitions to AgentOS execution graphs.
+ *
+ * This module bridges YAML-authored automation blueprints and the AgentOS fluent builder
+ * API. It parses a YAML string, validates the top-level structure, maps each declared step
+ * to the correct node factory (`toolNode`, `gmiNode`, or `humanNode`), and delegates the
+ * final compilation to the appropriate builder.
+ *
+ * Two entry points are exported:
+ * - {@link compileWorkflowYaml} — deterministic, acyclic workflow (sequential/branching).
+ * - {@link compileMissionYaml}  — goal-oriented mission with a planner strategy.
+ *
+ * @example Workflow YAML shape:
+ * ```yaml
+ * name: summarise
+ * steps:
+ *   - id: fetch
+ *     tool: web_fetch
+ *   - id: summarise
+ *     gmi:
+ *       instructions: Summarise the fetched content.
+ * ```
+ *
+ * @example Mission YAML shape:
+ * ```yaml
+ * name: research
+ * goal: Research {{topic}} and return a concise summary
+ * planner:
+ *   strategy: linear
+ *   maxSteps: 6
+ * ```
+ */
+import { parse } from 'yaml';
+import { z } from 'zod';
+import { workflow, mission, } from '@framers/agentos/orchestration';
+import { schemaFromYaml } from './yaml-schema.js';
+/**
+ * Fallback input schema used when the YAML document does not declare an `input` field.
+ * Accepts any key-value payload so the workflow/mission compiles without requiring
+ * authors to spell out a schema for every automation.
+ */
+const OPEN_INPUT_SCHEMA = z.record(z.string(), z.unknown());
+function resolveYamlSchema(schema, fallback = OPEN_INPUT_SCHEMA) {
+    if (!schema || Object.keys(schema).length === 0) {
+        return fallback;
+    }
+    return schemaFromYaml(schema);
+}
+// ---------------------------------------------------------------------------
+// Internal: safe condition expression evaluator
+// ---------------------------------------------------------------------------
+/**
+ * Rewrites a dot-path expression such as `scratch.decision` into safe optional-chain
+ * access on the runtime `state` object, then wraps it in a `new Function` closure.
+ *
+ * The implementation deliberately avoids `with` statements, which are forbidden in
+ * ESM strict-mode modules.
+ *
+ * Supported partitions: `scratch`, `input`, `artifacts`.
+ *
+ * @param expr - A simple expression string referencing state partitions.
+ * @returns A function that takes a runtime `state` object and returns a string label
+ *          matching one of the branch route keys.
+ *
+ * @example
+ * ```ts
+ * const fn = createConditionFn('scratch.decision');
+ * fn({ scratch: { decision: 'yes' } }); // → 'yes'
+ * ```
+ */
+/**
+ * Creates a safe condition evaluator function from a DSL expression string.
+ *
+ * Replaces the previous `new Function()` approach that was vulnerable to
+ * arbitrary code injection from YAML inputs. Now resolves partition references
+ * directly against state and supports only simple comparisons and boolean
+ * connectives — no arbitrary JS execution.
+ *
+ * @param expr - The condition expression (e.g. `'scratch.decision === "yes"'`).
+ * @returns A function that evaluates the expression against graph state.
+ */
+function createConditionFn(expr) {
+    return (state) => {
+        try {
+            return safeEvalCondition(expr, state);
+        }
+        catch {
+            return 'false';
+        }
+    };
+}
+/** Allowed partitions that can be referenced in YAML condition expressions. */
+const ALLOWED_PARTITIONS = new Set(['scratch', 'input', 'artifacts', 'memory', 'diagnostics']);
+/** Pattern matching `partition.path.to.value` references. */
+const PARTITION_REF = /\b(scratch|input|artifacts|memory|diagnostics)(?:\.(\w+(?:\.\w+)*))?/g;
+/**
+ * Resolve a dot-separated path against a nested object.
+ *
+ * @param root - The root object to traverse.
+ * @param path - Dot-separated field path.
+ * @returns The resolved value, or `undefined` if any segment is missing.
+ */
+function resolveDotPath(root, path) {
+    let current = root;
+    for (const key of path.split('.')) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+/**
+ * Parse a value token from a condition expression.
+ *
+ * @param token - The token string.
+ * @param refs  - Resolved partition references.
+ * @returns The parsed value.
+ */
+function parseCondToken(token, refs) {
+    const t = token.trim();
+    if (refs.has(t))
+        return refs.get(t);
+    // String literal (single or double quotes)
+    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+        return t.slice(1, -1);
+    }
+    if (t === 'true')
+        return true;
+    if (t === 'false')
+        return false;
+    if (t === 'null')
+        return null;
+    if (t === 'undefined')
+        return undefined;
+    const num = Number(t);
+    if (!isNaN(num) && t !== '')
+        return num;
+    return t;
+}
+/** Comparison operators ordered longest-first to avoid partial matches. */
+const CMP_OPS = ['===', '!==', '==', '!=', '>=', '<=', '>', '<'];
+/**
+ * Safely evaluate a YAML condition expression against state.
+ * Supports partition references, comparisons, and `&&`/`||` connectives.
+ * No `new Function()` or `eval()` — zero code execution risk.
+ *
+ * @param expr  - The condition expression.
+ * @param state - Graph state object.
+ * @returns The result as a string.
+ */
+function safeEvalCondition(expr, state) {
+    // Resolve all partition references to their actual values
+    const refs = new Map();
+    const pattern = new RegExp(PARTITION_REF.source, 'g');
+    let match;
+    while ((match = pattern.exec(expr)) !== null) {
+        const [fullMatch, partition, path] = match;
+        if (!ALLOWED_PARTITIONS.has(partition))
+            continue;
+        const partitionObj = state[partition];
+        refs.set(fullMatch, path ? resolveDotPath(partitionObj, path) : partitionObj);
+    }
+    // Evaluate a single comparison (no boolean connectives)
+    const evalSingle = (part) => {
+        const trimmed = part.trim();
+        for (const op of CMP_OPS) {
+            const idx = trimmed.indexOf(op);
+            if (idx === -1)
+                continue;
+            const left = parseCondToken(trimmed.slice(0, idx), refs);
+            const right = parseCondToken(trimmed.slice(idx + op.length), refs);
+            switch (op) {
+                case '===': return left === right;
+                case '!==': return left !== right;
+                case '==': return left == right; // eslint-disable-line eqeqeq
+                case '!=': return left != right; // eslint-disable-line eqeqeq
+                case '>=': return Number(left) >= Number(right);
+                case '<=': return Number(left) <= Number(right);
+                case '>': return Number(left) > Number(right);
+                case '<': return Number(left) < Number(right);
+            }
+        }
+        return parseCondToken(trimmed, refs);
+    };
+    // Split on || (lower precedence) then && (higher precedence)
+    const orParts = expr.split('||').map(s => s.trim());
+    for (const orPart of orParts) {
+        const andParts = orPart.split('&&').map(s => s.trim());
+        const allTrue = andParts.every(p => Boolean(evalSingle(p)));
+        if (allTrue) {
+            if (orParts.length === 1 && andParts.length === 1) {
+                return String(evalSingle(expr) ?? 'false');
+            }
+            return 'true';
+        }
+    }
+    return 'false';
+}
+/**
+ * Converts a raw YAML step definition to the `StepConfig` shape expected by
+ * `WorkflowBuilder.step()`.
+ *
+ * @param def - A single YAML step definition (may omit `id`).
+ * @returns A plain `StepConfig` object.
+ * @throws {Error} When none of `tool`, `gmi`, or `human` are specified.
+ */
+function yamlStepToConfig(def) {
+    if (def.tool) {
+        return { tool: def.tool, timeout: def.timeout, onFailure: def.onFailure };
+    }
+    if (def.gmi) {
+        return {
+            gmi: { instructions: def.gmi.instructions, maxTokens: def.gmi.maxTokens },
+            timeout: def.timeout,
+            onFailure: def.onFailure,
+        };
+    }
+    if (def.human) {
+        return { human: { prompt: def.human.prompt }, timeout: def.timeout };
+    }
+    if (def.voice) {
+        if (!def.voice.mode) {
+            throw new Error(`YAML voice step must specify a \`mode\` (conversation|listen-only|speak-only). Got: ${JSON.stringify(def.voice)}`);
+        }
+        // Return a StepConfig shape with `voice` set — WorkflowBuilder.configToNode()
+        // handles voice steps and lowers them to a NodeExecutorConfig of type 'voice'.
+        return {
+            voice: def.voice,
+        };
+    }
+    throw new Error(`YAML step must specify one of: tool, gmi, human, or voice. Got: ${JSON.stringify(def)}`);
+}
+/**
+ * Parses a YAML string describing a workflow and compiles it to a `CompiledWorkflow`.
+ *
+ * The YAML document must contain:
+ * - `name` (string) — workflow identifier.
+ * - `steps` (array)  — ordered list of step definitions.
+ *
+ * Each step requires an `id` and exactly one of `tool`, `gmi`, `human`, or `voice`.  A step
+ * may also carry a `condition` (string expression) and `routes` (map of route key → step) to
+ * declare a conditional branch.
+ *
+ * An optional top-level `transport` field configures the I/O layer used to drive the whole
+ * workflow.  When `transport.type` is `'voice'`, the workflow is intended to be executed inside
+ * a phone call or real-time voice session; every node receives input from STT and delivers
+ * output to TTS via a {@link VoiceTransportAdapter}.
+ *
+ * @param yamlContent - Raw YAML string to parse and compile.
+ * @returns A `CompiledWorkflow` ready to be invoked or streamed.
+ *          The compiled graph carries `transport` metadata at `compiled._transport` when
+ *          a transport block is present in the YAML.
+ *
+ * @throws {Error} When required fields are missing or a step has an invalid shape.
+ *
+ * @example Basic workflow
+ * ```yaml
+ * name: fetch-and-summarise
+ * steps:
+ *   - id: fetch
+ *     tool: web_fetch
+ *   - id: summarise
+ *     gmi:
+ *       instructions: Summarise the fetched content in 3 sentences.
+ * ```
+ *
+ * @example Voice transport workflow
+ * ```yaml
+ * name: phone-intake
+ * transport:
+ *   type: voice
+ *   stt: deepgram
+ *   tts: elevenlabs
+ *   bargeIn: hard-cut
+ * steps:
+ *   - id: greet
+ *     voice:
+ *       mode: conversation
+ *       maxTurns: 1
+ *   - id: collect-info
+ *     voice:
+ *       mode: conversation
+ *       exitOn: keyword
+ *       exitKeywords: [confirmed, done]
+ * ```
+ */
+export function compileWorkflowYaml(yamlContent) {
+    const doc = parse(yamlContent);
+    if (!doc.name)
+        throw new Error('YAML workflow must have a `name` field');
+    if (!Array.isArray(doc.steps))
+        throw new Error('YAML workflow must have a `steps` array');
+    // Validate transport block if present.
+    const transport = doc.transport;
+    if (transport !== undefined && transport.type !== 'voice') {
+        throw new Error(`YAML workflow \`transport.type\` must be \`voice\`. Got: ${JSON.stringify(transport.type)}`);
+    }
+    let builder = workflow(doc.name)
+        .input(resolveYamlSchema(doc.input))
+        .returns(resolveYamlSchema(doc.returns));
+    for (const stepDef of doc.steps) {
+        if (!stepDef.id)
+            throw new Error(`Each YAML step must have an \`id\` field: ${JSON.stringify(stepDef)}`);
+        if (stepDef.condition) {
+            // Branch step: convert each route arm to a StepConfig.
+            if (!stepDef.routes || typeof stepDef.routes !== 'object') {
+                throw new Error(`Step "${stepDef.id}" has a condition but no routes map`);
+            }
+            const conditionFn = createConditionFn(stepDef.condition);
+            const routeConfigs = {};
+            for (const [routeKey, routeStep] of Object.entries(stepDef.routes)) {
+                routeConfigs[routeKey] = yamlStepToConfig(routeStep);
+            }
+            builder = builder.branch(conditionFn, routeConfigs);
+        }
+        else {
+            // Regular sequential step.
+            const config = yamlStepToConfig(stepDef);
+            builder = builder.step(stepDef.id, config);
+        }
+    }
+    const compiled = builder.compile();
+    // Attach transport metadata as a non-enumerable shadow property so that the
+    // graph runtime can detect that this workflow was authored for voice transport
+    // without polluting the standard CompiledExecutionGraph shape.
+    if (transport) {
+        compiled._transport = transport;
+    }
+    return compiled;
+}
+// parseMissionTools lives in ./mission-tools (no agentos imports) so it stays
+// unit-testable in isolation; re-exported here for discoverability.
+export { parseMissionTools } from './mission-tools.js';
+export function compileMissionYaml(yamlContent, opts) {
+    const doc = parse(yamlContent);
+    if (!doc.name)
+        throw new Error('YAML mission must have a `name` field');
+    if (!doc.goal)
+        throw new Error('YAML mission must have a `goal` field');
+    if (!doc.planner)
+        throw new Error('YAML mission must have a `planner` field');
+    if (!doc.planner.strategy)
+        throw new Error('YAML mission `planner` must have a `strategy`');
+    // The 'llm' planner style fans out to an async LLM call before passing
+    // the resulting plan into agentos via plannerConfig.plan. All other
+    // styles stay synchronous, but when opts is supplied at all the overload
+    // contract requires us to return a Promise — wrap the sync result so a
+    // caller that always awaits gets consistent behaviour regardless of
+    // style choice.
+    if (doc.planner.style === 'llm') {
+        if (!opts?.llmCaller) {
+            throw new Error("YAML mission planner.style: 'llm' requires the caller to pass an llmCaller via " +
+                "compileMissionYaml(yaml, { llmCaller }). The mission CLI provides one automatically; " +
+                "programmatic callers must supply their own.");
+        }
+        return compileMissionYamlWithLlmPlan(doc, opts.llmCaller);
+    }
+    const compileResult = buildMissionFromDoc(doc);
+    return opts === undefined ? compileResult : Promise.resolve(compileResult);
+}
+/**
+ * Synchronous shared compile path used by both the sync entrypoint and
+ * the async LLM path (after the LLM has produced a plan). Pulled out so
+ * the wiring of mission(), planner(), policy(), compile(), and the eager
+ * toIR() stays in one place.
+ */
+function buildMissionFromDoc(doc) {
+    let builder = mission(doc.name)
+        .input(resolveYamlSchema(doc.input))
+        .returns(resolveYamlSchema(doc.returns))
+        .goal(doc.goal)
+        .planner({
+        strategy: doc.planner.strategy,
+        maxSteps: doc.planner.maxSteps ?? 8,
+        maxIterationsPerNode: doc.planner.maxIterations,
+        ...(doc.planner.parallelTools !== undefined ? { parallelTools: doc.planner.parallelTools } : {}),
+        ...(doc.planner.style ? { style: doc.planner.style } : {}),
+    });
+    if (doc.policy) {
+        builder = builder.policy(doc.policy);
+    }
+    const compiled = builder.compile();
+    // Eagerly invoke the agentos compiler so YAML-level errors (unknown
+    // planner.style, malformed anchors, etc.) surface at parse time instead
+    // of waiting for the first execution. The IR is cheap to generate; the
+    // CompiledMission re-compiles lazily on every run anyway, so re-doing
+    // it here costs nothing meaningful.
+    compiled.toIR();
+    return compiled;
+}
+/**
+ * Async branch of compileMissionYaml — invoked when the YAML sets
+ * `planner.style: 'llm'`. Issues a single LLM call to decompose the goal
+ * into a SimplePlan, then passes it through agentos's plannerConfig.plan
+ * so the same validation and graph-building runs as for any other plan
+ * source. The plan is cached by goal in the LLM plan generator so re-
+ * compiling the same YAML doesn't re-call the model.
+ *
+ * Errors propagate. Callers can catch and fall back to a stub style if
+ * they want graceful degradation; the mission CLI surfaces the error
+ * message directly so users know the LLM planner failed.
+ */
+async function compileMissionYamlWithLlmPlan(doc, llmCaller) {
+    const { generateLlmPlan } = await import('./llm-plan-generator.js');
+    const plan = await generateLlmPlan({
+        goal: doc.goal,
+        llmCaller,
+        maxSteps: doc.planner.maxSteps ?? 8,
+    });
+    let builder = mission(doc.name)
+        .input(resolveYamlSchema(doc.input))
+        .returns(resolveYamlSchema(doc.returns))
+        .goal(doc.goal)
+        .planner({
+        strategy: doc.planner.strategy,
+        maxSteps: doc.planner.maxSteps ?? 8,
+        maxIterationsPerNode: doc.planner.maxIterations,
+        ...(doc.planner.parallelTools !== undefined ? { parallelTools: doc.planner.parallelTools } : {}),
+        // Carry through `style: 'llm'` so any downstream code that inspects
+        // `plannerConfig.style` for logging/telemetry sees the actual choice;
+        // the agentos compiler ignores `style` when `plan` is set, so this
+        // is observability-only.
+        style: 'llm',
+        plan,
+    });
+    if (doc.policy) {
+        builder = builder.policy(doc.policy);
+    }
+    const compiled = builder.compile();
+    compiled.toIR();
+    return compiled;
+}
+//# sourceMappingURL=yaml-compiler.js.map