feat: engine injects extract provider at runtime (Phase 2)

- createWorkflow(def, binding) — no more extract/llmProvider params
- Engine resolves extract provider from workflow.yaml via resolveModel
- WorkflowFnOptions now carries extract + llmProvider (engine-injected)
- Delete extract-provider.ts, inline maxDepth helper
- Template packages simplified: only take agent binding
- Breaking change: bundles no longer carry provider config

Refs #110

examples/hello-world.ts

@@ -1,4 +1,4 @@
-import { createExtract, createWorkflow, END, type RoleDefinition } from "@uncaged/workflow";
+import { createWorkflow, END, type RoleDefinition } from "@uncaged/workflow";
 import * as z from "zod/v4";
 
 type Roles = {
@@ -32,12 +32,6 @@ const greeter: RoleDefinition<Roles["greeter"]> = {
   extractMode: "single",
 };
 
-const extract = createExtract({
-  baseUrl: "http://127.0.0.1:9",
-  apiKey: "",
-  model: "",
-});
-
 export const run = createWorkflow<Roles>(
   {
     roles: { greeter },
@@ -48,6 +42,4 @@ export const run = createWorkflow<Roles>(
   {
     agent: async (ctx) => `Hello, ${ctx.start.content}`,
   },
-  extract,
-  null,
 );

packages/cli-workflow/README.md

@@ -1,76 +0,0 @@
-# @uncaged/cli-workflow
-
-Command-line interface for the Uncaged workflow engine (`uncaged-workflow`).
-
-The CLI reads and writes the workflow registry, starts and inspects threads, manages CAS blobs, and prints agent-oriented reference docs via `skill`. It uses the same storage layout as `@uncaged/workflow` (default `~/.uncaged/workflow`).
-
-## Install
-
-```bash
-bun add @uncaged/cli-workflow
-```
-
-In this monorepo: `"@uncaged/cli-workflow": "workspace:*"`. Depends on `"@uncaged/workflow": "workspace:*"`.
-
-## Usage
-
-```bash
-uncaged-workflow workflow list
-uncaged-workflow run <name> --prompt "Your task"
-uncaged-workflow thread show <id>
-uncaged-workflow skill
-```
-
-Invoking the CLI with no command (or from this repo: `bun packages/cli-workflow/src/cli.ts`) prints:
-
-```
-uncaged-workflow — workflow engine CLI
-
-Workflow registry:
-  workflow add <name> <file.esm.js> [--types <path>]  Register a workflow bundle in the registry
-  workflow list                                       List all registered workflows
-  workflow show <name>                                Show details of a registered workflow
-  workflow rm <name>                                  Remove a workflow from the registry
-  workflow history <name>                             Show version history of a workflow
-  workflow rollback <name> [hash]                     Rollback a workflow to a previous version
-
-Thread execution:
-  thread run <name> [--prompt <text>] [--max-rounds N]          Start a new thread executing a workflow
-  thread list [name]                                            List threads, optionally filtered by workflow name
-  thread show <id>                                              Show thread details and state
-  thread rm <id>                                                Remove a thread
-  thread fork <thread-id> [--from-role <role>]                  Fork a thread, optionally from a specific role
-  thread ps                                                     List running threads
-  thread kill <thread-id>                                       Kill a running thread
-  thread live <thread-id> | --latest [--debug] [--role <name>]  Attach to a thread and stream output live
-  thread pause <thread-id>                                      Pause a running thread
-  thread resume <thread-id>                                     Resume a paused thread
-
-Content-addressable storage:
-  cas get <hash>     Retrieve content by hash from CAS
-  cas put <content>  Store content in CAS, prints hash
-  cas list           List all hashes in CAS
-  cas rm <hash>      Remove a CAS entry by hash
-  cas gc             Garbage-collect unreferenced CAS entries
-
-Development:
-  init workspace <name>  Initialize a new workflow workspace
-  init template <name>   Initialize a new workflow template
-
-Shortcuts:
-  run <name> [...]  → thread run
-  live <id> [...]   → thread live
-
-Reference:
-  skill [topic]  Agent-consumable docs (cli, develop, author)
-
-Use <command> --help for subcommand details.
-
-Environment variables:
-  WORKFLOW_STORAGE_ROOT              Override storage directory (default: ~/.uncaged/workflow)
-  UNCAGED_WORKFLOW_STORAGE_ROOT      Internal override (takes priority over WORKFLOW_STORAGE_ROOT)
-```
-
-## API overview
-
-This package is bin-only; programmatic use is via `@uncaged/workflow`. Entry: `src/cli.ts` → `runCli` in `src/cli-dispatch.js`.

packages/cli-workflow/__tests__/fork-cli.test.ts

@@ -7,6 +7,7 @@ import { cmdFork, cmdRun } from "../src/commands/thread/index.js";
 import { cmdAdd } from "../src/commands/workflow/index.js";
 import { pathExists } from "../src/fs-utils.js";
 import { addCliArgs } from "./bundle-fixture.js";
+import { ensureTestWorkflowRegistryConfig } from "./workflow-registry-fixture.js";
 
 /** Three-role workflow that respects `input.steps` for fork/resume. */
 const threeRoleBundleSource = `import { putContentMerkleNode } from "@uncaged/workflow";
@@ -77,6 +78,7 @@ describe("cli fork", () => {
     prevEnv = process.env.UNCAGED_WORKFLOW_STORAGE_ROOT;
     storageRoot = await mkdtemp(join(tmpdir(), "uncaged-wf-fork-"));
     process.env.UNCAGED_WORKFLOW_STORAGE_ROOT = storageRoot;
+    await ensureTestWorkflowRegistryConfig(storageRoot);
   });
 
   afterEach(async () => {

packages/cli-workflow/__tests__/thread-cli.test.ts

@@ -19,6 +19,7 @@ import {
 import { cmdAdd } from "../src/commands/workflow/index.js";
 import { pathExists, readTextFileIfExists } from "../src/fs-utils.js";
 import { addCliArgs } from "./bundle-fixture.js";
+import { ensureTestWorkflowRegistryConfig } from "./workflow-registry-fixture.js";
 
 const wfPutImport = `import { putContentMerkleNode } from "@uncaged/workflow";
 `;
@@ -142,6 +143,7 @@ describe("cli thread commands", () => {
     prevEnv = process.env.UNCAGED_WORKFLOW_STORAGE_ROOT;
     storageRoot = await mkdtemp(join(tmpdir(), "uncaged-wf-thread-"));
     process.env.UNCAGED_WORKFLOW_STORAGE_ROOT = storageRoot;
+    await ensureTestWorkflowRegistryConfig(storageRoot);
   });
 
   afterEach(async () => {

packages/cli-workflow/__tests__/workflow-registry-fixture.ts

@@ -0,0 +1,18 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+/** Minimal valid global config so {@link executeThread} can resolve the extract scene (CLI integration tests). */
+export const TEST_WORKFLOW_REGISTRY_YAML = `config:
+  maxDepth: 3
+  providers:
+    stub:
+      baseUrl: http://127.0.0.1:9
+      apiKey: test
+  models:
+    default: stub/m
+workflows: {}
+`;
+
+export async function ensureTestWorkflowRegistryConfig(storageRoot: string): Promise<void> {
+  await writeFile(join(storageRoot, "workflow.yaml"), TEST_WORKFLOW_REGISTRY_YAML, "utf8");
+}

packages/cli-workflow/src/commands/init/template.ts

@@ -13,19 +13,7 @@ import {
   templateTsconfigJson,
 } from "./templates.js";
 import type { CmdInitTemplateSuccess } from "./types.js";
-
-function validateWorkspaceSegment(name: string): Result<void, string> {
-  if (name.length === 0) {
-    return err("workspace name must not be empty");
-  }
-  if (name === "." || name === "..") {
-    return err("invalid workspace name");
-  }
-  if (name.includes("/") || name.includes("\\")) {
-    return err("workspace name must not contain path separators");
-  }
-  return ok(undefined);
-}
+import { validateWorkspaceSegment } from "./validate.js";
 
 function hasTemplatesWorkspaceGlob(workspaces: unknown): boolean {
   return Array.isArray(workspaces) && workspaces.includes("templates/*");

packages/cli-workflow/src/commands/init/validate.ts

@@ -0,0 +1,15 @@
+import { err, ok, type Result } from "@uncaged/workflow";
+
+/** Validates a single path segment for workspace / template names (no separators, not `.` / `..`). */
+export function validateWorkspaceSegment(name: string): Result<void, string> {
+  if (name.length === 0) {
+    return err("workspace name must not be empty");
+  }
+  if (name === "." || name === "..") {
+    return err("invalid workspace name");
+  }
+  if (name.includes("/") || name.includes("\\")) {
+    return err("workspace name must not contain path separators");
+  }
+  return ok(undefined);
+}

packages/cli-workflow/src/commands/init/workspace.ts

@@ -5,19 +5,7 @@ import { err, ok, type Result } from "@uncaged/workflow";
 
 import { pathExists } from "../../fs-utils.js";
 import type { CmdInitWorkspaceSuccess } from "./types.js";
-
-function validateWorkspaceSegment(name: string): Result<void, string> {
-  if (name.length === 0) {
-    return err("workspace name must not be empty");
-  }
-  if (name === "." || name === "..") {
-    return err("invalid workspace name");
-  }
-  if (name.includes("/") || name.includes("\\")) {
-    return err("workspace name must not contain path separators");
-  }
-  return ok(undefined);
-}
+import { validateWorkspaceSegment } from "./validate.js";
 
 function rootPackageJson(workspaceName: string): string {
   return `${JSON.stringify(
@@ -119,7 +107,7 @@ Init 生成的骨架：\`templates/\` 下放可复用定义，\`workflows/\` 下
 2. **编写 RoleDefinition**：为每个角色写 Zod \`schema\`，补齐 \`systemPrompt\` / \`extractPrompt\` / \`description\`。
 3. **编写 Moderator**：根据 \`ctx.steps\` 与业务状态返回下一个角色名或 \`END\`。
 4. **组装 WorkflowDefinition**：在模板 \`index\` 中导出 definition（以及必要的角色 / moderator 导出）。
-5. **实例化**：在 workflow 包中使用 \`createWorkflow(def, binding, extract)\`（或项目约定的封装）绑定 **AgentFn** / **ExtractFn**。
+5. **实例化**：在 workflow 包中使用 \`createWorkflow(def, binding)\`（或项目约定的封装）绑定 **AgentFn**；**ExtractFn** 由引擎从 **workflow.yaml** 注入 \`WorkflowFnOptions\`。
 6. **构建**：打包为单个 **.esm.js** bundle，使用 **uncaged-workflow add** 注册。
 
 ## 4. 编码规范

packages/workflow-agent-cursor/README.md

@@ -1,36 +0,0 @@
-# @uncaged/workflow-agent-cursor
-
-`AgentFn` adapter that runs the `cursor-agent` CLI against a workspace path derived from the thread.
-
-The agent builds a full prompt (system + task + step history via `@uncaged/workflow-util-agent`), extracts the absolute workspace path with your `extract` + Zod schema, then spawns `cursor-agent` with `--workspace`, model, and non-interactive flags.
-
-## Install
-
-```bash
-bun add @uncaged/workflow-agent-cursor @uncaged/workflow @uncaged/workflow-util-agent zod
-```
-
-In this monorepo: `"@uncaged/workflow-agent-cursor": "workspace:*"` plus `workspace:*` for `@uncaged/workflow` and `@uncaged/workflow-util-agent`.
-
-## Usage
-
-```typescript
-import { createCursorAgent } from "@uncaged/workflow-agent-cursor";
-
-const agent = createCursorAgent({
-  model: null, // null → "auto"
-  timeout: 0, // ms; 0 = no limit (spawnCli timeout disabled)
-  extract: myExtractFn,
-});
-```
-
-## API overview
-
-| Export | Description |
-|--------|-------------|
-| `createCursorAgent(config)` | Returns `AgentFn` that runs `cursor-agent` with `buildAgentPrompt(ctx)` |
-| `CursorAgentConfig` | `model`, `timeout`, `extract` (must supply workspace path) |
-| `validateCursorAgentConfig` | Config validation result |
-| `buildAgentPrompt` | Re-exported from `@uncaged/workflow-util-agent` |
-
-Requires `cursor-agent` on `PATH` at runtime.

packages/workflow-agent-hermes/README.md

@@ -1,35 +0,0 @@
-# @uncaged/workflow-agent-hermes
-
-`AgentFn` adapter that runs the `hermes` CLI in non-interactive `chat` mode (Nerve-style flags: `-q`, `--yolo`, `--quiet`, bounded `--max-turns`).
-
-The agent composes the same thread-aware prompt as other CLI-backed agents via `buildAgentPrompt` from `@uncaged/workflow-util-agent`, then spawns `hermes` and returns stdout on success.
-
-## Install
-
-```bash
-bun add @uncaged/workflow-agent-hermes @uncaged/workflow @uncaged/workflow-util-agent
-```
-
-In this monorepo: use `workspace:*` for all three `@uncaged/*` packages.
-
-## Usage
-
-```typescript
-import { createHermesAgent } from "@uncaged/workflow-agent-hermes";
-
-const agent = createHermesAgent({
-  model: "your-model", // or null to omit --model
-  timeout: 600_000, // ms, or null for no timeout
-});
-```
-
-## API overview
-
-| Export | Description |
-|--------|-------------|
-| `createHermesAgent(config)` | Returns `AgentFn` wrapping `hermes chat -q ...` |
-| `HermesAgentConfig` | `model`, `timeout` |
-| `validateHermesAgentConfig` | Config validation result |
-| `buildAgentPrompt` | Re-exported from `@uncaged/workflow-util-agent` |
-
-Requires `hermes` on `PATH` at runtime.

packages/workflow-agent-llm/README.md

@@ -1,34 +0,0 @@
-# @uncaged/workflow-agent-llm
-
-`AgentFn` adapter that calls an OpenAI-compatible `POST /chat/completions` endpoint using `@uncaged/workflow`’s `LlmProvider` (base URL, API key, model).
-
-Single-turn: system text is the current role’s `systemPrompt`, user text is the thread’s initial prompt (`ctx.start.content`). Errors from HTTP, JSON, or empty choices are thrown as `Error` with a JSON payload string.
-
-## Install
-
-```bash
-bun add @uncaged/workflow-agent-llm @uncaged/workflow
-```
-
-In this monorepo: `"@uncaged/workflow-agent-llm": "workspace:*"`, `"@uncaged/workflow": "workspace:*"`.
-
-## Usage
-
-```typescript
-import { createLlmAdapter } from "@uncaged/workflow-agent-llm";
-
-const agent = createLlmAdapter({
-  baseUrl: "https://api.openai.com/v1",
-  apiKey: process.env.OPENAI_API_KEY!,
-  model: "gpt-4.1-mini",
-});
-```
-
-## API overview
-
-| Export | Description |
-|--------|-------------|
-| `createLlmAdapter(provider)` | `LlmProvider` → `AgentFn` |
-| `chatCompletionText({ provider, messages })` | Low-level `Result<string, LlmChatError>` helper |
-| `LlmMessage` | `{ role: "system" \| "user" \| "assistant"; content: string }` |
-| `LlmChatError` | Discriminated error kinds for failed completions |

packages/workflow-template-develop/README.md

@@ -1,53 +0,0 @@
-# @uncaged/workflow-template-develop
-
-Reference **develop** workflow template: plan phases, implement in a loop, review, test, then commit.
-
-Export a `WorkflowDefinition` and `createDevelopRun` so a host can bind agents/LLM and run the same graph the bundled `.esm.js` would use. Use `buildDevelopDescriptor()` when assembling `descriptor` metadata for a bundle.
-
-## Install
-
-```bash
-bun add @uncaged/workflow-template-develop @uncaged/workflow zod
-```
-
-In this monorepo: `workspace:*` for `@uncaged/workflow-template-develop` and `@uncaged/workflow`.
-
-## Usage
-
-```typescript
-import { createDevelopRun, developWorkflowDefinition } from "@uncaged/workflow-template-develop";
-
-const run = createDevelopRun(binding, extract, llmProvider);
-// run(...) executes the develop moderator graph with your AgentBinding
-```
-
-## Roles
-
-| Role | Purpose |
-|------|---------|
-| **planner** | Break work into ordered phases (hashes) |
-| **coder** | Implement current phase; repeats until phases complete or limits hit |
-| **reviewer** | Code review gate (`approved` vs send back to coder) |
-| **tester** | Verify via tests/build/lint (`passed` vs send back to coder) |
-| **committer** | Final commit step |
-
-Also exported: role factories/meta schemas (`plannerRole`, `coderRole`, …), `DevelopMeta`, `developRoles`.
-
-## Moderator flow
-
-1. **Start** → `planner`  
-2. After **planner** → `coder`  
-3. After **coder** → if all planned phases are done (or last phase completed) → `reviewer`; else `coder` again, until `maxRounds` then `END`  
-4. After **reviewer** → if approved → `tester`; else `coder` (or `END` if out of rounds)  
-5. After **tester** → if passed → `committer`; else `coder` (or `END` if out of rounds)  
-6. After **committer** → `END`
-
-## API overview
-
-| Export | Description |
-|--------|-------------|
-| `createDevelopRun` | `createWorkflow(developWorkflowDefinition, …)` factory |
-| `developWorkflowDefinition` | `description`, `roles`, `developModerator` |
-| `developModerator` | `Moderator<DevelopMeta>` |
-| `buildDevelopDescriptor` | `buildDescriptor({ … })` for bundle metadata |
-| `DEVELOP_WORKFLOW_DESCRIPTION` | Human-readable one-liner |

packages/workflow-template-develop/src/index.ts

@@ -1,8 +1,6 @@
 import {
   type AgentBinding,
   createWorkflow,
-  type ExtractFn,
-  type LlmProvider,
   type WorkflowDefinition,
   type WorkflowFn,
 } from "@uncaged/workflow";
@@ -43,10 +41,6 @@ export const developWorkflowDefinition: WorkflowDefinition<DevelopMeta> = {
   moderator: developModerator,
 };
 
-export function createDevelopRun(
-  binding: AgentBinding,
-  extract: ExtractFn,
-  llmProvider: LlmProvider | null,
-): WorkflowFn {
-  return createWorkflow(developWorkflowDefinition, binding, extract, llmProvider);
+export function createDevelopRun(binding: AgentBinding): WorkflowFn {
+  return createWorkflow(developWorkflowDefinition, binding);
 }

packages/workflow-template-solve-issue/README.md

@@ -1,48 +0,0 @@
-# @uncaged/workflow-template-solve-issue
-
-Reference **solve-issue** workflow template: prepare a repo, delegate implementation to the **develop** workflow, then submit (e.g. open a PR).
-
-`createSolveIssueRun` wires the `developer` role to `workflowAsAgent("develop")` by default; `binding.overrides.developer` wins if you pass one (for tests or custom hosts).
-
-## Install
-
-```bash
-bun add @uncaged/workflow-template-solve-issue @uncaged/workflow zod
-```
-
-In this monorepo: `workspace:*` for this package and `@uncaged/workflow`.
-
-## Usage
-
-```typescript
-import { createSolveIssueRun, solveIssueWorkflowDefinition } from "@uncaged/workflow-template-solve-issue";
-
-const run = createSolveIssueRun(binding, extract, llmProvider);
-```
-
-## Roles
-
-| Role | Purpose |
-|------|---------|
-| **preparer** | Set up context / repo state for the issue |
-| **developer** | Implementation; default runs the registered `develop` workflow as a sub-agent |
-| **submitter** | Finalize and submit the outcome (e.g. PR) |
-
-Also exported: `preparerRole`, `developerRole`, `submitterRole` and their Zod meta schemas, `SolveIssueMeta`, `solveIssueRoles`.
-
-## Moderator flow
-
-1. **Start** → `preparer`  
-2. After **preparer** → `developer`  
-3. After **developer** → `submitter`  
-4. After **submitter** → `END`
-
-## API overview
-
-| Export | Description |
-|--------|-------------|
-| `createSolveIssueRun` | Merges `developer` override with `workflowAsAgent("develop")`, then `createWorkflow` |
-| `solveIssueWorkflowDefinition` | `description`, `roles`, `solveIssueModerator` |
-| `solveIssueModerator` | Linear `Moderator<SolveIssueMeta>` |
-| `buildSolveIssueDescriptor` | Descriptor helper for bundles |
-| `SOLVE_ISSUE_WORKFLOW_DESCRIPTION` | Human-readable one-liner |

packages/workflow-template-solve-issue/__tests__/solve-issue-template.test.ts

@@ -250,17 +250,20 @@ describe("createSolveIssueRun", () => {
     const cas = createCasStore(casDir);
 
     // Override developer so the test does not spin up a child workflow.
-    const run = createSolveIssueRun(
-      {
-        agent: async () => "",
-        overrides: { developer: async () => "stub-root-hash" },
-      },
-      stubExtract,
-      stubLlmProvider,
-    );
+    const run = createSolveIssueRun({
+      agent: async () => "",
+      overrides: { developer: async () => "stub-root-hash" },
+    });
     const gen = run(
       { prompt: "task", steps: [] },
-      { threadId: "01TEST000000000000000000TR", maxRounds: 20, depth: 0, cas },
+      {
+        threadId: "01TEST000000000000000000TR",
+        maxRounds: 20,
+        depth: 0,
+        cas,
+        extract: stubExtract,
+        llmProvider: stubLlmProvider,
+      },
     );
     const first = await gen.next();
     expect(first.done).toBe(false);
@@ -294,33 +297,36 @@ describe("createSolveIssueRun", () => {
     const cas = createCasStore(casDir);
 
     const calls: string[] = [];
-    const run = createSolveIssueRun(
-      {
-        agent: async () => {
-          calls.push("default");
+    const run = createSolveIssueRun({
+      agent: async () => {
+        calls.push("default");
+        return "";
+      },
+      overrides: {
+        preparer: async () => {
+          calls.push("preparer");
           return "";
         },
-        overrides: {
-          preparer: async () => {
-            calls.push("preparer");
-            return "";
-          },
-          developer: async () => {
-            calls.push("developer");
-            return "stub-root-hash";
-          },
-          submitter: async () => {
-            calls.push("submitter");
-            return "";
-          },
+        developer: async () => {
+          calls.push("developer");
+          return "stub-root-hash";
+        },
+        submitter: async () => {
+          calls.push("submitter");
+          return "";
         },
       },
-      stubExtract,
-      stubLlmProvider,
-    );
+    });
     const gen = run(
       { prompt: "task", steps: [] },
-      { threadId: "01TEST000000000000000000TR", maxRounds: 20, depth: 0, cas },
+      {
+        threadId: "01TEST000000000000000000TR",
+        maxRounds: 20,
+        depth: 0,
+        cas,
+        extract: stubExtract,
+        llmProvider: stubLlmProvider,
+      },
     );
     await gen.next();
     expect(calls).toEqual(["preparer"]);
@@ -353,22 +359,25 @@ describe("createSolveIssueRun", () => {
     const cas = createCasStore(casDir);
 
     let developerInvocations = 0;
-    const run = createSolveIssueRun(
-      {
-        agent: async () => "",
-        overrides: {
-          developer: async () => {
-            developerInvocations += 1;
-            return "stub-root-hash";
-          },
+    const run = createSolveIssueRun({
+      agent: async () => "",
+      overrides: {
+        developer: async () => {
+          developerInvocations += 1;
+          return "stub-root-hash";
         },
       },
-      stubExtract,
-      stubLlmProvider,
-    );
+    });
     const gen = run(
       { prompt: "task", steps: [] },
-      { threadId: "01TEST000000000000000000TR", maxRounds: 20, depth: 0, cas },
+      {
+        threadId: "01TEST000000000000000000TR",
+        maxRounds: 20,
+        depth: 0,
+        cas,
+        extract: stubExtract,
+        llmProvider: stubLlmProvider,
+      },
     );
     // preparer
     await gen.next();

packages/workflow-template-solve-issue/src/index.ts

@@ -1,8 +1,6 @@
 import {
   type AgentBinding,
   createWorkflow,
-  type ExtractFn,
-  type LlmProvider,
   type WorkflowDefinition,
   type WorkflowFn,
   workflowAsAgent,
@@ -46,11 +44,7 @@ export const solveIssueWorkflowDefinition: WorkflowDefinition<SolveIssueMeta> =
  * {@link workflowAsAgent}; if the caller supplies their own `developer` override in
  * `binding.overrides`, it takes precedence so tests and custom hosts can stub it.
  */
-export function createSolveIssueRun(
-  binding: AgentBinding,
-  extract: ExtractFn,
-  llmProvider: LlmProvider | null,
-): WorkflowFn {
+export function createSolveIssueRun(binding: AgentBinding): WorkflowFn {
   const developerOverride = binding.overrides?.developer ?? workflowAsAgent("develop");
   const mergedBinding: AgentBinding = {
     agent: binding.agent,
@@ -59,5 +53,5 @@ export function createSolveIssueRun(
       developer: developerOverride,
     },
   };
-  return createWorkflow(solveIssueWorkflowDefinition, mergedBinding, extract, llmProvider);
+  return createWorkflow(solveIssueWorkflowDefinition, mergedBinding);
 }

packages/workflow-util-agent/README.md

@@ -1,34 +0,0 @@
-# @uncaged/workflow-util-agent
-
-Shared helpers for CLI-backed workflow agents: assemble prompts from thread context and spawn subprocesses with timeouts.
-
-Used by `@uncaged/workflow-agent-cursor` and `@uncaged/workflow-agent-hermes`. Depends on `@uncaged/workflow` for CAS reads (`getContentMerklePayload`) and `Result` typing.
-
-## Install
-
-```bash
-bun add @uncaged/workflow-util-agent @uncaged/workflow
-```
-
-In this monorepo: `workspace:*` for both packages.
-
-## Usage
-
-```typescript
-import { buildAgentPrompt, spawnCli } from "@uncaged/workflow-util-agent";
-
-const prompt = await buildAgentPrompt(agentContext);
-const result = await spawnCli("my-cli", ["--json"], { cwd: "/tmp", timeoutMs: 60_000 });
-if (!result.ok) { /* handle SpawnCliError */ }
-const stdout = result.value;
-```
-
-## API overview
-
-| Export | Description |
-|--------|-------------|
-| `buildAgentPrompt(ctx)` | System prompt + task + prior step summaries + latest body from CAS; appends `uncaged-workflow thread <id>` tool hint |
-| `spawnCli(cmd, args, { cwd, timeoutMs })` | `Promise<Result<string, SpawnCliError>>`; captures stdout, non-zero exit and spawn failures as `err` |
-| `SpawnCliConfig` | `cwd: string \| null`, `timeoutMs: number \| null` |
-| `SpawnCliError` | `non_zero_exit` \| `timeout` \| `spawn_failed` |
-| `SpawnCliResult` | Alias for `Result<string, SpawnCliError>` |

packages/workflow/README.md

@@ -1,36 +0,0 @@
-# @uncaged/workflow
-
-Core workflow engine: registry, CAS, thread execution, bundle validation, and role/workflow types.
-
-This package implements the three-phase engine loop that runs single-file ESM workflow bundles (each exports `run` and `descriptor`). It persists threads under `~/.uncaged/workflow/` by default and hashes bundles with XXH64 (Crockford Base32). See the repo root [README](../../README.md) for workflow, bundle, thread, role, and registry concepts.
-
-## Install
-
-```bash
-bun add @uncaged/workflow zod
-```
-
-In this monorepo, depend with `"@uncaged/workflow": "workspace:*"`. `zod` is a peer dependency (used by bundle/shape validation at the integration boundary).
-
-## Usage
-
-```typescript
-import { createWorkflow, readWorkflowRegistry, executeThread } from "@uncaged/workflow";
-// Wire a WorkflowDefinition + AgentBinding + extract + optional LlmProvider into createWorkflow,
-// then run the returned WorkflowFn inside your host (or use executeThread for disk-backed runs).
-```
-
-## API overview
-
-| Area | Exports (representative) |
-|------|--------------------------|
-| **Types** | `WorkflowDefinition`, `WorkflowFn`, `AgentFn`, `AgentBinding`, `Moderator`, `RoleDefinition`, `ThreadContext`, `LlmProvider`, `Result` shape via `ok` / `err`, `START` / `END` |
-| **Bundle** | `buildDescriptor`, `extractBundleExports`, `validateWorkflowBundle`, `validateWorkflowDescriptor`, `WorkflowDescriptor`, `WorkflowRoleDescriptor` |
-| **Registry** | `readWorkflowRegistry`, `writeWorkflowRegistry`, `registerWorkflowVersion`, `workflowRegistryPath`, YAML helpers |
-| **CAS** | `createCasStore`, `createThreadCas`, Merkle helpers (`putStepMerkleNode`, `getContentMerklePayload`, …), `hashWorkflowBundleBytes` |
-| **Engine** | `createWorkflow`, `executeThread`, `parseThreadDataJsonl`, fork helpers, `garbageCollectCas` |
-| **Extract / LLM tools** | `llmExtract`, `reactExtract`, `createExtract`, `getExtractProvider` |
-| **Agent bridge** | `workflowAsAgent` — expose a registered workflow as an agent-backed role |
-| **Utilities** | `createLogger`, ULID / Crockford Base32 codecs, `getDefaultWorkflowStorageRoot`, paths |
-
-Full surface is re-exported from `src/index.ts`.

packages/workflow/__tests__/engine.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import * as z from "zod/v4";
@@ -13,8 +13,7 @@ import {
 } from "../src/cas/merkle.js";
 import { createWorkflow } from "../src/engine/create-workflow.js";
 import { executeThread } from "../src/engine/engine.js";
-import { createExtract } from "../src/extract/extract-fn.js";
-import { END, type LlmProvider } from "../src/types.js";
+import { END } from "../src/types.js";
 import { createLogger } from "../src/util/logger.js";
 
 const plannerMetaSchema = z.object({
@@ -82,11 +81,20 @@ function installMockChatCompletions(sequence: ReadonlyArray<Record<string, unkno
   };
 }
 
-const demoExtract = createExtract({
-  baseUrl: "http://127.0.0.1:9",
-  apiKey: "test",
-  model: "test",
-});
+const EXTRACT_REGISTRY_YAML = `config:
+  maxDepth: 3
+  providers:
+    stub:
+      baseUrl: http://127.0.0.1:9
+      apiKey: test
+  models:
+    default: stub/model
+workflows: {}
+`;
+
+async function writeExtractRegistryConfig(storageRoot: string): Promise<void> {
+  await writeFile(join(storageRoot, "workflow.yaml"), EXTRACT_REGISTRY_YAML, "utf8");
+}
 
 const demoWorkflow = createWorkflow<DemoMeta>(
   {
@@ -125,8 +133,6 @@ const demoWorkflow = createWorkflow<DemoMeta>(
       coder: async () => "code-body",
     },
   },
-  demoExtract,
-  null,
 );
 
 describe("executeThread", () => {
@@ -150,6 +156,7 @@ describe("executeThread", () => {
       const dataPath = join(root, "logs", hash, `${threadId}.data.jsonl`);
       const infoPath = join(root, "logs", hash, `${threadId}.info.jsonl`);
       await mkdir(join(root, "logs", hash), { recursive: true });
+      await writeExtractRegistryConfig(root);
       const cas = createCasStore(join(root, "cas"));
 
       const logger = createLogger({ sink: { kind: "file", path: infoPath } });
@@ -166,6 +173,7 @@ describe("executeThread", () => {
           awaitAfterEachYield: async () => {},
           forkSourceThreadId: null,
           prefilledDiskSteps: null,
+          storageRoot: root,
         },
         { threadId, hash, dataJsonlPath: dataPath, infoJsonlPath: infoPath, cas },
         logger,
@@ -258,6 +266,7 @@ describe("executeThread", () => {
       const dataPath = join(root, "logs", hash, `${threadId}.data.jsonl`);
       const infoPath = join(root, "logs", hash, `${threadId}.info.jsonl`);
       await mkdir(join(root, "logs", hash), { recursive: true });
+      await writeExtractRegistryConfig(root);
       const cas = createCasStore(join(root, "cas"));
       const plannerHash = await cas.put(serializeMerkleNode(createContentMerkleNode("plan-body")));
 
@@ -295,6 +304,7 @@ describe("executeThread", () => {
               timestamp: histTs,
             },
           ],
+          storageRoot: root,
         },
         { threadId, hash, dataJsonlPath: dataPath, infoJsonlPath: infoPath, cas },
         logger,
@@ -354,6 +364,7 @@ describe("executeThread", () => {
           awaitAfterEachYield: async () => {},
           forkSourceThreadId: null,
           prefilledDiskSteps: null,
+          storageRoot: root,
         },
         { threadId, hash, dataJsonlPath: dataPath, infoJsonlPath: infoPath, cas },
         logger,
@@ -391,6 +402,7 @@ describe("executeThread", () => {
       const dataPath = join(root, "logs", hash, `${threadId}.data.jsonl`);
       const infoPath = join(root, "logs", hash, `${threadId}.info.jsonl`);
       await mkdir(join(root, "logs", hash), { recursive: true });
+      await writeExtractRegistryConfig(root);
       const cas = createCasStore(join(root, "cas"));
 
       const logger = createLogger({ sink: { kind: "file", path: infoPath } });
@@ -407,6 +419,7 @@ describe("executeThread", () => {
           awaitAfterEachYield: async () => {},
           forkSourceThreadId: null,
           prefilledDiskSteps: null,
+          storageRoot: root,
         },
         { threadId, hash, dataJsonlPath: dataPath, infoJsonlPath: infoPath, cas },
         logger,
@@ -549,9 +562,6 @@ describe("executeThread", () => {
         { preconnect: origFetch.preconnect.bind(origFetch) },
       ) as typeof fetch;
 
-      const llm: LlmProvider = { baseUrl: "http://127.0.0.1:9", apiKey: "test", model: "test" };
-      const extractFn = createExtract(llm);
-
       const dagWorkflow = createWorkflow<DagDemoMeta>(
         {
           roles: {
@@ -568,8 +578,6 @@ describe("executeThread", () => {
           moderator: (ctx) => (ctx.steps.length === 0 ? "walker" : END),
         },
         { agent: async () => dagRootHash },
-        extractFn,
-        llm,
       );
 
       const threadId = "01KQXKW18CT8G75T53R8F4G7YG";
@@ -577,6 +585,7 @@ describe("executeThread", () => {
       const dataPath = join(root, "logs", hash, `${threadId}.data.jsonl`);
       const infoPath = join(root, "logs", hash, `${threadId}.info.jsonl`);
       await mkdir(join(root, "logs", hash), { recursive: true });
+      await writeExtractRegistryConfig(root);
 
       const logger = createLogger({ sink: { kind: "file", path: infoPath } });
       const ac = new AbortController();
@@ -592,6 +601,7 @@ describe("executeThread", () => {
           awaitAfterEachYield: async () => {},
           forkSourceThreadId: null,
           prefilledDiskSteps: null,
+          storageRoot: root,
         },
         { threadId, hash, dataJsonlPath: dataPath, infoJsonlPath: infoPath, cas },
         logger,

packages/workflow/__tests__/extract-provider.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { getExtractProvider } from "../src/extract-provider.js";
-
-describe("getExtractProvider", () => {
-  test("returns provider when config.extract is present", async () => {
-    const root = await mkdtemp(join(tmpdir(), "wf-ext-prov-ok-"));
-    try {
-      await mkdir(root, { recursive: true });
-      await writeFile(
-        join(root, "workflow.yaml"),
-        `config:
-  maxDepth: 3
-  extract:
-    baseUrl: https://dashscope.aliyuncs.com/compatible-mode/v1
-    model: qwen-plus
-    apiKey: literal-key
-workflows: {}
-`,
-        "utf8",
-      );
-      const r = await getExtractProvider(root);
-      expect(r.ok).toBe(true);
-      if (!r.ok) {
-        return;
-      }
-      expect(r.value.baseUrl).toBe("https://dashscope.aliyuncs.com/compatible-mode/v1");
-      expect(r.value.model).toBe("qwen-plus");
-      expect(r.value.apiKey).toBe("literal-key");
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  test("errs when registry has no config section", async () => {
-    const root = await mkdtemp(join(tmpdir(), "wf-ext-prov-missing-"));
-    try {
-      await mkdir(root, { recursive: true });
-      await writeFile(join(root, "workflow.yaml"), "workflows: {}\n", "utf8");
-      const r = await getExtractProvider(root);
-      expect(r.ok).toBe(false);
-      if (r.ok) {
-        return;
-      }
-      expect(r.error).toContain("no global config");
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  test("resolves apiKey from env at registry read time", async () => {
-    const root = await mkdtemp(join(tmpdir(), "wf-ext-prov-env-"));
-    const prev = process.env.WF_GET_EXTRACT_PROVIDER_KEY;
-    process.env.WF_GET_EXTRACT_PROVIDER_KEY = "resolved-secret";
-    try {
-      await mkdir(root, { recursive: true });
-      await writeFile(
-        join(root, "workflow.yaml"),
-        `config:
-  maxDepth: 1
-  extract:
-    baseUrl: https://example.com
-    model: m
-    apiKey: env:WF_GET_EXTRACT_PROVIDER_KEY
-workflows: {}
-`,
-        "utf8",
-      );
-      const r = await getExtractProvider(root);
-      expect(r.ok).toBe(true);
-      if (!r.ok) {
-        return;
-      }
-      expect(r.value.apiKey).toBe("resolved-secret");
-    } finally {
-      if (prev === undefined) {
-        delete process.env.WF_GET_EXTRACT_PROVIDER_KEY;
-      } else {
-        process.env.WF_GET_EXTRACT_PROVIDER_KEY = prev;
-      }
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-});

packages/workflow/__tests__/refs-tracking.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import * as z from "zod/v4";
@@ -8,7 +8,6 @@ import { createCasStore } from "../src/cas/cas.js";
 import { createWorkflow } from "../src/engine/create-workflow.js";
 import { executeThread } from "../src/engine/engine.js";
 import { buildForkPlan, parseThreadDataJsonl } from "../src/engine/fork-thread.js";
-import { createExtract } from "../src/extract/extract-fn.js";
 import { END } from "../src/types.js";
 import { createLogger } from "../src/util/logger.js";
 
@@ -76,11 +75,16 @@ function installMockChatCompletions(sequence: ReadonlyArray<Record<string, unkno
   };
 }
 
-const refsDemoExtract = createExtract({
-  baseUrl: "http://127.0.0.1:9",
-  apiKey: "test",
-  model: "test",
-});
+const EXTRACT_REGISTRY_YAML = `config:
+  maxDepth: 3
+  providers:
+    stub:
+      baseUrl: http://127.0.0.1:9
+      apiKey: test
+  models:
+    default: stub/model
+workflows: {}
+`;
 
 const refsDemoWorkflow = createWorkflow<RefsDemoMeta>(
   {
@@ -99,8 +103,6 @@ const refsDemoWorkflow = createWorkflow<RefsDemoMeta>(
   {
     agent: async () => "plan-output",
   },
-  refsDemoExtract,
-  null,
 );
 
 describe("RoleStep refs tracking", () => {
@@ -142,6 +144,7 @@ describe("RoleStep refs tracking", () => {
       const dataPath = join(root, "logs", hash, `${threadId}.data.jsonl`);
       const infoPath = join(root, "logs", hash, `${threadId}.info.jsonl`);
       await mkdir(join(root, "logs", hash), { recursive: true });
+      await writeFile(join(root, "workflow.yaml"), EXTRACT_REGISTRY_YAML, "utf8");
       const cas = createCasStore(join(root, "cas"));
 
       const logger = createLogger({ sink: { kind: "file", path: infoPath } });
@@ -158,6 +161,7 @@ describe("RoleStep refs tracking", () => {
           awaitAfterEachYield: async () => {},
           forkSourceThreadId: null,
           prefilledDiskSteps: null,
+          storageRoot: root,
         },
         { threadId, hash, dataJsonlPath: dataPath, infoJsonlPath: infoPath, cas },
         logger,

packages/workflow/__tests__/registry.test.ts

@@ -105,10 +105,13 @@ describe("workflow registry", () => {
     const yaml = `
 config:
   maxDepth: 3
-  extract:
-    baseUrl: https://example.com/v1
-    model: qwen-plus
-    apiKey: secret-key
+  providers:
+    dashscope:
+      baseUrl: https://example.com/v1
+      apiKey: secret-key
+  models:
+    default: dashscope/qwen-turbo
+    extract: dashscope/qwen-plus
 workflows:
   solve-issue:
     hash: SPVR4BDMSGC1W
@@ -125,9 +128,10 @@ workflows:
       return;
     }
     expect(r.value.config.maxDepth).toBe(3);
-    expect(r.value.config.extract.baseUrl).toBe("https://example.com/v1");
-    expect(r.value.config.extract.model).toBe("qwen-plus");
-    expect(r.value.config.extract.apiKey).toBe("secret-key");
+    expect(r.value.config.providers.dashscope?.baseUrl).toBe("https://example.com/v1");
+    expect(r.value.config.providers.dashscope?.apiKey).toBe("secret-key");
+    expect(r.value.config.models.extract).toBe("dashscope/qwen-plus");
+    expect(r.value.config.models.default).toBe("dashscope/qwen-turbo");
   });
 
   test("parses config apiKey env: prefix from process.env", () => {
@@ -137,10 +141,13 @@ workflows:
       const yaml = `
 config:
   maxDepth: 1
-  extract:
-    baseUrl: https://dashscope.aliyuncs.com/compatible-mode/v1
-    model: qwen-plus
-    apiKey: env:WF_REGISTRY_TEST_API_KEY
+  providers:
+    dashscope:
+      baseUrl: https://dashscope.aliyuncs.com/compatible-mode/v1
+      apiKey: env:WF_REGISTRY_TEST_API_KEY
+  models:
+    default: dashscope/qwen-plus
+    extract: dashscope/qwen-plus
 workflows: {}
 `;
       const r = parseWorkflowRegistryYaml(yaml);
@@ -148,7 +155,7 @@ workflows: {}
       if (!r.ok) {
         return;
       }
-      expect(r.value.config?.extract.apiKey).toBe("from-env");
+      expect(r.value.config?.providers.dashscope?.apiKey).toBe("from-env");
     } finally {
       if (prev === undefined) {
         delete process.env.WF_REGISTRY_TEST_API_KEY;
@@ -165,10 +172,12 @@ workflows: {}
       const yaml = `
 config:
   maxDepth: 1
-  extract:
-    baseUrl: https://example.com
-    model: m
-    apiKey: env:WF_REGISTRY_TEST_API_KEY_UNSET
+  providers:
+    p:
+      baseUrl: https://example.com
+      apiKey: env:WF_REGISTRY_TEST_API_KEY_UNSET
+  models:
+    default: p/m
 workflows: {}
 `;
       const r = parseWorkflowRegistryYaml(yaml);

packages/workflow/__tests__/resolve-model.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+
+import { resolveModel } from "../src/config/resolve-model.js";
+import type { WorkflowConfig } from "../src/registry/index.js";
+
+function sampleConfig(): WorkflowConfig {
+  return {
+    maxDepth: 3,
+    providers: {
+      dashscope: {
+        baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+        apiKey: "secret",
+      },
+      other: {
+        baseUrl: "https://other.example/v1",
+        apiKey: "k2",
+      },
+    },
+    models: {
+      default: "dashscope/qwen-plus",
+      extract: "other/foo/bar-model",
+    },
+  };
+}
+
+describe("resolveModel", () => {
+  test("uses explicit scene mapping", () => {
+    const config = sampleConfig();
+    const r = resolveModel(config, "extract");
+    expect(r.ok).toBe(true);
+    if (!r.ok) {
+      return;
+    }
+    expect(r.value.baseUrl).toBe("https://other.example/v1");
+    expect(r.value.apiKey).toBe("k2");
+    expect(r.value.model).toBe("foo/bar-model");
+  });
+
+  test("falls back to models.default when scene is missing", () => {
+    const config = sampleConfig();
+    const r = resolveModel(config, "unknown-scene");
+    expect(r.ok).toBe(true);
+    if (!r.ok) {
+      return;
+    }
+    expect(r.value.model).toBe("qwen-plus");
+    expect(r.value.baseUrl).toBe("https://dashscope.aliyuncs.com/compatible-mode/v1");
+  });
+
+  test("errs when scene missing and no default", () => {
+    const config: WorkflowConfig = {
+      maxDepth: 1,
+      providers: {
+        p: { baseUrl: "https://x", apiKey: "k" },
+      },
+      models: {
+        extract: "p/m",
+      },
+    };
+    const r = resolveModel(config, "other");
+    expect(r.ok).toBe(false);
+    if (r.ok) {
+      return;
+    }
+    expect(r.error).toContain("no model mapping");
+    expect(r.error).toContain("default");
+  });
+
+  test("errs when provider is unknown", () => {
+    const config: WorkflowConfig = {
+      maxDepth: 1,
+      providers: {
+        p: { baseUrl: "https://x", apiKey: "k" },
+      },
+      models: {
+        default: "missing/m",
+      },
+    };
+    const r = resolveModel(config, "any");
+    expect(r.ok).toBe(false);
+    if (r.ok) {
+      return;
+    }
+    expect(r.error).toContain("unknown provider");
+  });
+
+  test("errs on invalid model reference shape", () => {
+    const config: WorkflowConfig = {
+      maxDepth: 1,
+      providers: {
+        p: { baseUrl: "https://x", apiKey: "k" },
+      },
+      models: {
+        default: "no-slash-model",
+      },
+    };
+    const r = resolveModel(config, "x");
+    expect(r.ok).toBe(false);
+  });
+});

packages/workflow/__tests__/worker.test.ts

@@ -9,6 +9,17 @@ import { createCasStore } from "../src/cas/cas.js";
 import { createContentMerkleNode, serializeMerkleNode } from "../src/cas/merkle.js";
 import { getWorkerHostScriptPath } from "../src/engine/worker-entry-path.js";
 
+const WORKER_REGISTRY_YAML = `config:
+  maxDepth: 3
+  providers:
+    stub:
+      baseUrl: http://127.0.0.1:9
+      apiKey: test
+  models:
+    default: stub/model
+workflows: {}
+`;
+
 const bundleSource = `import { putContentMerkleNode } from "@uncaged/workflow";
 
 export const descriptor = {
@@ -89,6 +100,7 @@ describe("worker process", () => {
     try {
       const hash = "C9NMV6V2TQT81";
       await mkdir(join(root, "bundles"), { recursive: true });
+      await writeFile(join(root, "workflow.yaml"), WORKER_REGISTRY_YAML, "utf8");
       const bundlePath = join(root, "bundles", `${hash}.esm.js`);
       await writeFile(bundlePath, bundleSource, "utf8");
 
@@ -136,6 +148,7 @@ describe("worker process", () => {
     try {
       const hash = "C9NMV6V2TQT81";
       await mkdir(join(root, "bundles"), { recursive: true });
+      await writeFile(join(root, "workflow.yaml"), WORKER_REGISTRY_YAML, "utf8");
       const bundlePath = join(root, "bundles", `${hash}.esm.js`);
       await writeFile(bundlePath, bundleSource, "utf8");
 

packages/workflow/__tests__/workflow-as-agent-integration.test.ts

@@ -9,7 +9,6 @@ import { hashWorkflowBundleBytes } from "../src/cas/hash.js";
 import { getContentMerklePayload, parseMerkleNode } from "../src/cas/merkle.js";
 import { createWorkflow } from "../src/engine/create-workflow.js";
 import { executeThread } from "../src/engine/engine.js";
-import { createExtract } from "../src/extract/extract-fn.js";
 import {
   readWorkflowRegistry,
   registerWorkflowVersion,
@@ -76,11 +75,16 @@ function installMockChatCompletions(sequence: ReadonlyArray<Record<string, unkno
   };
 }
 
-const parentExtract = createExtract({
-  baseUrl: "http://127.0.0.1:9",
-  apiKey: "test",
-  model: "test",
-});
+const PARENT_REGISTRY_WITH_CONFIG = `config:
+  maxDepth: 3
+  providers:
+    stub:
+      baseUrl: http://127.0.0.1:9
+      apiKey: test
+  models:
+    default: stub/m
+workflows: {}
+`;
 
 const childBundleSource = `import { putContentMerkleNode } from "@uncaged/workflow";
 
@@ -131,6 +135,8 @@ describe("workflowAsAgent integration", () => {
 
     const root = await mkdtemp(join(tmpdir(), "wf-waa-int-"));
     try {
+      await mkdir(root, { recursive: true });
+      await writeFile(join(root, "workflow.yaml"), PARENT_REGISTRY_WITH_CONFIG, "utf8");
       const { hash: childHash } = await installChildWorkflow(root);
 
       const parentWorkflow = createWorkflow<ParentMeta>(
@@ -148,8 +154,6 @@ describe("workflowAsAgent integration", () => {
           moderator: (ctx) => (ctx.steps.length === 0 ? "caller" : END),
         },
         { agent: workflowAsAgent("child-wf", { storageRoot: root }) },
-        parentExtract,
-        null,
       );
 
       const threadId = "01KQXKW18CT8G75T53R8F4G7YG";
@@ -173,6 +177,7 @@ describe("workflowAsAgent integration", () => {
           awaitAfterEachYield: async () => {},
           forkSourceThreadId: null,
           prefilledDiskSteps: null,
+          storageRoot: root,
         },
         { threadId, hash: parentHash, dataJsonlPath: dataPath, infoJsonlPath: infoPath, cas },
         logger,

packages/workflow/__tests__/workflow-as-agent.test.ts

@@ -93,6 +93,21 @@ describe("workflowAsAgent", () => {
   test("runs registered workflow and returns child thread root CAS hash", async () => {
     const root = await mkdtemp(join(tmpdir(), "wf-waa-ok-"));
     try {
+      await mkdir(root, { recursive: true });
+      await writeFile(
+        join(root, "workflow.yaml"),
+        `config:
+  maxDepth: 3
+  providers:
+    stub:
+      baseUrl: http://127.0.0.1:9
+      apiKey: test
+  models:
+    default: stub/m
+workflows: {}
+`,
+        "utf8",
+      );
       await installChildWorkflow(root);
       const agent = workflowAsAgent("child-wf", { storageRoot: root });
       const out = await agent(
@@ -140,10 +155,15 @@ describe("workflowAsAgent", () => {
         ...reg.value,
         config: {
           maxDepth: 2,
-          extract: {
-            baseUrl: "http://127.0.0.1:9",
-            model: "m",
-            apiKey: "k",
+          providers: {
+            local: {
+              baseUrl: "http://127.0.0.1:9",
+              apiKey: "k",
+            },
+          },
+          models: {
+            default: "local/m",
+            extract: "local/m",
           },
         },
       };

packages/workflow/src/config/index.ts

@@ -0,0 +1,3 @@
+export { resolveModel } from "./resolve-model.js";
+export { splitProviderModelRef } from "./split-provider-model-ref.js";
+export type { ProviderConfig, ResolvedModel } from "./types.js";

packages/workflow/src/config/resolve-model.ts

@@ -0,0 +1,30 @@
+import type { WorkflowConfig } from "../registry/index.js";
+import { err, ok, type Result } from "../util/index.js";
+import { splitProviderModelRef } from "./split-provider-model-ref.js";
+import type { ResolvedModel } from "./types.js";
+
+/** Resolves scene → provider endpoint + model using {@link WorkflowConfig.providers} and {@link WorkflowConfig.models}. */
+export function resolveModel(config: WorkflowConfig, scene: string): Result<ResolvedModel, string> {
+  const models = config.models;
+  let ref = models[scene] ?? null;
+  if (ref === null) {
+    ref = models.default ?? null;
+  }
+  if (ref === null) {
+    return err(`no model mapping for scene "${scene}" and no models.default fallback`);
+  }
+  const split = splitProviderModelRef(ref);
+  if (!split.ok) {
+    return split;
+  }
+  const { providerName, modelName } = split.value;
+  const provider = config.providers[providerName] ?? null;
+  if (provider === null) {
+    return err(`unknown provider "${providerName}" referenced by scene "${scene}"`);
+  }
+  return ok({
+    baseUrl: provider.baseUrl,
+    apiKey: provider.apiKey,
+    model: modelName,
+  });
+}

packages/workflow/src/config/split-provider-model-ref.ts

@@ -0,0 +1,17 @@
+import { err, ok, type Result } from "../util/index.js";
+
+/** Parses `providerName/modelName` references used in {@link WorkflowConfig.models}. */
+export function splitProviderModelRef(
+  ref: string,
+): Result<{ providerName: string; modelName: string }, string> {
+  const idx = ref.indexOf("/");
+  if (idx <= 0 || idx === ref.length - 1) {
+    return err(`invalid model reference "${ref}": expected providerName/modelName`);
+  }
+  const providerName = ref.slice(0, idx);
+  const modelName = ref.slice(idx + 1);
+  if (providerName === "" || modelName === "") {
+    return err(`invalid model reference "${ref}": expected providerName/modelName`);
+  }
+  return ok({ providerName, modelName });
+}

packages/workflow/src/config/types.ts

@@ -0,0 +1,10 @@
+export type ProviderConfig = {
+  baseUrl: string;
+  apiKey: string;
+};
+
+export type ResolvedModel = {
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+};

packages/workflow/src/engine/create-workflow.ts

@@ -1,12 +1,10 @@
-import type { CasStore } from "../cas/index.js";
 import { putContentMerkleNode } from "../cas/index.js";
-import { buildExtractUserContent, type ExtractFn, reactExtract } from "../extract/index.js";
+import { buildExtractUserContent, reactExtract } from "../extract/index.js";
 import {
   type AgentBinding,
   type AgentContext,
   END,
   type ExtractContext,
-  type LlmProvider,
   type ModeratorContext,
   type RoleDefinition,
   type RoleMeta,
@@ -41,14 +39,12 @@ function resolveExtractedRefs(
 async function resolveRoleMeta<M extends RoleMeta>(
   roleDef: RoleDefinition<Record<string, unknown>>,
   extractCtx: ExtractContext<M>,
-  extract: ExtractFn,
-  llmProvider: LlmProvider | null,
-  cas: CasStore,
+  options: WorkflowFnOptions,
 ): Promise<Record<string, unknown>> {
   if (roleDef.extractMode === "react") {
-    if (llmProvider === null) {
+    if (options.llmProvider === null) {
       throw new Error(
-        'createWorkflow: llmProvider is required when a role uses extractMode "react"',
+        'createWorkflow: WorkflowFnOptions.llmProvider is required when a role uses extractMode "react"',
       );
     }
     const text = await buildExtractUserContent(
@@ -58,15 +54,15 @@ async function resolveRoleMeta<M extends RoleMeta>(
     const reactResult = await reactExtract({
       text,
       schema: roleDef.schema,
-      provider: llmProvider,
-      cas,
+      provider: options.llmProvider,
+      cas: options.cas,
     });
     if (!reactResult.ok) {
       throw new Error(`react extract failed: ${reactResult.error}`);
     }
     return reactResult.value as Record<string, unknown>;
   }
-  return (await extract(
+  return (await options.extract(
     roleDef.schema,
     roleDef.extractPrompt,
     extractCtx as unknown as ExtractContext,
@@ -74,15 +70,13 @@ async function resolveRoleMeta<M extends RoleMeta>(
 }
 
 /**
- * Binds pure role definitions + moderator to runtime agents and structured extraction.
- * Assign with `export const run = createWorkflow(def, binding, extract, llmProvider)`.
- * Pass the same {@link LlmProvider} as {@link createExtract} when any role uses `extractMode: "react"`.
+ * Binds pure role definitions + moderator to runtime agents.
+ * Assign with `export const run = createWorkflow(def, binding)`.
+ * The engine supplies {@link WorkflowFnOptions.extract} and {@link WorkflowFnOptions.llmProvider} from workflow.yaml.
  */
 export function createWorkflow<M extends RoleMeta>(
   def: Pick<WorkflowDefinition<M>, "roles" | "moderator">,
   binding: AgentBinding,
-  extract: ExtractFn,
-  llmProvider: LlmProvider | null,
 ): WorkflowFn {
   return async function* workflowLoop(
     input: ThreadInput,
@@ -149,9 +143,7 @@ export function createWorkflow<M extends RoleMeta>(
       const meta = await resolveRoleMeta(
         roleDef as unknown as RoleDefinition<Record<string, unknown>>,
         extractCtx,
-        extract,
-        llmProvider,
-        options.cas,
+        options,
       );
 
       const contentHash = await putContentMerkleNode(options.cas, raw);

packages/workflow/src/engine/engine.ts

@@ -7,17 +7,47 @@ import {
   putStepMerkleNode,
   putThreadMerkleNode,
 } from "../cas/index.js";
+import { resolveModel } from "../config/index.js";
+import { createExtract } from "../extract/index.js";
+import { readWorkflowRegistry } from "../registry/index.js";
 import type {
+  LlmProvider,
   ThreadInput,
   WorkflowCompletion,
   WorkflowFn,
   WorkflowFnOptions,
   WorkflowResult,
 } from "../types.js";
-import { type LogFn, normalizeRefsField } from "../util/index.js";
+import { err, type LogFn, normalizeRefsField, ok, type Result } from "../util/index.js";
 
 import type { ExecuteThreadIo, ExecuteThreadOptions } from "./types.js";
 
+async function resolveExtractRuntime(
+  storageRoot: string,
+): Promise<
+  Result<{ extract: ReturnType<typeof createExtract>; llmProvider: LlmProvider }, string>
+> {
+  const reg = await readWorkflowRegistry(storageRoot);
+  if (!reg.ok) {
+    return err(reg.error.message);
+  }
+  const cfg = reg.value.config;
+  if (cfg === null) {
+    return err("workflow registry has no global config section");
+  }
+  const resolved = resolveModel(cfg, "extract");
+  if (!resolved.ok) {
+    return resolved;
+  }
+  const ex = resolved.value;
+  const llmProvider: LlmProvider = {
+    baseUrl: ex.baseUrl,
+    apiKey: ex.apiKey,
+    model: ex.model,
+  };
+  return ok({ extract: createExtract(llmProvider), llmProvider });
+}
+
 async function appendDataLine(path: string, record: unknown): Promise<void> {
   const line = `${JSON.stringify(record)}\n`;
   await appendFile(path, line, "utf8");
@@ -250,11 +280,18 @@ export async function executeThread(
     });
   }
 
+  const extractRuntime = await resolveExtractRuntime(options.storageRoot);
+  if (!extractRuntime.ok) {
+    throw new Error(extractRuntime.error);
+  }
+
   const bundleOptions: WorkflowFnOptions = {
     threadId: io.threadId,
     maxRounds: options.maxRounds,
     depth: options.depth,
     cas: io.cas,
+    extract: extractRuntime.value.extract,
+    llmProvider: extractRuntime.value.llmProvider,
   };
 
   return await driveWorkflowGenerator({

packages/workflow/src/engine/types.ts

@@ -33,6 +33,8 @@ export type ExecuteThreadOptions = {
    * Must match `input.steps` length and order when present.
    */
   prefilledDiskSteps: PrefilledDiskStep[] | null;
+  /** Workspace root containing `workflow.yaml`; used to resolve the `extract` scene for meta extraction. */
+  storageRoot: string;
 };
 
 /** Role steps replayed from `.data.jsonl`, including persisted timestamps. */

packages/workflow/src/engine/worker.ts

@@ -417,6 +417,7 @@ async function main(): Promise<void> {
           awaitAfterEachYield: () => pauseGate.awaitAfterYield(),
           forkSourceThreadId: cmd.forkSourceThreadId,
           prefilledDiskSteps,
+          storageRoot,
         },
         io,
         logger,

packages/workflow/src/extract-provider.ts

@@ -1,34 +0,0 @@
-import type { WorkflowConfig } from "./registry/index.js";
-import { readWorkflowRegistry } from "./registry/index.js";
-import type { LlmProvider } from "./types.js";
-import { err, getDefaultWorkflowStorageRoot, ok, type Result } from "./util/index.js";
-
-const DEFAULT_WORKFLOW_AS_AGENT_MAX_DEPTH = 3;
-
-export function getWorkflowAsAgentMaxDepth(config: WorkflowConfig | null): number {
-  if (config === null) {
-    return DEFAULT_WORKFLOW_AS_AGENT_MAX_DEPTH;
-  }
-  return config.maxDepth;
-}
-
-/** Loads `config.extract` from workflow.yaml (apiKey already resolved at registry parse time). */
-export async function getExtractProvider(
-  storageRoot: string | undefined,
-): Promise<Result<LlmProvider, string>> {
-  const root = storageRoot ?? getDefaultWorkflowStorageRoot();
-  const regResult = await readWorkflowRegistry(root);
-  if (!regResult.ok) {
-    return err(regResult.error.message);
-  }
-  const cfg = regResult.value.config;
-  if (cfg === null) {
-    return err("workflow registry has no global config section");
-  }
-  const ex = cfg.extract;
-  return ok({
-    baseUrl: ex.baseUrl,
-    apiKey: ex.apiKey,
-    model: ex.model,
-  });
-}

packages/workflow/src/index.ts

@@ -28,6 +28,11 @@ export {
   serializeMerkleNode,
   type ThreadMerklePayload,
 } from "./cas/index.js";
+export {
+  type ProviderConfig,
+  type ResolvedModel,
+  resolveModel,
+} from "./config/index.js";
 export {
   buildForkPlan,
   createThreadPauseGate,
@@ -58,9 +63,7 @@ export {
   type ReactExtractArgs,
   reactExtract,
 } from "./extract/index.js";
-export { getExtractProvider } from "./extract-provider.js";
 export {
-  type ExtractProviderConfig,
   getRegisteredWorkflow,
   listRegisteredWorkflowNames,
   parseWorkflowRegistryYaml,

packages/workflow/src/registry/index.ts

@@ -11,7 +11,6 @@ export {
   writeWorkflowRegistry,
 } from "./registry.js";
 export type {
-  ExtractProviderConfig,
   WorkflowConfig,
   WorkflowHistoryEntry,
   WorkflowRegistryEntry,

packages/workflow/src/registry/registry-normalize.ts

@@ -1,49 +1,107 @@
-import { err, ok, type Result } from "../util/index.js";
+import { type ProviderConfig, splitProviderModelRef } from "../config/index.js";
+import { createLogger, err, ok, type Result } from "../util/index.js";
 import type {
-  ExtractProviderConfig,
   WorkflowConfig,
   WorkflowHistoryEntry,
   WorkflowRegistryEntry,
   WorkflowRegistryFile,
 } from "./types.js";
 
-function resolveRegistryApiKey(raw: string): Result<string, Error> {
+const registryNormalizeLog = createLogger({ sink: { kind: "stderr" } });
+
+function resolveRegistryApiKey(raw: string, ctx: string): Result<string, Error> {
   if (raw.startsWith("env:")) {
     const name = raw.slice("env:".length);
     if (name === "") {
-      return err(new Error('config.extract.apiKey "env:" reference must name a variable'));
+      return err(new Error(`${ctx}: "env:" apiKey reference must name a variable`));
     }
     const value = process.env[name];
     if (value === undefined) {
-      return err(new Error(`config.extract.apiKey: environment variable "${name}" is not set`));
+      return err(new Error(`${ctx}: environment variable "${name}" is not set`));
     }
     return ok(value);
   }
   return ok(raw);
 }
 
-function normalizeExtractProviderConfig(raw: unknown): Result<ExtractProviderConfig, Error> {
-  if (raw === null || typeof raw !== "object") {
-    return err(new Error('registry config must contain an "extract" mapping'));
+function normalizeProviderEntry(name: string, entryRaw: unknown): Result<ProviderConfig, Error> {
+  if (name === "") {
+    return err(new Error("config.providers must not contain an empty provider name"));
   }
-  const e = raw as Record<string, unknown>;
+  if (entryRaw === null || typeof entryRaw !== "object" || Array.isArray(entryRaw)) {
+    return err(new Error(`config.providers.${name} must be a mapping`));
+  }
+  const e = entryRaw as Record<string, unknown>;
   const baseUrl = e.baseUrl;
-  const model = e.model;
   const apiKeyRaw = e.apiKey;
   if (typeof baseUrl !== "string" || baseUrl === "") {
-    return err(new Error("config.extract.baseUrl must be a non-empty string"));
-  }
-  if (typeof model !== "string" || model === "") {
-    return err(new Error("config.extract.model must be a non-empty string"));
+    return err(new Error(`config.providers.${name}.baseUrl must be a non-empty string`));
   }
   if (typeof apiKeyRaw !== "string" || apiKeyRaw === "") {
-    return err(new Error("config.extract.apiKey must be a non-empty string"));
+    return err(new Error(`config.providers.${name}.apiKey must be a non-empty string`));
   }
-  const apiKeyResult = resolveRegistryApiKey(apiKeyRaw);
+  const apiKeyCtx = `config.providers.${name}.apiKey`;
+  const apiKeyResult = resolveRegistryApiKey(apiKeyRaw, apiKeyCtx);
   if (!apiKeyResult.ok) {
     return apiKeyResult;
   }
-  return ok({ baseUrl, model, apiKey: apiKeyResult.value });
+  return ok({ baseUrl, apiKey: apiKeyResult.value });
+}
+
+function normalizeProviders(raw: unknown): Result<Record<string, ProviderConfig>, Error> {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return err(new Error('registry config must contain a "providers" mapping'));
+  }
+  const root = raw as Record<string, unknown>;
+  const providers: Record<string, ProviderConfig> = {};
+  for (const [name, entryRaw] of Object.entries(root)) {
+    const next = normalizeProviderEntry(name, entryRaw);
+    if (!next.ok) {
+      return next;
+    }
+    providers[name] = next.value;
+  }
+  return ok(providers);
+}
+
+function normalizeModels(
+  raw: unknown,
+  providers: Record<string, ProviderConfig>,
+): Result<Record<string, string>, Error> {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    return err(new Error('registry config must contain a "models" mapping'));
+  }
+  const root = raw as Record<string, unknown>;
+  const models: Record<string, string> = {};
+  const providerKeys = new Set(Object.keys(providers));
+  for (const [scene, refRaw] of Object.entries(root)) {
+    if (scene === "") {
+      return err(new Error("config.models must not contain an empty scene name"));
+    }
+    if (typeof refRaw !== "string" || refRaw === "") {
+      return err(new Error(`config.models.${scene} must be a non-empty string (provider/model)`));
+    }
+    const ctx = `config.models.${scene}`;
+    const parsed = splitProviderModelRef(refRaw);
+    if (!parsed.ok) {
+      return err(new Error(`${ctx}: ${parsed.error}`));
+    }
+    if (!providerKeys.has(parsed.value.providerName)) {
+      return err(
+        new Error(
+          `${ctx}: unknown provider "${parsed.value.providerName}" (not listed under config.providers)`,
+        ),
+      );
+    }
+    models[scene] = refRaw;
+  }
+  if (!Object.hasOwn(models, "default")) {
+    registryNormalizeLog(
+      "Z2KP9NWQ",
+      'registry config: models mapping has no "default" key; scenes without explicit model mappings may fail at resolveModel',
+    );
+  }
+  return ok(models);
 }
 
 function normalizeWorkflowConfig(raw: unknown): Result<WorkflowConfig, Error> {
@@ -52,15 +110,24 @@ function normalizeWorkflowConfig(raw: unknown): Result<WorkflowConfig, Error> {
   }
   const c = raw as Record<string, unknown>;
   const maxDepth = c.maxDepth;
-  const extractRaw = c.extract;
+  const providersRaw = c.providers;
+  const modelsRaw = c.models;
   if (typeof maxDepth !== "number" || !Number.isInteger(maxDepth) || maxDepth < 0) {
     return err(new Error("config.maxDepth must be a non-negative integer"));
   }
-  const extractResult = normalizeExtractProviderConfig(extractRaw);
-  if (!extractResult.ok) {
-    return extractResult;
+  const providersResult = normalizeProviders(providersRaw);
+  if (!providersResult.ok) {
+    return providersResult;
   }
-  return ok({ maxDepth, extract: extractResult.value });
+  const modelsResult = normalizeModels(modelsRaw, providersResult.value);
+  if (!modelsResult.ok) {
+    return modelsResult;
+  }
+  return ok({
+    maxDepth,
+    providers: providersResult.value,
+    models: modelsResult.value,
+  });
 }
 
 export function normalizeWorkflowHistoryEntry(

packages/workflow/src/registry/types.ts

@@ -1,3 +1,5 @@
+import type { ProviderConfig } from "../config/index.js";
+
 export type WorkflowHistoryEntry = {
   hash: string;
   timestamp: number;
@@ -9,16 +11,10 @@ export type WorkflowRegistryEntry = {
   history: WorkflowHistoryEntry[];
 };
 
-/** LLM provider settings under `config.extract` in workflow.yaml (apiKey resolved after parse). */
-export type ExtractProviderConfig = {
-  baseUrl: string;
-  model: string;
-  apiKey: string;
-};
-
 export type WorkflowConfig = {
   maxDepth: number;
-  extract: ExtractProviderConfig;
+  providers: Record<string, ProviderConfig>;
+  models: Record<string, string>;
 };
 
 export type WorkflowRegistryFile = {

packages/workflow/src/types.ts

@@ -1,6 +1,7 @@
 import type * as z from "zod/v4";
 
 import type { CasStore } from "./cas/index.js";
+import type { ExtractFn } from "./extract/types.js";
 
 /** Sentinel values for automaton control flow. */
 export const START = "__start__" as const;
@@ -54,6 +55,10 @@ export type WorkflowFnOptions = {
   depth: number;
   /** Global CAS store for Merkle content blobs (role step bodies). */
   cas: CasStore;
+  /** Structured meta extraction; resolved from workflow.yaml `extract` scene by the engine. */
+  extract: ExtractFn;
+  /** Provider for `extractMode: "react"` roles; same backing config as `extract`. */
+  llmProvider: LlmProvider | null;
 };
 
 /** Bundle contract — named export `run` is a function returning an AsyncGenerator. */

packages/workflow/src/workflow-as-agent.ts

@@ -4,7 +4,7 @@ import { extractBundleExports } from "./bundle/index.js";
 import { createCasStore } from "./cas/index.js";
 import type { ExecuteThreadIo } from "./engine/index.js";
 import { executeThread } from "./engine/index.js";
-import { getWorkflowAsAgentMaxDepth } from "./extract-provider.js";
+import type { WorkflowConfig } from "./registry/index.js";
 import { getRegisteredWorkflow, readWorkflowRegistry } from "./registry/index.js";
 import type { AgentContext, AgentFn, ThreadInput } from "./types.js";
 import {
@@ -14,6 +14,15 @@ import {
   getGlobalCasDir,
 } from "./util/index.js";
 
+const DEFAULT_WORKFLOW_AS_AGENT_MAX_DEPTH = 3;
+
+function workflowAsAgentMaxDepth(config: WorkflowConfig | null): number {
+  if (config === null) {
+    return DEFAULT_WORKFLOW_AS_AGENT_MAX_DEPTH;
+  }
+  return config.maxDepth;
+}
+
 export type WorkflowAsAgentOptions = {
   /** When `null`, uses `getDefaultWorkflowStorageRoot()`. */
   storageRoot: string | null;
@@ -44,7 +53,7 @@ export function workflowAsAgent(
       return `ERROR: failed to read workflow registry: ${registryResult.error.message}`;
     }
 
-    const maxDepth = getWorkflowAsAgentMaxDepth(registryResult.value.config);
+    const maxDepth = workflowAsAgentMaxDepth(registryResult.value.config);
     if (nextDepth > maxDepth) {
       return `ERROR: workflow-as-agent depth limit exceeded (max ${maxDepth})`;
     }
@@ -92,6 +101,7 @@ export function workflowAsAgent(
           awaitAfterEachYield: async () => {},
           forkSourceThreadId: ctx.threadId,
           prefilledDiskSteps: null,
+          storageRoot,
         },
         io,
         logger,