chore: switch json-cas deps from file: to npm ^0.1.0

小橘 <xiaoju@shazhou.work>

.cards/_index.md

@@ -0,0 +1,35 @@
+# Uncaged Workflow Architecture
+
+Uncaged Workflow is a monorepo implementing a workflow engine that executes single-file ESM bundles. Each workflow is identified by an XXH64 hash (Crockford Base32); execution state is stored in a content-addressable store (CAS) as immutable Merkle nodes. Agents are pluggable — the same workflow definition runs with Cursor, Hermes, a raw LLM, or a ReAct loop.
+
+## Core Concepts
+
+| Card | Description |
+|------|-------------|
+| [Bundle](./bundle.md) | A single-file `.esm.js` module with an XXH64 hash identity, stored in `~/.uncaged/workflow/bundles/` |
+| [Thread](./thread.md) | A single execution instance of a workflow, identified by a ULID, with CAS-linked state nodes |
+| [CAS](./cas.md) | The content-addressable store that holds all immutable blobs — content, start nodes, and state nodes |
+| [Registry](./registry.md) | `workflow.yaml` — maps workflow names to current and historical bundle hashes |
+
+## Execution
+
+| Card | Description |
+|------|-------------|
+| [Engine](./engine.md) | The three-phase loop that drives the workflow `AsyncGenerator` and writes each step to CAS |
+| [Role](./role.md) | A named actor defined as pure data (`RoleDefinition`) — description, system prompt, and Zod schema |
+| [Agent Binding](./agent-binding.md) | The runtime binding that connects a role to a concrete agent implementation via `AdapterFn` |
+| [Reactor](./reactor.md) | The ReAct loop abstraction for LLM function-calling, used by both the extract phase and agent adapters |
+
+## Tooling
+
+| Card | Description |
+|------|-------------|
+| [CLI](./cli.md) | The `uncaged-workflow` command-line tool for managing workflows, threads, and CAS |
+| [Dashboard](./dashboard.md) | A private React app for inspecting threads, workflows, and live execution via the gateway |
+| [Package Map](./package-map.md) | All packages in the monorepo with their layer positions and dependency graph |
+
+## Authoring
+
+| Card | Description |
+|------|-------------|
+| [Workflow Templates](./workflow-templates.md) | The `solve-issue` and `develop` reference templates and how to author custom workflows |

.cards/agent-binding.md

@@ -0,0 +1,104 @@
+# Agent Binding
+
+> The runtime connection between a workflow's role definitions and a concrete agent implementation, expressed as an `AdapterBinding` passed to `createWorkflow`.
+
+## Overview
+
+Agent binding is how a workflow author specifies which agent executes each role. Roles are pure data (see [Role](./role.md)); the binding supplies the execution strategy. The same `WorkflowDefinition` can be run with different agents by changing the `AdapterBinding` — useful for testing, cost optimization, or environment-specific deployment.
+
+An `AdapterFn` receives a role's `systemPrompt` and Zod `schema`, and returns a `RoleFn` — a function that takes `ThreadContext` and `WorkflowRuntime` and returns `RoleResult<T>`. The adapter is responsible for producing typed structured output directly; there is no separate extract phase when using adapters.
+
+## Key Types
+
+```typescript
+// The core adapter interface
+type AdapterFn = <T>(prompt: string, schema: z.ZodType<T>) => RoleFn<T>;
+
+type RoleFn<T> = (ctx: ThreadContext, runtime: WorkflowRuntime) => Promise<RoleResult<T>>;
+
+type RoleResult<T> = { meta: T; childThread: string | null };
+
+// The binding passed to createWorkflow
+type AdapterBinding = {
+  adapter: AdapterFn;
+  overrides: Partial<Record<string, AdapterFn>> | null;
+};
+```
+
+`overrides` allows per-role adapters — for example, using Cursor for one role and an LLM for another within the same workflow.
+
+## AgentFn (Legacy / Low-level)
+
+Below the adapter layer, the original `AgentFn` type still exists for agent implementations that produce raw strings rather than structured output:
+
+```typescript
+type AgentFn<Opt = void> = Opt extends void
+  ? (ctx: ThreadContext) => Promise<string>
+  : (ctx: ThreadContext, options: Opt) => Promise<string>;
+```
+
+The `createAgentAdapter` utility in `@uncaged/workflow-util-agent` wraps an `AgentFn` into an `AdapterFn` by composing it with extraction logic.
+
+## Concrete Implementations
+
+| Package | Export | Agent |
+|---------|--------|-------|
+| `@uncaged/workflow-agent-cursor` | `createCursorAgent` | Runs `cursor` CLI non-interactively in a workspace directory |
+| `@uncaged/workflow-agent-hermes` | `createHermesAgent` | Runs `hermes chat` with `--yolo --quiet` (Nerve-style argv) |
+| `@uncaged/workflow-agent-llm` | `createLlmAdapter` | Direct LLM completion via the OpenAI-compatible chat endpoint |
+| `@uncaged/workflow-agent-react` | `createReactAdapter` | ReAct loop with file and shell tools (read, write, patch, exec) |
+
+All four return an `AdapterFn` suitable for use in `AdapterBinding.adapter`.
+
+## workflow-util-agent
+
+`@uncaged/workflow-util-agent` provides two helpers shared by adapter implementations:
+
+- **`buildThreadInput(ctx)`** — constructs the user-message string from thread context (task, previous steps, tool hints). Used by all CLI-based agents.
+- **`spawnCli(command, args, opts)`** — spawns an external process (e.g., `cursor`, `hermes`) and captures stdout, with optional timeout.
+- **`createAgentAdapter(agentFn, optionsFn)`** — wraps an `AgentFn<Opt>` into an `AdapterFn`, handling the options extraction step.
+
+## Cursor Agent
+
+`createCursorAgent(config)` invokes the `cursor` CLI binary:
+
+```
+cursor -p <fullPrompt> --model <model> --workspace <path> --output-format text --trust --force
+```
+
+The workspace path is taken from `config.workspace` or extracted from the thread context via `runtime.extract`.
+
+## Hermes Agent
+
+`createHermesAgent(config)` invokes `hermes chat`:
+
+```
+hermes chat -q <fullPrompt> --yolo --max-turns 90 --quiet [--model <model>]
+```
+
+## LLM Adapter
+
+`createLlmAdapter(provider)` calls the OpenAI-compatible chat completions endpoint directly. It builds a two-message conversation (system + user) from the role's `systemPrompt` and `buildThreadInput` output, then extracts structured output from the response.
+
+## React Adapter
+
+`createReactAdapter(config)` creates a ReAct loop agent with four default tools: `read_file`, `write_file`, `patch_file`, and `shell_exec`. The loop continues until the agent calls the structured extraction tool or until `maxRounds` is exceeded.
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-protocol` | `src/types.ts` | `AdapterFn`, `AdapterBinding`, `RoleFn`, `RoleResult`, `AgentFn` |
+| `@uncaged/workflow-runtime` | `src/create-workflow.ts` | `createWorkflow` — dispatches `adapterForRole` each iteration |
+| `@uncaged/workflow-util-agent` | `src/build-agent-prompt.ts` | `buildThreadInput`, `buildAgentPrompt` |
+| `@uncaged/workflow-util-agent` | `src/spawn-cli.ts` | `spawnCli` — subprocess runner with timeout |
+| `@uncaged/workflow-util-agent` | `src/create-agent-adapter.ts` | `createAgentAdapter` — wraps `AgentFn` into `AdapterFn` |
+| `@uncaged/workflow-agent-cursor` | `src/index.ts` | `createCursorAgent` |
+| `@uncaged/workflow-agent-hermes` | `src/index.ts` | `createHermesAgent` |
+| `@uncaged/workflow-agent-llm` | `src/create-llm-adapter.ts` | `createLlmAdapter` |
+| `@uncaged/workflow-agent-react` | `src/create-react-adapter.ts` | `createReactAdapter` |
+
+## See Also
+
+- [Role](./role.md) — the pure data that the binding executes
+- [Engine](./engine.md) — the loop that invokes the bound adapter each step

.cards/bundle.md

@@ -0,0 +1,83 @@
+# Bundle
+
+> A self-contained single-file ESM module (`.esm.js`) that implements one workflow, identified by its XXH64 hash encoded as 13-char Crockford Base32.
+
+## Overview
+
+A bundle is the physical unit of workflow distribution. Workflow authors build their TypeScript source into a single ESM file using `bun build` with `@uncaged/*` packages as externals. The resulting `.esm.js` is the artifact that gets registered and executed.
+
+Every bundle is immutable and content-addressed: its identity is the XXH64 hash of its bytes, encoded as 13 characters of Crockford Base32 (e.g., `3TNKQRJ7BM4XH`). Registering a bundle with a new version simply adds a new hash entry; old hashes stay in the registry history and remain valid.
+
+Bundles are stored on disk at `~/.uncaged/workflow/bundles/<hash>/` after registration. The `cas/` and `threads.json` for that bundle's execution state live under the same directory.
+
+## Exports
+
+Every valid bundle must export exactly two named exports — no default export is permitted:
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `run` | `WorkflowFn` | The `AsyncGenerator` that drives the execution loop |
+| `descriptor` | `WorkflowDescriptor` | Serializable metadata: description, roles, and routing graph |
+
+```typescript
+// Minimal bundle shape
+export const run: WorkflowFn = createWorkflow(def, binding);
+export const descriptor: WorkflowDescriptor = buildDescriptor(def);
+```
+
+The validator in `@uncaged/workflow-register` enforces this contract before a bundle can be registered — see `extractBundleExports`.
+
+## Hash Algorithm
+
+The bundle hash is computed with **XXH64** (seed 0) over the raw bytes of the `.esm.js` file, then encoded as 13-char Crockford Base32 using `encodeUint64AsCrockford`:
+
+```typescript
+// packages/workflow-cas/src/hash.ts
+export function hashWorkflowBundleBytes(data: Uint8Array): string {
+  const buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  const digest = XXH.h64(0).update(buf).digest();
+  return encodeUint64AsCrockford(digestToUint64(digest));
+}
+```
+
+The same algorithm hashes CAS blob content (`hashString`), so all IDs in the system are consistent Crockford Base32 strings.
+
+## Build Process
+
+Bundles are not distributed from the monorepo directly. The typical flow is:
+
+1. Create a separate workspace (e.g., `my-workflows/`) with `@uncaged/workflow-runtime` as a dependency.
+2. Write a TypeScript workflow module that imports `createWorkflow` from `@uncaged/workflow-runtime`.
+3. Run `bun build --entrypoints src/my-workflow.ts --outfile dist/my-workflow.esm.js --format esm --external '@uncaged/*'`.
+4. Register with `uncaged-workflow workflow add <name> dist/my-workflow.esm.js`.
+
+## Storage Layout
+
+```
+~/.uncaged/workflow/
+  workflow.yaml                     # registry (name → hash mapping)
+  bundles/
+    <hash>/
+      threads.json                  # active thread index
+      history/
+        YYYY-MM-DD.jsonl            # completed thread records
+  cas/
+    <hash>.txt                      # CAS blobs (all bundles share one global CAS)
+```
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-cas` | `src/hash.ts` | `hashWorkflowBundleBytes` and `hashString` — XXH64 + Crockford encoding |
+| `@uncaged/workflow-register` | `src/bundle/extract-bundle-exports.ts` | Loads a `.esm.js` bundle and validates `run` + `descriptor` |
+| `@uncaged/workflow-register` | `src/bundle/bundle-validator.ts` | Schema validation of bundle exports |
+| `@uncaged/workflow-runtime` | `src/create-workflow.ts` | `createWorkflow` — the primary bundle authoring function |
+| `@uncaged/workflow-util` | `src/base32.ts` | `encodeUint64AsCrockford` — Crockford Base32 encoding |
+| `@uncaged/workflow-util` | `src/storage-root.ts` | `getDefaultWorkflowStorageRoot` → `~/.uncaged/workflow` |
+
+## See Also
+
+- [Registry](./registry.md) — how bundles are registered and named in `workflow.yaml`
+- [Thread](./thread.md) — how a bundle's `run` export is executed as a thread
+- [Engine](./engine.md) — the executor that drives the bundle's `AsyncGenerator`

.cards/cas.md

@@ -0,0 +1,111 @@
+# CAS (Content-Addressable Storage)
+
+> An append-only store where every blob is identified by its XXH64 hash, used to persist all workflow thread state as immutable Merkle nodes.
+
+## Overview
+
+CAS is the persistence substrate for the entire workflow engine. Rather than mutating a database row, every piece of state — agent output, role metadata, thread start parameters — is serialized as a YAML blob and stored under its hash. Because content determines identity, the same content always maps to the same hash, and writes are idempotent.
+
+The `CasStore` interface is intentionally simple: `put`, `get`, `delete`, `list`. The default filesystem implementation stores each blob as `<hash>.txt` under `~/.uncaged/workflow/cas/`. Writes use an atomic rename-from-tmp pattern to prevent partial writes.
+
+## Hash Algorithm
+
+All hashes in the system are **XXH64** (seed 0) over UTF-8 content, encoded as 13-char Crockford Base32. This applies to both CAS blob hashes and bundle file hashes. The encoding function `encodeUint64AsCrockford` lives in `@uncaged/workflow-util`.
+
+## Node Types
+
+The CAS holds three types of YAML nodes, all sharing the `{ type, payload, refs }` envelope:
+
+### `content` node
+Stores the raw text output of an agent or the initial prompt. `refs` lists any artifact hashes the content references.
+
+```yaml
+type: content
+payload: "The implementation is complete. Changed files: src/foo.ts"
+refs:
+  - 3TNKQRJ7BM4XH   # optional artifact refs
+```
+
+### `start` node
+Written once when a thread begins. Anchors the thread to a specific workflow name, bundle hash, and depth level.
+
+```yaml
+type: start
+payload:
+  name: solve-issue
+  hash: 3TNKQRJ7BM4XH
+  depth: 0
+  parentState: null
+refs:
+  - <promptHash>
+```
+
+### `state` node
+Written once per completed role step. Points back to the `start` node, the role's content node, and maintains an ancestor skip-list for traversal.
+
+```yaml
+type: state
+payload:
+  role: coder
+  meta: { status: "done", completedPhase: "..." }
+  start: <startHash>
+  content: <contentHash>
+  ancestors: [<prev_state>, ...]
+  compact: null
+  timestamp: 1716000000000
+  childThread: null
+refs:
+  - <contentHash>
+  - <startHash>
+  - <ancestor hashes>
+```
+
+## Merkle Structure
+
+The `ancestors` array in each `StateNode` implements a **skip-list** capped at 11 entries (1 direct parent + up to 10 skip-list ancestors). This allows `O(log n)` traversal of the chain without loading every node, while keeping each blob self-contained.
+
+```mermaid
+graph LR
+    S[StartNode] --> C1[content₁]
+    N1[StateNode₁] --> S
+    N1 --> C1
+    N2[StateNode₂] --> N1
+    N2 --> S
+    N2 --> C2[content₂]
+    END[StateNode __end__] --> N2
+    END --> S
+```
+
+## CasStore Interface
+
+```typescript
+type CasStore = {
+  put(content: string): Promise<string>;    // returns hash
+  get(hash: string): Promise<string | null>;
+  delete(hash: string): Promise<void>;
+  list(): Promise<string[]>;
+};
+```
+
+`put` normalizes raw strings into `content` Merkle nodes before hashing; pre-serialized RFC v3 nodes pass through unchanged.
+
+## Garbage Collection
+
+`cas gc` performs a mark-and-sweep over all CAS blobs. It seeds the reachable set from `head` and `start` hashes in every `threads.json` and `history/*.jsonl`, then traverses `refs` edges transitively. Unreachable blobs are deleted. The result reports `scannedThreads`, `activeRefs`, and `deletedEntries`.
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-protocol` | `src/types.ts` | `CasStore` interface definition |
+| `@uncaged/workflow-protocol` | `src/cas-types.ts` | `StartNode`, `StateNode`, `ContentMerkleNode` types |
+| `@uncaged/workflow-cas` | `src/cas.ts` | `createCasStore` — filesystem implementation |
+| `@uncaged/workflow-cas` | `src/hash.ts` | `hashString`, `hashWorkflowBundleBytes` — XXH64 + Crockford |
+| `@uncaged/workflow-cas` | `src/nodes.ts` | `putStartNode`, `putStateNode`, `putContentNodeWithRefs`, `parseCasThreadNode` |
+| `@uncaged/workflow-cas` | `src/merkle.ts` | `parseMerkleNode`, `serializeMerkleNode`, `getContentMerklePayload` |
+| `@uncaged/workflow-cas` | `src/reachable.ts` | Reachability traversal for GC |
+| `@uncaged/workflow-execute` | `src/engine/gc.ts` | GC orchestration |
+
+## See Also
+
+- [Thread](./thread.md) — how thread execution state maps to CAS nodes

.cards/cli.md

@@ -0,0 +1,107 @@
+# CLI
+
+> `uncaged-workflow` — the command-line tool for registering bundles, running threads, inspecting CAS, and connecting to the gateway.
+
+## Overview
+
+The CLI (`@uncaged/cli-workflow`) is the primary human interface to the workflow engine. It is a multi-level command dispatcher: top-level command groups (`workflow`, `thread`, `cas`, `init`, `setup`) each have a set of subcommands. Two shortcuts (`run`, `live`) alias frequently-used subcommands.
+
+The storage root defaults to `~/.uncaged/workflow` and can be overridden with `WORKFLOW_STORAGE_ROOT` or `UNCAGED_WORKFLOW_STORAGE_ROOT` environment variables.
+
+## Command Reference
+
+### Workflow Registry (`workflow`)
+
+| Subcommand | Args | Description |
+|-----------|------|-------------|
+| `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 bundle hash, timestamp, and descriptor |
+| `workflow rm` | `<name>` | Remove a workflow from the registry |
+| `workflow history` | `<name>` | Show version history for a workflow |
+| `workflow rollback` | `<name> [hash]` | Roll back to a previous version |
+
+### Thread Execution (`thread`)
+
+| Subcommand | Args | Description |
+|-----------|------|-------------|
+| `thread run` | `<name> [--prompt <text>]` | Start a new thread for a workflow; prints thread ID |
+| `thread list` | `[name]` | List threads, optionally filtered by workflow name |
+| `thread show` | `<id>` | Show thread steps and state from CAS |
+| `thread rm` | `<id>` | Remove a thread (from index and history) |
+| `thread fork` | `<thread-id> [--from-role <role>]` | Fork from an existing thread |
+| `thread ps` | | List running (active) threads |
+| `thread kill` | `<thread-id>` | Send kill signal to a running thread |
+| `thread live` | `<thread-id> \| --latest [--debug] [--role <name>]` | Attach and stream output live |
+| `thread pause` | `<thread-id>` | Pause a running thread |
+| `thread resume` | `<thread-id>` | Resume a paused thread |
+
+### CAS Inspection (`cas`)
+
+| Subcommand | Args | Description |
+|-----------|------|-------------|
+| `cas get` | `<hash>` | Print a CAS blob by hash |
+| `cas put` | `<content>` | Store content in CAS, print hash |
+| `cas list` | | List all hashes in CAS |
+| `cas rm` | `<hash>` | Remove a CAS entry |
+| `cas gc` | | Garbage-collect unreferenced entries |
+
+### Other Commands
+
+| Command | Args | Description |
+|---------|------|-------------|
+| `run <name> [...]` | | Shortcut for `thread run` |
+| `live <id> [...]` | | Shortcut for `thread live` |
+| `init` | | Scaffold a workflow workspace |
+| `setup` | | Configure LLM providers in `workflow.yaml` |
+| `connect [--name NAME] [--gateway URL]` | | Connect to gateway via WebSocket |
+| `skill [topic]` | | Print agent-consumable docs (`cli`, `develop`, `author`) |
+
+## Common Usage Examples
+
+```bash
+# Register a bundle
+uncaged-workflow workflow add solve-issue dist/solve-issue.esm.js
+
+# Run a workflow (prints thread ID)
+uncaged-workflow run solve-issue --prompt "Fix the login bug in auth.ts"
+
+# Watch live output
+uncaged-workflow live <thread-id>
+
+# Inspect a CAS blob
+uncaged-workflow cas get 3TNKQRJ7BM4XH
+
+# Show all running threads
+uncaged-workflow thread ps
+
+# Garbage-collect
+uncaged-workflow cas gc
+
+# Roll back to previous version
+uncaged-workflow workflow rollback solve-issue
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `WORKFLOW_STORAGE_ROOT` | Override storage directory (default: `~/.uncaged/workflow`) |
+| `UNCAGED_WORKFLOW_STORAGE_ROOT` | Internal override; takes priority over `WORKFLOW_STORAGE_ROOT` |
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/cli-workflow` | `src/cli-dispatch.ts` | Top-level command router (`COMMAND_TABLE`) |
+| `@uncaged/cli-workflow` | `src/cli-usage.ts` | Usage text formatting |
+| `@uncaged/cli-workflow` | `src/commands/workflow/dispatch.ts` | `WORKFLOW_SUBCOMMAND_TABLE` |
+| `@uncaged/cli-workflow` | `src/commands/thread/dispatch.ts` | `THREAD_SUBCOMMAND_TABLE` |
+| `@uncaged/cli-workflow` | `src/commands/cas/dispatch.ts` | `CAS_SUBCOMMAND_TABLE` |
+| `@uncaged/cli-workflow` | `src/cli.ts` | CLI entry point |
+
+## See Also
+
+- [Bundle](./bundle.md) — what `workflow add` registers
+- [Thread](./thread.md) — what `thread run` creates
+- [Registry](./registry.md) — the `workflow.yaml` that `workflow` commands manage

.cards/dashboard.md

@@ -0,0 +1,74 @@
+# Dashboard
+
+> A private React single-page application for browsing workflows, inspecting thread execution records, and triggering runs via a connected gateway.
+
+## Overview
+
+The dashboard (`workflow-dashboard`) is a read-mostly web UI that surfaces thread history and workflow metadata. It is a private package (not published to npm) and is deployed separately from the CLI. It communicates with one or more remote workflow engine instances through the `workflow-gateway` WebSocket gateway, which proxies API calls back to each connected CLI client.
+
+The dashboard is not required to use the workflow engine — it is an optional observability layer on top of the same data that the CLI exposes.
+
+## Tech Stack
+
+| Concern | Choice |
+|---------|--------|
+| Framework | React (functional components, hooks) |
+| Build | Vite |
+| Styling | CSS variables via Tailwind-compatible utility classes |
+| Charts/graphs | ReactFlow (workflow graph visualization) |
+| HTTP | Native `fetch` with Bearer token auth |
+| Transport | REST over HTTP (proxied through the gateway) |
+
+## Data Sources
+
+The dashboard consumes four REST endpoints per connected client (proxied by the gateway):
+
+| Endpoint | Data |
+|----------|------|
+| `GET /workflows` | List of registered workflows with current hash and timestamp |
+| `GET /workflows/:name` | Full workflow detail including `WorkflowDescriptor` and version history |
+| `GET /threads` | All threads (active + completed) with summary fields |
+| `GET /threads/:id` | Thread records: `ThreadStartRecord`, `RoleRecord[]`, `WorkflowResultRecord` |
+
+The gateway multiplexes multiple CLI clients; the sidebar allows switching between them.
+
+## Views
+
+| View | Description |
+|------|-------------|
+| **Workflows** | Lists all registered workflows; clicking shows hash, descriptor, role graph, and version history |
+| **Threads** | Lists all threads; clicking shows the full step-by-step execution record with role metadata |
+| **Run dialog** | Form to start a new thread by picking a workflow and entering a prompt |
+
+### Workflow Graph
+
+Each workflow's `WorkflowDescriptor.graph` is rendered as an interactive ReactFlow diagram. Nodes represent roles (plus `__start__` and `__end__` terminals); edges represent moderator transitions labeled with condition names.
+
+## Authentication
+
+A Bearer token (stored in `localStorage` under `workflow-api-key`) is sent with every API request. The login page prompts for this key on first load. The gateway validates the token before proxying requests to connected clients.
+
+## Gateway Connection
+
+`uncaged-workflow connect [--name NAME] [--gateway URL]` registers the local workflow engine as a named client with the gateway over a WebSocket. The gateway then forwards REST API calls from the dashboard to the connected CLI process. The dashboard calls `GET /api/gateway/endpoints` to discover connected clients.
+
+## Private App Status
+
+`workflow-dashboard` has `"private": true` in its `package.json` and is excluded from the changeset versioning pipeline. It is developed alongside the engine packages but distributed separately (e.g., as a static build hosted alongside the gateway server).
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `workflow-dashboard` | `src/app.tsx` | Root component — routing, auth state, view switching |
+| `workflow-dashboard` | `src/api.ts` | All API functions + endpoint types (`ThreadRecord`, `WorkflowDetail`, etc.) |
+| `workflow-dashboard` | `src/components/thread-detail.tsx` | Thread step viewer |
+| `workflow-dashboard` | `src/components/workflow-graph/workflow-graph.tsx` | ReactFlow graph of workflow roles and transitions |
+| `workflow-dashboard` | `src/components/sidebar.tsx` | Client selector and view navigation |
+| `@uncaged/workflow-gateway` | `src/index.ts` | Gateway server entry point |
+| `@uncaged/workflow-gateway` | `src/ws-protocol.ts` | WebSocket message protocol between CLI and gateway |
+
+## See Also
+
+- [Thread](./thread.md) — the execution records the dashboard displays
+- [Engine](./engine.md) — the process that produces those records

.cards/engine.md

@@ -0,0 +1,110 @@
+# Engine
+
+> The execution loop that drives a workflow bundle's `AsyncGenerator`, persisting each yielded `RoleOutput` as a CAS `StateNode` and managing thread lifecycle.
+
+## Overview
+
+The engine (`executeThread`) takes a `WorkflowFn` and runs it to completion. It is responsible for three concerns: persisting each role output to CAS, updating the active-thread index after every step, and terminating the thread cleanly when the generator finishes, is aborted, or is killed by the supervisor.
+
+The engine does not interact with LLMs directly — that responsibility belongs to the workflow bundle's `run` function and its bound agent adapters. The engine only observes `RoleOutput` values yielded by the generator.
+
+## Execution Flow
+
+```mermaid
+flowchart TD
+    A[executeThread] --> B[putStartNode → CAS]
+    B --> C[publishHead → threads.json]
+    C --> D{generator.next}
+    D -- done --> E[finalizeThread]
+    D -- yield RoleOutput --> F[appendStateForStep → CAS]
+    F --> G[publishHead → threads.json]
+    G --> H{supervisorInterval?}
+    H -- kill --> E
+    H -- continue --> I{awaitAfterEachYield}
+    I --> D
+    D -- AbortSignal --> J[finalizeAbortedThread]
+    E --> K[removeThreadEntry]
+    K --> L[appendThreadHistoryEntry]
+```
+
+## Role Loop (inside the bundle's `createWorkflow`)
+
+The `WorkflowFn` produced by `createWorkflow` runs its own loop — one iteration per role step:
+
+1. **Moderator**: calls `pickNext(ctx)` (derived from the `ModeratorTable`) → returns a role name or `END`.
+2. **Adapter**: calls the bound `AdapterFn` with the role's `systemPrompt` and Zod schema → returns `RoleFn` → executes → returns `RoleResult<T>`.
+3. **Persist**: calls `putContentNodeWithRefs` to store the role output in CAS, constructs a `RoleStep`, and `yield`s a `RoleOutput` to the engine.
+
+```mermaid
+sequenceDiagram
+    participant E as Engine
+    participant W as WorkflowFn (bundle)
+    participant M as Moderator
+    participant A as AdapterFn
+    participant C as CAS
+
+    E->>W: generator.next()
+    W->>M: pickNext(ctx) → roleName
+    W->>A: adapter(systemPrompt, schema)(ctx, runtime)
+    A-->>W: RoleResult { meta, childThread }
+    W->>C: putContentNodeWithRefs(JSON.stringify(meta))
+    W-->>E: yield RoleOutput
+    E->>C: putStateNode(StateNodePayload)
+    E->>E: publishHead(threads.json)
+```
+
+## Key Types
+
+```typescript
+// Engine input
+type ExecuteThreadOptions = {
+  depth: number;
+  parentStateHash: string | null;
+  signal: AbortSignal;
+  awaitAfterEachYield: () => Promise<void>;  // used for pause/resume gate
+  forkContinuation: ForkContinuationOptions | null;
+  prefilledDiskSteps: PrefilledDiskStep[] | null;
+  replayTimestamps: readonly number[] | null;
+  storageRoot: string;
+};
+
+// Engine output
+type WorkflowResult = {
+  returnCode: number;
+  summary: string;
+  rootHash: string;   // hash of the __end__ StateNode
+};
+```
+
+## Pause Gate
+
+`awaitAfterEachYield` is a function injected by the worker/runner that can block the loop between steps. The `ThreadPauseGate` in `thread-pause-gate.ts` provides `pause()` / `resume()` operations that control this gate. When paused, the loop suspends after writing the current step but before requesting the next one.
+
+## Supervisor
+
+If `workflowConfig.supervisorInterval > 0`, the engine runs a supervisor check after every `supervisorInterval` steps. The supervisor calls an LLM with a summary of recent steps and returns `"continue"` or `"kill"`. A `"kill"` decision finalizes the thread immediately with `returnCode: 1` and a summary string.
+
+## Summarizer
+
+On normal completion (generator returns), the engine calls `createSummarizer` to produce a single LLM-generated summary string from recent step content. This summary replaces the bundle's raw `WorkflowCompletion.summary` in the final history record.
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-execute` | `src/engine/engine.ts` | `executeThread` — main engine entry point |
+| `@uncaged/workflow-execute` | `src/engine/types.ts` | `ExecuteThreadOptions`, `ExecuteThreadIo`, `ChainState`, `ThreadPauseGate` |
+| `@uncaged/workflow-execute` | `src/engine/threads-index.ts` | `threads.json` persistence, history append |
+| `@uncaged/workflow-execute` | `src/engine/supervisor.ts` | Supervisor LLM check (`"continue"` / `"kill"`) |
+| `@uncaged/workflow-execute` | `src/engine/summarizer.ts` | Post-completion LLM summary |
+| `@uncaged/workflow-execute` | `src/engine/thread-pause-gate.ts` | Pause/resume gate |
+| `@uncaged/workflow-execute` | `src/engine/worker.ts` | Worker-process entry that spawns `executeThread` in a subprocess |
+| `@uncaged/workflow-runtime` | `src/create-workflow.ts` | `createWorkflow` — the role loop inside the bundle |
+| `@uncaged/workflow-protocol` | `src/types.ts` | `WorkflowFn`, `RoleOutput`, `WorkflowCompletion`, `AdvanceOutcome` |
+
+## See Also
+
+- [Role](./role.md) — what the moderator selects each iteration
+- [Agent Binding](./agent-binding.md) — what executes a role and returns its output
+- [Reactor](./reactor.md) — used internally for the extract and supervisor LLM calls
+- [Thread](./thread.md) — the CAS-persisted result of running the engine

.cards/package-map.md

@@ -0,0 +1,129 @@
+# Package Map
+
+> All packages in the monorepo with their responsibilities, dependency layers, and publication status.
+
+## Overview
+
+The monorepo is organized as a strict dependency DAG. Each layer may only depend on layers below it. The execution stack flows from the shared protocol types at the bottom up to the CLI at the top. Agent packages and template packages are leaf nodes that depend on the runtime layer but are not depended upon by the core stack.
+
+## Package List
+
+| Package | Description |
+|---------|-------------|
+| `@uncaged/workflow-protocol` | Shared types (`ThreadContext`, `RoleDefinition`, `CasStore`, `Result`, etc.) and constants (`START`, `END`) |
+| `@uncaged/workflow-runtime` | `createWorkflow`, type re-exports; primary dependency for bundle authors |
+| `@uncaged/workflow-util` | Utilities: Crockford Base32, ULID, structured logger, storage paths |
+| `@uncaged/workflow-reactor` | `createThreadReactor` (ReAct loop), `createLlmFn` (OpenAI-compatible LLM caller) |
+| `@uncaged/workflow-cas` | `createCasStore` (filesystem CAS), XXH64 hashing, Merkle node serialization |
+| `@uncaged/workflow-register` | Bundle validation, `workflow.yaml` registry read/write, model resolution |
+| `@uncaged/workflow-execute` | Engine (`executeThread`), extract phase, fork, GC, `workflowAsAgent` |
+| `@uncaged/cli-workflow` | `uncaged-workflow` CLI — command dispatcher for all user-facing operations |
+| `@uncaged/workflow-agent-cursor` | Adapter that runs the `cursor` CLI non-interactively in a workspace |
+| `@uncaged/workflow-agent-hermes` | Adapter that runs `hermes chat` (Nerve-style CLI agent) |
+| `@uncaged/workflow-agent-llm` | Adapter for direct LLM chat completions |
+| `@uncaged/workflow-agent-react` | Adapter with ReAct loop and file/shell tools |
+| `@uncaged/workflow-util-agent` | Shared agent utilities: `buildThreadInput`, `spawnCli`, `createAgentAdapter` |
+| `@uncaged/workflow-template-develop` | `develop` workflow template (planner → coder → reviewer → tester → committer) |
+| `@uncaged/workflow-template-solve-issue` | `solve-issue` workflow template (preparer → developer → submitter) |
+| `@uncaged/workflow-gateway` | WebSocket gateway for remote CLI-to-dashboard communication |
+| `workflow-dashboard` | React dashboard (private, unpublished) — thread/workflow viewer |
+
+## Dependency Layer Diagram
+
+```mermaid
+graph TD
+    subgraph Layer 0 — Protocol
+        P[workflow-protocol]
+    end
+
+    subgraph Layer 1 — Foundations
+        RT[workflow-runtime]
+        UT[workflow-util]
+        RX[workflow-reactor]
+    end
+
+    subgraph Layer 2 — Storage & Register
+        CAS[workflow-cas]
+        REG[workflow-register]
+    end
+
+    subgraph Layer 3 — Execute
+        EX[workflow-execute]
+    end
+
+    subgraph Layer 4 — CLI
+        CLI[cli-workflow]
+    end
+
+    subgraph Agents (leaf)
+        AGC[workflow-agent-cursor]
+        AGH[workflow-agent-hermes]
+        AGL[workflow-agent-llm]
+        AGR[workflow-agent-react]
+        UA[workflow-util-agent]
+    end
+
+    subgraph Templates (leaf)
+        TD[workflow-template-develop]
+        TS[workflow-template-solve-issue]
+    end
+
+    subgraph Dashboard
+        GW[workflow-gateway]
+        DB[workflow-dashboard]
+    end
+
+    RT --> P
+    UT --> P
+    RX --> P
+    CAS --> P
+    REG --> P
+    REG --> UT
+    EX --> RT
+    EX --> UT
+    EX --> CAS
+    EX --> REG
+    EX --> RX
+    CLI --> EX
+    CLI --> UT
+    CLI --> REG
+    AGC --> RT
+    AGC --> UT
+    AGC --> UA
+    AGH --> RT
+    AGH --> UA
+    AGL --> RT
+    AGR --> RT
+    AGR --> RX
+    UA --> RT
+    TD --> RT
+    TS --> RT
+    DB --> GW
+```
+
+## Published vs. Private
+
+All `@uncaged/*` packages are published to **npmjs.org** under a fixed versioning scheme (all packages share the same version number via `@changesets/cli` in fixed mode).
+
+| Status | Packages |
+|--------|---------|
+| **Published** | All packages with `@uncaged/` scope |
+| **Private** | `workflow-dashboard` (no `@uncaged/` scope, `"private": true`) |
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-protocol` | `src/types.ts` | Root type definitions for the entire stack |
+| `@uncaged/workflow-runtime` | `src/index.ts` | Public API for bundle authors |
+| `@uncaged/workflow-util` | `src/index.ts` | Utility re-exports |
+| `@uncaged/workflow-execute` | `src/index.ts` | Engine public API |
+| `@uncaged/cli-workflow` | `src/cli-dispatch.ts` | Top-level command table |
+
+## See Also
+
+- [Bundle](./bundle.md) — produced by workspace authors using `@uncaged/workflow-runtime`
+- [Engine](./engine.md) — the core of `@uncaged/workflow-execute`
+- [Reactor](./reactor.md) — `@uncaged/workflow-reactor`
+- [Registry](./registry.md) — `@uncaged/workflow-register`
+- [CLI](./cli.md) — `@uncaged/cli-workflow`

.cards/reactor.md

@@ -0,0 +1,102 @@
+# Reactor
+
+> A generic ReAct (Reason + Act) loop that drives an LLM through multiple tool-call rounds until it produces structured output matching a Zod schema.
+
+## Overview
+
+The reactor is a reusable abstraction for LLM interactions that require tool use. It runs a multi-turn conversation loop: the LLM is presented with a user message and a set of tools, and responds either with a tool call (which the reactor dispatches and feeds back) or with a plain JSON object matching the expected schema. The loop repeats until structured output is obtained or `maxRounds` is exhausted.
+
+The reactor is used in two places:
+
+1. **Extract phase** — `createExtract` in `@uncaged/workflow-execute` uses a CAS-backed reactor to extract typed `meta` from a role's content hash.
+2. **React agent** — `createReactAdapter` in `@uncaged/workflow-agent-react` uses the reactor as its execution backbone.
+
+## createThreadReactor
+
+```typescript
+function createThreadReactor<TThread>(
+  config: ThreadReactorConfig<TThread>,
+): ThreadReactorFn<TThread>
+```
+
+`ThreadReactorConfig` bundles:
+
+| Field | Purpose |
+|-------|---------|
+| `llm` | The `LlmFn` to call each round |
+| `staticTools` | Tools always available (e.g., `cas_get`) |
+| `structuredToolFromSchema` | Derives a schema-specific extraction tool from the Zod schema |
+| `systemPromptForStructuredTool` | Constructs the system prompt given the extraction tool name |
+| `toolHandler` | Handles non-structured tool calls; receives the raw `ToolCall` and thread context |
+| `maxRounds` | Hard stop after N rounds; returns `err("max_react_rounds_exceeded")` |
+
+## Round Lifecycle
+
+```mermaid
+sequenceDiagram
+    participant R as Reactor
+    participant L as LLM
+    participant H as toolHandler
+
+    R->>L: messages + tools
+    L-->>R: response
+
+    alt plain JSON (valid schema)
+        R-->>R: return ok(value)
+    else plain JSON (invalid)
+        R->>L: correction message
+    else tool_calls
+        loop each call
+            alt structured tool
+                R-->>R: validate args → return ok(value)
+            else static tool
+                R->>H: toolHandler(call, thread)
+                H-->>R: content string
+                R->>L: tool result message
+            end
+        end
+    end
+```
+
+## LlmFn
+
+```typescript
+type LlmFn = (input: {
+  messages: ChatMessage[];
+  tools: readonly ToolDefinition[];
+}) => Promise<Result<string, string>>;
+```
+
+`createLlmFn(provider)` in `@uncaged/workflow-reactor` builds an `LlmFn` that calls the OpenAI-compatible chat completions endpoint and returns the raw response body as a string for the reactor to parse.
+
+## Extract Phase
+
+`createExtract(provider, { cas })` in `@uncaged/workflow-execute` creates a `CasReactor` — a preconfigured `ThreadReactorFn` with a `cas_get` static tool. The extract function loads the content payload for a given hash, sends it to the reactor with the role's Zod schema, and returns `ExtractResult<T>`.
+
+```typescript
+type ExtractFn = <T extends Record<string, unknown>>(
+  schema: z.ZodType<T>,
+  contentHash: string,
+) => Promise<ExtractResult<T>>;
+```
+
+The `cas_get` tool allows the LLM to dereference CAS hashes during extraction — important when the content node references artifact hashes.
+
+## Relationship to Engine
+
+The reactor is called within `AdapterFn` implementations (e.g., `createLlmAdapter`, `createReactAdapter`) when the agent needs multi-turn tool interaction to complete a role. The engine itself does not call the reactor directly — it only drives the outer `WorkflowFn` generator and persists `RoleOutput` values.
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-reactor` | `src/thread-reactor.ts` | `createThreadReactor` — generic ReAct loop |
+| `@uncaged/workflow-reactor` | `src/llm-fn.ts` | `createLlmFn` — OpenAI-compatible LLM caller |
+| `@uncaged/workflow-reactor` | `src/types.ts` | `LlmFn`, `ThreadReactorConfig`, `ToolCall`, `ToolDefinition`, `ChatMessage` |
+| `@uncaged/workflow-execute` | `src/cas-reactor.ts` | `createCasReactor` — reactor with `cas_get` static tool |
+| `@uncaged/workflow-execute` | `src/extract/extract-fn.ts` | `createExtract` — extract phase using the CAS reactor |
+
+## See Also
+
+- [Engine](./engine.md) — drives the workflow generator; extract is called inside the adapter layer
+- [Agent Binding](./agent-binding.md) — adapter implementations that use the reactor internally

.cards/registry.md

@@ -0,0 +1,95 @@
+# Registry
+
+> `workflow.yaml` — the local file that maps workflow names to their current and historical bundle hashes, plus global LLM provider configuration.
+
+## Overview
+
+The registry is a single YAML file at `<storageRoot>/workflow.yaml` (default: `~/.uncaged/workflow/workflow.yaml`). It is the authoritative index of which bundles are available on a machine and what name each one is known by. All CLI workflow commands read or write this file.
+
+The registry is read on every `uncaged-workflow run` invocation to look up the bundle hash for a given name, then used again to resolve the `extract` model configuration. It is written atomically via the `writeWorkflowRegistry` function.
+
+## Schema
+
+```yaml
+config:
+  maxDepth: 3
+  supervisorInterval: 5
+  providers:
+    openrouter:
+      baseUrl: "https://openrouter.ai/api/v1"
+      apiKey: "sk-or-..."
+  models:
+    extract: "openrouter/anthropic/claude-sonnet-4-5"
+    supervisor: "openrouter/anthropic/claude-haiku-3-5"
+
+workflows:
+  solve-issue:
+    hash: "3TNKQRJ7BM4XH"
+    timestamp: 1716000000000
+    history:
+      - hash: "2BMJPQ6YAK3WG"
+        timestamp: 1715000000000
+  develop:
+    hash: "7VQWX8NRHK1ZT"
+    timestamp: 1716100000000
+    history: []
+```
+
+## Types
+
+```typescript
+type WorkflowRegistryFile = {
+  config: WorkflowConfig | null;
+  workflows: Record<string, WorkflowRegistryEntry>;
+};
+
+type WorkflowRegistryEntry = {
+  hash: string;       // current bundle hash (13-char Crockford Base32)
+  timestamp: number;  // Unix epoch ms when this version was registered
+  history: WorkflowHistoryEntry[];
+};
+
+type WorkflowHistoryEntry = {
+  hash: string;
+  timestamp: number;
+};
+```
+
+## Bundle Registration Flow
+
+1. `uncaged-workflow workflow add <name> <file.esm.js>` is called.
+2. The bundle bytes are hashed with XXH64 → 13-char Crockford Base32.
+3. The bundle file is copied into `<storageRoot>/bundles/<hash>/` (if not already present).
+4. `registerWorkflowVersion` prepends the current head to `history` and sets the new hash as head.
+5. The updated registry is written back to `workflow.yaml`.
+
+## Version History
+
+Every `workflow add` on an already-registered name pushes the previous hash into `history`. History is ordered most-recent-first. `workflow rollback <name> [hash]` swaps the specified history entry back to head (or defaults to `history[0]`).
+
+## Model Resolution
+
+The `config.models` section uses `provider/model` references (e.g., `"openrouter/anthropic/claude-sonnet-4-5"`). `resolveModel` splits the reference on the first `/`, looks up the provider in `config.providers`, and returns a `ResolvedModel` with `{ baseUrl, apiKey, model }`. This is used by the engine to configure the `extract` LLM.
+
+```typescript
+// packages/workflow-register/src/config/resolve-model.ts
+export function resolveModel(
+  config: WorkflowConfig,
+  modelKey: string,
+): Result<ResolvedModel, string>
+```
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-register` | `src/registry/registry.ts` | `readWorkflowRegistry`, `writeWorkflowRegistry`, `registerWorkflowVersion`, `rollbackWorkflowToHistoryHash` |
+| `@uncaged/workflow-register` | `src/registry/types.ts` | `WorkflowRegistryFile`, `WorkflowRegistryEntry`, `WorkflowHistoryEntry` |
+| `@uncaged/workflow-register` | `src/registry/registry-normalize.ts` | YAML normalization for the registry root |
+| `@uncaged/workflow-register` | `src/config/resolve-model.ts` | `resolveModel` — splits `provider/model` refs |
+| `@uncaged/workflow-register` | `src/bundle/extract-bundle-exports.ts` | Validates bundle exports before registration |
+| `@uncaged/workflow-protocol` | `src/types.ts` | `WorkflowConfig`, `ProviderConfig`, `ResolvedModel` |
+
+## See Also
+
+- [Bundle](./bundle.md) — what is stored and indexed in the registry

.cards/role.md

@@ -0,0 +1,72 @@
+# Role
+
+> A named actor within a workflow defined entirely as pure data — a description, a system prompt, an extraction schema, and an optional refs extractor — with no embedded agent logic.
+
+## Overview
+
+A role is a `RoleDefinition<Meta>` value: a plain TypeScript object that describes what an actor in the workflow does and how its output should be structured. Roles are authored in the template or bundle source and passed to `createWorkflow` as part of the `WorkflowDefinition`. They never hold a reference to an agent implementation.
+
+This separation of concerns is deliberate. The same role definition can be executed by different agents (Cursor, Hermes, an LLM, a React loop) simply by changing the `AdapterBinding` passed to `createWorkflow`. Roles are also serialized into the `WorkflowDescriptor` for tooling like the dashboard.
+
+## RoleDefinition Type
+
+```typescript
+type RoleDefinition<Meta extends Record<string, unknown>> = {
+  description: string;
+  systemPrompt: string;
+  schema: z.ZodType<Meta>;
+  extractRefs: ((meta: Meta) => string[]) | null;
+};
+```
+
+| Field | Purpose |
+|-------|---------|
+| `description` | Human-readable summary for tooling and the `WorkflowDescriptor` |
+| `systemPrompt` | Passed to the adapter as the agent's persona/instruction for this role |
+| `schema` | Zod v4 schema that defines the structured output (`Meta`) of the role |
+| `extractRefs` | Optional function that extracts CAS hashes from `meta` to record as artifact refs |
+
+## Schema and Extraction
+
+Each role's `schema` is a Zod v4 type parameterized to the role's `Meta` type. When a role executes via an `AdapterFn`, the adapter is responsible for producing a value that satisfies this schema directly (the `AdapterFn` receives the schema and system prompt and returns a `RoleFn` that yields `RoleResult<T>`).
+
+If `extractRefs` is non-null, the engine calls it on the completed `meta` to collect additional CAS hashes that should appear in the `StateNode.refs` skip-list, enabling traversal of artifacts produced by the role.
+
+## WorkflowDefinition
+
+Roles are collected into a `WorkflowDefinition<M>` alongside the moderator table:
+
+```typescript
+type WorkflowDefinition<M extends RoleMeta> = {
+  description: string;
+  roles: { [K in keyof M & string]: RoleDefinition<M[K]> };
+  table: ModeratorTable<M>;
+};
+```
+
+`M` is the `RoleMeta` map that binds each role name to its concrete `Meta` type. This gives full TypeScript type safety across the moderator, adapter, and CAS storage layers.
+
+## WorkflowRoleDescriptor (Serialized)
+
+The `WorkflowDescriptor` (stored in the bundle's `descriptor` export) contains a `roles` map of `WorkflowRoleDescriptor` objects — a JSON-serializable projection of each `RoleDefinition`:
+
+```typescript
+type WorkflowRoleDescriptor = {
+  description: string;
+  systemPrompt: string;
+  schema: WorkflowRoleSchema;  // JSON-compatible schema shape
+};
+```
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-protocol` | `src/types.ts` | `RoleDefinition`, `WorkflowDefinition`, `RoleMeta`, `WorkflowRoleDescriptor`, `WorkflowDescriptor` |
+| `@uncaged/workflow-runtime` | `src/create-workflow.ts` | Consumes `WorkflowDefinition` roles in the adapter dispatch loop |
+| `@uncaged/workflow-register` | `src/bundle/build-descriptor.ts` | Serializes `RoleDefinition[]` to `WorkflowDescriptor` |
+
+## See Also
+
+- [Engine](./engine.md) — the loop that selects and executes roles
+- [Agent Binding](./agent-binding.md) — the runtime binding that executes a role via a concrete agent

.cards/thread.md

@@ -0,0 +1,97 @@
+# Thread
+
+> A single execution instance of a workflow, identified by a ULID, whose state is stored as a linked chain of immutable CAS nodes.
+
+## Overview
+
+A thread is the runtime envelope around one call to a workflow's `run` function. It carries a unique ULID (26-char Crockford Base32) and tracks the full sequence of role steps that have executed. Because all state is written to CAS as immutable blobs, threads are append-only and fully auditable.
+
+Every thread belongs to a specific workflow bundle (identified by hash). The engine writes a `StartNode` when the thread begins and one `StateNode` per completed role step — including a final `__end__` state on completion or abort. Steps accumulate in `ThreadContext.steps` and are replayed into the context whenever a thread is resumed.
+
+## Lifecycle
+
+```mermaid
+stateDiagram-v2
+    [*] --> Active: thread run / fork
+    Active --> Active: role step yielded
+    Active --> Paused: pause signal
+    Paused --> Active: resume signal
+    Active --> Completed: generator returns WorkflowCompletion
+    Active --> Aborted: kill signal / AbortSignal
+    Completed --> [*]: entry in history/*.jsonl
+    Aborted --> [*]: entry in history/*.jsonl (returnCode=130)
+```
+
+## Identity
+
+Thread IDs are ULIDs: 26-char Crockford Base32 strings composed of a 10-char timestamp prefix and a 16-char random suffix. Generated by `generateUlid` from `@uncaged/workflow-util`.
+
+## State Storage
+
+Thread state is stored entirely in CAS as a linked list of nodes:
+
+```
+StartNode  (type: "start")
+  payload: { name, hash, depth, parentState }
+  refs: [promptHash, parentState?]
+
+StateNode  (type: "state")  ← one per role step
+  payload: { role, meta, start, content, ancestors[], compact, timestamp, childThread }
+  refs: [contentHash, startHash, ancestor hashes...]
+
+StateNode  (type: "state", role: "__end__")  ← final node
+  payload: { returnCode, summary }
+```
+
+The `ancestors` array implements a skip-list (capped at 11 entries: 1 direct parent + up to 10 ancestors) to allow efficient traversal without loading every node in the chain.
+
+## Index Files
+
+| File | Purpose |
+|------|---------|
+| `<bundleDir>/threads.json` | Active thread index — maps `threadId → { head, start, updatedAt }` |
+| `<bundleDir>/history/YYYY-MM-DD.jsonl` | Completed thread records — one JSON line per completed/aborted thread |
+| `<storageRoot>/cas/` | All CAS blobs shared across all bundles |
+
+A thread is "active" while it appears in `threads.json`. On completion, its entry is removed from `threads.json` and a record appended to the appropriate `history/*.jsonl` file.
+
+## ThreadContext
+
+The `ThreadContext` type is the read-only view passed into every role and moderator call:
+
+```typescript
+type ThreadContext<M extends RoleMeta = RoleMeta> = {
+  threadId: string;
+  depth: number;
+  bundleHash: string;
+  start: StartStep;
+  steps: RoleStep<M>[];
+};
+```
+
+`depth` tracks nesting for sub-workflow invocations (workflow-as-agent). `steps` grows by one entry after each successful role execution.
+
+## Fork
+
+A thread can be forked from any completed role step via `thread fork <id> [--from-role <role>]`. The fork reuses the original `StartNode` (same `startHash`) and replays CAS steps up to the fork point before resuming the generator. The forked thread gets a new ULID.
+
+## Debug Logs
+
+Each thread writes structured JSONL debug logs to `.info.jsonl` in the bundle directory. Each log line is `{ tag, content, timestamp }` where `tag` is an 8-char Crockford Base32 call-site identifier.
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-protocol` | `src/types.ts` | `ThreadContext`, `StartStep`, `RoleStep`, `RoleMeta` types |
+| `@uncaged/workflow-protocol` | `src/cas-types.ts` | `StartNode`, `StartNodePayload`, `StateNode`, `StateNodePayload` |
+| `@uncaged/workflow-execute` | `src/engine/threads-index.ts` | `threads.json` read/write, history append, `ThreadIndexEntry` |
+| `@uncaged/workflow-execute` | `src/engine/engine.ts` | `executeThread` — starts, drives, and finalizes a thread |
+| `@uncaged/workflow-execute` | `src/engine/fork-thread.ts` | Fork logic |
+| `@uncaged/workflow-util` | `src/ulid.ts` | `generateUlid` — ULID generation |
+
+## See Also
+
+- [CAS](./cas.md) — the storage layer that holds all thread state nodes
+- [Engine](./engine.md) — the execution loop that drives the thread
+- [Bundle](./bundle.md) — the workflow being executed in this thread

.cards/workflow-templates.md

@@ -0,0 +1,153 @@
+# Workflow Templates
+
+> Pre-built `WorkflowDefinition` objects exported from `@uncaged/workflow-template-*` packages that bundle authors can import, customize, or use directly.
+
+## Overview
+
+Templates are the reference implementations of common workflow patterns. They export a complete `WorkflowDefinition<M>` — typed roles with Zod schemas, and a `ModeratorTable` — ready to be passed to `createWorkflow`. A bundle author imports a template definition, supplies an `AdapterBinding`, calls `createWorkflow`, and exports the result as `run`.
+
+Templates are published as regular `@uncaged/*` npm packages. They are not bundles themselves; they are TypeScript libraries that become part of a bundle when the author's workspace is built.
+
+## solve-issue Template
+
+**Package**: `@uncaged/workflow-template-solve-issue`
+
+Resolves an issue end-to-end by preparing the repository, delegating implementation to a nested `develop` workflow, and opening a pull request.
+
+### Roles
+
+| Role | Description |
+|------|-------------|
+| `preparer` | Reads the issue, clones/checks out the repo, sets up the environment |
+| `developer` | Delegates to the `develop` workflow via `workflowAsAgent` (child thread) |
+| `submitter` | Opens a pull request with the completed changes |
+
+### Moderator Table
+
+```
+__start__ → preparer → developer → submitter → __end__
+```
+
+Linear routing — each role runs exactly once in sequence.
+
+### Meta Types
+
+```typescript
+type SolveIssueMeta = {
+  preparer: PreparerMeta;
+  developer: DeveloperMeta;
+  submitter: SubmitterMeta;
+};
+```
+
+## develop Template
+
+**Package**: `@uncaged/workflow-template-develop`
+
+Plans an implementation in phases, codes each phase incrementally, reviews, verifies with tests/build/lint, and commits.
+
+### Roles
+
+| Role | Description |
+|------|-------------|
+| `planner` | Produces an ordered list of implementation phases with hashes |
+| `coder` | Implements one phase; reports `completedPhase` hash in meta |
+| `reviewer` | Reviews the accumulated changes; approves or requests changes |
+| `tester` | Runs tests/lint/build; reports `passed` or `failed` |
+| `committer` | Creates the final git commit |
+
+### Moderator Table
+
+```
+__start__ → planner
+planner   → __end__      (if status == "aborted")
+planner   → coder        (fallback)
+coder     → reviewer     (if allPhasesComplete)
+coder     → coder        (fallback — repeat per phase)
+reviewer  → tester       (if status == "approved")
+reviewer  → coder        (fallback — request changes)
+tester    → committer    (if status == "passed")
+tester    → coder        (fallback — fix failures)
+committer → __end__
+```
+
+### Meta Types
+
+```typescript
+type DevelopMeta = {
+  planner: PlannerMeta;
+  coder: CoderMeta;
+  reviewer: ReviewerMeta;
+  tester: TesterMeta;
+  committer: CommitterMeta;
+};
+```
+
+## Writing a Custom Template
+
+A minimal custom workflow:
+
+```typescript
+import { createWorkflow, type WorkflowDefinition, END, START } from "@uncaged/workflow-runtime";
+import { z } from "zod/v4";
+import type { AdapterBinding } from "@uncaged/workflow-runtime";
+
+type MyMeta = {
+  analyst: { summary: string; confidence: number };
+  writer: { report: string };
+};
+
+const def: WorkflowDefinition<MyMeta> = {
+  description: "Analyse then write a report.",
+  roles: {
+    analyst: {
+      description: "Analyses the input and produces a structured summary.",
+      systemPrompt: "You are an expert analyst...",
+      schema: z.object({ summary: z.string(), confidence: z.number() }),
+      extractRefs: null,
+    },
+    writer: {
+      description: "Writes the final report.",
+      systemPrompt: "You are a technical writer...",
+      schema: z.object({ report: z.string() }),
+      extractRefs: null,
+    },
+  },
+  table: {
+    [START]: [{ condition: "FALLBACK", role: "analyst" }],
+    analyst: [{ condition: "FALLBACK", role: "writer" }],
+    writer: [{ condition: "FALLBACK", role: END }],
+  },
+};
+
+// In the bundle entry point:
+export const run = createWorkflow(def, binding);
+export const descriptor = buildDescriptor(def);
+```
+
+## Template → Bundle Relationship
+
+Templates are TypeScript library packages, not bundles. To use a template:
+
+1. Install the template package from npm: `bun add @uncaged/workflow-template-develop`.
+2. Import the definition: `import { developWorkflowDefinition } from "@uncaged/workflow-template-develop"`.
+3. Supply an `AdapterBinding` and call `createWorkflow`.
+4. Build with `bun build` to produce `.esm.js`.
+5. Register with `uncaged-workflow workflow add`.
+
+## Code Pointers
+
+| Package | File | What it does |
+|---------|------|-------------|
+| `@uncaged/workflow-template-solve-issue` | `src/index.ts` | `solveIssueWorkflowDefinition`, role and moderator exports |
+| `@uncaged/workflow-template-solve-issue` | `src/roles.ts` | `SolveIssueMeta`, `solveIssueRoles` |
+| `@uncaged/workflow-template-solve-issue` | `src/moderator.ts` | `solveIssueTable` — linear transition table |
+| `@uncaged/workflow-template-develop` | `src/index.ts` | `developWorkflowDefinition`, role and moderator exports |
+| `@uncaged/workflow-template-develop` | `src/roles.ts` | `DevelopMeta`, `developRoles` |
+| `@uncaged/workflow-template-develop` | `src/moderator.ts` | `developTable` — conditional multi-phase table |
+
+## See Also
+
+- [Bundle](./bundle.md) — the build artifact produced from a template + adapter
+- [Role](./role.md) — the `RoleDefinition` type each template role implements
+- [Engine](./engine.md) — the execution loop that drives the template's `WorkflowFn`

develop-entry.ts

@@ -0,0 +1,16 @@
+import { createCursorAgent } from "./packages/workflow-agent-cursor/src/index.js";
+import { createWorkflow } from "./packages/workflow-runtime/src/create-workflow.js";
+import {
+  buildDevelopDescriptor,
+  developWorkflowDefinition,
+} from "./packages/workflow-template-develop/src/index.js";
+
+const agent = createCursorAgent({
+  command: "/home/azureuser/.local/bin/cursor-agent",
+  model: "auto",
+  timeout: 300_000,
+  workspace: null,
+});
+
+export const descriptor = buildDevelopDescriptor();
+export const run = createWorkflow(developWorkflowDefinition, { adapter: agent, overrides: null });

docs/wf-stateless-design.md

@@ -1,527 +0,0 @@
-# `uwf` — Stateless Workflow CLI
-
-> 将 workflow 引擎降维为无状态单步 CLI。Workflow 是纯数据（CAS 节点），执行是单步原子操作，agent 是可插拔外部命令。
-
----
-
-## 1. CLI Design
-
-### 1.1 命令总览
-
-```
-# thread 组
-uwf thread start <workflow> -p <prompt>     # 创建 thread，不执行
-uwf thread step  <thread-id> [--agent]      # 单步执行
-uwf thread show  <thread-id>                # thread-id → head 查询
-uwf thread list  [--all]                    # 列出活跃 threads（--all 含已归档）
-uwf thread kill  <thread-id>                # 终结 thread，归档
-
-# workflow 组
-uwf workflow put   <file.yaml>              # 注册 workflow（YAML → CAS）
-uwf workflow show  <workflow-id>            # 查看 workflow 定义
-uwf workflow list                           # 列出已注册 workflows
-```
-
-两组对称，各 3-4 个子命令。CAS 操作交给 `json-cas` CLI，不在 `uwf` 中重复。
-
-### 1.2 `uwf thread start`
-
-```bash
-uwf thread start <workflow> -p "Fix the login bug described in issue #42"
-```
-
-- `<workflow>` — workflow 名或 CAS hash
-- `-p` — 用户 prompt（必填）
-
-**输出（JSON to stdout）：**
-
-```jsonc
-{
-  "workflow": "4KNM2PXR3B1QW",   // workflow CAS hash (XXH64, 13-char Crockford Base32)
-  "thread": "01J7K9M2XNPQR5VWBCDF8G3H4T"      // ULID
-}
-```
-
-**做的事：**
-1. 解析 workflow（名字查 registry → CAS hash）
-2. 生成 thread ULID
-3. 写 StartNode 到 CAS
-4. 在 threads.yaml 中记录链头 → StartNode hash
-5. 输出 JSON
-
-### 1.3 `uwf thread step`
-
-```bash
-uwf thread step 01J7K9M2XNPQR5VWBCDF8G3H4T
-uwf thread step 01J7K9M2XNPQR5VWBCDF8G3H4T --agent "bunx uwf-cursor"
-```
-
-**输出（JSON to stdout）：**
-
-```jsonc
-{
-  "workflow": "4KNM2PXR3B1QW",
-  "thread": "01J7K9M2XNPQR5VWBCDF8G3H4T",
-  "head": "8FWKR3TN5V1QA",       // 新链头 StepNode 的 CAS hash
-  "done": false                    // true = moderator 返回 END，thread 已归档
-}
-```
-
-`done: true` 时 head 仍然有值（最后一个 StepNode），但 thread 已从 threads.yaml 移除。
-对已结束或不存在的 thread 调用 step 会报错（非 active thread）。
-
-详细信息通过 `uwf thread show <thread-id>` 或 `json-cas get <head>` 查看。
-
-**做的事：**
-1. 读链头 → 当前 StepNode（或 StartNode）
-2. 收集 thread 历史（遍历链）
-3. 调 moderator：评估 JSONata conditions → 得到下一个 role（或 END）
-4. 若 END → 归档 thread，输出最后链头，退出
-5. 确定 agent command（`--agent` override > config.yaml per-workflow/role > config.yaml defaultAgent）
-6. 调用：`<agent-cmd> <thread-id> <role>`，捕获 stdout 得到新 StepNode hash
-7. 更新链头指针
-8. 再次调 moderator（基于新 StepNode）判断 done
-9. 输出 JSON
-
-### 1.4 `uwf thread show`
-
-```bash
-uwf thread show 01J7K9M2XNPQR5VWBCDF8G3H4T
-```
-
-**输出（JSON to stdout）：**
-
-```jsonc
-{
-  "workflow": "4KNM2PXR3B1QW",
-  "thread": "01J7K9M2XNPQR5VWBCDF8G3H4T",
-  "head": "8FWKR3TN5V1QA",
-  "done": false
-}
-```
-
-纯 thread-id → head 查询。详细内容用 `json-cas get <head>` 或 `json-cas walk <head>` 查看。
-
-### 1.5 Agent CLI 协议
-
-每个 agent 是一个命令，接受 thread-id 和 role 两个参数：
-
-```bash
-uwf-hermes <thread-id> <role>
-```
-
-**约定：**
-- `uwf step` 负责 moderator 决策，将 role 传给 agent CLI
-- agent-kit 根据 thread + role 从 CAS 读 systemPrompt / outputSchema
-- agent-kit 组装完整 prompt（role systemPrompt + thread context + user prompt from StartNode）
-- agent 执行实际逻辑，agent-kit 负责 extract
-- agent 将 StepNode 写入 CAS（含 output、detail、agent、prev），但**不挪链头指针**
-- stdout 输出新 StepNode 的 CAS hash（纯文本，一行）
-- 所有配置从环境变量读（LLM model、API key、extractor config）
-- exit 0 = 成功，非 0 = 失败
-
-**stdout 输出：**
-
-```
-8FWKR3TN5V1QA
-```
-
-`uwf step` 拿到这个 hash 后更新链头指针、判断 done。
-
----
-
-## 2. CAS 结构定义
-
-### 2.1 类型层级
-
-沿用 json-cas 的三层：bootstrap meta-schema → JSON Schema nodes → data nodes。
-
-下面所有 CAS 节点都遵循 `{ type: cas_ref, payload: T, timestamp: number }` 的标准格式。
-`cas_ref` 类型的字符串字段在 json-cas 中已内置支持，不需要额外的 `$ref` 包装。
-
-### 2.2 数据节点
-
-#### `Workflow`
-
-Roles 和 moderator 内联在 Workflow 中，只有 outputSchema 独立为 CAS 节点（方便 json-cas 校验）。
-
-```yaml
-type: <workflow-schema-hash>
-payload:
-  name: "solve-issue"
-  description: "End-to-end issue resolution"
-  roles:
-    planner:
-      description: "Creates implementation plan"
-      systemPrompt: "You are a planning agent..."
-      outputSchema: "5GWKR8TN1V3JA"    # cas_ref → JSON Schema 节点（json-cas 内置）
-    developer:
-      description: "Implements code changes"
-      systemPrompt: "You are a developer agent..."
-      outputSchema: "8CNWT4KR6D1HV"    # cas_ref → JSON Schema 节点
-    reviewer:
-      description: "Reviews code changes"
-      systemPrompt: "You are a code reviewer..."
-      outputSchema: "1VPBG9SM5E7WK"    # cas_ref → JSON Schema 节点
-  conditions:
-    needsClarification:
-      description: "Planner requests clarification from user"
-      expression: "$exists(steps[-1].output.needsClarification)"
-    notApproved:
-      description: "Reviewer rejected the implementation"
-      expression: "steps[-1].output.approved = false"
-  graph:
-    $START:
-      - role: "planner"
-        condition: null                  # 无条件（fallback）
-    planner:
-      - role: "developer"
-        condition: "needsClarification"
-      - role: "$END"
-        condition: null
-    developer:
-      - role: "reviewer"
-        condition: null
-    reviewer:
-      - role: "developer"
-        condition: "notApproved"
-      - role: "$END"
-        condition: null
-```
-
-- `roles` — 内联定义，每个 role 的 `outputSchema` 是独立的 cas_ref（指向 json-cas 内置 JSON Schema 节点）
-- `conditions` — `Record<Name, JSONata>`，命名条件，方便画图描述
-- `graph` — `Record<Role | "$START", Transition[]>`，每个 Transition = `{ role, condition }`
-- `condition` 引用 conditions 中的 key，`null` = fallback
-- 按数组顺序求值，第一个匹配的 transition 胜出
-- 不含 agent binding — agent 配置在 `~/.uncaged/workflow/config.yaml` 中管理
-
-JSONata 表达式的求值上下文：
-
-```jsonc
-{
-  "start": {                          // StartNode 信息
-    "workflow": "4KNM2PXR3B1QW",
-    "prompt": "Fix the login bug..."
-  },
-  "steps": [                          // 所有已完成 steps，从旧到新
-    { "role": "planner", "output": { "phases": [...] }, "detail": "7BQST3VW9F2MA", "agent": "uwf-hermes" },
-    { "role": "developer", "output": { "filesChanged": ["src/auth.ts"], "summary": "Fixed redirect" }, "detail": "9KRVW3TN5F1QA", "agent": "uwf-cursor" },
-    { "role": "reviewer", "output": { "approved": false }, "detail": "2MXBG6PN4A8JR", "agent": "uwf-hermes" }
-  ]
-}
-```
-
-注：`output` 在上下文中会被自动展开为实际的 CAS 节点内容（而非 hash），方便 JSONata 表达式直接访问字段。
-
-#### `StartNode`（Thread 起点）
-
-```yaml
-type: <start-node-schema-hash>
-payload:
-  workflow: "4KNM2PXR3B1QW"        # cas_ref → Workflow
-  prompt: "Fix the login bug..."
-```
-
-- 没有 thread-id — thread-id 是索引层面的事，不进 CAS 内容
-- 没有 agent binding — 运行时从 config.yaml 解析
-
-#### `StepNode`（Thread 每一步）
-
-```yaml
-type: <step-node-schema-hash>
-payload:
-  start: "4TNVW8KR2B3MA"          # cas_ref → StartNode（每个 step 都引用）
-  prev: "2MXBG6PN4A8JR"           # cas_ref → 前一个 StepNode，第一步为 null
-  role: "developer"
-  output: "9KRVW3TN5F1QA"         # cas_ref → 结构化输出节点（符合 role 的 outputSchema）
-  detail: "7BQST3VW9F2MA"         # cas_ref → 执行详情（content node / 子 workflow terminal StepNode / ...）
-  agent: "uwf-cursor"              # 实际使用的 agent 命令（纯字符串）
-```
-
-- `start` — 每个 StepNode 都直接引用 StartNode，方便随机访问
-- `prev` — 前一个 StepNode 的 cas_ref，第一步为 `null`（不指向 StartNode）
-- `output` — cas_ref，指向符合 role outputSchema 的 CAS 节点，可用 json-cas 校验
-- `detail` — cas_ref，指向执行详情。可以是原始 agent 输出（content node），也可以是子 workflow thread 的 terminal StepNode（workflowAsAgent 场景）
-- `agent` — 纯字符串，不是 CAS 节点
-
-### 2.3 链式结构
-
-```
-threads.yaml: { "01J7K9M2XNPQR5VWBCDF8G3H4T": "8FWKR3TN5V1QA" }
-                                      │
-                                      ▼
-                              StepNode (step 3)
-                              ├── start ──→ StartNode
-                              │              ├── workflow → CAS(Workflow)
-                              │              └── prompt: "Fix..."
-                              ├── prev ──→ StepNode (step 2)
-                              │             ├── start ──→ (same StartNode)
-                              │             ├── prev ──→ StepNode (step 1)
-                              │             │             ├── start ──→ (same StartNode)
-                              │             │             ├── prev: null
-                              │             │             ├── role: "planner"
-                              │             │             └── ...
-                              │             ├── role: "developer"
-                              │             └── ...
-                              ├── role: "reviewer"
-                              ├── output → CAS({ approved: true })
-                              ├── detail → CAS(raw output | sub-workflow terminal node)
-                              └── agent: "uwf-hermes"
-```
-
-### 2.4 可变状态
-
-系统两个顶层 YAML 文件和一个 env 文件：
-
-```yaml
-# ~/.uncaged/workflow/config.yaml — 全局配置
-providers:
-  openai:
-    baseUrl: "https://api.openai.com/v1"
-    apiKeyEnv: "OPENAI_API_KEY"
-  anthropic:
-    baseUrl: "https://api.anthropic.com/v1"
-    apiKeyEnv: "ANTHROPIC_API_KEY"
-  openrouter:
-    baseUrl: "https://openrouter.ai/api/v1"
-    apiKeyEnv: "OPENROUTER_API_KEY"
-
-models:
-  sonnet:
-    provider: "openrouter"
-    name: "anthropic/claude-sonnet-4"
-  gpt4o-mini:
-    provider: "openai"
-    name: "gpt-4o-mini"
-
-agents:
-  hermes:
-    command: "uwf-hermes"
-    args: []
-  cursor:
-    command: "uwf-cursor"
-    args: []
-
-defaultAgent: "hermes"
-agentOverrides:
-  solve-issue:
-    developer: "cursor"
-
-defaultModel: "sonnet"
-modelOverrides:
-  extract: "gpt4o-mini"
-```
-
-```yaml
-# ~/.uncaged/workflow/threads.yaml — active thread 链头指针
-01J7K9M2XNPQR5VWBCDF8G3H4T: "8FWKR3TN5V1QA"
-01J8AB3QRMSTV6WKXZ2C4DF7GN: "3CNWT9KR6D2HV"
-```
-
-Thread 结束时从 threads.yaml 移除。可选：追加到 `history.jsonl` 做归档。
-
-```bash
-# ~/.uncaged/workflow/.env — 敏感信息（API keys）
-OPENAI_API_KEY=sk-...
-ANTHROPIC_API_KEY=sk-ant-...
-OPENROUTER_API_KEY=sk-or-...
-```
-
-- `config.yaml` — 非敏感配置（agent 命令、model 名、provider 名）
-- `.env` — 敏感信息（API keys），agent-kit 启动时自动加载
-- `threads.yaml` — 运行时状态
-
----
-
-## 3. 包结构
-
-全新包，不复用现有 packages，避免命名冲突。CAS 直接依赖 `@uncaged/json-cas`。
-
-```
-packages/
-├── cli-uwf/              # @uncaged/cli-uwf — uwf CLI（thread/workflow 命令）
-├── uwf-moderator/        # @uncaged/uwf-moderator — JSONata moderator 引擎
-├── uwf-agent-kit/        # @uncaged/uwf-agent-kit — Agent CLI 框架（含 extractor）
-├── uwf-agent-hermes/     # @uncaged/uwf-agent-hermes — uwf-hermes CLI
-├── uwf-agent-cursor/     # @uncaged/uwf-agent-cursor — uwf-cursor CLI
-└── uwf-protocol/         # @uncaged/uwf-protocol — 共享类型定义
-```
-
-**外部依赖：**
-- `@uncaged/json-cas` — CAS 存储、hash、schema 校验
-- `@uncaged/json-cas-fs` — 文件系统 CAS 后端
-
-**现有包全部保留不动**，新旧并存，逐步迁移。
-
----
-
-## 4. 关键数据类型
-
-JSONata 求值上下文本质上是 thread 链表的线性化表达。StepNode payload 和上下文中的 step 共享大量字段，提取为公共类型。
-
-### 4.1 公共类型
-
-```typescript
-/** CAS hash — XXH64, 13-char Crockford Base32 */
-type CasRef = string;
-
-/** Thread ID — ULID, 26-char Crockford Base32 */
-type ThreadId = string;
-
-/** 一个 step 的核心数据，被 StepNode payload 和 JSONata 上下文共享 */
-type StepRecord = {
-  role: string;
-  output: CasRef;                    // cas_ref → 结构化输出节点（符合 role outputSchema）
-  detail: CasRef;                    // cas_ref → 执行详情（content node / 子 workflow terminal StepNode）
-  agent: string;                     // 实际使用的 agent 命令（纯字符串）
-};
-```
-
-### 4.2 Workflow 定义
-
-```typescript
-type RoleDefinition = {
-  description: string;
-  systemPrompt: string;
-  outputSchema: CasRef;              // cas_ref → json-cas 内置 JSON Schema 节点
-};
-
-type Transition = {
-  role: string;                      // 目标 role 名 或 "$END"
-  condition: string | null;          // 引用 conditions 中的 key，null = fallback
-};
-
-type ConditionDefinition = {
-  description: string;
-  expression: string;                           // JSONata expression
-};
-
-type WorkflowPayload = {
-  name: string;
-  description: string;
-  roles: Record<string, RoleDefinition>;
-  conditions: Record<string, ConditionDefinition>;
-  graph: Record<string, Transition[]>;          // Record<Role | "$START", Transition[]>
-};
-```
-
-### 4.3 Thread 节点
-
-```typescript
-type StartNodePayload = {
-  workflow: CasRef;                  // cas_ref → Workflow
-  prompt: string;
-};
-
-type StepNodePayload = StepRecord & {
-  start: CasRef;                     // cas_ref → StartNode（每个 step 都引用）
-  prev: CasRef | null;               // cas_ref → 前一个 StepNode，第一步为 null
-};
-```
-
-### 4.4 JSONata 求值上下文
-
-Thread 链表的线性化。`steps[n]` 的字段和 `StepRecord` 一致，但 `output` 被展开为实际内容。
-
-```typescript
-/** JSONata 上下文中的 step — output 被展开 */
-type StepContext = Omit<StepRecord, "output"> & {
-  output: unknown;                   // 展开后的 CAS 节点内容，非 hash
-};
-
-type ModeratorContext = {
-  start: StartNodePayload;
-  steps: StepContext[];              // 从旧到新
-};
-```
-
-### 4.5 CLI 输出
-
-```typescript
-/** uwf thread start */
-type StartOutput = {
-  workflow: CasRef;
-  thread: ThreadId;
-};
-
-/** uwf thread step / uwf thread show */
-type StepOutput = {
-  workflow: CasRef;
-  thread: ThreadId;
-  head: CasRef;
-  done: boolean;
-};
-
-/** uwf thread list */
-type ThreadListItem = {
-  thread: ThreadId;
-  workflow: CasRef;
-  head: CasRef;
-};
-```
-
-### 4.6 配置
-
-```typescript
-/** Alias types for config references */
-type AgentAlias = string;
-type ModelAlias = string;
-type ProviderAlias = string;
-type WorkflowName = string;
-type RoleName = string;
-type Scenario = string;              // e.g. "extract"
-
-type ProviderConfig = {
-  baseUrl: string;
-  apiKeyEnv: string;                 // env var name to read API key from
-};
-
-type ModelConfig = {
-  provider: ProviderAlias;
-  name: string;                      // e.g. "anthropic/claude-sonnet-4", "gpt-4o-mini"
-};
-
-type AgentConfig = {
-  command: string;
-  args: string[];
-};
-
-/** ~/.uncaged/workflow/config.yaml */
-type WorkflowConfig = {
-  providers: Record<ProviderAlias, ProviderConfig>;
-  models: Record<ModelAlias, ModelConfig>;
-  agents: Record<AgentAlias, AgentConfig>;
-  defaultAgent: AgentAlias;
-  agentOverrides: Record<WorkflowName, Record<RoleName, AgentAlias>> | null;
-  defaultModel: ModelAlias;
-  modelOverrides: Record<Scenario, ModelAlias> | null;
-};
-
-/** ~/.uncaged/workflow/threads.yaml */
-type ThreadsIndex = Record<ThreadId, CasRef>;
-//                         ^ thread-id  ^ head StepNode/StartNode hash
-```
-
-### 4.7 类型关系图
-
-```
-WorkflowConfig (config.yaml)
-ThreadsIndex (threads.yaml)          ← 唯二可变状态
-    │
-    │ thread-id → head hash
-    ▼
-StepNodePayload ──extends──→ StepRecord ←──maps to──→ StepContext
-    │                           │                          │
-    ├── start → StartNodePayload│                          │ (output 展开)
-    ├── prev → StepNodePayload  │                          │
-    │                           ├── role                   ├── role
-    │                           ├── output (CasRef)        ├── output (展开)
-    │                           ├── detail (CasRef)        ├── detail (CasRef)
-    │                           └── agent (string)         └── agent (string)
-    │
-    └── start.workflow → WorkflowPayload
-                             ├── roles: Record<name, RoleDefinition>
-                             ├── conditions: Record<name, JSONata>
-                             └── graph: Record<role, Transition[]>
-```

package.json

@@ -4,6 +4,10 @@
   "workspaces": [
     "packages/*"
   ],
+  "overrides": {
+    "@uncaged/json-cas": "^0.1.0",
+    "@uncaged/json-cas-workflow": "^0.1.0"
+  },
   "scripts": {
     "build": "bunx tsc --build",
     "check": "bunx tsc --build && biome check . && bash scripts/lint-log-tags.sh",

packages/cli-uwf/package.json

@@ -1,30 +0,0 @@
-{
-  "name": "@uncaged/cli-uwf",
-  "version": "0.1.0",
-  "files": [
-    "src",
-    "dist",
-    "package.json"
-  ],
-  "type": "module",
-  "bin": {
-    "uwf": "./src/cli.ts"
-  },
-  "dependencies": {
-    "@uncaged/json-cas": "^0.1.3",
-    "@uncaged/json-cas-fs": "^0.1.2",
-    "@uncaged/uwf-agent-kit": "workspace:^",
-    "@uncaged/uwf-moderator": "workspace:^",
-    "@uncaged/uwf-protocol": "workspace:^",
-    "@uncaged/workflow-util": "workspace:^",
-    "commander": "^14.0.3",
-    "dotenv": "^16.6.1",
-    "yaml": "^2.8.4"
-  },
-  "scripts": {
-    "test": "bun test"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}

packages/cli-uwf/src/cli.ts

@@ -1,281 +0,0 @@
-#!/usr/bin/env bun
-
-import { Command } from "commander";
-
-import {
-  cmdThreadKill,
-  cmdThreadList,
-  cmdThreadShow,
-  cmdThreadStart,
-  cmdThreadStep,
-} from "./commands/thread.js";
-import { cmdWorkflowList, cmdWorkflowPut, cmdWorkflowShow } from "./commands/workflow.js";
-import { cmdSetup, cmdSetupInteractive } from "./commands/setup.js";
-import {
-  cmdCasCat,
-  cmdCasGet,
-  cmdCasHas,
-  cmdCasPut,
-  cmdCasRefs,
-  cmdCasSchemaGet,
-  cmdCasSchemaList,
-  cmdCasWalk,
-} from "./commands/cas.js";
-import { resolveStorageRoot } from "./store.js";
-import { type OutputFormat, formatOutput } from "./format.js";
-
-function writeOutput(data: unknown): void {
-  const fmt = program.opts().format as OutputFormat;
-  process.stdout.write(`${formatOutput(data, fmt)}\n`);
-}
-
-function runAction(action: () => Promise<void>): void {
-  action().catch((e: unknown) => {
-    const message = e instanceof Error ? e.message : String(e);
-    process.stderr.write(`${message}\n`);
-    process.exit(1);
-  });
-}
-
-const program = new Command();
-
-program.name("uwf").description("Stateless workflow CLI");
-program.option("--format <fmt>", "Output format: json, yaml, table", "json");
-
-const workflow = program.command("workflow").description("Workflow registry and CAS");
-
-workflow
-  .command("put")
-  .description("Register a workflow from YAML")
-  .argument("<file>", "Workflow YAML file")
-  .action((file: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdWorkflowPut(storageRoot, file);
-      writeOutput(result);
-    });
-  });
-
-workflow
-  .command("show")
-  .description("Show a workflow by name or CAS hash")
-  .argument("<id>", "Workflow name or hash")
-  .action((id: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdWorkflowShow(storageRoot, id);
-      writeOutput(result);
-    });
-  });
-
-workflow
-  .command("list")
-  .description("List registered workflows")
-  .action(() => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdWorkflowList(storageRoot);
-      writeOutput(result);
-    });
-  });
-
-const thread = program.command("thread").description("Thread lifecycle and execution");
-
-thread
-  .command("start")
-  .description("Create a thread without executing")
-  .argument("<workflow>", "Workflow name or hash")
-  .requiredOption("-p, --prompt <text>", "User prompt")
-  .action((workflow: string, opts: { prompt: string }) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdThreadStart(storageRoot, workflow, opts.prompt);
-      writeOutput(result);
-    });
-  });
-
-thread
-  .command("step")
-  .description("Execute one step")
-  .argument("<thread-id>", "Thread ULID")
-  .option("--agent <cmd>", "Override agent command")
-  .action((threadId: string, opts: { agent: string | undefined }) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const agentOverride = opts.agent ?? null;
-      const result = await cmdThreadStep(storageRoot, threadId, agentOverride);
-      writeOutput(result);
-    });
-  });
-
-thread
-  .command("show")
-  .description("Show thread head pointer")
-  .argument("<thread-id>", "Thread ULID")
-  .action((threadId: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdThreadShow(storageRoot, threadId);
-      writeOutput(result);
-    });
-  });
-
-thread
-  .command("list")
-  .description("List active threads")
-  .option("--all", "Include archived threads")
-  .action((opts: { all: boolean }) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdThreadList(storageRoot, opts.all);
-      writeOutput(result);
-    });
-  });
-
-thread
-  .command("kill")
-  .description("Terminate and archive a thread")
-  .argument("<thread-id>", "Thread ULID")
-  .action((threadId: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      const result = await cmdThreadKill(storageRoot, threadId);
-      writeOutput(result);
-    });
-  });
-
-program
-  .command("setup")
-  .description("Configure provider, model, and agent")
-  .option("--provider <name>", "Provider name")
-  .option("--base-url <url>", "OpenAI-compatible API base URL")
-  .option("--api-key <key>", "API key")
-  .option("--model <name>", "Default model name")
-  .option("--agent <name>", "Default agent alias")
-  .action((opts: {
-    provider?: string;
-    baseUrl?: string;
-    apiKey?: string;
-    model?: string;
-    agent?: string;
-  }) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      if (opts.provider && opts.baseUrl && opts.apiKey && opts.model) {
-        const result = await cmdSetup({
-          provider: opts.provider,
-          baseUrl: opts.baseUrl,
-          apiKey: opts.apiKey,
-          model: opts.model,
-          agent: opts.agent ?? undefined,
-          storageRoot,
-        });
-        writeOutput(result);
-      } else if (!opts.provider && !opts.baseUrl && !opts.apiKey && !opts.model) {
-        await cmdSetupInteractive(storageRoot);
-      } else {
-        throw new Error(
-          "Non-interactive setup requires all of: --provider, --base-url, --api-key, --model",
-        );
-      }
-    });
-  });
-
-const cas = program.command("cas").description("Content-addressable storage operations");
-
-cas
-  .command("get")
-  .description("Read a CAS node as JSON")
-  .argument("<hash>", "CAS hash (13 char)")
-  .action((hash: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasGet(storageRoot, hash));
-    });
-  });
-
-cas
-  .command("cat")
-  .description("Output a CAS node (--payload for payload only)")
-  .argument("<hash>", "CAS hash (13 char)")
-  .option("--payload", "Output only the payload")
-  .action((hash: string, opts: { payload?: boolean }) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasCat(storageRoot, hash, opts));
-    });
-  });
-
-cas
-  .command("put")
-  .description("Store a node, print its hash")
-  .argument("<type-hash>", "Type (schema) hash")
-  .argument("<data>", "JSON file path or inline JSON string")
-  .action((typeHash: string, data: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasPut(storageRoot, typeHash, data));
-    });
-  });
-
-cas
-  .command("has")
-  .description("Check if a hash exists")
-  .argument("<hash>", "CAS hash (13 char)")
-  .action((hash: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasHas(storageRoot, hash));
-    });
-  });
-
-cas
-  .command("refs")
-  .description("List direct CAS references from a node")
-  .argument("<hash>", "CAS hash (13 char)")
-  .action((hash: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasRefs(storageRoot, hash));
-    });
-  });
-
-cas
-  .command("walk")
-  .description("Recursive traversal from a node")
-  .argument("<hash>", "CAS hash (13 char)")
-  .action((hash: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasWalk(storageRoot, hash));
-    });
-  });
-
-const casSchema = cas.command("schema").description("CAS schema operations");
-
-casSchema
-  .command("list")
-  .description("List all registered schemas")
-  .action(() => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasSchemaList(storageRoot));
-    });
-  });
-
-casSchema
-  .command("get")
-  .description("Show a schema by its type hash")
-  .argument("<hash>", "Schema type hash")
-  .action((hash: string) => {
-    const storageRoot = resolveStorageRoot();
-    runAction(async () => {
-      writeOutput(await cmdCasSchemaGet(storageRoot, hash));
-    });
-  });
-
-program.parseAsync(process.argv).catch((e: unknown) => {
-  const message = e instanceof Error ? e.message : String(e);
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-});

packages/cli-uwf/src/commands/cas.ts

@@ -1,136 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import type { Hash, JSONSchema, Store } from "@uncaged/json-cas";
-import { bootstrap, getSchema, refs, walk } from "@uncaged/json-cas";
-import { createFsStore } from "@uncaged/json-cas-fs";
-
-// ---- Helpers ----
-
-function openStore(storageRoot: string): Store {
-  return createFsStore(join(storageRoot, "cas"));
-}
-
-function readJsonArg(fileOrInline: string): unknown {
-  try {
-    return JSON.parse(fileOrInline);
-  } catch {
-    try {
-      return JSON.parse(readFileSync(fileOrInline, "utf-8"));
-    } catch (e) {
-      throw new Error(`Cannot parse JSON from "${fileOrInline}": ${e}`);
-    }
-  }
-}
-
-// ---- Commands (all return JSON-serializable data) ----
-
-export async function cmdCasGet(
-  storageRoot: string,
-  hash: string,
-): Promise<unknown> {
-  const store = openStore(storageRoot);
-  const node = store.get(hash);
-  if (node === null) {
-    throw new Error(`Node not found: ${hash}`);
-  }
-  return node;
-}
-
-export async function cmdCasCat(
-  storageRoot: string,
-  hash: string,
-  opts: { payload?: boolean },
-): Promise<unknown> {
-  const store = openStore(storageRoot);
-  const node = store.get(hash);
-  if (node === null) {
-    throw new Error(`Node not found: ${hash}`);
-  }
-  return opts.payload ? node.payload : node;
-}
-
-export async function cmdCasPut(
-  storageRoot: string,
-  typeHash: string,
-  data: string,
-): Promise<{ hash: string }> {
-  const store = openStore(storageRoot);
-  const payload = readJsonArg(data);
-  const hash = await store.put(typeHash, payload);
-  return { hash };
-}
-
-export async function cmdCasHas(
-  storageRoot: string,
-  hash: string,
-): Promise<{ exists: boolean }> {
-  const store = openStore(storageRoot);
-  return { exists: store.has(hash) };
-}
-
-export async function cmdCasRefs(
-  storageRoot: string,
-  hash: string,
-): Promise<{ refs: string[] }> {
-  const store = openStore(storageRoot);
-  const node = store.get(hash);
-  if (node === null) {
-    throw new Error(`Node not found: ${hash}`);
-  }
-  return { refs: refs(store, node) };
-}
-
-export async function cmdCasWalk(
-  storageRoot: string,
-  hash: string,
-): Promise<{ hashes: string[] }> {
-  const store = openStore(storageRoot);
-  const result: string[] = [];
-  walk(store, hash, (h) => {
-    result.push(h);
-  });
-  return { hashes: result };
-}
-
-export type SchemaListEntry = {
-  hash: string;
-  title: string;
-};
-
-export async function cmdCasSchemaList(
-  storageRoot: string,
-): Promise<SchemaListEntry[]> {
-  const store = openStore(storageRoot);
-  const metaHash = await bootstrap(store);
-  const entries: SchemaListEntry[] = [];
-
-  // Include meta-schema itself
-  entries.push({ hash: metaHash, title: "(meta-schema)" });
-
-  for (const hash of store.list()) {
-    if (hash === metaHash) continue;
-    const node = store.get(hash);
-    if (node !== null && node.type === metaHash) {
-      const schema = node.payload as JSONSchema;
-      const title =
-        (schema.title as string | undefined) ??
-        (schema.description as string | undefined) ??
-        "(unnamed)";
-      entries.push({ hash, title });
-    }
-  }
-  return entries;
-}
-
-export async function cmdCasSchemaGet(
-  storageRoot: string,
-  hash: string,
-): Promise<unknown> {
-  const store = openStore(storageRoot);
-  const schema = getSchema(store, hash);
-  if (schema === null) {
-    throw new Error(`Schema not found: ${hash}`);
-  }
-  return schema;
-}

packages/cli-uwf/src/commands/setup.ts

@@ -1,332 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-
-import { stringify, parse } from "yaml";
-
-/**
- * Preset provider list — embedded to avoid runtime YAML loading dependency.
- * Keep in sync with providers.yaml in cli-workflow.
- */
-const PRESET_PROVIDERS = [
-  // International
-  { name: "openai", label: "OpenAI", baseUrl: "https://api.openai.com/v1" },
-  { name: "xai", label: "xAI", baseUrl: "https://api.x.ai/v1" },
-  { name: "openrouter", label: "OpenRouter", baseUrl: "https://openrouter.ai/api/v1" },
-  { name: "venice", label: "Venice", baseUrl: "https://api.venice.ai/api/v1" },
-  // China
-  { name: "dashscope", label: "DashScope (Alibaba)", baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1" },
-  { name: "deepseek", label: "DeepSeek", baseUrl: "https://api.deepseek.com/v1" },
-  { name: "siliconflow", label: "SiliconFlow", baseUrl: "https://api.siliconflow.cn/v1" },
-  { name: "volcengine", label: "Volcengine (ByteDance)", baseUrl: "https://ark.cn-beijing.volces.com/api/v3" },
-  { name: "kimi", label: "Kimi (Moonshot)", baseUrl: "https://api.moonshot.cn/v1" },
-  { name: "glm", label: "GLM (Zhipu AI)", baseUrl: "https://open.bigmodel.cn/api/paas/v4" },
-  { name: "stepfun", label: "StepFun", baseUrl: "https://api.stepfun.com/v1" },
-  { name: "minimax", label: "MiniMax", baseUrl: "https://api.minimax.io/v1" },
-  // Local
-  { name: "ollama", label: "Ollama (local)", baseUrl: "http://localhost:11434/v1" },
-] as const;
-
-type SetupArgs = {
-  provider: string;
-  baseUrl: string;
-  apiKey: string;
-  model: string;
-  agent?: string | undefined;
-  storageRoot: string;
-};
-
-function getConfigPath(root: string): string {
-  return join(root, "config.yaml");
-}
-
-function getEnvPath(root: string): string {
-  return join(root, ".env");
-}
-
-/**
- * Load existing config.yaml or return empty structure.
- */
-function loadExistingConfig(configPath: string): Record<string, unknown> {
-  try {
-    if (existsSync(configPath)) {
-      const raw = parse(readFileSync(configPath, "utf8")) as unknown;
-      if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
-        return raw as Record<string, unknown>;
-      }
-    }
-  } catch {
-    // ignore parse errors, start fresh
-  }
-  return {};
-}
-
-/**
- * Load existing .env as key=value map.
- */
-function loadEnvFile(envPath: string): Record<string, string> {
-  const env: Record<string, string> = {};
-  try {
-    if (existsSync(envPath)) {
-      for (const line of readFileSync(envPath, "utf8").split("\n")) {
-        const trimmed = line.trim();
-        if (trimmed === "" || trimmed.startsWith("#")) continue;
-        const eq = trimmed.indexOf("=");
-        if (eq > 0) {
-          env[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
-        }
-      }
-    }
-  } catch {
-    // ignore
-  }
-  return env;
-}
-
-function saveEnvFile(envPath: string, env: Record<string, string>): void {
-  const lines = Object.entries(env).map(([k, v]) => `${k}=${v}`);
-  writeFileSync(envPath, `${lines.join("\n")}\n`, "utf8");
-}
-
-function apiKeyEnvName(providerName: string): string {
-  return `${providerName.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
-}
-
-/**
- * Merge setup args into config.yaml structure. Non-destructive — preserves existing entries.
- */
-function mergeConfig(existing: Record<string, unknown>, args: SetupArgs): Record<string, unknown> {
-  const providers = (typeof existing.providers === "object" && existing.providers !== null
-    ? { ...(existing.providers as Record<string, unknown>) }
-    : {}) as Record<string, unknown>;
-
-  const envName = apiKeyEnvName(args.provider);
-  providers[args.provider] = { baseUrl: args.baseUrl, apiKeyEnv: envName };
-
-  const models = (typeof existing.models === "object" && existing.models !== null
-    ? { ...(existing.models as Record<string, unknown>) }
-    : {}) as Record<string, unknown>;
-  models.default = { provider: args.provider, name: args.model };
-
-  const agents = (typeof existing.agents === "object" && existing.agents !== null
-    ? { ...(existing.agents as Record<string, unknown>) }
-    : {}) as Record<string, unknown>;
-
-  const agentName = args.agent ?? "hermes";
-  if (Object.keys(agents).length === 0) {
-    agents.hermes = { command: "uwf-hermes", args: [] };
-  }
-
-  return {
-    ...existing,
-    providers,
-    models,
-    agents,
-    defaultAgent: existing.defaultAgent ?? agentName,
-    defaultModel: existing.defaultModel ?? "default",
-  };
-}
-
-/**
- * Non-interactive setup. All required args provided via CLI flags.
- */
-export async function cmdSetup(args: SetupArgs): Promise<Record<string, unknown>> {
-  const { storageRoot } = args;
-  mkdirSync(storageRoot, { recursive: true });
-
-  const configPath = getConfigPath(storageRoot);
-  const envPath = getEnvPath(storageRoot);
-
-  const existing = loadExistingConfig(configPath);
-  const merged = mergeConfig(existing, args);
-
-  writeFileSync(configPath, stringify(merged, { indent: 2 }), "utf8");
-
-  // Write API key to .env
-  const envName = apiKeyEnvName(args.provider);
-  const envData = loadEnvFile(envPath);
-  envData[envName] = args.apiKey;
-  saveEnvFile(envPath, envData);
-
-  return {
-    configPath,
-    envPath,
-    provider: args.provider,
-    model: args.model,
-    defaultAgent: merged.defaultAgent,
-  };
-}
-
-/** Read a line with terminal echo disabled (for secrets). */
-async function promptSecret(label: string): Promise<string> {
-  process.stdout.write(label);
-  return new Promise((resolve) => {
-    const rawWasSet = process.stdin.isRaw;
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-    process.stdin.setEncoding("utf8");
-
-    let buf = "";
-    const onData = (chunk: string) => {
-      for (const c of chunk.toString()) {
-        if (c === "\n" || c === "\r" || c === "\u0004") {
-          if (process.stdin.isTTY) process.stdin.setRawMode(rawWasSet);
-          process.stdin.pause();
-          process.stdin.removeListener("data", onData);
-          process.stdout.write("\n");
-          resolve(buf.trim());
-          return;
-        }
-        if (c === "\u007F" || c === "\b") {
-          if (buf.length > 0) {
-            buf = buf.slice(0, -1);
-            process.stdout.write("\b \b");
-          }
-          continue;
-        }
-        if (c === "\u0003") {
-          if (process.stdin.isTTY) process.stdin.setRawMode(rawWasSet);
-          process.exit(130);
-        }
-        buf += c;
-        process.stdout.write("*");
-      }
-    };
-    process.stdin.on("data", onData);
-  });
-}
-
-/** Fetch available models from an OpenAI-compatible /models endpoint. */
-async function fetchModels(baseUrl: string, apiKey: string): Promise<string[]> {
-  try {
-    const url = `${baseUrl.replace(/\/+$/, "")}/models`;
-    const res = await fetch(url, {
-      headers: { Authorization: `Bearer ${apiKey}` },
-      signal: AbortSignal.timeout(10_000),
-    });
-    if (!res.ok) return [];
-    const body = (await res.json()) as { data?: { id: string }[] };
-    if (!Array.isArray(body.data)) return [];
-    const NON_CHAT = /speech|embed|image|video|audio|ocr|rerank|tts|asr|paraformer|sambert|cosyvoice|wordart|wanx|wan2|flux|stable-diffusion|gui-/i;
-    return body.data.map((m) => m.id).filter((id) => !NON_CHAT.test(id)).sort();
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Interactive setup — prompts user for provider, API key, model.
- */
-export async function cmdSetupInteractive(storageRoot: string): Promise<Record<string, unknown>> {
-  const rl = createInterface({ input, output });
-
-  try {
-    console.log("Configure LLM provider for uwf workflow agents.\n");
-
-    // 1. Provider selection
-    const numWidth = String(PRESET_PROVIDERS.length + 1).length;
-    console.log("Select a provider:\n");
-    for (let i = 0; i < PRESET_PROVIDERS.length; i++) {
-      const p = PRESET_PROVIDERS[i];
-      if (!p) continue;
-      const num = String(i + 1).padStart(numWidth);
-      console.log(`  ${num}) ${p.label.padEnd(28)} ${p.baseUrl}`);
-    }
-    const customNum = String(PRESET_PROVIDERS.length + 1).padStart(numWidth);
-    console.log(`  ${customNum}) Custom (enter name and URL manually)\n`);
-
-    const choice = (await rl.question(`Choose [1-${PRESET_PROVIDERS.length + 1}]: `)).trim();
-    const choiceNum = Number.parseInt(choice, 10);
-    if (Number.isNaN(choiceNum) || choiceNum < 1 || choiceNum > PRESET_PROVIDERS.length + 1) {
-      throw new Error(`Invalid choice: ${choice}`);
-    }
-
-    let providerName: string;
-    let baseUrl: string;
-
-    if (choiceNum <= PRESET_PROVIDERS.length) {
-      const selected = PRESET_PROVIDERS[choiceNum - 1];
-      if (!selected) throw new Error("Invalid selection");
-      providerName = selected.name;
-      baseUrl = selected.baseUrl;
-      console.log(`\n  → ${selected.label} (${selected.baseUrl})\n`);
-    } else {
-      providerName = (await rl.question("Provider name (e.g. my-proxy): ")).trim();
-      if (!providerName) throw new Error("Provider name required");
-      baseUrl = (await rl.question("OpenAI-compatible API base URL: ")).trim();
-      if (!baseUrl) throw new Error("Base URL required");
-    }
-
-    // 2. API key
-    rl.close();
-    const apiKey = await promptSecret("API key: ");
-    if (!apiKey) throw new Error("API key required");
-
-    // 3. Model selection
-    const rl2 = createInterface({ input, output });
-    console.log("\nFetching available models...");
-    const models = await fetchModels(baseUrl, apiKey);
-
-    let model: string;
-    if (models.length > 0) {
-      console.log(`\nAvailable models (${models.length}):\n`);
-      const nw = String(models.length).length;
-      // Multi-column layout
-      const maxLen = models.reduce((m, s) => Math.max(m, s.length), 0);
-      const colWidth = nw + 2 + maxLen + 4; // "  N) name    "
-      const termCols = process.stdout.columns || 100;
-      const cols = Math.max(1, Math.floor(termCols / colWidth));
-      const rows = Math.ceil(models.length / cols);
-      for (let r = 0; r < rows; r++) {
-        let line = "";
-        for (let c = 0; c < cols; c++) {
-          const idx = c * rows + r;
-          if (idx >= models.length) break;
-          const num = String(idx + 1).padStart(nw);
-          const name = (models[idx] ?? "").padEnd(maxLen);
-          line += `  ${num}) ${name}  `;
-        }
-        console.log(line.trimEnd());
-      }
-      console.log(`\nChoose a number, or type a model name directly.`);
-      const modelInput = (await rl2.question(`Default model [1-${models.length}]: `)).trim();
-      if (!modelInput) throw new Error("Model required");
-      const modelNum = Number.parseInt(modelInput, 10);
-      if (!Number.isNaN(modelNum) && modelNum >= 1 && modelNum <= models.length) {
-        model = models[modelNum - 1] ?? modelInput;
-      } else {
-        model = modelInput;
-      }
-    } else {
-      console.log("Could not fetch models. Enter model name manually.");
-      model = (await rl2.question("Default model (e.g. qwen-plus, gpt-4o): ")).trim();
-      if (!model) throw new Error("Model required");
-    }
-
-    rl2.close();
-
-    console.log(`  → ${providerName}/${model}\n`);
-
-    await cmdSetup({
-      provider: providerName,
-      baseUrl,
-      apiKey,
-      model,
-      storageRoot,
-    });
-
-    console.log("Setup complete! Get started:\n");
-    console.log("  uwf workflow put <workflow.yaml>   Register a workflow");
-    console.log('  uwf thread start <name> -p "..."   Start a thread');
-    console.log("  uwf thread step <thread-id>        Execute next step");
-    console.log("");
-
-    return null as unknown as Record<string, unknown>;
-  } finally {
-    rl.close();
-  }
-}

packages/cli-uwf/src/commands/thread.ts

@@ -1,465 +0,0 @@
-import { execFileSync } from "node:child_process";
-
-import { validate } from "@uncaged/json-cas";
-import { getEnvPath, loadWorkflowConfig } from "@uncaged/uwf-agent-kit";
-import { evaluate } from "@uncaged/uwf-moderator";
-import type {
-  AgentAlias,
-  AgentConfig,
-  CasRef,
-  ModeratorContext,
-  StartNodePayload,
-  StartOutput,
-  StepContext,
-  StepNodePayload,
-  StepOutput,
-  ThreadId,
-  ThreadListItem,
-  WorkflowConfig,
-  WorkflowPayload,
-} from "@uncaged/uwf-protocol";
-import { generateUlid } from "@uncaged/workflow-util";
-import { config as loadDotenv } from "dotenv";
-
-import {
-  appendThreadHistory,
-  createUwfStore,
-  findThreadInHistory,
-  loadThreadHistory,
-  loadThreadsIndex,
-  loadWorkflowRegistry,
-  resolveWorkflowHash,
-  saveThreadsIndex,
-  type ThreadHistoryLine,
-  type UwfStore,
-} from "../store.js";
-import { isCasRef } from "../validate.js";
-
-const END_ROLE = "$END";
-
-type ChainState = {
-  startHash: CasRef;
-  start: StartNodePayload;
-  stepsNewestFirst: StepNodePayload[];
-  headIsStart: boolean;
-};
-
-export type KillOutput = {
-  thread: ThreadId;
-  archived: boolean;
-};
-
-function fail(message: string): never {
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-}
-
-async function resolveWorkflowCasRef(
-  uwf: UwfStore,
-  storageRoot: string,
-  workflowId: string,
-): Promise<CasRef> {
-  const registry = await loadWorkflowRegistry(storageRoot);
-  const hash = resolveWorkflowHash(registry, workflowId);
-  if (!isCasRef(hash)) {
-    fail(`workflow not found: ${workflowId}`);
-  }
-  const node = uwf.store.get(hash);
-  if (node === null) {
-    fail(`CAS node not found: ${hash}`);
-  }
-  if (node.type !== uwf.schemas.workflow) {
-    fail(`node ${hash} is not a Workflow (type ${node.type})`);
-  }
-  return hash;
-}
-
-function resolveWorkflowFromHead(uwf: UwfStore, head: CasRef): CasRef | null {
-  const node = uwf.store.get(head);
-  if (node === null) {
-    return null;
-  }
-
-  if (node.type === uwf.schemas.startNode) {
-    const payload = node.payload as StartNodePayload;
-    return payload.workflow;
-  }
-
-  const payload = node.payload as StepNodePayload;
-  if (typeof payload.start !== "string") {
-    return null;
-  }
-
-  const startNode = uwf.store.get(payload.start);
-  if (startNode === null || startNode.type !== uwf.schemas.startNode) {
-    return null;
-  }
-
-  return (startNode.payload as StartNodePayload).workflow;
-}
-
-export async function cmdThreadStart(
-  storageRoot: string,
-  workflowId: string,
-  prompt: string,
-): Promise<StartOutput> {
-  const uwf = await createUwfStore(storageRoot);
-  const workflowHash = await resolveWorkflowCasRef(uwf, storageRoot, workflowId);
-
-  const threadId = generateUlid(Date.now()) as ThreadId;
-  const startPayload: StartNodePayload = {
-    workflow: workflowHash,
-    prompt,
-  };
-
-  const headHash = await uwf.store.put(uwf.schemas.startNode, startPayload);
-  const node = uwf.store.get(headHash);
-  if (node === null || !validate(uwf.store, node)) {
-    fail("stored StartNode failed schema validation");
-  }
-
-  const index = await loadThreadsIndex(storageRoot);
-  index[threadId] = headHash;
-  await saveThreadsIndex(storageRoot, index);
-
-  return { workflow: workflowHash, thread: threadId };
-}
-
-export async function cmdThreadShow(storageRoot: string, threadId: ThreadId): Promise<StepOutput> {
-  const index = await loadThreadsIndex(storageRoot);
-  const activeHead = index[threadId];
-  if (activeHead !== undefined) {
-    const uwf = await createUwfStore(storageRoot);
-    const workflow = resolveWorkflowFromHead(uwf, activeHead);
-    if (workflow === null) {
-      fail(`failed to resolve workflow from head: ${activeHead}`);
-    }
-    return {
-      workflow,
-      thread: threadId,
-      head: activeHead,
-      done: false,
-    };
-  }
-
-  const hist = await findThreadInHistory(storageRoot, threadId);
-  if (hist !== null) {
-    return {
-      workflow: hist.workflow,
-      thread: threadId,
-      head: hist.head,
-      done: true,
-    };
-  }
-
-  fail(`thread not found: ${threadId}`);
-}
-
-async function threadListItemFromActive(
-  uwf: UwfStore,
-  threadId: ThreadId,
-  head: CasRef,
-): Promise<ThreadListItem | null> {
-  const workflow = resolveWorkflowFromHead(uwf, head);
-  if (workflow === null) {
-    return null;
-  }
-  return { thread: threadId, workflow, head };
-}
-
-export async function cmdThreadList(
-  storageRoot: string,
-  includeAll: boolean,
-): Promise<ThreadListItem[]> {
-  const uwf = await createUwfStore(storageRoot);
-  const index = await loadThreadsIndex(storageRoot);
-  const items: ThreadListItem[] = [];
-
-  for (const [threadId, head] of Object.entries(index)) {
-    const item = await threadListItemFromActive(uwf, threadId as ThreadId, head);
-    if (item !== null) {
-      items.push(item);
-    }
-  }
-
-  if (!includeAll) {
-    return items;
-  }
-
-  const activeIds = new Set(items.map((i) => i.thread));
-  const history = await loadThreadHistory(storageRoot);
-  for (const entry of history) {
-    if (!activeIds.has(entry.thread)) {
-      items.push({
-        thread: entry.thread,
-        workflow: entry.workflow,
-        head: entry.head,
-      });
-    }
-  }
-
-  return items;
-}
-
-function walkChain(uwf: UwfStore, headHash: CasRef): ChainState {
-  const headNode = uwf.store.get(headHash);
-  if (headNode === null) {
-    fail(`CAS node not found: ${headHash}`);
-  }
-
-  if (headNode.type === uwf.schemas.startNode) {
-    return {
-      startHash: headHash,
-      start: headNode.payload as StartNodePayload,
-      stepsNewestFirst: [],
-      headIsStart: true,
-    };
-  }
-
-  if (headNode.type !== uwf.schemas.stepNode) {
-    fail(`head ${headHash} is not a StartNode or StepNode`);
-  }
-
-  const stepsNewestFirst: StepNodePayload[] = [];
-  let hash: CasRef | null = headHash;
-
-  while (hash !== null) {
-    const node = uwf.store.get(hash);
-    if (node === null) {
-      fail(`CAS node not found while walking chain: ${hash}`);
-    }
-    if (node.type !== uwf.schemas.stepNode) {
-      break;
-    }
-    const payload = node.payload as StepNodePayload;
-    stepsNewestFirst.push(payload);
-    hash = payload.prev;
-  }
-
-  const newest = stepsNewestFirst[0];
-  if (newest === undefined) {
-    fail(`empty step chain at head ${headHash}`);
-  }
-
-  const startNode = uwf.store.get(newest.start);
-  if (startNode === null || startNode.type !== uwf.schemas.startNode) {
-    fail(`StartNode not found: ${newest.start}`);
-  }
-
-  return {
-    startHash: newest.start,
-    start: startNode.payload as StartNodePayload,
-    stepsNewestFirst,
-    headIsStart: false,
-  };
-}
-
-function expandOutput(uwf: UwfStore, outputRef: CasRef): unknown {
-  const node = uwf.store.get(outputRef);
-  if (node === null) {
-    return {};
-  }
-  return node.payload;
-}
-
-function buildModeratorContext(uwf: UwfStore, chain: ChainState): ModeratorContext {
-  const chronological = [...chain.stepsNewestFirst].reverse();
-  const steps: StepContext[] = chronological.map((step) => ({
-    role: step.role,
-    output: expandOutput(uwf, step.output),
-    detail: step.detail,
-    agent: step.agent,
-  }));
-  return { start: chain.start, steps };
-}
-
-function loadWorkflowPayload(uwf: UwfStore, workflowRef: CasRef): WorkflowPayload {
-  const node = uwf.store.get(workflowRef);
-  if (node === null) {
-    fail(`workflow CAS node not found: ${workflowRef}`);
-  }
-  if (node.type !== uwf.schemas.workflow) {
-    fail(`node ${workflowRef} is not a Workflow`);
-  }
-  return node.payload as WorkflowPayload;
-}
-
-function parseAgentOverride(override: string): AgentConfig {
-  const parts = override
-    .trim()
-    .split(/\s+/)
-    .filter((p) => p.length > 0);
-  const command = parts[0];
-  if (command === undefined) {
-    fail("agent override must not be empty");
-  }
-  return { command, args: parts.slice(1) };
-}
-
-function resolveAgentConfig(
-  config: WorkflowConfig,
-  workflow: WorkflowPayload,
-  role: string,
-  agentOverride: string | null,
-): AgentConfig {
-  if (agentOverride !== null) {
-    return parseAgentOverride(agentOverride);
-  }
-
-  let alias: AgentAlias = config.defaultAgent;
-  if (config.agentOverrides !== null) {
-    const roleOverrides = config.agentOverrides[workflow.name];
-    if (roleOverrides !== undefined && roleOverrides[role] !== undefined) {
-      alias = roleOverrides[role];
-    }
-  }
-
-  const agentConfig = config.agents[alias];
-  if (agentConfig === undefined) {
-    fail(`unknown agent alias in config: ${alias}`);
-  }
-  return agentConfig;
-}
-
-function spawnAgent(agent: AgentConfig, threadId: ThreadId, role: string): CasRef {
-  const argv = [...agent.args, threadId, role];
-  let stdout: string;
-  try {
-    stdout = execFileSync(agent.command, argv, {
-      encoding: "utf8",
-      env: process.env,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-  } catch (e) {
-    const err = e as NodeJS.ErrnoException & { stderr?: Buffer | string };
-    const stderr =
-      err.stderr === undefined
-        ? ""
-        : typeof err.stderr === "string"
-          ? err.stderr
-          : err.stderr.toString("utf8");
-    const detail = stderr.trim() !== "" ? `: ${stderr.trim()}` : "";
-    fail(`agent command failed (${agent.command})${detail}`);
-  }
-
-  const line = stdout.trim().split("\n").pop()?.trim() ?? "";
-  if (!isCasRef(line)) {
-    fail(`agent stdout is not a valid CAS hash: ${line || "(empty)"}`);
-  }
-  return line;
-}
-
-async function archiveThread(
-  storageRoot: string,
-  threadId: ThreadId,
-  workflow: CasRef,
-  head: CasRef,
-): Promise<void> {
-  const index = await loadThreadsIndex(storageRoot);
-  delete index[threadId];
-  await saveThreadsIndex(storageRoot, index);
-  await appendThreadHistory(storageRoot, {
-    thread: threadId,
-    workflow,
-    head,
-    completedAt: Date.now(),
-  });
-}
-
-export async function cmdThreadStep(
-  storageRoot: string,
-  threadId: ThreadId,
-  agentOverride: string | null,
-): Promise<StepOutput> {
-  const index = await loadThreadsIndex(storageRoot);
-  const headHash = index[threadId];
-  if (headHash === undefined) {
-    fail(`thread not active: ${threadId}`);
-  }
-
-  const uwf = await createUwfStore(storageRoot);
-  const chain = walkChain(uwf, headHash);
-  const workflowHash = chain.start.workflow;
-  const workflow = loadWorkflowPayload(uwf, workflowHash);
-  const context = buildModeratorContext(uwf, chain);
-
-  const nextResult = await evaluate(workflow, context);
-  if (!nextResult.ok) {
-    fail(nextResult.error.message);
-  }
-
-  if (nextResult.value === END_ROLE) {
-    await archiveThread(storageRoot, threadId, workflowHash, headHash);
-    return {
-      workflow: workflowHash,
-      thread: threadId,
-      head: headHash,
-      done: true,
-    };
-  }
-
-  const role = nextResult.value;
-  const config = await loadWorkflowConfig(storageRoot);
-  const agent = resolveAgentConfig(config, workflow, role, agentOverride);
-
-  loadDotenv({ path: getEnvPath(storageRoot) });
-  const newHead = spawnAgent(agent, threadId, role);
-
-  // Re-create store to pick up nodes written by the agent subprocess
-  const uwfAfter = await createUwfStore(storageRoot);
-  const newNode = uwfAfter.store.get(newHead);
-  if (newNode === null || newNode.type !== uwfAfter.schemas.stepNode) {
-    fail(`agent returned hash that is not a StepNode: ${newHead}`);
-  }
-
-  // Reload threads index to avoid overwriting changes made by the agent subprocess
-  const freshIndex = await loadThreadsIndex(storageRoot);
-  freshIndex[threadId] = newHead;
-  await saveThreadsIndex(storageRoot, freshIndex);
-
-  const chainAfter = walkChain(uwfAfter, newHead);
-  const contextAfter = buildModeratorContext(uwfAfter, chainAfter);
-  const afterResult = await evaluate(workflow, contextAfter);
-  if (!afterResult.ok) {
-    fail(afterResult.error.message);
-  }
-
-  const done = afterResult.value === END_ROLE;
-  if (done) {
-    await archiveThread(storageRoot, threadId, workflowHash, newHead);
-  }
-
-  return {
-    workflow: workflowHash,
-    thread: threadId,
-    head: newHead,
-    done,
-  };
-}
-
-export async function cmdThreadKill(storageRoot: string, threadId: ThreadId): Promise<KillOutput> {
-  const index = await loadThreadsIndex(storageRoot);
-  const head = index[threadId];
-  if (head === undefined) {
-    fail(`thread not active: ${threadId}`);
-  }
-
-  const uwf = await createUwfStore(storageRoot);
-  const workflow = resolveWorkflowFromHead(uwf, head);
-  if (workflow === null) {
-    fail(`failed to resolve workflow from head: ${head}`);
-  }
-
-  delete index[threadId];
-  await saveThreadsIndex(storageRoot, index);
-
-  const historyEntry: ThreadHistoryLine = {
-    thread: threadId,
-    workflow,
-    head,
-    completedAt: Date.now(),
-  };
-  await appendThreadHistory(storageRoot, historyEntry);
-
-  return { thread: threadId, archived: true };
-}

packages/cli-uwf/src/commands/workflow.ts

@@ -1,153 +0,0 @@
-import { readFile } from "node:fs/promises";
-
-import type { JSONSchema } from "@uncaged/json-cas";
-import { putSchema, validate } from "@uncaged/json-cas";
-import type { CasRef, RoleDefinition, WorkflowPayload } from "@uncaged/uwf-protocol";
-import { parse } from "yaml";
-
-import {
-  createUwfStore,
-  findRegistryName,
-  loadWorkflowRegistry,
-  resolveWorkflowHash,
-  saveWorkflowRegistry,
-  type UwfStore,
-} from "../store.js";
-import { parseWorkflowPayload } from "../validate.js";
-
-export type WorkflowListEntry = {
-  name: string;
-  hash: CasRef;
-};
-
-export type WorkflowPutOutput = {
-  name: string;
-  hash: CasRef;
-};
-
-export type WorkflowShowOutput = {
-  hash: CasRef;
-  name: string | null;
-  type: CasRef;
-  payload: WorkflowPayload;
-  timestamp: number;
-};
-
-function fail(message: string): never {
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-}
-
-function isJsonSchema(value: unknown): value is JSONSchema {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-async function resolveOutputSchemaRef(
-  uwf: UwfStore,
-  roleName: string,
-  outputSchema: unknown,
-): Promise<CasRef> {
-  if (!isJsonSchema(outputSchema)) {
-    fail(`role "${roleName}": outputSchema must be a JSON Schema object`);
-  }
-  const schema: JSONSchema = outputSchema.title === undefined
-    ? { ...outputSchema, title: roleName }
-    : outputSchema;
-  return putSchema(uwf.store, schema);
-}
-
-async function materializeWorkflowPayload(
-  uwf: UwfStore,
-  raw: WorkflowPayload,
-): Promise<WorkflowPayload> {
-  const roles: Record<string, RoleDefinition> = {};
-  for (const [roleName, role] of Object.entries(raw.roles)) {
-    const outputSchema = await resolveOutputSchemaRef(
-      uwf,
-      `${raw.name}.${roleName}`,
-      role.outputSchema,
-    );
-    roles[roleName] = {
-      description: role.description,
-      systemPrompt: role.systemPrompt,
-      outputSchema,
-    };
-  }
-  return {
-    name: raw.name,
-    description: raw.description,
-    roles,
-    conditions: raw.conditions,
-    graph: raw.graph,
-  };
-}
-
-export async function cmdWorkflowPut(
-  storageRoot: string,
-  filePath: string,
-): Promise<WorkflowPutOutput> {
-  let text: string;
-  try {
-    text = await readFile(filePath, "utf8");
-  } catch {
-    fail(`file not found: ${filePath}`);
-  }
-
-  let raw: unknown;
-  try {
-    raw = parse(text) as unknown;
-  } catch (e) {
-    fail(`invalid YAML: ${e instanceof Error ? e.message : String(e)}`);
-  }
-
-  const payload = parseWorkflowPayload(raw);
-  if (payload === null) {
-    fail("invalid workflow YAML: expected WorkflowPayload shape");
-  }
-
-  const uwf = await createUwfStore(storageRoot);
-  const materialized = await materializeWorkflowPayload(uwf, payload);
-
-  const hash = await uwf.store.put(uwf.schemas.workflow, materialized);
-  const node = uwf.store.get(hash);
-  if (node === null || !validate(uwf.store, node)) {
-    fail("stored workflow failed schema validation");
-  }
-
-  const registry = await loadWorkflowRegistry(storageRoot);
-  registry[materialized.name] = hash;
-  await saveWorkflowRegistry(storageRoot, registry);
-
-  return { name: materialized.name, hash };
-}
-
-export async function cmdWorkflowShow(
-  storageRoot: string,
-  id: string,
-): Promise<WorkflowShowOutput> {
-  const uwf = await createUwfStore(storageRoot);
-  const registry = await loadWorkflowRegistry(storageRoot);
-  const hash = resolveWorkflowHash(registry, id);
-
-  const node = uwf.store.get(hash);
-  if (node === null) {
-    fail(`CAS node not found: ${hash}`);
-  }
-  if (node.type !== uwf.schemas.workflow) {
-    fail(`node ${hash} is not a Workflow (type ${node.type})`);
-  }
-
-  const payload = node.payload as WorkflowPayload;
-  return {
-    hash,
-    name: findRegistryName(registry, hash),
-    type: node.type,
-    payload,
-    timestamp: node.timestamp,
-  };
-}
-
-export async function cmdWorkflowList(storageRoot: string): Promise<WorkflowListEntry[]> {
-  const registry = await loadWorkflowRegistry(storageRoot);
-  return Object.entries(registry).map(([name, hash]) => ({ name, hash }));
-}

packages/cli-uwf/src/format.ts

@@ -1,35 +0,0 @@
-import { stringify } from "yaml";
-
-export type OutputFormat = "json" | "yaml" | "table";
-
-function formatTable(data: Array<Record<string, unknown>>): string {
-  if (data.length === 0) return "";
-  const keys = Object.keys(data[0]);
-  const widths = keys.map((k) => {
-    let max = k.length;
-    for (const row of data) {
-      const len = String(row[k] ?? "").length;
-      if (len > max) max = len;
-    }
-    return max;
-  });
-  const header = keys.map((k, i) => k.toUpperCase().padEnd(widths[i])).join("  ");
-  const rows = data.map((row) =>
-    keys.map((k, i) => String(row[k] ?? "").padEnd(widths[i])).join("  "),
-  );
-  return [header, ...rows].join("\n");
-}
-
-export function formatOutput(data: unknown, format: OutputFormat): string {
-  switch (format) {
-    case "json":
-      return JSON.stringify(data);
-    case "yaml":
-      return stringify(data).trimEnd();
-    case "table":
-      if (Array.isArray(data) && data.length > 0 && typeof data[0] === "object" && data[0] !== null) {
-        return formatTable(data as Array<Record<string, unknown>>);
-      }
-      return stringify(data).trimEnd();
-  }
-}

packages/cli-uwf/src/schemas.ts

@@ -1,26 +0,0 @@
-import type { Hash, Store } from "@uncaged/json-cas";
-import { putSchema } from "@uncaged/json-cas";
-import {
-  START_NODE_SCHEMA,
-  STEP_NODE_SCHEMA,
-  WORKFLOW_SCHEMA,
-} from "@uncaged/uwf-protocol";
-
-export type UwfSchemaHashes = {
-  workflow: Hash;
-  startNode: Hash;
-  stepNode: Hash;
-};
-
-/**
- * Register Workflow, StartNode, and StepNode JSON Schemas in the CAS store.
- * Idempotent: safe to call on every CLI invocation.
- */
-export async function registerUwfSchemas(store: Store): Promise<UwfSchemaHashes> {
-  const [workflow, startNode, stepNode] = await Promise.all([
-    putSchema(store, WORKFLOW_SCHEMA),
-    putSchema(store, START_NODE_SCHEMA),
-    putSchema(store, STEP_NODE_SCHEMA),
-  ]);
-  return { workflow, startNode, stepNode };
-}

packages/cli-uwf/src/store.ts

@@ -1,212 +0,0 @@
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-import type { Hash, Store } from "@uncaged/json-cas";
-import { createFsStore } from "@uncaged/json-cas-fs";
-import type { CasRef, ThreadId, ThreadListItem, ThreadsIndex } from "@uncaged/uwf-protocol";
-import { parse, stringify } from "yaml";
-
-import { registerUwfSchemas, type UwfSchemaHashes } from "./schemas.js";
-
-export type WorkflowRegistry = Record<string, CasRef>;
-
-/** Default filesystem root for uwf data (`~/.uncaged/workflow`). */
-export function getDefaultStorageRoot(): string {
-  return join(homedir(), ".uncaged", "workflow");
-}
-
-/**
- * Resolve storage root.
- * Priority: `UNCAGED_WORKFLOW_STORAGE_ROOT` → `WORKFLOW_STORAGE_ROOT` → default.
- */
-export function resolveStorageRoot(): string {
-  const internal = process.env.UNCAGED_WORKFLOW_STORAGE_ROOT;
-  if (internal !== undefined && internal !== "") {
-    return internal;
-  }
-  const userOverride = process.env.WORKFLOW_STORAGE_ROOT;
-  if (userOverride !== undefined && userOverride !== "") {
-    return userOverride;
-  }
-  return getDefaultStorageRoot();
-}
-
-export function getCasDir(storageRoot: string): string {
-  return join(storageRoot, "cas");
-}
-
-export function getRegistryPath(storageRoot: string): string {
-  return join(storageRoot, "workflows.yaml");
-}
-
-export function getThreadsPath(storageRoot: string): string {
-  return join(storageRoot, "threads.yaml");
-}
-
-export function getHistoryPath(storageRoot: string): string {
-  return join(storageRoot, "history.jsonl");
-}
-
-export type ThreadHistoryLine = ThreadListItem & {
-  completedAt: number;
-};
-
-export type UwfStore = {
-  storageRoot: string;
-  store: Store;
-  schemas: UwfSchemaHashes;
-};
-
-export async function createUwfStore(storageRoot: string): Promise<UwfStore> {
-  const casDir = getCasDir(storageRoot);
-  await mkdir(casDir, { recursive: true });
-  const store = createFsStore(casDir);
-  const schemas = await registerUwfSchemas(store);
-  return { storageRoot, store, schemas };
-}
-
-export async function loadWorkflowRegistry(storageRoot: string): Promise<WorkflowRegistry> {
-  const path = getRegistryPath(storageRoot);
-  try {
-    const text = await readFile(path, "utf8");
-    const raw = parse(text) as unknown;
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-      return {};
-    }
-    const registry: WorkflowRegistry = {};
-    for (const [name, hash] of Object.entries(raw as Record<string, unknown>)) {
-      if (typeof hash === "string") {
-        registry[name] = hash;
-      }
-    }
-    return registry;
-  } catch (e) {
-    const err = e as NodeJS.ErrnoException;
-    if (err.code === "ENOENT") {
-      return {};
-    }
-    throw e;
-  }
-}
-
-export async function saveWorkflowRegistry(
-  storageRoot: string,
-  registry: WorkflowRegistry,
-): Promise<void> {
-  const path = getRegistryPath(storageRoot);
-  await mkdir(storageRoot, { recursive: true });
-  const text = stringify(registry, { indent: 2 });
-  await writeFile(path, text, "utf8");
-}
-
-export function resolveWorkflowHash(registry: WorkflowRegistry, id: string): CasRef {
-  return registry[id] !== undefined ? registry[id] : id;
-}
-
-export function findRegistryName(registry: WorkflowRegistry, hash: Hash): string | null {
-  for (const [name, h] of Object.entries(registry)) {
-    if (h === hash) {
-      return name;
-    }
-  }
-  return null;
-}
-
-export async function loadThreadsIndex(storageRoot: string): Promise<ThreadsIndex> {
-  const path = getThreadsPath(storageRoot);
-  try {
-    const text = await readFile(path, "utf8");
-    const raw = parse(text) as unknown;
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-      return {};
-    }
-    const index: ThreadsIndex = {};
-    for (const [threadId, head] of Object.entries(raw as Record<string, unknown>)) {
-      if (typeof head === "string") {
-        index[threadId as ThreadId] = head;
-      }
-    }
-    return index;
-  } catch (e) {
-    const err = e as NodeJS.ErrnoException;
-    if (err.code === "ENOENT") {
-      return {};
-    }
-    throw e;
-  }
-}
-
-export async function saveThreadsIndex(storageRoot: string, index: ThreadsIndex): Promise<void> {
-  const path = getThreadsPath(storageRoot);
-  await mkdir(storageRoot, { recursive: true });
-  const text = stringify(index, { indent: 2 });
-  await writeFile(path, text, "utf8");
-}
-
-export async function loadThreadHistory(storageRoot: string): Promise<ThreadHistoryLine[]> {
-  const path = getHistoryPath(storageRoot);
-  try {
-    const text = await readFile(path, "utf8");
-    const lines: ThreadHistoryLine[] = [];
-    for (const line of text.split("\n")) {
-      const trimmed = line.trim();
-      if (trimmed === "") {
-        continue;
-      }
-      let raw: unknown;
-      try {
-        raw = JSON.parse(trimmed) as unknown;
-      } catch {
-        continue;
-      }
-      if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-        continue;
-      }
-      const rec = raw as Record<string, unknown>;
-      const thread = rec.thread;
-      const workflow = rec.workflow;
-      const head = rec.head;
-      const completedAt = rec.completedAt;
-      if (
-        typeof thread === "string" &&
-        typeof workflow === "string" &&
-        typeof head === "string" &&
-        typeof completedAt === "number"
-      ) {
-        lines.push({ thread: thread as ThreadId, workflow, head, completedAt });
-      }
-    }
-    return lines;
-  } catch (e) {
-    const err = e as NodeJS.ErrnoException;
-    if (err.code === "ENOENT") {
-      return [];
-    }
-    throw e;
-  }
-}
-
-export async function findThreadInHistory(
-  storageRoot: string,
-  threadId: ThreadId,
-): Promise<ThreadHistoryLine | null> {
-  const history = await loadThreadHistory(storageRoot);
-  for (let i = history.length - 1; i >= 0; i--) {
-    const entry = history[i];
-    if (entry !== undefined && entry.thread === threadId) {
-      return entry;
-    }
-  }
-  return null;
-}
-
-export async function appendThreadHistory(
-  storageRoot: string,
-  entry: ThreadHistoryLine,
-): Promise<void> {
-  const path = getHistoryPath(storageRoot);
-  await mkdir(storageRoot, { recursive: true });
-  const line = `${JSON.stringify(entry)}\n`;
-  await appendFile(path, line, "utf8");
-}

packages/cli-uwf/src/validate.ts

@@ -1,71 +0,0 @@
-import type { CasRef, WorkflowPayload } from "@uncaged/uwf-protocol";
-
-const CAS_REF_PATTERN = /^[0-9A-HJKMNP-TV-Z]{13}$/;
-
-export function isCasRef(value: string): value is CasRef {
-  return CAS_REF_PATTERN.test(value);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isRoleDefinition(value: unknown): boolean {
-  if (!isRecord(value)) {
-    return false;
-  }
-  const outputSchema = value.outputSchema;
-  const schemaOk = isRecord(outputSchema) && typeof outputSchema.type === "string";
-  return (
-    typeof value.description === "string" && typeof value.systemPrompt === "string" && schemaOk
-  );
-}
-
-function isConditionDefinition(value: unknown): boolean {
-  if (!isRecord(value)) {
-    return false;
-  }
-  return typeof value.description === "string" && typeof value.expression === "string";
-}
-
-function isTransition(value: unknown): boolean {
-  if (!isRecord(value)) {
-    return false;
-  }
-  const condition = value.condition;
-  return typeof value.role === "string" && (condition === null || typeof condition === "string");
-}
-
-function isStringRecord(value: unknown, itemCheck: (item: unknown) => boolean): boolean {
-  if (!isRecord(value)) {
-    return false;
-  }
-  return Object.values(value).every(itemCheck);
-}
-
-function isGraph(value: unknown): boolean {
-  if (!isRecord(value)) {
-    return false;
-  }
-  return Object.values(value).every(
-    (transitions) => Array.isArray(transitions) && transitions.every((t) => isTransition(t)),
-  );
-}
-
-/** Validate YAML-parsed workflow document shape (outputSchema may be inline JSON Schema). */
-export function parseWorkflowPayload(raw: unknown): WorkflowPayload | null {
-  if (!isRecord(raw)) {
-    return null;
-  }
-  if (typeof raw.name !== "string" || typeof raw.description !== "string") {
-    return null;
-  }
-  if (
-    !isStringRecord(raw.roles, isRoleDefinition) ||
-    !isStringRecord(raw.conditions, isConditionDefinition) ||
-    !isGraph(raw.graph)
-  ) {
-    return null;
-  }
-  return raw as WorkflowPayload;
-}

packages/cli-uwf/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  },
-  "include": ["src"],
-  "references": [
-    { "path": "../uwf-protocol" },
-    { "path": "../uwf-moderator" },
-    { "path": "../uwf-agent-kit" }
-  ]
-}

packages/uwf-agent-hermes/package.json

@@ -1,32 +0,0 @@
-{
-  "name": "@uncaged/uwf-agent-hermes",
-  "version": "0.1.0",
-  "files": [
-    "src",
-    "dist",
-    "package.json"
-  ],
-  "type": "module",
-  "bin": {
-    "uwf-hermes": "./src/cli.ts"
-  },
-  "exports": {
-    ".": {
-      "bun": "./src/index.ts",
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "test": "bun test"
-  },
-  "dependencies": {
-    "@uncaged/uwf-agent-kit": "workspace:^"
-  },
-  "devDependencies": {
-    "typescript": "^5.8.3"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}

packages/uwf-agent-hermes/src/cli.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env bun
-
-import { createHermesAgent } from "./hermes.js";
-
-const main = createHermesAgent();
-void main();

packages/uwf-agent-hermes/src/hermes.ts

@@ -1,90 +0,0 @@
-import { spawn } from "node:child_process";
-
-import { type AgentContext, createAgent } from "@uncaged/uwf-agent-kit";
-
-const HERMES_COMMAND = "hermes";
-const HERMES_MAX_TURNS = 90;
-
-function buildHistorySummary(history: AgentContext["history"]): string {
-  if (history.length === 0) {
-    return "";
-  }
-
-  const lines: string[] = ["## Previous Steps"];
-  for (let i = 0; i < history.length; i++) {
-    const step = history[i];
-    if (step === undefined) {
-      continue;
-    }
-    lines.push("");
-    lines.push(`### Step ${i + 1}: ${step.role}`);
-    lines.push(`Output: ${JSON.stringify(step.output)}`);
-    lines.push(`Agent: ${step.agent}`);
-  }
-  return lines.join("\n");
-}
-
-/** Assemble system prompt, task, and prior step outputs for Hermes. */
-export function buildHermesPrompt(ctx: AgentContext): string {
-  const parts: string[] = [ctx.systemPrompt, "", "## Task", ctx.prompt];
-  const historyBlock = buildHistorySummary(ctx.history);
-  if (historyBlock !== "") {
-    parts.push("", historyBlock);
-  }
-  return parts.join("\n");
-}
-
-function spawnHermesChat(prompt: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const args = [
-      "chat",
-      "-q",
-      prompt,
-      "--yolo",
-      "--max-turns",
-      String(HERMES_MAX_TURNS),
-      "--quiet",
-    ];
-    const child = spawn(HERMES_COMMAND, args, {
-      env: process.env,
-      shell: false,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (chunk: Buffer) => {
-      stdout += chunk.toString();
-    });
-    child.stderr?.on("data", (chunk: Buffer) => {
-      stderr += chunk.toString();
-    });
-
-    child.on("error", (cause) => {
-      const message = cause instanceof Error ? cause.message : String(cause);
-      reject(new Error(`hermes spawn failed: ${message}`));
-    });
-
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve(stdout);
-        return;
-      }
-      const detail = stderr.trim() !== "" ? ` stderr=${stderr.trim()}` : "";
-      reject(new Error(`hermes exited with code ${code ?? "null"}${detail}`));
-    });
-  });
-}
-
-async function runHermes(ctx: AgentContext): Promise<string> {
-  const fullPrompt = buildHermesPrompt(ctx);
-  return spawnHermesChat(fullPrompt);
-}
-
-/** Agent CLI factory: parses argv, runs Hermes, extracts output, writes StepNode. */
-export function createHermesAgent(): () => Promise<void> {
-  return createAgent({
-    name: "hermes",
-    run: runHermes,
-  });
-}

packages/uwf-agent-hermes/src/index.ts

@@ -1 +0,0 @@
-export { buildHermesPrompt, createHermesAgent } from "./hermes.js";

packages/uwf-agent-hermes/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  },
-  "include": ["src"],
-  "references": [{ "path": "../uwf-agent-kit" }]
-}

packages/uwf-agent-kit/__tests__/resolve-extract-model.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { WorkflowConfig } from "@uncaged/uwf-protocol";
-import { resolveExtractModelAlias } from "../src/extract.js";
-
-function baseConfig(overrides: Partial<WorkflowConfig> = {}): WorkflowConfig {
-  return {
-    providers: {},
-    models: {
-      sonnet: { provider: "openrouter", name: "anthropic/claude-sonnet-4" },
-      "gpt4o-mini": { provider: "openai", name: "gpt-4o-mini" },
-    },
-    agents: {},
-    defaultAgent: "hermes",
-    agentOverrides: null,
-    defaultModel: "sonnet",
-    modelOverrides: null,
-    ...overrides,
-  };
-}
-
-describe("resolveExtractModelAlias", () => {
-  test("uses modelOverrides.extract when set", () => {
-    const config = baseConfig({
-      modelOverrides: { extract: "gpt4o-mini" },
-    });
-    expect(resolveExtractModelAlias(config)).toBe("gpt4o-mini");
-  });
-
-  test("falls back to models.extract alias when present", () => {
-    const config = baseConfig({
-      models: {
-        extract: { provider: "openai", name: "gpt-4o-mini" },
-        sonnet: { provider: "openrouter", name: "anthropic/claude-sonnet-4" },
-      },
-    });
-    expect(resolveExtractModelAlias(config)).toBe("extract");
-  });
-
-  test("falls back to defaultModel", () => {
-    expect(resolveExtractModelAlias(baseConfig())).toBe("sonnet");
-  });
-});

packages/uwf-agent-kit/package.json

@@ -1,33 +0,0 @@
-{
-  "name": "@uncaged/uwf-agent-kit",
-  "version": "0.1.0",
-  "files": [
-    "src",
-    "dist",
-    "package.json"
-  ],
-  "type": "module",
-  "exports": {
-    ".": {
-      "bun": "./src/index.ts",
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "test": "bun test"
-  },
-  "dependencies": {
-    "@uncaged/json-cas": "^0.1.3",
-    "@uncaged/json-cas-fs": "^0.1.2",
-    "@uncaged/uwf-protocol": "workspace:^",
-    "dotenv": "^16.6.1",
-    "yaml": "^2.8.4"
-  },
-  "devDependencies": {
-    "typescript": "^5.8.3"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}

packages/uwf-agent-kit/src/context.ts

@@ -1,199 +0,0 @@
-import type {
-  CasRef,
-  StartNodePayload,
-  StepContext,
-  StepNodePayload,
-  ThreadId,
-} from "@uncaged/uwf-protocol";
-import { createAgentStore, loadThreadsIndex, resolveStorageRoot } from "./storage.js";
-import type { AgentContext } from "./types.js";
-
-type ChainState = {
-  startHash: CasRef;
-  start: StartNodePayload;
-  stepsNewestFirst: StepNodePayload[];
-  headIsStart: boolean;
-};
-
-function fail(message: string): never {
-  throw new Error(message);
-}
-
-function walkChain(
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"],
-  schemas: Awaited<ReturnType<typeof createAgentStore>>["schemas"],
-  headHash: CasRef,
-): ChainState {
-  const headNode = store.get(headHash);
-  if (headNode === null) {
-    fail(`CAS node not found: ${headHash}`);
-  }
-
-  if (headNode.type === schemas.startNode) {
-    return {
-      startHash: headHash,
-      start: headNode.payload as StartNodePayload,
-      stepsNewestFirst: [],
-      headIsStart: true,
-    };
-  }
-
-  if (headNode.type !== schemas.stepNode) {
-    fail(`head ${headHash} is not a StartNode or StepNode`);
-  }
-
-  const stepsNewestFirst: StepNodePayload[] = [];
-  let hash: CasRef | null = headHash;
-
-  while (hash !== null) {
-    const node = store.get(hash);
-    if (node === null) {
-      fail(`CAS node not found while walking chain: ${hash}`);
-    }
-    if (node.type !== schemas.stepNode) {
-      break;
-    }
-    const payload = node.payload as StepNodePayload;
-    stepsNewestFirst.push(payload);
-    hash = payload.prev;
-  }
-
-  const newest = stepsNewestFirst[0];
-  if (newest === undefined) {
-    fail(`empty step chain at head ${headHash}`);
-  }
-
-  const startNode = store.get(newest.start);
-  if (startNode === null || startNode.type !== schemas.startNode) {
-    fail(`StartNode not found: ${newest.start}`);
-  }
-
-  return {
-    startHash: newest.start,
-    start: startNode.payload as StartNodePayload,
-    stepsNewestFirst,
-    headIsStart: false,
-  };
-}
-
-function expandOutput(
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"],
-  outputRef: CasRef,
-): unknown {
-  const node = store.get(outputRef);
-  if (node === null) {
-    return {};
-  }
-  return node.payload;
-}
-
-async function buildHistory(
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"],
-  stepsNewestFirst: StepNodePayload[],
-): Promise<StepContext[]> {
-  const chronological = [...stepsNewestFirst].reverse();
-  const history: StepContext[] = [];
-  for (const step of chronological) {
-    history.push({
-      role: step.role,
-      output: expandOutput(store, step.output),
-      detail: step.detail,
-      agent: step.agent,
-    });
-  }
-  return history;
-}
-
-async function loadWorkflow(
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"],
-  schemas: Awaited<ReturnType<typeof createAgentStore>>["schemas"],
-  workflowRef: CasRef,
-) {
-  const node = store.get(workflowRef);
-  if (node === null) {
-    fail(`workflow CAS node not found: ${workflowRef}`);
-  }
-  if (node.type !== schemas.workflow) {
-    fail(`node ${workflowRef} is not a Workflow`);
-  }
-  return node.payload as AgentContext["workflow"];
-}
-
-/**
- * Build agent execution context from thread head in threads.yaml.
- * Walks the CAS chain from head to StartNode and expands step outputs.
- */
-export async function buildContext(threadId: ThreadId, role: string): Promise<AgentContext> {
-  const storageRoot = resolveStorageRoot();
-  const agentStore = await createAgentStore(storageRoot);
-  const { store, schemas } = agentStore;
-
-  const index = await loadThreadsIndex(storageRoot);
-  const headHash = index[threadId];
-  if (headHash === undefined) {
-    fail(`thread not found in threads.yaml: ${threadId}`);
-  }
-
-  const chain = walkChain(store, schemas, headHash);
-  const workflow = await loadWorkflow(store, schemas, chain.start.workflow);
-  const roleDef = workflow.roles[role];
-  if (roleDef === undefined) {
-    fail(`unknown role "${role}" in workflow "${workflow.name}"`);
-  }
-
-  const history = await buildHistory(store, chain.stepsNewestFirst);
-
-  return {
-    threadId,
-    role,
-    systemPrompt: roleDef.systemPrompt,
-    prompt: chain.start.prompt,
-    history,
-    workflow,
-  };
-}
-
-export type BuildContextMeta = {
-  storageRoot: string;
-  store: Awaited<ReturnType<typeof createAgentStore>>["store"];
-  schemas: Awaited<ReturnType<typeof createAgentStore>>["schemas"];
-  headHash: CasRef;
-  chain: ChainState;
-};
-
-/**
- * Same as {@link buildContext} but also returns chain metadata for writing the next StepNode.
- */
-export async function buildContextWithMeta(
-  threadId: ThreadId,
-  role: string,
-): Promise<AgentContext & { meta: BuildContextMeta }> {
-  const storageRoot = resolveStorageRoot();
-  const agentStore = await createAgentStore(storageRoot);
-  const { store, schemas } = agentStore;
-
-  const index = await loadThreadsIndex(storageRoot);
-  const headHash = index[threadId];
-  if (headHash === undefined) {
-    fail(`thread not found in threads.yaml: ${threadId}`);
-  }
-
-  const chain = walkChain(store, schemas, headHash);
-  const workflow = await loadWorkflow(store, schemas, chain.start.workflow);
-  const roleDef = workflow.roles[role];
-  if (roleDef === undefined) {
-    fail(`unknown role "${role}" in workflow "${workflow.name}"`);
-  }
-
-  const history = await buildHistory(store, chain.stepsNewestFirst);
-
-  return {
-    threadId,
-    role,
-    systemPrompt: roleDef.systemPrompt,
-    prompt: chain.start.prompt,
-    history,
-    workflow,
-    meta: { storageRoot, store, schemas, headHash, chain },
-  };
-}

packages/uwf-agent-kit/src/extract.ts

@@ -1,181 +0,0 @@
-import { getSchema, validate } from "@uncaged/json-cas";
-
-import type { CasRef, ModelAlias, WorkflowConfig } from "@uncaged/uwf-protocol";
-import { config as loadDotenv } from "dotenv";
-import { createAgentStore, getEnvPath, resolveStorageRoot } from "./storage.js";
-
-export type ResolvedLlmProvider = {
-  baseUrl: string;
-  apiKey: string;
-  model: string;
-};
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** Resolve model alias for extract: modelOverrides.extract → models.extract → defaultModel. */
-export function resolveExtractModelAlias(config: WorkflowConfig): ModelAlias {
-  const fromOverride = config.modelOverrides?.extract ?? null;
-  if (fromOverride !== null) {
-    return fromOverride;
-  }
-  if (config.models.extract !== undefined) {
-    return "extract";
-  }
-  if (config.models.default !== undefined) {
-    return "default";
-  }
-  return config.defaultModel;
-}
-
-export function resolveModel(config: WorkflowConfig, alias: ModelAlias): ResolvedLlmProvider {
-  const modelEntry = config.models[alias];
-  if (modelEntry === undefined) {
-    throw new Error(`unknown model alias: ${alias}`);
-  }
-  const providerEntry = config.providers[modelEntry.provider];
-  if (providerEntry === undefined) {
-    throw new Error(`unknown provider "${modelEntry.provider}" for model "${alias}"`);
-  }
-  const apiKey = process.env[providerEntry.apiKeyEnv];
-  if (apiKey === undefined || apiKey === "") {
-    throw new Error(`missing API key env var: ${providerEntry.apiKeyEnv}`);
-  }
-  return {
-    baseUrl: providerEntry.baseUrl,
-    apiKey,
-    model: modelEntry.name,
-  };
-}
-
-function chatUrl(baseUrl: string): string {
-  const trimmed = baseUrl.replace(/\/+$/, "");
-  return `${trimmed}/chat/completions`;
-}
-
-function extractJsonFromAssistantText(text: string): unknown {
-  const trimmed = text.trim();
-  const fenceMatch = /^```(?:json)?\s*([\s\S]*?)```$/m.exec(trimmed);
-  const candidate = fenceMatch !== null ? fenceMatch[1].trim() : trimmed;
-  return JSON.parse(candidate) as unknown;
-}
-
-function parseAssistantText(parsed: unknown): string {
-  if (!isRecord(parsed)) {
-    throw new Error("LLM response is not an object");
-  }
-  const choices = parsed.choices;
-  if (!Array.isArray(choices) || choices.length === 0) {
-    throw new Error("LLM response has no choices");
-  }
-  const c0 = choices[0];
-  if (!isRecord(c0)) {
-    throw new Error("LLM choice is not an object");
-  }
-  const messageObj = c0.message;
-  if (!isRecord(messageObj)) {
-    throw new Error("LLM message is not an object");
-  }
-  const content = messageObj.content;
-  if (typeof content !== "string") {
-    throw new Error("LLM message has no text content");
-  }
-  return content;
-}
-
-async function chatCompletionText(
-  provider: ResolvedLlmProvider,
-  messages: Array<{ role: "system" | "user"; content: string }>,
-): Promise<string> {
-  let response: Response;
-  try {
-    response = await fetch(chatUrl(provider.baseUrl), {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${provider.apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        model: provider.model,
-        messages,
-        response_format: { type: "json_object" },
-      }),
-    });
-  } catch (cause) {
-    const message = cause instanceof Error ? cause.message : String(cause);
-    throw new Error(`LLM network error: ${message}`);
-  }
-
-  const responseText = await response.text();
-  if (!response.ok) {
-    throw new Error(`LLM HTTP ${response.status}: ${responseText.slice(0, 2000)}`);
-  }
-
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(responseText) as unknown;
-  } catch (cause) {
-    const message = cause instanceof Error ? cause.message : String(cause);
-    throw new Error(`LLM invalid JSON response: ${message}`);
-  }
-
-  return parseAssistantText(parsed);
-}
-
-export type ExtractResult = {
-  value: unknown;
-  hash: CasRef;
-};
-
-/**
- * Call an OpenAI-compatible LLM to extract structured output matching outputSchema.
- * Loads config.yaml and .env from the workflow storage root.
- */
-export async function extract(
-  rawOutput: string,
-  outputSchema: CasRef,
-  config: WorkflowConfig,
-): Promise<ExtractResult> {
-  const storageRoot = resolveStorageRoot();
-  loadDotenv({ path: getEnvPath(storageRoot) });
-
-  const { store } = await createAgentStore(storageRoot);
-  const schema = getSchema(store, outputSchema);
-  if (schema === null) {
-    throw new Error(`output schema not found in CAS: ${outputSchema}`);
-  }
-
-  const modelAlias = resolveExtractModelAlias(config);
-  const provider = resolveModel(config, modelAlias);
-
-  const schemaText = JSON.stringify(schema, null, 2);
-  const assistantText = await chatCompletionText(provider, [
-    {
-      role: "system",
-      content:
-        "Extract structured data from the agent output. Reply with a single JSON object only, no markdown or prose. The JSON must validate against this JSON Schema:\n" +
-        schemaText,
-    },
-    {
-      role: "user",
-      content: rawOutput,
-    },
-  ]);
-
-  let structured: unknown;
-  try {
-    structured = extractJsonFromAssistantText(assistantText);
-  } catch (cause) {
-    const message = cause instanceof Error ? cause.message : String(cause);
-    throw new Error(`failed to parse extracted JSON: ${message}`);
-  }
-
-  const outputHash = await store.put(outputSchema, structured);
-  const node = store.get(outputHash);
-  if (node === null || !validate(store, node)) {
-    throw new Error("extracted output failed JSON Schema validation");
-  }
-
-  return { value: structured, hash: outputHash };
-}

packages/uwf-agent-kit/src/index.ts

@@ -1,11 +0,0 @@
-export type { BuildContextMeta } from "./context.js";
-export { buildContext, buildContextWithMeta } from "./context.js";
-export { getConfigPath, getEnvPath, loadWorkflowConfig } from "./storage.js";
-export type { ExtractResult, ResolvedLlmProvider } from "./extract.js";
-export {
-  extract,
-  resolveExtractModelAlias,
-  resolveModel,
-} from "./extract.js";
-export { createAgent } from "./run.js";
-export type { AgentContext, AgentOptions, AgentRunFn } from "./types.js";

packages/uwf-agent-kit/src/run.ts

@@ -1,135 +0,0 @@
-import { validate } from "@uncaged/json-cas";
-import type { CasRef, StepNodePayload, ThreadId } from "@uncaged/uwf-protocol";
-import { config as loadDotenv } from "dotenv";
-
-import { buildContextWithMeta } from "./context.js";
-import { extract } from "./extract.js";
-import type { AgentStore } from "./storage.js";
-import { getEnvPath, loadWorkflowConfig, resolveStorageRoot } from "./storage.js";
-import type { AgentContext, AgentOptions } from "./types.js";
-
-function fail(message: string): never {
-  process.stderr.write(`${message}\n`);
-  process.exit(1);
-}
-
-function agentLabel(name: string): string {
-  if (name.startsWith("uwf-")) {
-    return name;
-  }
-  return `uwf-${name}`;
-}
-
-function parseArgv(argv: string[]): { threadId: ThreadId; role: string } {
-  const threadId = argv[2];
-  const role = argv[3];
-  if (threadId === undefined || threadId === "") {
-    fail("usage: <agent-cli> <thread-id> <role>");
-  }
-  if (role === undefined || role === "") {
-    fail("usage: <agent-cli> <thread-id> <role>");
-  }
-  return { threadId: threadId as ThreadId, role };
-}
-
-function runWithMessage<T>(label: string, fn: () => Promise<T>): Promise<T> {
-  return fn().catch((e: unknown) => {
-    const message = e instanceof Error ? e.message : String(e);
-    fail(`${label}: ${message}`);
-  });
-}
-
-async function writeStepNode(options: {
-  store: AgentStore["store"];
-  schemas: AgentStore["schemas"];
-  startHash: CasRef;
-  prevHash: CasRef | null;
-  role: string;
-  outputHash: CasRef;
-  detailHash: CasRef;
-  agentName: string;
-}): Promise<CasRef> {
-  const payload: StepNodePayload = {
-    start: options.startHash,
-    prev: options.prevHash,
-    role: options.role,
-    output: options.outputHash,
-    detail: options.detailHash,
-    agent: options.agentName,
-  };
-  const hash = await options.store.put(options.schemas.stepNode, payload);
-  const node = options.store.get(hash);
-  if (node === null || !validate(options.store, node)) {
-    fail("stored StepNode failed schema validation");
-  }
-  return hash;
-}
-
-async function runAgent(options: AgentOptions, ctx: AgentContext): Promise<string> {
-  return runWithMessage("agent run failed", () => options.run(ctx));
-}
-
-async function extractOutput(
-  rawOutput: string,
-  outputSchema: CasRef,
-  storageRoot: string,
-): Promise<CasRef> {
-  const config = await runWithMessage("failed to load config", () =>
-    loadWorkflowConfig(storageRoot),
-  );
-  const extracted = await runWithMessage("extract failed", () =>
-    extract(rawOutput, outputSchema, config),
-  );
-  return extracted.hash;
-}
-
-async function persistStep(options: {
-  ctx: Awaited<ReturnType<typeof buildContextWithMeta>>;
-  rawOutput: string;
-  outputHash: CasRef;
-  agentName: string;
-}): Promise<CasRef> {
-  const { store, schemas, chain, headHash } = options.ctx.meta;
-  const detailHash = await store.put(null, options.rawOutput);
-  return writeStepNode({
-    store,
-    schemas,
-    startHash: chain.startHash,
-    prevHash: chain.headIsStart ? null : headHash,
-    role: options.ctx.role,
-    outputHash: options.outputHash,
-    detailHash,
-    agentName: options.agentName,
-  });
-}
-
-/**
- * Create an agent CLI entrypoint.
- * Parses argv (`<thread-id> <role>`), runs the agent, extracts structured output,
- * writes StepNode to CAS, and prints the new node hash to stdout.
- */
-export function createAgent(options: AgentOptions): () => Promise<void> {
-  return async function main(): Promise<void> {
-    const { threadId, role } = parseArgv(process.argv);
-    const storageRoot = resolveStorageRoot();
-    loadDotenv({ path: getEnvPath(storageRoot) });
-
-    const ctx = await runWithMessage("context", () => buildContextWithMeta(threadId, role));
-
-    const roleDef = ctx.workflow.roles[role];
-    if (roleDef === undefined) {
-      fail(`unknown role: ${role}`);
-    }
-
-    const rawOutput = await runAgent(options, ctx);
-    const outputHash = await extractOutput(rawOutput, roleDef.outputSchema, storageRoot);
-    const stepHash = await persistStep({
-      ctx,
-      rawOutput,
-      outputHash,
-      agentName: agentLabel(options.name),
-    });
-
-    process.stdout.write(`${stepHash}\n`);
-  };
-}

packages/uwf-agent-kit/src/schemas.ts

@@ -1,26 +0,0 @@
-import type { Hash, Store } from "@uncaged/json-cas";
-import { putSchema } from "@uncaged/json-cas";
-import {
-  START_NODE_SCHEMA,
-  STEP_NODE_SCHEMA,
-  WORKFLOW_SCHEMA,
-} from "@uncaged/uwf-protocol";
-
-export type UwfAgentSchemaHashes = {
-  workflow: Hash;
-  startNode: Hash;
-  stepNode: Hash;
-};
-
-/**
- * Register Workflow, StartNode, and StepNode JSON Schemas in the CAS store.
- * Idempotent: safe to call on every agent invocation.
- */
-export async function registerAgentSchemas(store: Store): Promise<UwfAgentSchemaHashes> {
-  const [workflow, startNode, stepNode] = await Promise.all([
-    putSchema(store, WORKFLOW_SCHEMA),
-    putSchema(store, START_NODE_SCHEMA),
-    putSchema(store, STEP_NODE_SCHEMA),
-  ]);
-  return { workflow, startNode, stepNode };
-}

packages/uwf-agent-kit/src/storage.ts

@@ -1,227 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-import type { Store } from "@uncaged/json-cas";
-import { createFsStore } from "@uncaged/json-cas-fs";
-import type {
-  AgentAlias,
-  AgentConfig,
-  ModelAlias,
-  ModelConfig,
-  ProviderAlias,
-  ProviderConfig,
-  Scenario,
-  ThreadId,
-  ThreadsIndex,
-  WorkflowConfig,
-  WorkflowName,
-} from "@uncaged/uwf-protocol";
-import { parse } from "yaml";
-
-import { registerAgentSchemas } from "./schemas.js";
-
-/** Default filesystem root for uwf data (`~/.uncaged/workflow`). */
-export function getDefaultStorageRoot(): string {
-  return join(homedir(), ".uncaged", "workflow");
-}
-
-/**
- * Resolve storage root.
- * Priority: `UNCAGED_WORKFLOW_STORAGE_ROOT` → `WORKFLOW_STORAGE_ROOT` → default.
- */
-export function resolveStorageRoot(): string {
-  const internal = process.env.UNCAGED_WORKFLOW_STORAGE_ROOT;
-  if (internal !== undefined && internal !== "") {
-    return internal;
-  }
-  const userOverride = process.env.WORKFLOW_STORAGE_ROOT;
-  if (userOverride !== undefined && userOverride !== "") {
-    return userOverride;
-  }
-  return getDefaultStorageRoot();
-}
-
-export function getCasDir(storageRoot: string): string {
-  return join(storageRoot, "cas");
-}
-
-export function getConfigPath(storageRoot: string): string {
-  return join(storageRoot, "config.yaml");
-}
-
-export function getEnvPath(storageRoot: string): string {
-  return join(storageRoot, ".env");
-}
-
-export function getThreadsPath(storageRoot: string): string {
-  return join(storageRoot, "threads.yaml");
-}
-
-export type AgentStore = {
-  storageRoot: string;
-  store: Store;
-  schemas: Awaited<ReturnType<typeof registerAgentSchemas>>;
-};
-
-export async function createAgentStore(storageRoot: string): Promise<AgentStore> {
-  const store = createFsStore(getCasDir(storageRoot));
-  const schemas = await registerAgentSchemas(store);
-  return { storageRoot, store, schemas };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function normalizeProviders(raw: unknown): Record<ProviderAlias, ProviderConfig> {
-  if (!isRecord(raw)) {
-    throw new Error("config.providers must be a mapping");
-  }
-  const providers: Record<ProviderAlias, ProviderConfig> = {};
-  for (const [name, entry] of Object.entries(raw)) {
-    if (!isRecord(entry)) {
-      throw new Error(`config.providers.${name} must be a mapping`);
-    }
-    const baseUrl = entry.baseUrl;
-    const apiKeyEnv = entry.apiKeyEnv;
-    if (typeof baseUrl !== "string" || typeof apiKeyEnv !== "string") {
-      throw new Error(`config.providers.${name} requires baseUrl and apiKeyEnv`);
-    }
-    providers[name] = { baseUrl, apiKeyEnv };
-  }
-  return providers;
-}
-
-function normalizeModels(raw: unknown): Record<ModelAlias, ModelConfig> {
-  if (!isRecord(raw)) {
-    throw new Error("config.models must be a mapping");
-  }
-  const models: Record<ModelAlias, ModelConfig> = {};
-  for (const [name, entry] of Object.entries(raw)) {
-    if (!isRecord(entry)) {
-      throw new Error(`config.models.${name} must be a mapping`);
-    }
-    const provider = entry.provider;
-    const modelName = entry.name;
-    if (typeof provider !== "string" || typeof modelName !== "string") {
-      throw new Error(`config.models.${name} requires provider and name`);
-    }
-    models[name] = { provider, name: modelName };
-  }
-  return models;
-}
-
-function normalizeAgents(raw: unknown): Record<AgentAlias, AgentConfig> {
-  if (!isRecord(raw)) {
-    throw new Error("config.agents must be a mapping");
-  }
-  const agents: Record<AgentAlias, AgentConfig> = {};
-  for (const [name, entry] of Object.entries(raw)) {
-    if (!isRecord(entry)) {
-      throw new Error(`config.agents.${name} must be a mapping`);
-    }
-    const command = entry.command;
-    const argsRaw = entry.args;
-    if (typeof command !== "string") {
-      throw new Error(`config.agents.${name} requires command`);
-    }
-    const args = Array.isArray(argsRaw)
-      ? argsRaw.filter((a): a is string => typeof a === "string")
-      : [];
-    agents[name] = { command, args };
-  }
-  return agents;
-}
-
-function normalizeModelOverrides(raw: unknown): Record<Scenario, ModelAlias> | null {
-  if (raw === undefined || raw === null) {
-    return null;
-  }
-  if (!isRecord(raw)) {
-    throw new Error("config.modelOverrides must be a mapping or null");
-  }
-  const overrides: Record<Scenario, ModelAlias> = {};
-  for (const [scene, alias] of Object.entries(raw)) {
-    if (typeof alias === "string") {
-      overrides[scene] = alias;
-    }
-  }
-  return overrides;
-}
-
-function normalizeAgentOverrides(
-  raw: unknown,
-): Record<WorkflowName, Record<string, AgentAlias>> | null {
-  if (raw === undefined || raw === null) {
-    return null;
-  }
-  if (!isRecord(raw)) {
-    throw new Error("config.agentOverrides must be a mapping or null");
-  }
-  const overrides: Record<WorkflowName, Record<string, AgentAlias>> = {};
-  for (const [workflowName, rolesRaw] of Object.entries(raw)) {
-    if (!isRecord(rolesRaw)) {
-      continue;
-    }
-    const roles: Record<string, AgentAlias> = {};
-    for (const [roleName, alias] of Object.entries(rolesRaw)) {
-      if (typeof alias === "string") {
-        roles[roleName] = alias;
-      }
-    }
-    overrides[workflowName] = roles;
-  }
-  return overrides;
-}
-
-export function normalizeWorkflowConfig(raw: unknown): WorkflowConfig {
-  if (!isRecord(raw)) {
-    throw new Error("config.yaml root must be a mapping");
-  }
-  const defaultAgent = raw.defaultAgent;
-  const defaultModel = raw.defaultModel;
-  if (typeof defaultAgent !== "string" || typeof defaultModel !== "string") {
-    throw new Error("config requires defaultAgent and defaultModel");
-  }
-  return {
-    providers: normalizeProviders(raw.providers),
-    models: normalizeModels(raw.models),
-    agents: normalizeAgents(raw.agents),
-    defaultAgent,
-    agentOverrides: normalizeAgentOverrides(raw.agentOverrides),
-    defaultModel,
-    modelOverrides: normalizeModelOverrides(raw.modelOverrides),
-  };
-}
-
-export async function loadWorkflowConfig(storageRoot: string): Promise<WorkflowConfig> {
-  const path = getConfigPath(storageRoot);
-  const text = await readFile(path, "utf8");
-  const raw = parse(text) as unknown;
-  return normalizeWorkflowConfig(raw);
-}
-
-export async function loadThreadsIndex(storageRoot: string): Promise<ThreadsIndex> {
-  const path = getThreadsPath(storageRoot);
-  try {
-    const text = await readFile(path, "utf8");
-    const raw = parse(text) as unknown;
-    if (!isRecord(raw)) {
-      return {};
-    }
-    const index: ThreadsIndex = {};
-    for (const [threadId, head] of Object.entries(raw)) {
-      if (typeof head === "string") {
-        index[threadId as ThreadId] = head;
-      }
-    }
-    return index;
-  } catch (e) {
-    const err = e as NodeJS.ErrnoException;
-    if (err.code === "ENOENT") {
-      return {};
-    }
-    throw e;
-  }
-}

packages/uwf-agent-kit/src/types.ts

@@ -1,17 +0,0 @@
-import type { StepContext, ThreadId, WorkflowPayload } from "@uncaged/uwf-protocol";
-
-export type AgentContext = {
-  threadId: ThreadId;
-  role: string;
-  systemPrompt: string;
-  prompt: string;
-  history: StepContext[];
-  workflow: WorkflowPayload;
-};
-
-export type AgentRunFn = (ctx: AgentContext) => Promise<string>;
-
-export type AgentOptions = {
-  name: string;
-  run: AgentRunFn;
-};

packages/uwf-agent-kit/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  },
-  "include": ["src"],
-  "references": [{ "path": "../uwf-protocol" }]
-}

packages/uwf-moderator/__tests__/evaluate.test.ts

@@ -1,120 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ModeratorContext, WorkflowPayload } from "@uncaged/uwf-protocol";
-
-import { evaluate } from "../src/evaluate.js";
-
-const solveIssueWorkflow: WorkflowPayload = {
-  name: "solve-issue",
-  description: "End-to-end issue resolution",
-  roles: {
-    planner: {
-      description: "Creates implementation plan",
-      systemPrompt: "You are a planning agent...",
-      outputSchema: "5GWKR8TN1V3JA",
-    },
-    developer: {
-      description: "Implements code changes",
-      systemPrompt: "You are a developer agent...",
-      outputSchema: "8CNWT4KR6D1HV",
-    },
-    reviewer: {
-      description: "Reviews code changes",
-      systemPrompt: "You are a code reviewer...",
-      outputSchema: "1VPBG9SM5E7WK",
-    },
-  },
-  conditions: {
-    needsClarification: {
-      description: "Planner requests clarification from user",
-      expression: "$exists(steps[-1].output.needsClarification)",
-    },
-    notApproved: {
-      description: "Reviewer rejected the implementation",
-      expression: "steps[-1].output.approved = false",
-    },
-  },
-  graph: {
-    $START: [{ role: "planner", condition: null }],
-    planner: [
-      { role: "developer", condition: "needsClarification" },
-      { role: "$END", condition: null },
-    ],
-    developer: [{ role: "reviewer", condition: null }],
-    reviewer: [
-      { role: "developer", condition: "notApproved" },
-      { role: "$END", condition: null },
-    ],
-  },
-};
-
-function makeContext(steps: ModeratorContext["steps"]): ModeratorContext {
-  return {
-    start: {
-      workflow: "4KNM2PXR3B1QW",
-      prompt: "Fix the login bug",
-    },
-    steps,
-  };
-}
-
-describe("evaluate", () => {
-  test("$START → first role (fallback)", async () => {
-    const result = await evaluate(solveIssueWorkflow, makeContext([]));
-    expect(result).toEqual({ ok: true, value: "planner" });
-  });
-
-  test("condition match (notApproved → developer)", async () => {
-    const context = makeContext([
-      {
-        role: "reviewer",
-        output: { approved: false },
-        detail: "2MXBG6PN4A8JR",
-        agent: "uwf-hermes",
-      },
-    ]);
-    const result = await evaluate(solveIssueWorkflow, context);
-    expect(result).toEqual({ ok: true, value: "developer" });
-  });
-
-  test("fallback when condition does not match → $END", async () => {
-    const context = makeContext([
-      {
-        role: "reviewer",
-        output: { approved: true },
-        detail: "2MXBG6PN4A8JR",
-        agent: "uwf-hermes",
-      },
-    ]);
-    const result = await evaluate(solveIssueWorkflow, context);
-    expect(result).toEqual({ ok: true, value: "$END" });
-  });
-
-  test("missing role in graph → error", async () => {
-    const context = makeContext([
-      {
-        role: "unknown-role",
-        output: {},
-        detail: "2MXBG6PN4A8JR",
-        agent: "uwf-hermes",
-      },
-    ]);
-    const result = await evaluate(solveIssueWorkflow, context);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.message).toBe('no transitions defined for role "unknown-role"');
-    }
-  });
-
-  test("output expansion in context works with JSONata", async () => {
-    const context = makeContext([
-      {
-        role: "planner",
-        output: { needsClarification: true },
-        detail: "7BQST3VW9F2MA",
-        agent: "uwf-hermes",
-      },
-    ]);
-    const result = await evaluate(solveIssueWorkflow, context);
-    expect(result).toEqual({ ok: true, value: "developer" });
-  });
-});

packages/uwf-moderator/src/evaluate.ts

@@ -1,82 +0,0 @@
-import type { ModeratorContext, WorkflowPayload } from "@uncaged/uwf-protocol";
-import jsonata from "jsonata";
-
-import type { Result } from "./types.js";
-
-const START_ROLE = "$START";
-
-function isTruthy(value: unknown): boolean {
-  if (value === null || value === undefined) {
-    return false;
-  }
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "number") {
-    return value !== 0 && !Number.isNaN(value);
-  }
-  if (typeof value === "string") {
-    return value.length > 0;
-  }
-  return true;
-}
-
-async function evaluateJsonata(expression: string, context: ModeratorContext): Promise<Result<unknown, Error>> {
-  try {
-    const result = await jsonata(expression).evaluate(context);
-    return { ok: true, value: result };
-  } catch (error) {
-    return {
-      ok: false,
-      error: error instanceof Error ? error : new Error(String(error)),
-    };
-  }
-}
-
-function currentRole(context: ModeratorContext): string {
-  if (context.steps.length === 0) {
-    return START_ROLE;
-  }
-  return context.steps[context.steps.length - 1].role;
-}
-
-export async function evaluate(
-  workflow: WorkflowPayload,
-  context: ModeratorContext,
-): Promise<Result<string, Error>> {
-  const role = currentRole(context);
-  const transitions = workflow.graph[role];
-  if (transitions === undefined) {
-    return {
-      ok: false,
-      error: new Error(`no transitions defined for role "${role}"`),
-    };
-  }
-
-  for (const transition of transitions) {
-    if (transition.condition === null) {
-      return { ok: true, value: transition.role };
-    }
-
-    const conditionDef = workflow.conditions[transition.condition];
-    if (conditionDef === undefined) {
-      return {
-        ok: false,
-        error: new Error(`unknown condition "${transition.condition}"`),
-      };
-    }
-
-    const evalResult = await evaluateJsonata(conditionDef.expression, context);
-    if (!evalResult.ok) {
-      return evalResult;
-    }
-    if (isTruthy(evalResult.value)) {
-      return { ok: true, value: transition.role };
-    }
-  }
-
-  return {
-    ok: false,
-    error: new Error(`no transition matched for role "${role}"`),
-  };
-}

packages/uwf-moderator/src/index.ts

@@ -1 +0,0 @@
-export { evaluate } from "./evaluate.js";

packages/uwf-moderator/src/types.ts

@@ -1 +0,0 @@
-export type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };

packages/uwf-moderator/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  },
-  "include": ["src"],
-  "references": [{ "path": "../uwf-protocol" }]
-}

packages/uwf-protocol/package.json

@@ -1,26 +0,0 @@
-{
-  "name": "@uncaged/uwf-protocol",
-  "version": "0.1.0",
-  "files": [
-    "src",
-    "dist",
-    "package.json"
-  ],
-  "type": "module",
-  "exports": {
-    ".": {
-      "bun": "./src/index.ts",
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "dependencies": {
-"@uncaged/json-cas-fs": "^0.1.3"
-  },
-  "devDependencies": {
-    "typescript": "^5.8.3"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}

packages/uwf-protocol/src/index.ts

@@ -1,32 +0,0 @@
-export {
-  START_NODE_SCHEMA,
-  STEP_NODE_SCHEMA,
-  WORKFLOW_SCHEMA,
-} from "./schemas.js";
-export type {
-  AgentAlias,
-  AgentConfig,
-  CasRef,
-  ConditionDefinition,
-  ModelAlias,
-  ModelConfig,
-  ModeratorContext,
-  ProviderAlias,
-  ProviderConfig,
-  RoleDefinition,
-  RoleName,
-  Scenario,
-  StartNodePayload,
-  StartOutput,
-  StepContext,
-  StepNodePayload,
-  StepOutput,
-  StepRecord,
-  ThreadId,
-  ThreadListItem,
-  ThreadsIndex,
-  Transition,
-  WorkflowConfig,
-  WorkflowName,
-  WorkflowPayload,
-} from "./types.js";

packages/uwf-protocol/src/schemas.ts

@@ -1,86 +0,0 @@
-import type { JSONSchema } from "@uncaged/json-cas";
-
-const ROLE_DEFINITION: JSONSchema = {
-  type: "object",
-  required: ["description", "systemPrompt", "outputSchema"],
-  properties: {
-    description: { type: "string" },
-    systemPrompt: { type: "string" },
-    outputSchema: { type: "string", format: "cas_ref" },
-  },
-  additionalProperties: false,
-};
-
-const CONDITION_DEFINITION: JSONSchema = {
-  type: "object",
-  required: ["description", "expression"],
-  properties: {
-    description: { type: "string" },
-    expression: { type: "string" },
-  },
-  additionalProperties: false,
-};
-
-const TRANSITION: JSONSchema = {
-  type: "object",
-  required: ["role", "condition"],
-  properties: {
-    role: { type: "string" },
-    condition: { anyOf: [{ type: "string" }, { type: "null" }] },
-  },
-  additionalProperties: false,
-};
-
-export const WORKFLOW_SCHEMA: JSONSchema = {
-  title: "Workflow",
-  type: "object",
-  required: ["name", "description", "roles", "conditions", "graph"],
-  properties: {
-    name: { type: "string" },
-    description: { type: "string" },
-    roles: {
-      type: "object",
-      additionalProperties: ROLE_DEFINITION,
-    },
-    conditions: {
-      type: "object",
-      additionalProperties: CONDITION_DEFINITION,
-    },
-    graph: {
-      type: "object",
-      additionalProperties: {
-        type: "array",
-        items: TRANSITION,
-      },
-    },
-  },
-  additionalProperties: false,
-};
-
-export const START_NODE_SCHEMA: JSONSchema = {
-  title: "StartNode",
-  type: "object",
-  required: ["workflow", "prompt"],
-  properties: {
-    workflow: { type: "string", format: "cas_ref" },
-    prompt: { type: "string" },
-  },
-  additionalProperties: false,
-};
-
-export const STEP_NODE_SCHEMA: JSONSchema = {
-  title: "StepNode",
-  type: "object",
-  required: ["start", "prev", "role", "output", "detail", "agent"],
-  properties: {
-    start: { type: "string", format: "cas_ref" },
-    prev: {
-      anyOf: [{ type: "string", format: "cas_ref" }, { type: "null" }],
-    },
-    role: { type: "string" },
-    output: { type: "string", format: "cas_ref" },
-    detail: { type: "string", format: "cas_ref" },
-    agent: { type: "string" },
-  },
-  additionalProperties: false,
-};

packages/uwf-protocol/src/types.ts

@@ -1,127 +0,0 @@
-// ── 4.1 公共类型 ────────────────────────────────────────────────────
-
-/** CAS hash — XXH64, 13-char Crockford Base32 */
-export type CasRef = string;
-
-/** Thread ID — ULID, 26-char Crockford Base32 */
-export type ThreadId = string;
-
-/** 一个 step 的核心数据，被 StepNode payload 和 JSONata 上下文共享 */
-export type StepRecord = {
-  role: string;
-  output: CasRef;
-  detail: CasRef;
-  agent: string;
-};
-
-// ── 4.2 Workflow 定义 ───────────────────────────────────────────────
-
-export type RoleDefinition = {
-  description: string;
-  systemPrompt: string;
-  outputSchema: CasRef;
-};
-
-export type Transition = {
-  role: string;
-  condition: string | null;
-};
-
-export type ConditionDefinition = {
-  description: string;
-  expression: string;
-};
-
-export type WorkflowPayload = {
-  name: string;
-  description: string;
-  roles: Record<string, RoleDefinition>;
-  conditions: Record<string, ConditionDefinition>;
-  graph: Record<string, Transition[]>;
-};
-
-// ── 4.3 Thread 节点 ─────────────────────────────────────────────────
-
-export type StartNodePayload = {
-  workflow: CasRef;
-  prompt: string;
-};
-
-export type StepNodePayload = StepRecord & {
-  start: CasRef;
-  prev: CasRef | null;
-};
-
-// ── 4.4 JSONata 求值上下文 ──────────────────────────────────────────
-
-/** JSONata 上下文中的 step — output 被展开 */
-export type StepContext = Omit<StepRecord, "output"> & {
-  output: unknown;
-};
-
-export type ModeratorContext = {
-  start: StartNodePayload;
-  steps: StepContext[];
-};
-
-// ── 4.5 CLI 输出 ────────────────────────────────────────────────────
-
-/** uwf thread start */
-export type StartOutput = {
-  workflow: CasRef;
-  thread: ThreadId;
-};
-
-/** uwf thread step / uwf thread show */
-export type StepOutput = {
-  workflow: CasRef;
-  thread: ThreadId;
-  head: CasRef;
-  done: boolean;
-};
-
-/** uwf thread list */
-export type ThreadListItem = {
-  thread: ThreadId;
-  workflow: CasRef;
-  head: CasRef;
-};
-
-// ── 4.6 配置 ────────────────────────────────────────────────────────
-
-/** Alias types for config references */
-export type AgentAlias = string;
-export type ModelAlias = string;
-export type ProviderAlias = string;
-export type WorkflowName = string;
-export type RoleName = string;
-export type Scenario = string;
-
-export type ProviderConfig = {
-  baseUrl: string;
-  apiKeyEnv: string;
-};
-
-export type ModelConfig = {
-  provider: ProviderAlias;
-  name: string;
-};
-
-export type AgentConfig = {
-  command: string;
-  args: string[];
-};
-
-/** ~/.uncaged/workflow/config.yaml */
-export type WorkflowConfig = {
-  providers: Record<ProviderAlias, ProviderConfig>;
-  models: Record<ModelAlias, ModelConfig>;
-  agents: Record<AgentAlias, AgentConfig>;
-  defaultAgent: AgentAlias;
-  agentOverrides: Record<WorkflowName, Record<RoleName, AgentAlias>> | null;
-  defaultModel: ModelAlias;
-  modelOverrides: Record<Scenario, ModelAlias> | null;
-};
-
-/** ~/.uncaged/workflow/threads.yaml */
-export type ThreadsIndex = Record<ThreadId, CasRef>;

packages/uwf-protocol/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  },
-  "include": ["src"]
-}

packages/workflow-agent-cursor/__tests__/package-descriptor.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test";
+import { packageDescriptor } from "../src/index.js";
+
+describe("packageDescriptor", () => {
+  test("has the correct package name", () => {
+    expect(packageDescriptor.name).toBe("@uncaged/workflow-agent-cursor");
+  });
+
+  test("has a non-empty version string", () => {
+    expect(typeof packageDescriptor.version).toBe("string");
+    expect(packageDescriptor.version.length).toBeGreaterThan(0);
+  });
+
+  test("capabilities is a non-empty array of strings", () => {
+    expect(Array.isArray(packageDescriptor.capabilities)).toBe(true);
+    expect(packageDescriptor.capabilities.length).toBeGreaterThan(0);
+    for (const cap of packageDescriptor.capabilities) {
+      expect(typeof cap).toBe("string");
+    }
+  });
+
+  test("configSchema is an object with type 'object'", () => {
+    expect(typeof packageDescriptor.configSchema).toBe("object");
+    expect(packageDescriptor.configSchema.type).toBe("object");
+  });
+
+  test("configSchema requires 'command' and 'timeout'", () => {
+    const required = packageDescriptor.configSchema.required as string[];
+    expect(required).toContain("command");
+    expect(required).toContain("timeout");
+  });
+
+  test("configSchema properties include command, model, timeout, workspace", () => {
+    const props = packageDescriptor.configSchema.properties as Record<string, unknown>;
+    expect(props).toHaveProperty("command");
+    expect(props).toHaveProperty("model");
+    expect(props).toHaveProperty("timeout");
+    expect(props).toHaveProperty("workspace");
+  });
+});

packages/workflow-agent-cursor/src/index.ts

@@ -11,6 +11,7 @@ import { extractWorkspacePath } from "./extract-workspace.js";
 import type { CursorAgentConfig } from "./types.js";
 import { validateCursorAgentConfig } from "./validate-config.js";
 
+export { packageDescriptor } from "./package-descriptor.js";
 export type { CursorAgentConfig } from "./types.js";
 export { validateCursorAgentConfig } from "./validate-config.js";
 

packages/workflow-agent-cursor/src/package-descriptor.ts

@@ -0,0 +1,34 @@
+import type { PackageDescriptor } from "@uncaged/workflow-protocol";
+
+/**
+ * Static metadata for @uncaged/workflow-agent-cursor.
+ * Config maps to {@link CursorAgentConfig}.
+ */
+export const packageDescriptor: PackageDescriptor = {
+  name: "@uncaged/workflow-agent-cursor",
+  version: "0.5.0-alpha.4",
+  capabilities: ["cursor-cli", "workspace-agent"],
+  configSchema: {
+    type: "object",
+    required: ["command", "timeout"],
+    properties: {
+      command: {
+        type: "string",
+        description: "Absolute path to the cursor-agent CLI binary.",
+      },
+      model: {
+        anyOf: [{ type: "string" }, { type: "null" }],
+        description: "Model identifier passed to cursor-agent --model; null means auto.",
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds; 0 means no limit.",
+      },
+      workspace: {
+        anyOf: [{ type: "string" }, { type: "null" }],
+        description: "Override workspace path; null resolves from thread context.",
+      },
+    },
+    additionalProperties: false,
+  },
+};

packages/workflow-agent-hermes/__tests__/package-descriptor.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { packageDescriptor } from "../src/index.js";
+
+describe("packageDescriptor", () => {
+  test("has the correct package name", () => {
+    expect(packageDescriptor.name).toBe("@uncaged/workflow-agent-hermes");
+  });
+
+  test("has a non-empty version string", () => {
+    expect(typeof packageDescriptor.version).toBe("string");
+    expect(packageDescriptor.version.length).toBeGreaterThan(0);
+  });
+
+  test("capabilities is a non-empty array of strings", () => {
+    expect(Array.isArray(packageDescriptor.capabilities)).toBe(true);
+    expect(packageDescriptor.capabilities.length).toBeGreaterThan(0);
+    for (const cap of packageDescriptor.capabilities) {
+      expect(typeof cap).toBe("string");
+    }
+  });
+
+  test("configSchema is an object with type 'object'", () => {
+    expect(typeof packageDescriptor.configSchema).toBe("object");
+    expect(packageDescriptor.configSchema.type).toBe("object");
+  });
+
+  test("configSchema requires 'command'", () => {
+    const required = packageDescriptor.configSchema.required as string[];
+    expect(required).toContain("command");
+  });
+
+  test("configSchema properties include command, model, timeout", () => {
+    const props = packageDescriptor.configSchema.properties as Record<string, unknown>;
+    expect(props).toHaveProperty("command");
+    expect(props).toHaveProperty("model");
+    expect(props).toHaveProperty("timeout");
+  });
+});

packages/workflow-agent-hermes/src/index.ts

@@ -13,6 +13,7 @@ const HERMES_DEFAULT_MAX_TURNS = 90;
 
 type HermesAgentOpt = { prompt: string };
 
+export { packageDescriptor } from "./package-descriptor.js";
 export type { HermesAgentConfig } from "./types.js";
 export { validateHermesAgentConfig } from "./validate-config.js";
 

packages/workflow-agent-hermes/src/package-descriptor.ts

@@ -0,0 +1,30 @@
+import type { PackageDescriptor } from "@uncaged/workflow-runtime";
+
+/**
+ * Static metadata for @uncaged/workflow-agent-hermes.
+ * Config maps to {@link HermesAgentConfig}.
+ */
+export const packageDescriptor: PackageDescriptor = {
+  name: "@uncaged/workflow-agent-hermes",
+  version: "0.5.0-alpha.4",
+  capabilities: ["hermes-cli", "yolo-mode"],
+  configSchema: {
+    type: "object",
+    required: ["command"],
+    properties: {
+      command: {
+        type: "string",
+        description: "Absolute path to the hermes CLI binary.",
+      },
+      model: {
+        anyOf: [{ type: "string" }, { type: "null" }],
+        description: "Model identifier passed to hermes --model; null uses the CLI default.",
+      },
+      timeout: {
+        anyOf: [{ type: "number" }, { type: "null" }],
+        description: "Timeout in milliseconds; null means no limit.",
+      },
+    },
+    additionalProperties: false,
+  },
+};

packages/workflow-agent-llm/__tests__/package-descriptor.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test";
+import { packageDescriptor } from "../src/index.js";
+
+describe("packageDescriptor", () => {
+  test("has the correct package name", () => {
+    expect(packageDescriptor.name).toBe("@uncaged/workflow-agent-llm");
+  });
+
+  test("has a non-empty version string", () => {
+    expect(typeof packageDescriptor.version).toBe("string");
+    expect(packageDescriptor.version.length).toBeGreaterThan(0);
+  });
+
+  test("capabilities is a non-empty array of strings", () => {
+    expect(Array.isArray(packageDescriptor.capabilities)).toBe(true);
+    expect(packageDescriptor.capabilities.length).toBeGreaterThan(0);
+    for (const cap of packageDescriptor.capabilities) {
+      expect(typeof cap).toBe("string");
+    }
+  });
+
+  test("configSchema is an object with type 'object'", () => {
+    expect(typeof packageDescriptor.configSchema).toBe("object");
+    expect(packageDescriptor.configSchema.type).toBe("object");
+  });
+
+  test("configSchema requires baseUrl, apiKey, model", () => {
+    const required = packageDescriptor.configSchema.required as string[];
+    expect(required).toContain("baseUrl");
+    expect(required).toContain("apiKey");
+    expect(required).toContain("model");
+  });
+
+  test("configSchema properties include baseUrl, apiKey, model", () => {
+    const props = packageDescriptor.configSchema.properties as Record<string, unknown>;
+    expect(props).toHaveProperty("baseUrl");
+    expect(props).toHaveProperty("apiKey");
+    expect(props).toHaveProperty("model");
+  });
+});

packages/workflow-agent-llm/src/index.ts

@@ -4,3 +4,4 @@ export {
   type LlmChatError,
   type LlmMessage,
 } from "./create-llm-adapter.js";
+export { packageDescriptor } from "./package-descriptor.js";

packages/workflow-agent-llm/src/package-descriptor.ts

@@ -0,0 +1,30 @@
+import type { PackageDescriptor } from "@uncaged/workflow-runtime";
+
+/**
+ * Static metadata for @uncaged/workflow-agent-llm.
+ * Config maps to {@link LlmProvider}: baseUrl + apiKey + model.
+ */
+export const packageDescriptor: PackageDescriptor = {
+  name: "@uncaged/workflow-agent-llm",
+  version: "0.5.0-alpha.4",
+  capabilities: ["llm-single-turn"],
+  configSchema: {
+    type: "object",
+    required: ["baseUrl", "apiKey", "model"],
+    properties: {
+      baseUrl: {
+        type: "string",
+        description: "Base URL of the OpenAI-compatible chat completions endpoint.",
+      },
+      apiKey: {
+        type: "string",
+        description: "API key for the provider.",
+      },
+      model: {
+        type: "string",
+        description: "Model identifier passed as the `model` field in the request body.",
+      },
+    },
+    additionalProperties: false,
+  },
+};

packages/workflow-agent-react/__tests__/package-descriptor.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import { packageDescriptor } from "../src/index.js";
+
+describe("packageDescriptor", () => {
+  test("has the correct package name", () => {
+    expect(packageDescriptor.name).toBe("@uncaged/workflow-agent-react");
+  });
+
+  test("has a non-empty version string", () => {
+    expect(typeof packageDescriptor.version).toBe("string");
+    expect(packageDescriptor.version.length).toBeGreaterThan(0);
+  });
+
+  test("capabilities is a non-empty array of strings", () => {
+    expect(Array.isArray(packageDescriptor.capabilities)).toBe(true);
+    expect(packageDescriptor.capabilities.length).toBeGreaterThan(0);
+    for (const cap of packageDescriptor.capabilities) {
+      expect(typeof cap).toBe("string");
+    }
+  });
+
+  test("configSchema is an object with type 'object'", () => {
+    expect(typeof packageDescriptor.configSchema).toBe("object");
+    expect(packageDescriptor.configSchema.type).toBe("object");
+  });
+
+  test("configSchema requires maxRounds", () => {
+    const required = packageDescriptor.configSchema.required as string[];
+    expect(required).toContain("maxRounds");
+  });
+
+  test("configSchema properties include maxRounds", () => {
+    const props = packageDescriptor.configSchema.properties as Record<string, unknown>;
+    expect(props).toHaveProperty("maxRounds");
+  });
+});

packages/workflow-agent-react/src/index.ts

@@ -1,4 +1,5 @@
 export { createReactAdapter } from "./create-react-adapter.js";
+export { packageDescriptor } from "./package-descriptor.js";
 export type { ToolEntry, ToolHandler } from "./tools/index.js";
 export { defaultToolHandler, defaultTools } from "./tools/index.js";
 export type { ReactAdapterConfig, ReactToolHandler } from "./types.js";

packages/workflow-agent-react/src/package-descriptor.ts

@@ -0,0 +1,25 @@
+import type { PackageDescriptor } from "@uncaged/workflow-protocol";
+
+/**
+ * Static metadata for @uncaged/workflow-agent-react.
+ *
+ * Config represents the serializable subset of {@link ReactAdapterConfig}.
+ * The `llm` function and `toolHandler` are runtime constructs and are not
+ * stored in the CAS agent node; only `maxRounds` is serializable.
+ */
+export const packageDescriptor: PackageDescriptor = {
+  name: "@uncaged/workflow-agent-react",
+  version: "0.5.0-alpha.4",
+  capabilities: ["react-loop", "tool-calling"],
+  configSchema: {
+    type: "object",
+    required: ["maxRounds"],
+    properties: {
+      maxRounds: {
+        type: "number",
+        description: "Maximum number of LLM ↔ tool-call rounds before the loop is terminated.",
+      },
+    },
+    additionalProperties: false,
+  },
+};

packages/workflow-dashboard/index.html

@@ -4,14 +4,6 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Workflow Dashboard</title>
-    <script>
-      (function () {
-        var t = localStorage.getItem("theme");
-        if (t === "dark" || (!t && matchMedia("(prefers-color-scheme: dark)").matches)) {
-          document.documentElement.classList.add("dark");
-        }
-      })();
-    </script>
   </head>
   <body>
     <div id="root"></div>

packages/workflow-dashboard/package.json

@@ -13,23 +13,11 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@radix-ui/react-collapsible": "^1.1.12",
-    "@radix-ui/react-dialog": "^1.1.15",
-    "@radix-ui/react-scroll-area": "^1.2.10",
-    "@radix-ui/react-select": "^2.2.6",
-    "@radix-ui/react-separator": "^1.1.8",
-    "@radix-ui/react-slot": "^1.2.4",
-    "@radix-ui/react-tooltip": "^1.2.8",
     "@xyflow/react": "^12.10.2",
-    "class-variance-authority": "^0.7.1",
-    "clsx": "^2.1.1",
-    "lucide-react": "^1.16.0",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
     "react-markdown": "^10.1.0",
-    "react-router": "^7.15.1",
-    "shiki": "^4.0.2",
-    "tailwind-merge": "^3.6.0"
+    "shiki": "^4.0.2"
   },
   "devDependencies": {
     "@tailwindcss/vite": "^4.2.4",

packages/workflow-dashboard/plugins/vite-limit-line-plugin.ts

@@ -1,362 +0,0 @@
-import { createFilter, type Plugin } from "vite";
-
-type LimitLineOverride = {
-  files: string;
-  maxReactFCLines: number | null;
-  maxFileLines: number | null;
-};
-
-type LimitLineOptions = {
-  maxReactFCLines: number;
-  maxFileLines: number;
-  include: RegExp;
-  exclude: RegExp | null;
-  overrides: Array<LimitLineOverride>;
-};
-
-const DEFAULT_OPTIONS: LimitLineOptions = {
-  maxReactFCLines: 300,
-  maxFileLines: 600,
-  include: /\.[tj]sx$/,
-  exclude: null,
-  overrides: [],
-};
-
-type ResolvedLimits = {
-  maxReactFCLines: number | null;
-  maxFileLines: number | null;
-};
-
-type ComponentInfo = {
-  name: string;
-  startLine: number;
-  lineCount: number;
-};
-
-const PASCAL_CASE = /^[A-Z][A-Za-z0-9]*$/;
-
-// --- AST types (Rolldown ESTree subset) ---
-
-type Identifier = {
-  type: "Identifier";
-  name: string;
-};
-
-type MemberExpression = {
-  type: "MemberExpression";
-  object: AstExpression;
-  property: Identifier;
-};
-
-type CallExpression = {
-  type: "CallExpression";
-  callee: AstExpression;
-  arguments: Array<AstExpression>;
-};
-
-type AstExpression = Identifier | MemberExpression | CallExpression | {
-  type: string;
-  [key: string]: unknown;
-};
-
-type VariableDeclarator = {
-  id: Identifier | null;
-  init: AstExpression | null;
-};
-
-type AstStatement = {
-  type: string;
-  id: Identifier | null;
-  declaration: AstStatement | null;
-  declarations: Array<VariableDeclarator>;
-  body: Array<AstStatement>;
-  [key: string]: unknown;
-};
-
-type AstProgram = {
-  type: "Program";
-  body: Array<AstStatement>;
-};
-
-// --- AST helpers ---
-
-function isFunctionLike(node: AstExpression): boolean {
-  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
-}
-
-const WRAPPER_NAMES = new Set(["memo", "forwardRef", "lazy"]);
-
-function isWrapperCall(node: AstExpression): boolean {
-  if (node.type !== "CallExpression") return false;
-  const call = node as CallExpression;
-  const callee = call.callee;
-
-  if (callee.type === "Identifier") {
-    return WRAPPER_NAMES.has((callee as Identifier).name);
-  }
-
-  if (callee.type === "MemberExpression") {
-    const member = callee as MemberExpression;
-    return member.property.type === "Identifier" && WRAPPER_NAMES.has(member.property.name);
-  }
-
-  return false;
-}
-
-function extractComponentNames(ast: AstProgram): Array<string> {
-  const names: Array<string> = [];
-
-  for (const node of ast.body) {
-    if (node.type === "FunctionDeclaration" && node.id && PASCAL_CASE.test(node.id.name)) {
-      names.push(node.id.name);
-      continue;
-    }
-
-    if (node.type === "ExportNamedDeclaration" && node.declaration) {
-      const decl = node.declaration;
-      if (decl.type === "FunctionDeclaration" && decl.id && PASCAL_CASE.test(decl.id.name)) {
-        names.push(decl.id.name);
-        continue;
-      }
-      if (decl.type === "VariableDeclaration") {
-        collectNamesFromVarDeclaration(decl, names);
-        continue;
-      }
-    }
-
-    if (node.type === "VariableDeclaration") {
-      collectNamesFromVarDeclaration(node, names);
-    }
-  }
-
-  return names;
-}
-
-function collectNamesFromVarDeclaration(node: AstStatement, names: Array<string>): void {
-  for (const declarator of node.declarations ?? []) {
-    if (!declarator.id || !PASCAL_CASE.test(declarator.id.name) || !declarator.init) continue;
-    const init = declarator.init;
-    if (isFunctionLike(init)) {
-      names.push(declarator.id.name);
-    } else if (isWrapperCall(init)) {
-      const args = (init as CallExpression).arguments;
-      if (args.length > 0 && isFunctionLike(args[0])) {
-        names.push(declarator.id.name);
-      }
-    }
-  }
-}
-
-// --- Source measurement ---
-
-function measureComponentInSource(name: string, lines: Array<string>): ComponentInfo | null {
-  const fnPattern = new RegExp(`^(?:export\\s+)?function\\s+${name}\\s*[(<]`);
-  const varPattern = new RegExp(`^(?:export\\s+)?const\\s+${name}\\s*[=:]`);
-
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trimStart();
-    const isFnDecl = fnPattern.test(trimmed);
-    const isVarDecl = varPattern.test(trimmed);
-    if (!isFnDecl && !isVarDecl) continue;
-
-    if (isFnDecl) {
-      const result = measureFromParams(i, lines);
-      if (result) return { ...result, name };
-      return null;
-    }
-    const result = measureFromArrow(i, lines);
-    if (result) return { ...result, name };
-    return null;
-  }
-
-  return null;
-}
-
-// function Foo(...) { ... } — skip params via parens, then brace-match the body
-function measureFromParams(startLine: number, lines: Array<string>): ComponentInfo | null {
-  let parenDepth = 0;
-  let pastParams = false;
-  let braceDepth = 0;
-
-  for (let j = startLine; j < lines.length; j++) {
-    for (const ch of lines[j]) {
-      if (!pastParams) {
-        if (ch === "(") parenDepth++;
-        else if (ch === ")") {
-          parenDepth--;
-          if (parenDepth === 0) pastParams = true;
-        }
-      } else {
-        if (ch === "{") braceDepth++;
-        else if (ch === "}") {
-          braceDepth--;
-          if (braceDepth === 0) {
-            return { name: "", startLine: startLine + 1, lineCount: j - startLine + 1 };
-          }
-        }
-      }
-    }
-  }
-
-  return null;
-}
-
-// const Foo = (...) => { ... } / const Foo = memo((...) => { ... })
-// Find `=>` first, then brace-match from there to skip type annotations in params
-function measureFromArrow(startLine: number, lines: Array<string>): ComponentInfo | null {
-  let arrowFound = false;
-  let braceDepth = 0;
-  let foundBrace = false;
-
-  for (let j = startLine; j < lines.length; j++) {
-    const line = lines[j];
-    for (let c = 0; c < line.length; c++) {
-      if (!arrowFound) {
-        if (line[c] === "=" && line[c + 1] === ">") {
-          arrowFound = true;
-          c++;
-        }
-        continue;
-      }
-      if (line[c] === "{") {
-        braceDepth++;
-        foundBrace = true;
-      } else if (line[c] === "}") {
-        braceDepth--;
-        if (foundBrace && braceDepth === 0) {
-          return { name: "", startLine: startLine + 1, lineCount: j - startLine + 1 };
-        }
-      }
-    }
-  }
-
-  return null;
-}
-
-// --- Config resolution ---
-
-function createLimitResolver(options: LimitLineOptions): (id: string) => ResolvedLimits {
-  const matchers = options.overrides.map((override) => ({
-    match: createFilter(override.files),
-    maxReactFCLines: override.maxReactFCLines,
-    maxFileLines: override.maxFileLines,
-  }));
-
-  return (id: string): ResolvedLimits => {
-    let maxReactFCLines: number | null = options.maxReactFCLines;
-    let maxFileLines: number | null = options.maxFileLines;
-
-    for (const matcher of matchers) {
-      if (matcher.match(id)) {
-        maxReactFCLines = matcher.maxReactFCLines;
-        maxFileLines = matcher.maxFileLines;
-      }
-    }
-
-    return { maxReactFCLines, maxFileLines };
-  };
-}
-
-function shouldProcess(id: string, options: LimitLineOptions): boolean {
-  return options.include.test(id) && !id.includes("node_modules") && (options.exclude === null || !options.exclude.test(id));
-}
-
-// --- Plugin ---
-
-function viteLimitLinePlugin(
-  userOptions: Partial<LimitLineOptions> = {},
-): Array<Plugin> {
-  const options: LimitLineOptions = { ...DEFAULT_OPTIONS, ...userOptions, overrides: userOptions.overrides ?? [] };
-  const resolve = createLimitResolver(options);
-
-  const rawCodeCache = new Map<string, string>();
-
-  return [
-    {
-      name: "vite-plugin-limit-line:pre",
-      enforce: "pre",
-
-      transform(code, id) {
-        if (!shouldProcess(id, options)) return null;
-
-        rawCodeCache.set(id, code);
-
-        const limits = resolve(id);
-        if (limits.maxFileLines === null) return null;
-
-        const totalLines = code.split("\n").length;
-        if (totalLines > limits.maxFileLines) {
-          this.error(
-            [
-              `[vite-limit-line] File too long: ${totalLines} lines (limit: ${limits.maxFileLines})`,
-              `  file: ${id}`,
-              "",
-              "How to fix:",
-              "  Split this file into smaller modules — extract related types, helpers,",
-              "  or sub-components into separate files and re-export from an index.ts.",
-            ].join("\n"),
-          );
-        }
-
-        return null;
-      },
-    },
-    {
-      name: "vite-plugin-limit-line:fc",
-
-      transform(code, id) {
-        if (!shouldProcess(id, options)) return null;
-
-        const limits = resolve(id);
-        if (limits.maxReactFCLines === null) return null;
-
-        const ast = this.parse(code) as unknown as AstProgram;
-        const componentNames = extractComponentNames(ast);
-        if (componentNames.length === 0) return null;
-
-        const raw = rawCodeCache.get(id) ?? code;
-        rawCodeCache.delete(id);
-        const rawLines = raw.split("\n");
-
-        const maxFCLines = limits.maxReactFCLines;
-        const violations: Array<ComponentInfo> = [];
-        for (const name of componentNames) {
-          const info = measureComponentInSource(name, rawLines);
-          if (info && info.lineCount > maxFCLines) {
-            violations.push(info);
-          }
-        }
-
-        if (violations.length > 0) {
-          const details = violations
-            .map(
-              (v) =>
-                `  ${v.name} (line ${v.startLine}): ${v.lineCount} lines (limit: ${maxFCLines})`,
-            )
-            .join("\n");
-
-          this.error(
-            [
-              `[vite-limit-line] React component too long in ${id}:`,
-              details,
-              "",
-              "How to fix:",
-              "  Break each oversized component into smaller ones. Extract reusable",
-              "  sections into child components, move complex logic into custom hooks,",
-              "  and keep each component focused on a single responsibility.",
-            ].join("\n"),
-          );
-        }
-
-        return null;
-      },
-
-      buildEnd() {
-        rawCodeCache.clear();
-      },
-    },
-  ];
-}
-
-export { viteLimitLinePlugin };
-export type { LimitLineOptions, LimitLineOverride };

packages/workflow-dashboard/src/app.tsx

@@ -1,38 +1,75 @@
 import { useState } from "react";
-import { Navigate, Outlet, useParams } from "react-router";
 import { clearApiKey, hasApiKey } from "./api.ts";
+import { LoginPage } from "./components/login.tsx";
 import { RunDialog } from "./components/run-dialog.tsx";
 import { Sidebar } from "./components/sidebar.tsx";
 import { StatusBar } from "./components/status-bar.tsx";
-import { useTheme } from "./hooks/use-theme.tsx";
+import { ThreadDetail } from "./components/thread-detail.tsx";
+import { ThreadList } from "./components/thread-list.tsx";
+import { WorkflowDetail } from "./components/workflow-detail.tsx";
+import { WorkflowList } from "./components/workflow-list.tsx";
+import { useHashRoute } from "./use-hash-route.ts";
 
-export function Layout() {
+export function App() {
   const [authed, setAuthed] = useState(hasApiKey());
-  const { client } = useParams();
+  const { view, client, threadId, workflowName, setView, setClient, setThreadId, setWorkflowName } =
+    useHashRoute();
   const [showRun, setShowRun] = useState(false);
-  const { theme, toggleTheme } = useTheme();
 
   if (!authed) {
-    return <Navigate to="/login" replace />;
+    return <LoginPage onLogin={() => setAuthed(true)} />;
   }
 
   return (
-    <div className="flex h-screen bg-background">
+    <div className="flex h-screen">
       <Sidebar
+        view={view}
+        client={client}
+        onViewChange={setView}
+        onClientChange={setClient}
         onLogout={() => {
           clearApiKey();
           setAuthed(false);
         }}
-        theme={theme}
-        onToggleTheme={toggleTheme}
       />
       <main className="flex-1 overflow-hidden flex flex-col">
-        <StatusBar client={client ?? null} onRun={() => setShowRun(true)} />
+        <StatusBar client={client} onRun={() => setShowRun(true)} />
         <div className="flex-1 overflow-auto p-6">
-          <Outlet />
+          {!client && (
+            <div className="flex items-center justify-center h-full">
+              <p style={{ color: "var(--color-text-muted)" }}>
+                Select an client from the sidebar to get started.
+              </p>
+            </div>
+          )}
+          {client && view === "threads" && threadId === null && (
+            <ThreadList client={client} onSelect={setThreadId} />
+          )}
+          {client && view === "threads" && threadId !== null && (
+            <ThreadDetail client={client} threadId={threadId} onBack={() => setThreadId(null)} />
+          )}
+          {client && view === "workflows" && workflowName === null && (
+            <WorkflowList client={client} onSelect={setWorkflowName} />
+          )}
+          {client && view === "workflows" && workflowName !== null && (
+            <WorkflowDetail
+              client={client}
+              workflowName={workflowName}
+              onBack={() => setWorkflowName(null)}
+            />
+          )}
         </div>
       </main>
-      {client && <RunDialog client={client} open={showRun} onOpenChange={setShowRun} />}
+      {showRun && client && (
+        <RunDialog
+          client={client}
+          onClose={() => setShowRun(false)}
+          onCreated={(id) => {
+            setShowRun(false);
+            setThreadId(id);
+          }}
+        />
+      )}
     </div>
   );
 }

packages/workflow-dashboard/src/components/client-redirect.tsx

@@ -1,31 +0,0 @@
-import { Loader2, Users } from "lucide-react";
-import { Navigate } from "react-router";
-import { listClients } from "../api.ts";
-import { useFetch } from "../hooks.ts";
-
-export function ClientRedirect() {
-  const { status, data } = useFetch(() => listClients(), []);
-
-  if (status === "loading") {
-    return (
-      <div className="flex flex-col items-center justify-center h-full gap-3">
-        <Loader2 className="h-6 w-6 animate-spin text-muted-foreground" />
-        <p className="text-sm text-muted-foreground">Loading clients...</p>
-      </div>
-    );
-  }
-
-  if (status === "ok" && data.length > 0) {
-    return <Navigate to={`/${data[0].name}/threads`} replace />;
-  }
-
-  return (
-    <div className="flex flex-col items-center justify-center h-full gap-3">
-      <Users className="h-12 w-12 text-muted-foreground/50" />
-      <p className="text-sm font-medium">No client selected</p>
-      <p className="text-xs text-muted-foreground">
-        Select a client from the sidebar to get started.
-      </p>
-    </div>
-  );
-}

packages/workflow-dashboard/src/components/login.tsx

@@ -1,18 +1,14 @@
-import { AlertCircle, Loader2, Moon, Settings, Sun } from "lucide-react";
 import { useState } from "react";
-import { useNavigate } from "react-router";
 import { setApiKey } from "../api.ts";
-import { useTheme } from "../hooks/use-theme.tsx";
-import { Button } from "./ui/button.tsx";
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "./ui/card.tsx";
-import { Input } from "./ui/input.tsx";
 
-export function LoginPage() {
-  const navigate = useNavigate();
+type Props = {
+  onLogin: () => void;
+};
+
+export function LoginPage({ onLogin }: Props) {
   const [key, setKey] = useState("");
   const [error, setError] = useState<string | null>(null);
   const [loading, setLoading] = useState(false);
-  const { theme, toggleTheme } = useTheme();
 
   async function handleSubmit(e: React.FormEvent) {
     e.preventDefault();
@@ -21,6 +17,7 @@ export function LoginPage() {
     setLoading(true);
     setError(null);
 
+    // Test the key by hitting the endpoints list
     const gatewayUrl = import.meta.env.VITE_GATEWAY_URL || "";
     try {
       const res = await fetch(`${gatewayUrl}/api/gateway/endpoints`, {
@@ -43,59 +40,56 @@ export function LoginPage() {
     }
 
     setApiKey(key.trim());
-    navigate("/", { replace: true });
+    onLogin();
   }
 
   return (
-    <div className="min-h-screen flex items-center justify-center bg-background relative">
-      <Button
-        variant="ghost"
-        size="icon"
-        className="absolute top-4 right-4 transition-colors duration-200"
-        onClick={toggleTheme}
+    <div
+      className="min-h-screen flex items-center justify-center"
+      style={{ background: "var(--color-bg)" }}
+    >
+      <div
+        className="p-8 rounded-lg border w-full max-w-sm"
+        style={{ background: "var(--color-surface)", borderColor: "var(--color-border)" }}
       >
-        {theme === "dark" ? <Sun className="h-5 w-5" /> : <Moon className="h-5 w-5" />}
-      </Button>
-      <Card className="w-full max-w-sm shadow-lg transition-all duration-200 hover:shadow-xl hover:border-primary/30">
-        <CardHeader>
-          <CardTitle className="flex items-center gap-2 text-xl tracking-tight">
-            <Settings className="h-5 w-5" />
-            Workflow Dashboard
-          </CardTitle>
-          <CardDescription>Enter your API key to continue</CardDescription>
-        </CardHeader>
-        <CardContent>
-          <form onSubmit={handleSubmit} className="space-y-4">
-            <Input
-              type="password"
-              value={key}
-              onChange={(e) => setKey(e.target.value)}
-              placeholder="API Key"
-              className="transition-all duration-200"
-            />
-            {error && (
-              <p className="text-xs text-destructive flex items-center gap-1.5">
-                <AlertCircle className="h-3.5 w-3.5 shrink-0" />
-                {error}
-              </p>
-            )}
-            <Button
-              type="submit"
-              disabled={loading || !key.trim()}
-              className="w-full transition-all duration-200"
-            >
-              {loading ? (
-                <span className="flex items-center gap-2">
-                  <Loader2 className="h-4 w-4 animate-spin" />
-                  Verifying…
-                </span>
-              ) : (
-                "Login"
-              )}
-            </Button>
-          </form>
-        </CardContent>
-      </Card>
+        <h1 className="text-xl font-bold mb-1" style={{ color: "var(--color-accent)" }}>
+          ⚙ Workflow Dashboard
+        </h1>
+        <p className="text-sm mb-6" style={{ color: "var(--color-text-muted)" }}>
+          Enter your API key to continue
+        </p>
+        <form onSubmit={handleSubmit}>
+          <input
+            type="password"
+            value={key}
+            onChange={(e) => setKey(e.target.value)}
+            placeholder="API Key"
+            className="w-full px-3 py-2 rounded border text-sm mb-3 outline-none"
+            style={{
+              background: "var(--color-bg)",
+              borderColor: "var(--color-border)",
+              color: "var(--color-text)",
+            }}
+          />
+          {error && (
+            <p className="text-xs mb-3" style={{ color: "var(--color-error)" }}>
+              {error}
+            </p>
+          )}
+          <button
+            type="submit"
+            disabled={loading || !key.trim()}
+            className="w-full px-3 py-2 rounded text-sm font-medium"
+            style={{
+              background: "var(--color-accent)",
+              color: "var(--color-bg)",
+              opacity: loading || !key.trim() ? 0.5 : 1,
+            }}
+          >
+            {loading ? "Verifying..." : "Login"}
+          </button>
+        </form>
+      </div>
     </div>
   );
 }

packages/workflow-dashboard/src/components/markdown.tsx

@@ -52,23 +52,19 @@ function CodeBlock({ className, children }: { className?: string; children?: Rea
 
   if (html !== null) {
     return (
-      <div className="relative rounded-lg border border-border overflow-hidden my-3">
-        {lang !== "text" && (
-          <span className="absolute top-2 right-2 text-[10px] uppercase tracking-wider text-muted-foreground/70 font-mono">
-            {lang}
-          </span>
-        )}
-        <div
-          className="overflow-x-auto text-xs"
-          // biome-ignore lint/security/noDangerouslySetInnerHtml: shiki output is safe
-          dangerouslySetInnerHTML={{ __html: html }}
-        />
-      </div>
+      <div
+        className="rounded overflow-x-auto text-xs my-2"
+        // biome-ignore lint/security/noDangerouslySetInnerHtml: shiki output is safe
+        dangerouslySetInnerHTML={{ __html: html }}
+      />
     );
   }
 
   return (
-    <pre className="rounded-lg overflow-x-auto text-xs my-3 p-3 bg-muted/50 border border-border">
+    <pre
+      className="rounded overflow-x-auto text-xs my-2 p-3"
+      style={{ background: "var(--color-bg)" }}
+    >
       <code>{code}</code>
     </pre>
   );
@@ -84,7 +80,8 @@ export function Markdown({ content }: { content: string }) {
             if (isInline) {
               return (
                 <code
-                  className="bg-muted rounded px-1.5 py-0.5 text-[13px] font-mono text-foreground"
+                  className="text-xs px-1 py-0.5 rounded"
+                  style={{ background: "var(--color-border)", color: "var(--color-accent)" }}
                   {...props}
                 >
                   {children}
@@ -94,7 +91,7 @@ export function Markdown({ content }: { content: string }) {
             return <CodeBlock className={className}>{children}</CodeBlock>;
           },
           p({ children }) {
-            return <p className="my-2 leading-relaxed">{children}</p>;
+            return <p className="my-1.5 leading-relaxed">{children}</p>;
           },
           ul({ children }) {
             return <ul className="list-disc pl-4 my-1.5">{children}</ul>;
@@ -103,25 +100,20 @@ export function Markdown({ content }: { content: string }) {
             return <ol className="list-decimal pl-4 my-1.5">{children}</ol>;
           },
           h1({ children }) {
-            return (
-              <h1 className="text-lg font-bold mt-3 mb-2 border-b border-border pb-1">
-                {children}
-              </h1>
-            );
+            return <h1 className="text-lg font-bold mt-3 mb-1">{children}</h1>;
           },
           h2({ children }) {
-            return (
-              <h2 className="text-base font-bold mt-2 mb-2 border-b border-border pb-1">
-                {children}
-              </h2>
-            );
+            return <h2 className="text-base font-bold mt-2 mb-1">{children}</h2>;
           },
           h3({ children }) {
             return <h3 className="text-sm font-bold mt-2 mb-1">{children}</h3>;
           },
           blockquote({ children }) {
             return (
-              <blockquote className="border-l-2 border-ring pl-3 my-2 text-sm text-muted-foreground bg-muted/30 rounded-r-md py-2">
+              <blockquote
+                className="border-l-2 pl-3 my-2 text-sm"
+                style={{ borderColor: "var(--color-accent)", color: "var(--color-text-muted)" }}
+              >
                 {children}
               </blockquote>
             );

packages/workflow-dashboard/src/components/record-card.tsx

@@ -1,26 +1,14 @@
-import { CheckCircle2, Clock, MessageSquare, Rocket, User, XCircle } from "lucide-react";
 import type { RoleRecord, ThreadRecord, ThreadStartRecord, WorkflowResultRecord } from "../api.ts";
-import { cn } from "../lib/utils.ts";
 import { Markdown } from "./markdown.tsx";
-import { Badge } from "./ui/badge.tsx";
-import { Card } from "./ui/card.tsx";
 
-const ROLE_HUES = [262, 210, 35, 150, 330, 180, 15, 280, 55, 195, 345, 120, 240, 75, 305];
+const ROLE_COLORS: Record<string, string> = {
+  preparer: "#8b5cf6",
+  client: "#3b82f6",
+  extractor: "#f59e0b",
+};
 
-function roleHue(role: string): number {
-  let hash = 0;
-  for (let i = 0; i < role.length; i++) {
-    hash = (hash * 31 + role.charCodeAt(i)) | 0;
-  }
-  return ROLE_HUES[Math.abs(hash) % ROLE_HUES.length];
-}
-
-function roleBadgeStyle(role: string): { backgroundColor: string; borderColor: string } {
-  const hue = roleHue(role);
-  return {
-    backgroundColor: `oklch(0.58 0.12 ${hue} / 0.85)`,
-    borderColor: `oklch(0.58 0.12 ${hue} / 0.25)`,
-  };
+function roleColor(role: string): string {
+  return ROLE_COLORS[role] ?? "var(--color-accent)";
 }
 
 function formatTime(ts: number | null): string | null {
@@ -30,86 +18,99 @@ function formatTime(ts: number | null): string | null {
 
 function StartCard({ record }: { record: ThreadStartRecord }) {
   return (
-    <Card className="p-4 transition-all duration-200 overflow-hidden relative">
-      <div className="absolute inset-x-0 top-0 h-0.5 bg-gradient-to-r from-primary/80 via-primary/40 to-transparent" />
+    <div
+      className="p-4 rounded-lg border"
+      style={{ background: "var(--color-surface)", borderColor: "var(--color-border)" }}
+    >
       <div className="flex items-center gap-2 mb-2">
-        <Rocket className="h-5 w-5 text-primary" />
-        <span className="font-semibold text-foreground">{record.workflow}</span>
-        <Badge variant={record.status === "active" ? "success" : "secondary"}>
+        <span className="text-lg">🚀</span>
+        <span className="font-semibold" style={{ color: "var(--color-accent)" }}>
+          {record.workflow}
+        </span>
+        <span
+          className="text-xs px-2 py-0.5 rounded"
+          style={{
+            background: record.status === "active" ? "var(--color-success)" : "var(--color-border)",
+            color: record.status === "active" ? "var(--color-bg)" : "var(--color-text-muted)",
+          }}
+        >
           {record.status}
-        </Badge>
+        </span>
       </div>
       {record.prompt !== null && (
-        <div className="mt-2 p-3 rounded-md text-sm border-l-2 border-ring bg-muted/50">
-          <div className="text-xs mb-1 text-muted-foreground flex items-center gap-1">
-            <MessageSquare className="h-3 w-3" />
+        <div
+          className="mt-2 p-3 rounded text-sm border-l-2"
+          style={{
+            background: "var(--color-bg)",
+            borderColor: "var(--color-accent)",
+            color: "var(--color-text)",
+          }}
+        >
+          <div className="text-xs mb-1" style={{ color: "var(--color-text-muted)" }}>
             Prompt
           </div>
           <Markdown content={record.prompt} />
         </div>
       )}
-    </Card>
+    </div>
   );
 }
 
 function RoleMessage({ record, highlighted }: { record: RoleRecord; highlighted: boolean }) {
-  const style = roleBadgeStyle(record.role);
+  const color = roleColor(record.role);
   return (
-    <Card
-      className={cn(
-        "p-3 text-sm transition-all duration-200 border-l-4",
-        highlighted && "wf-record-card-highlight",
-      )}
-      style={{ borderLeftColor: style.borderColor }}
+    <div
+      className={`p-3 rounded-lg border text-sm ${highlighted ? "wf-record-card-highlight" : ""}`}
+      style={{ background: "var(--color-surface)", borderColor: "var(--color-border)" }}
     >
       <div className="flex items-center gap-2 mb-2">
         <span
-          className="text-xs px-2 py-0.5 rounded font-mono font-medium text-white shadow-sm inline-flex items-center gap-1"
-          style={{ backgroundColor: style.backgroundColor }}
+          className="text-xs px-2 py-0.5 rounded font-mono font-medium"
+          style={{ background: color, color: "#fff" }}
         >
-          <User className="h-3 w-3" />
           {record.role}
         </span>
         {formatTime(record.timestamp) !== null && (
-          <span className="text-xs ml-auto text-muted-foreground tabular-nums flex items-center gap-1">
-            <Clock className="h-3 w-3" />
+          <span className="text-xs ml-auto" style={{ color: "var(--color-text-muted)" }}>
             {formatTime(record.timestamp)}
           </span>
         )}
       </div>
       <Markdown content={record.content} />
-    </Card>
+    </div>
   );
 }
 
 function ResultCard({ record }: { record: WorkflowResultRecord }) {
   const success = record.returnCode === 0;
   return (
-    <Card
-      className={cn(
-        "p-4 transition-all duration-200 border-l-4",
-        success ? "border-l-success" : "border-l-destructive",
-      )}
+    <div
+      className="p-4 rounded-lg border"
+      style={{
+        background: "var(--color-surface)",
+        borderColor: success ? "var(--color-success)" : "var(--color-error)",
+      }}
     >
       <div className="flex items-center gap-2 mb-2">
-        {success ? (
-          <CheckCircle2 className="h-5 w-5 text-success" />
-        ) : (
-          <XCircle className="h-5 w-5 text-destructive" />
-        )}
+        <span className="text-lg">{success ? "✅" : "❌"}</span>
         <span className="font-semibold text-sm">{success ? "Completed" : "Failed"}</span>
-        <Badge variant="outline" className="font-mono">
+        <span
+          className="text-xs px-2 py-0.5 rounded font-mono"
+          style={{
+            background: success ? "var(--color-success)" : "var(--color-error)",
+            color: "#fff",
+          }}
+        >
           exit {record.returnCode}
-        </Badge>
+        </span>
         {formatTime(record.timestamp) !== null && (
-          <span className="text-xs ml-auto text-muted-foreground tabular-nums flex items-center gap-1">
-            <Clock className="h-3 w-3" />
+          <span className="text-xs ml-auto" style={{ color: "var(--color-text-muted)" }}>
             {formatTime(record.timestamp)}
           </span>
         )}
       </div>
       <Markdown content={record.content} />
-    </Card>
+    </div>
   );
 }
 

packages/workflow-dashboard/src/components/run-dialog.tsx

@@ -1,27 +1,14 @@
 import { useState } from "react";
-import { useNavigate } from "react-router";
 import { listWorkflows, runThread } from "../api.ts";
 import { useFetch } from "../hooks.ts";
-import { Button } from "./ui/button.tsx";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from "./ui/dialog.tsx";
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "./ui/select.tsx";
-import { Textarea } from "./ui/textarea.tsx";
 
 type Props = {
   client: string;
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
+  onClose: () => void;
+  onCreated: (threadId: string) => void;
 };
 
-export function RunDialog({ client, open, onOpenChange }: Props) {
-  const navigate = useNavigate();
+export function RunDialog({ client, onClose, onCreated }: Props) {
   const workflows = useFetch(() => listWorkflows(client), [client]);
   const [workflow, setWorkflow] = useState("");
   const [prompt, setPrompt] = useState("");
@@ -35,8 +22,7 @@ export function RunDialog({ client, open, onOpenChange }: Props) {
     setError(null);
     try {
       const result = await runThread(client, workflow, prompt);
-      onOpenChange(false);
-      navigate(`/${client}/threads/${result.threadId}`);
+      onCreated(result.threadId);
     } catch (err) {
       setError(err instanceof Error ? err.message : String(err));
       setSubmitting(false);
@@ -44,54 +30,95 @@ export function RunDialog({ client, open, onOpenChange }: Props) {
   }
 
   return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent>
-        <DialogHeader>
-          <DialogTitle>Run Thread</DialogTitle>
-          <DialogDescription>Start a new thread on {client}</DialogDescription>
-        </DialogHeader>
+    <div
+      className="fixed inset-0 flex items-center justify-center z-50"
+      style={{ background: "rgba(0,0,0,0.6)" }}
+    >
+      <div
+        className="w-full max-w-lg p-6 rounded-lg border"
+        style={{ background: "var(--color-surface)", borderColor: "var(--color-border)" }}
+      >
+        <h3 className="text-lg font-semibold mb-4">Run Thread on {client}</h3>
         <form onSubmit={handleSubmit} className="space-y-4">
           <div>
-            <label htmlFor="run-workflow" className="text-sm block mb-1.5 text-muted-foreground">
+            <label
+              htmlFor="run-workflow"
+              className="text-sm block mb-1"
+              style={{ color: "var(--color-text-muted)" }}
+            >
               Workflow
             </label>
-            <Select value={workflow} onValueChange={setWorkflow}>
-              <SelectTrigger>
-                <SelectValue placeholder="Select a workflow..." />
-              </SelectTrigger>
-              <SelectContent>
-                {workflows.status === "ok" &&
-                  workflows.data.workflows.map((w) => (
-                    <SelectItem key={w.name} value={w.name}>
-                      {w.name}
-                    </SelectItem>
-                  ))}
-              </SelectContent>
-            </Select>
+            <select
+              id="run-workflow"
+              value={workflow}
+              onChange={(e) => setWorkflow(e.target.value)}
+              className="w-full px-3 py-2 rounded border text-sm"
+              style={{
+                background: "var(--color-bg)",
+                borderColor: "var(--color-border)",
+                color: "var(--color-text)",
+              }}
+            >
+              <option value="">Select a workflow...</option>
+              {workflows.status === "ok" &&
+                workflows.data.workflows.map((w) => (
+                  <option key={w.name} value={w.name}>
+                    {w.name}
+                  </option>
+                ))}
+            </select>
           </div>
           <div>
-            <label htmlFor="run-prompt" className="text-sm block mb-1.5 text-muted-foreground">
+            <label
+              htmlFor="run-prompt"
+              className="text-sm block mb-1"
+              style={{ color: "var(--color-text-muted)" }}
+            >
               Prompt
             </label>
-            <Textarea
+            <textarea
               id="run-prompt"
               value={prompt}
               onChange={(e) => setPrompt(e.target.value)}
               rows={4}
+              className="w-full px-3 py-2 rounded border text-sm"
+              style={{
+                background: "var(--color-bg)",
+                borderColor: "var(--color-border)",
+                color: "var(--color-text)",
+              }}
               placeholder="Enter the task prompt..."
             />
           </div>
-          {error && <p className="text-sm text-destructive">{error}</p>}
-          <DialogFooter>
-            <Button type="button" variant="outline" onClick={() => onOpenChange(false)}>
+          {error && (
+            <p className="text-sm" style={{ color: "var(--color-error)" }}>
+              {error}
+            </p>
+          )}
+          <div className="flex gap-2 justify-end">
+            <button
+              type="button"
+              onClick={onClose}
+              className="px-4 py-2 text-sm rounded border"
+              style={{ borderColor: "var(--color-border)", color: "var(--color-text-muted)" }}
+            >
               Cancel
-            </Button>
-            <Button type="submit" disabled={submitting || !workflow || !prompt}>
+            </button>
+            <button
+              type="submit"
+              disabled={submitting || !workflow || !prompt}
+              className="px-4 py-2 text-sm rounded"
+              style={{
+                background: submitting ? "var(--color-accent-dim)" : "var(--color-accent)",
+                color: "#fff",
+                opacity: !workflow || !prompt ? 0.5 : 1,
+              }}
+            >
               {submitting ? "Starting..." : "Run"}
-            </Button>
-          </DialogFooter>
+            </button>
+          </div>
         </form>
-      </DialogContent>
-    </Dialog>
+      </div>
+    </div>
   );
 }

packages/workflow-dashboard/src/components/sidebar.tsx

@@ -1,131 +1,109 @@
-import { Loader2, LogOut, Moon, Package, Sun, Zap } from "lucide-react";
-import { useLocation, useNavigate, useParams } from "react-router";
+import { useEffect } from "react";
 import type { ClientEndpoint } from "../api.ts";
 import { listClients } from "../api.ts";
 import { useFetch } from "../hooks.ts";
-import { cn } from "../lib/utils.ts";
-import { Button } from "./ui/button.tsx";
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "./ui/select.tsx";
-import { Separator } from "./ui/separator.tsx";
 
 type Props = {
+  view: "threads" | "workflows";
+  client: string | null;
+  onViewChange: (v: "threads" | "workflows") => void;
+  onClientChange: (a: string | null) => void;
   onLogout: () => void;
-  theme: "light" | "dark";
-  onToggleTheme: () => void;
 };
 
-export function Sidebar({ onLogout, theme, onToggleTheme }: Props) {
-  const { client } = useParams();
-  const navigate = useNavigate();
-  const location = useLocation();
+export function Sidebar({ view, client, onViewChange, onClientChange, onLogout }: Props) {
   const { status, data } = useFetch(() => listClients(), []);
 
   const clients: ClientEndpoint[] = status === "ok" ? data : [];
 
-  const view = location.pathname.includes("/workflows") ? "workflows" : "threads";
+  // Auto-select first client when none is selected
+  useEffect(() => {
+    if (client === null && clients.length > 0) {
+      onClientChange(clients[0].name);
+    }
+  }, [client, clients, onClientChange]);
 
   const viewItems = [
-    { key: "threads" as const, label: "Threads", icon: Zap },
-    { key: "workflows" as const, label: "Workflows", icon: Package },
+    { key: "threads" as const, label: "Threads", icon: "⚡" },
+    { key: "workflows" as const, label: "Workflows", icon: "📦" },
   ];
 
   return (
-    <aside className="w-56 border-r border-border flex flex-col bg-sidebar">
-      <div className="p-4 border-b border-primary/20">
-        <h1 className="text-xl font-bold text-foreground tracking-tight">Workflow</h1>
-        <p className="text-xs text-muted-foreground mt-0.5 tracking-wide uppercase">Dashboard</p>
+    <aside
+      className="w-56 border-r flex flex-col"
+      style={{ borderColor: "var(--color-border)", background: "var(--color-surface)" }}
+    >
+      <div className="p-4 border-b" style={{ borderColor: "var(--color-border)" }}>
+        <h1 className="text-lg font-semibold" style={{ color: "var(--color-accent)" }}>
+          ⚙ Workflow
+        </h1>
+        <p className="text-xs mt-1" style={{ color: "var(--color-text-muted)" }}>
+          Dashboard
+        </p>
       </div>
 
-      <div className="px-3 py-3">
+      {/* Client selector */}
+      <div className="px-4 py-3 border-b" style={{ borderColor: "var(--color-border)" }}>
         <label
-          className="block text-xs font-medium mb-1.5 text-muted-foreground"
+          className="block text-xs font-medium mb-1"
+          style={{ color: "var(--color-text-muted)" }}
           htmlFor="client-select"
         >
           Client
         </label>
-        {status === "loading" ? (
-          <div className="h-9 rounded-md border border-input bg-transparent px-3 py-2 text-xs text-muted-foreground flex items-center gap-2">
-            <Loader2 className="h-3.5 w-3.5 animate-spin" />
-            Loading…
-          </div>
-        ) : clients.length === 0 ? (
-          <div className="h-9 rounded-md border border-input bg-transparent px-3 py-2 text-xs text-muted-foreground flex items-center">
-            No clients online
-          </div>
-        ) : (
-          <Select
-            value={client ?? ""}
-            onValueChange={(name) => {
-              if (name) navigate(`/${name}/${view}`);
-            }}
-          >
-            <SelectTrigger className="h-8 text-xs transition-colors duration-200">
-              <SelectValue placeholder="Select client…" />
-            </SelectTrigger>
-            <SelectContent>
-              {clients.map((a) => (
-                <SelectItem key={a.name} value={a.name} className="text-xs">
-                  <span className="flex items-center gap-2">
-                    <span
-                      className={cn(
-                        "inline-block h-2 w-2 rounded-full",
-                        a.status === "online" ? "bg-success animate-pulse" : "bg-destructive",
-                      )}
-                    />
-                    {a.name}
-                  </span>
-                </SelectItem>
-              ))}
-            </SelectContent>
-          </Select>
-        )}
+        <select
+          id="client-select"
+          className="w-full rounded px-2 py-1.5 text-xs"
+          style={{
+            background: "var(--color-bg)",
+            color: "var(--color-text)",
+            border: "1px solid var(--color-border)",
+          }}
+          value={client ?? ""}
+          onChange={(e) => onClientChange(e.target.value || null)}
+          disabled={status === "loading"}
+        >
+          {status === "loading" ? (
+            <option value="">Loading…</option>
+          ) : clients.length === 0 ? (
+            <option value="">No clients online</option>
+          ) : (
+            clients.map((a) => (
+              <option key={a.name} value={a.name}>
+                {a.status === "online" ? "🟢" : "🔴"} {a.name}
+              </option>
+            ))
+          )}
+        </select>
       </div>
 
-      <Separator />
-
+      {/* View navigation */}
       <nav className="flex-1 p-2 space-y-1">
         {viewItems.map((item) => (
-          <Button
+          <button
+            type="button"
             key={item.key}
-            variant={view === item.key ? "secondary" : "ghost"}
-            size="sm"
-            className={cn(
-              "w-full justify-start gap-2 transition-colors duration-200",
-              view === item.key
-                ? "text-foreground border-l-2 border-primary rounded-l-none"
-                : "text-muted-foreground hover:text-foreground",
-            )}
-            onClick={() => {
-              if (client) navigate(`/${client}/${item.key}`);
+            onClick={() => onViewChange(item.key)}
+            className="w-full text-left px-3 py-2 rounded text-sm transition-colors"
+            style={{
+              background: view === item.key ? "var(--color-accent-dim)" : "transparent",
+              color: view === item.key ? "#fff" : "var(--color-text-muted)",
             }}
           >
-            <item.icon className="h-4 w-4" />
-            {item.label}
-          </Button>
+            {item.icon} {item.label}
+          </button>
         ))}
       </nav>
 
-      <Separator />
-
-      <div className="p-2 space-y-1">
-        <Button
-          variant="ghost"
-          size="sm"
-          className="w-full justify-start gap-2 text-muted-foreground hover:text-foreground transition-colors duration-200"
-          onClick={onToggleTheme}
-        >
-          {theme === "dark" ? <Sun className="h-4 w-4" /> : <Moon className="h-4 w-4" />}
-          {theme === "dark" ? "Light mode" : "Dark mode"}
-        </Button>
-        <Button
-          variant="ghost"
-          size="sm"
-          className="w-full justify-start gap-2 text-muted-foreground hover:text-foreground transition-colors duration-200"
+      <div className="p-2 border-t" style={{ borderColor: "var(--color-border)" }}>
+        <button
+          type="button"
           onClick={onLogout}
+          className="w-full text-left px-3 py-2 rounded text-xs transition-colors"
+          style={{ color: "var(--color-text-muted)" }}
         >
-          <LogOut className="h-4 w-4" />
-          Logout
-        </Button>
+          🚪 Logout
+        </button>
       </div>
     </aside>
   );

packages/workflow-dashboard/src/components/status-bar.tsx

@@ -1,7 +1,5 @@
-import { Loader2, Play, Wifi, WifiOff } from "lucide-react";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { getClientHealth } from "../api.ts";
-import { Button } from "./ui/button.tsx";
 
 type HealthStatus = "connected" | "disconnected" | "reconnecting";
 
@@ -10,29 +8,14 @@ type Props = {
   onRun: () => void;
 };
 
-function StatusIndicator({ status }: { status: HealthStatus }) {
+function statusLabel(status: HealthStatus): { text: string; color: string } {
   if (status === "connected") {
-    return (
-      <span className="flex items-center gap-1.5 text-xs text-success transition-colors duration-200">
-        <Wifi className="h-3.5 w-3.5" />
-        Connected
-      </span>
-    );
+    return { text: "● Connected", color: "var(--color-success)" };
   }
   if (status === "reconnecting") {
-    return (
-      <span className="flex items-center gap-1.5 text-xs text-warning transition-colors duration-200">
-        <Loader2 className="h-3.5 w-3.5 animate-spin" />
-        Reconnecting…
-      </span>
-    );
+    return { text: "● Reconnecting...", color: "var(--color-warning, #f59e0b)" };
   }
-  return (
-    <span className="flex items-center gap-1.5 text-xs text-destructive transition-colors duration-200">
-      <WifiOff className="h-3.5 w-3.5" />
-      Offline
-    </span>
-  );
+  return { text: "● Offline", color: "var(--color-error)" };
 }
 
 export function StatusBar({ client, onRun }: Props) {
@@ -65,24 +48,32 @@ export function StatusBar({ client, onRun }: Props) {
     return () => clearInterval(interval);
   }, [checkHealth]);
 
+  const label = statusLabel(status);
+
   return (
-    <div className="flex items-center justify-between px-6 py-2 text-xs border-b border-border bg-card/80 backdrop-blur-sm">
+    <div
+      className="flex items-center justify-between px-6 py-2 text-xs border-b"
+      style={{ borderColor: "var(--color-border)", background: "var(--color-surface)" }}
+    >
       <div className="flex items-center gap-4">
-        <span className="text-muted-foreground">
+        <span style={{ color: "var(--color-text-muted)" }}>
           {client ? `Client: ${client}` : "No client selected"}
         </span>
-        <Button
-          variant="default"
-          size="sm"
-          disabled={!client}
+        <button
+          type="button"
           onClick={onRun}
-          className="h-7 gap-1.5 transition-all duration-200"
+          disabled={!client}
+          className="px-3 py-1 rounded text-xs font-medium"
+          style={{
+            background: client ? "var(--color-accent)" : "var(--color-border)",
+            color: "#fff",
+            opacity: client ? 1 : 0.5,
+          }}
         >
-          <Play className="h-3.5 w-3.5" />
-          Run Thread
-        </Button>
+          ▶ Run Thread
+        </button>
       </div>
-      <StatusIndicator status={status} />
+      <span style={{ color: label.color }}>{label.text}</span>
     </div>
   );
 }

packages/workflow-dashboard/src/components/thread-detail.tsx

@@ -1,6 +1,4 @@
-import { AlertCircle, ArrowLeft, Layers, Loader2, Pause, Play, X } from "lucide-react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { useNavigate, useParams } from "react-router";
 import {
   getThread,
   getWorkflowDescriptor,
@@ -13,12 +11,14 @@ import {
 import { useFetch } from "../hooks.ts";
 import { useSSE } from "../use-sse.ts";
 import { RecordCard } from "./record-card.tsx";
-import { Badge } from "./ui/badge.tsx";
-import { Button } from "./ui/button.tsx";
-import { Card } from "./ui/card.tsx";
-import { ResizablePanel } from "./ui/resizable-panel.tsx";
 import { type NodeState, WorkflowGraph } from "./workflow-graph/index.ts";
 
+type Props = {
+  client: string;
+  threadId: string;
+  onBack: () => void;
+};
+
 function extractWorkflowName(records: readonly ThreadRecord[]): string | null {
   for (const r of records) {
     if (r.type === "thread-start") return r.workflow;
@@ -53,11 +53,36 @@ function computeNodeStates(records: readonly ThreadRecord[]): Map<string, NodeSt
   return states;
 }
 
-export function ThreadDetail() {
-  const params = useParams();
-  const navigate = useNavigate();
-  const client = params.client as string;
-  const threadId = params.threadId as string;
+function isClickableGraphNode(nodeStates: Map<string, NodeState>, nodeId: string): boolean {
+  const state = nodeStates.get(nodeId);
+  return state !== undefined && state !== "default";
+}
+
+function scrollToFirstRecord(): void {
+  const firstCard = document.querySelector('[data-record-index="0"]');
+  if (firstCard !== null) firstCard.scrollIntoView({ behavior: "smooth", block: "center" });
+}
+
+function scrollToRoleOccurrence(
+  nodeId: string,
+  indicesByRole: Map<string, number[]>,
+  clickCycleRef: { current: Map<string, number> },
+  onHighlight: (role: string) => void,
+): void {
+  const indices = indicesByRole.get(nodeId);
+  if (indices === undefined || indices.length === 0) return;
+
+  const cycle = clickCycleRef.current.get(nodeId) ?? 0;
+  const idx = indices[cycle % indices.length];
+  clickCycleRef.current.set(nodeId, cycle + 1);
+
+  const el = document.querySelector(`[data-record-index="${idx}"]`);
+  if (el === null) return;
+  el.scrollIntoView({ behavior: "smooth", block: "center" });
+  onHighlight(nodeId);
+}
+
+export function ThreadDetail({ client, threadId, onBack }: Props) {
   const sse = useSSE(client, threadId);
   const { status, data, error } = useFetch(() => getThread(client, threadId), [client, threadId]);
   const [actionStatus, setActionStatus] = useState<string | null>(null);
@@ -97,42 +122,32 @@ export function ThreadDetail() {
     return m;
   }, [records]);
 
+  // Track which occurrence to jump to next per role (cycling)
   const clickCycleRef = useRef<Map<string, number>>(new Map());
 
+  const highlightRole = useCallback((role: string) => {
+    if (highlightTimerRef.current !== null) clearTimeout(highlightTimerRef.current);
+    setHighlightedRole(role);
+    highlightTimerRef.current = setTimeout(() => {
+      setHighlightedRole(null);
+      highlightTimerRef.current = null;
+    }, 1500);
+  }, []);
+
   const handleGraphNodeClick = useCallback(
     (nodeId: string) => {
-      if (nodeStates.get(nodeId) === undefined || nodeStates.get(nodeId) === "default") return;
-
+      if (!isClickableGraphNode(nodeStates, nodeId)) return;
       if (nodeId === "__start__") {
-        const firstCard = document.querySelector('[data-record-index="0"]');
-        if (firstCard !== null) firstCard.scrollIntoView({ behavior: "smooth", block: "center" });
+        scrollToFirstRecord();
         return;
       }
-
       if (nodeId === "__end__") {
         recordsEndRef.current?.scrollIntoView({ behavior: "smooth", block: "end" });
         return;
       }
-
-      const indices = indicesByRole.get(nodeId);
-      if (indices === undefined || indices.length === 0) return;
-
-      const cycle = clickCycleRef.current.get(nodeId) ?? 0;
-      const idx = indices[cycle % indices.length];
-      clickCycleRef.current.set(nodeId, cycle + 1);
-
-      const el = document.querySelector(`[data-record-index="${idx}"]`);
-      if (el !== null) {
-        el.scrollIntoView({ behavior: "smooth", block: "center" });
-        if (highlightTimerRef.current !== null) clearTimeout(highlightTimerRef.current);
-        setHighlightedRole(nodeId);
-        highlightTimerRef.current = setTimeout(() => {
-          setHighlightedRole(null);
-          highlightTimerRef.current = null;
-        }, 1500);
-      }
+      scrollToRoleOccurrence(nodeId, indicesByRole, clickCycleRef, highlightRole);
     },
-    [nodeStates, indicesByRole],
+    [nodeStates, indicesByRole, highlightRole],
   );
 
   useEffect(() => {
@@ -151,7 +166,7 @@ export function ThreadDetail() {
     try {
       const fn = action === "kill" ? killThread : action === "pause" ? pauseThread : resumeThread;
       await fn(client, threadId);
-      setActionStatus(null);
+      setActionStatus(`${action} sent ✓`);
     } catch (e) {
       setActionStatus(`${action} failed: ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -160,84 +175,88 @@ export function ThreadDetail() {
   return (
     <div>
       <div className="flex items-center justify-between mb-4">
-        <Button
-          variant="ghost"
-          className="gap-1.5 px-2 text-muted-foreground hover:text-foreground transition-colors duration-200"
-          onClick={() => navigate(`/${client}/threads`)}
+        <button
+          type="button"
+          onClick={onBack}
+          className="text-sm hover:underline"
+          style={{ color: "var(--color-accent)" }}
         >
-          <ArrowLeft className="h-4 w-4" />
-          Back to threads
-        </Button>
-        <div className="flex gap-1 rounded-lg border border-border bg-muted/30 p-1">
-          <Button
-            variant="outline"
-            size="sm"
-            className="transition-colors duration-200"
+          ← Back to threads
+        </button>
+        <div className="flex gap-2">
+          <button
+            type="button"
             onClick={() => handleAction("pause")}
+            className="px-3 py-1 text-xs rounded border"
+            style={{ borderColor: "var(--color-warning)", color: "var(--color-warning)" }}
           >
-            <Pause className="h-3.5 w-3.5 text-warning" />
-            Pause
-          </Button>
-          <Button
-            variant="outline"
-            size="sm"
-            className="transition-colors duration-200"
+            ⏸ Pause
+          </button>
+          <button
+            type="button"
             onClick={() => handleAction("resume")}
+            className="px-3 py-1 text-xs rounded border"
+            style={{ borderColor: "var(--color-success)", color: "var(--color-success)" }}
           >
-            <Play className="h-3.5 w-3.5 text-success" />
-            Resume
-          </Button>
-          <Button
-            variant="outline"
-            size="sm"
-            className="transition-colors duration-200"
+            ▶ Resume
+          </button>
+          <button
+            type="button"
             onClick={() => handleAction("kill")}
+            className="px-3 py-1 text-xs rounded border"
+            style={{ borderColor: "var(--color-error)", color: "var(--color-error)" }}
           >
-            <X className="h-3.5 w-3.5 text-destructive" />
-            Kill
-          </Button>
+            ✕ Kill
+          </button>
         </div>
       </div>
 
-      <h2 className="text-xl font-semibold mb-2 font-mono tracking-tight flex items-center gap-2 flex-wrap">
+      <h2 className="text-xl font-semibold mb-2 font-mono flex items-center gap-2 flex-wrap">
         <span>{threadId}</span>
         {sse.connected && !sse.completed && (
-          <Badge variant="success" className="animate-pulse flex items-center gap-1.5">
-            <span className="inline-block h-2 w-2 rounded-full bg-success-foreground" />
+          <span
+            className="text-xs font-medium px-2 py-0.5 rounded"
+            style={{ background: "var(--color-success)", color: "var(--color-bg)" }}
+          >
             Live
-          </Badge>
+          </span>
         )}
       </h2>
       {actionStatus && (
-        <Badge variant="secondary" className="mb-4 text-xs font-normal">
+        <p className="text-xs mb-4" style={{ color: "var(--color-text-muted)" }}>
           {actionStatus}
-        </Badge>
+        </p>
       )}
 
       <div className="flex gap-4" style={{ minHeight: "calc(100vh - 120px)" }}>
         {descriptor !== null && descriptor.graph.edges.length > 0 && (
-          <ResizablePanel
-            defaultWidth={360}
-            minWidth={240}
-            maxWidth={560}
-            className={null}
+          <div
+            className="shrink-0"
             style={{
+              width: 280,
               position: "sticky",
               top: 16,
               height: "calc(100vh - 120px)",
               alignSelf: "flex-start",
             }}
           >
-            <Card className="h-full flex flex-col overflow-hidden">
-              <div className="flex items-center justify-between px-3 py-2 text-xs text-muted-foreground bg-muted/50 border-b border-border">
-                <span className="font-mono flex items-center gap-1.5">
-                  <Layers className="h-3.5 w-3.5" />
+            <div
+              className="rounded-lg border h-full flex flex-col overflow-hidden"
+              style={{ borderColor: "var(--color-border)", background: "var(--color-surface)" }}
+            >
+              <div
+                className="flex items-center justify-between px-3 py-2 text-xs"
+                style={{ color: "var(--color-text-muted)" }}
+              >
+                <span className="font-mono">
                   Workflow graph
                   {workflowName !== null && (
-                    <span className="ml-2 text-foreground">{workflowName}</span>
+                    <span className="ml-2" style={{ color: "var(--color-text)" }}>
+                      {workflowName}
+                    </span>
                   )}
                 </span>
-                <span className="tabular-nums">
+                <span>
                   {descriptor.graph.edges.length} edge
                   {descriptor.graph.edges.length === 1 ? "" : "s"}
                 </span>
@@ -250,25 +269,19 @@ export function ThreadDetail() {
                   onNodeClick={handleGraphNodeClick}
                 />
               </div>
-            </Card>
-          </ResizablePanel>
+            </div>
+          </div>
         )}
 
         <div className="flex-1 min-w-0">
           {status === "loading" && !liveActive && records.length === 0 && (
-            <div className="flex flex-col items-center justify-center py-16 text-muted-foreground gap-3">
-              <Loader2 className="h-6 w-6 animate-spin" />
-              <span className="text-sm">Loading thread...</span>
-            </div>
+            <p style={{ color: "var(--color-text-muted)" }}>Loading...</p>
           )}
           {status === "error" && !liveActive && (
-            <div className="flex items-center gap-2 py-8 justify-center text-destructive">
-              <AlertCircle className="h-5 w-5" />
-              <span className="text-sm">Error: {error}</span>
-            </div>
+            <p style={{ color: "var(--color-error)" }}>Error: {error}</p>
           )}
           {(status === "ok" || liveActive || records.length > 0) && (
-            <div className="border-l-2 border-border ml-2 pl-4 space-y-3">
+            <div className="space-y-3">
               {records.map((r, i) => {
                 const key = `${threadId}-${i}`;
                 if (r.type === "role") {
@@ -279,21 +292,18 @@ export function ThreadDetail() {
                     <div
                       key={key}
                       data-record-index={i}
-                      className="relative"
                       ref={(el) => {
                         if (!isFirstForRole) return;
                         if (el !== null) firstCardByRoleRef.current.set(r.role, el);
                         else firstCardByRoleRef.current.delete(r.role);
                       }}
                     >
-                      <div className="absolute -left-[1.3rem] top-4 h-2.5 w-2.5 rounded-full border-2 border-border bg-background" />
                       <RecordCard record={r} highlighted={flash} />
                     </div>
                   );
                 }
                 return (
-                  <div key={key} data-record-index={i} className="relative">
-                    <div className="absolute -left-[1.3rem] top-4 h-2.5 w-2.5 rounded-full border-2 border-border bg-background" />
+                  <div key={key} data-record-index={i}>
                     <RecordCard record={r} highlighted={false} />
                   </div>
                 );

packages/workflow-dashboard/src/components/thread-list.tsx

@@ -1,37 +1,17 @@
-import { AlertCircle, Clock, Loader2, Workflow, Zap } from "lucide-react";
-import { useNavigate, useParams } from "react-router";
 import { listThreads } from "../api.ts";
 import { useFetch } from "../hooks.ts";
-import { Badge } from "./ui/badge.tsx";
-import { Card } from "./ui/card.tsx";
 
-function statusVariant(status: string): "success" | "destructive" | "secondary" {
-  if (status === "completed") return "success";
-  if (status === "failed") return "destructive";
-  return "secondary";
-}
+type Props = {
+  client: string;
+  onSelect: (id: string) => void;
+};
 
-export function ThreadList() {
-  const params = useParams();
-  const navigate = useNavigate();
-  const client = params.client as string;
+export function ThreadList({ client, onSelect }: Props) {
   const { status, data, error } = useFetch(() => listThreads(client), [client]);
 
   if (status === "loading")
-    return (
-      <div className="flex flex-col items-center justify-center py-16 gap-3">
-        <Loader2 className="h-4 w-4 animate-spin text-muted-foreground" />
-        <p className="text-sm text-muted-foreground">Loading threads...</p>
-      </div>
-    );
-
-  if (status === "error")
-    return (
-      <div className="flex flex-col items-center justify-center py-16 gap-3">
-        <AlertCircle className="h-5 w-5 text-destructive" />
-        <p className="text-sm text-destructive">Error: {error}</p>
-      </div>
-    );
+    return <p style={{ color: "var(--color-text-muted)" }}>Loading threads...</p>;
+  if (status === "error") return <p style={{ color: "var(--color-error)" }}>Error: {error}</p>;
 
   const threads = [...data.threads].sort((a, b) => {
     if (!a.startedAt && !b.startedAt) return 0;
@@ -42,44 +22,51 @@ export function ThreadList() {
 
   return (
     <div>
-      <h2 className="text-xl font-semibold tracking-tight mb-4">Threads</h2>
+      <h2 className="text-xl font-semibold mb-4">Threads</h2>
       {threads.length === 0 ? (
-        <div className="flex flex-col items-center justify-center py-16 gap-3">
-          <Zap className="h-12 w-12 text-muted-foreground/50" />
-          <p className="text-sm font-medium">No threads</p>
-          <p className="text-xs text-muted-foreground">
-            Run a workflow to create your first thread.
-          </p>
-        </div>
+        <p style={{ color: "var(--color-text-muted)" }}>No threads found.</p>
       ) : (
         <div className="space-y-2">
           {threads.map((t) => (
-            <Card
+            <button
+              type="button"
               key={t.threadId}
-              className="p-4 cursor-pointer hover:bg-accent/50 hover:shadow-sm transition-all duration-200"
-              onClick={() => navigate(`/${client}/threads/${t.threadId}`)}
+              onClick={() => onSelect(t.threadId)}
+              className="w-full text-left p-4 rounded-lg border transition-colors hover:border-[var(--color-accent-dim)]"
+              style={{ background: "var(--color-surface)", borderColor: "var(--color-border)" }}
             >
               <div className="flex items-center justify-between">
-                <code className="font-mono text-sm text-foreground">{t.threadId}</code>
+                <code className="text-sm font-mono" style={{ color: "var(--color-accent)" }}>
+                  {t.threadId}
+                </code>
                 {t.status && (
-                  <Badge variant={statusVariant(t.status)} className="text-xs">
+                  <span
+                    className="text-xs px-2 py-0.5 rounded"
+                    style={{
+                      background:
+                        t.status === "completed"
+                          ? "var(--color-success)"
+                          : t.status === "failed"
+                            ? "var(--color-error)"
+                            : "var(--color-accent)",
+                      color: "#000",
+                    }}
+                  >
                     {t.status}
-                  </Badge>
+                  </span>
                 )}
               </div>
               {t.workflow && (
-                <p className="text-sm mt-1 font-medium text-foreground flex items-center gap-1.5">
-                  <Workflow className="h-3.5 w-3.5 text-muted-foreground" />
+                <p className="text-sm mt-1" style={{ color: "var(--color-text-muted)" }}>
                   {t.workflow}
                 </p>
               )}
               {t.startedAt && (
-                <p className="text-xs mt-1 text-muted-foreground flex items-center gap-1.5">
-                  <Clock className="h-3 w-3" />
+                <p className="text-xs mt-1" style={{ color: "var(--color-text-muted)" }}>
                   {t.startedAt}
                 </p>
               )}
-            </Card>
+            </button>
           ))}
         </div>
       )}

packages/workflow-dashboard/src/components/ui/badge.tsx

@@ -1,30 +0,0 @@
-import { cva, type VariantProps } from "class-variance-authority";
-import type { HTMLAttributes } from "react";
-import { cn } from "../../lib/utils.ts";
-
-const badgeVariants = cva(
-  "inline-flex items-center rounded-md border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
-  {
-    variants: {
-      variant: {
-        default: "border-transparent bg-primary text-primary-foreground shadow",
-        secondary: "border-transparent bg-secondary text-secondary-foreground",
-        destructive: "border-transparent bg-destructive text-destructive-foreground shadow",
-        outline: "text-foreground",
-        success: "border-transparent bg-success text-success-foreground shadow",
-        warning: "border-transparent bg-warning text-warning-foreground shadow",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-    },
-  },
-);
-
-export type BadgeProps = HTMLAttributes<HTMLDivElement> & VariantProps<typeof badgeVariants>;
-
-function Badge({ className, variant, ...props }: BadgeProps) {
-  return <div className={cn(badgeVariants({ variant }), className)} {...props} />;
-}
-
-export { Badge, badgeVariants };

packages/workflow-dashboard/src/components/ui/button.tsx

@@ -1,45 +0,0 @@
-import { Slot } from "@radix-ui/react-slot";
-import { cva, type VariantProps } from "class-variance-authority";
-import type { ButtonHTMLAttributes } from "react";
-import { cn } from "../../lib/utils.ts";
-
-const buttonVariants = cva(
-  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
-  {
-    variants: {
-      variant: {
-        default: "bg-primary text-primary-foreground shadow hover:bg-primary/90",
-        destructive: "bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90",
-        outline:
-          "border border-input bg-background shadow-sm hover:bg-accent hover:text-accent-foreground",
-        secondary: "bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80",
-        ghost: "hover:bg-accent hover:text-accent-foreground",
-        link: "text-primary underline-offset-4 hover:underline",
-        success: "border border-success text-success hover:bg-success/10",
-        warning: "border border-warning text-warning hover:bg-warning/10",
-      },
-      size: {
-        default: "h-9 px-4 py-2",
-        sm: "h-8 rounded-md px-3 text-xs",
-        lg: "h-10 rounded-md px-8",
-        icon: "h-9 w-9",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-      size: "default",
-    },
-  },
-);
-
-export type ButtonProps = ButtonHTMLAttributes<HTMLButtonElement> &
-  VariantProps<typeof buttonVariants> & {
-    asChild?: boolean;
-  };
-
-function Button({ className, variant, size, asChild = false, ...props }: ButtonProps) {
-  const Comp = asChild ? Slot : "button";
-  return <Comp className={cn(buttonVariants({ variant, size, className }))} {...props} />;
-}
-
-export { Button, buttonVariants };

packages/workflow-dashboard/src/components/ui/card.tsx

@@ -1,36 +0,0 @@
-import type { HTMLAttributes } from "react";
-import { cn } from "../../lib/utils.ts";
-
-function Card({ className, ...props }: HTMLAttributes<HTMLDivElement>) {
-  return (
-    <div
-      className={cn(
-        "rounded-lg border border-border bg-card text-card-foreground shadow-sm",
-        className,
-      )}
-      {...props}
-    />
-  );
-}
-
-function CardHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>) {
-  return <div className={cn("flex flex-col space-y-1.5 p-6", className)} {...props} />;
-}
-
-function CardTitle({ className, ...props }: HTMLAttributes<HTMLDivElement>) {
-  return <div className={cn("font-semibold leading-none tracking-tight", className)} {...props} />;
-}
-
-function CardDescription({ className, ...props }: HTMLAttributes<HTMLDivElement>) {
-  return <div className={cn("text-sm text-muted-foreground", className)} {...props} />;
-}
-
-function CardContent({ className, ...props }: HTMLAttributes<HTMLDivElement>) {
-  return <div className={cn("p-6 pt-0", className)} {...props} />;
-}
-
-function CardFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>) {
-  return <div className={cn("flex items-center p-6 pt-0", className)} {...props} />;
-}
-
-export { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle };

packages/workflow-dashboard/src/components/ui/collapsible.tsx

@@ -1,7 +0,0 @@
-import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
-
-const Collapsible = CollapsiblePrimitive.Root;
-const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger;
-const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent;
-
-export { Collapsible, CollapsibleContent, CollapsibleTrigger };

packages/workflow-dashboard/src/components/ui/dialog.tsx

@@ -1,104 +0,0 @@
-import * as DialogPrimitive from "@radix-ui/react-dialog";
-import { X } from "lucide-react";
-import type { ComponentPropsWithoutRef, HTMLAttributes } from "react";
-import { cn } from "../../lib/utils.ts";
-
-const Dialog = DialogPrimitive.Root;
-const DialogTrigger = DialogPrimitive.Trigger;
-const DialogPortal = DialogPrimitive.Portal;
-const DialogClose = DialogPrimitive.Close;
-
-function DialogOverlay({
-  className,
-  ...props
-}: ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>) {
-  return (
-    <DialogPrimitive.Overlay
-      className={cn(
-        "fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
-        className,
-      )}
-      {...props}
-    />
-  );
-}
-
-function DialogContent({
-  className,
-  children,
-  ...props
-}: ComponentPropsWithoutRef<typeof DialogPrimitive.Content>) {
-  return (
-    <DialogPortal>
-      <DialogOverlay />
-      <DialogPrimitive.Content
-        className={cn(
-          "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border border-border bg-card p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] rounded-lg",
-          className,
-        )}
-        {...props}
-      >
-        {children}
-        <DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
-          <X className="h-4 w-4" />
-          <span className="sr-only">Close</span>
-        </DialogPrimitive.Close>
-      </DialogPrimitive.Content>
-    </DialogPortal>
-  );
-}
-
-function DialogHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>) {
-  return (
-    <div
-      className={cn("flex flex-col space-y-1.5 text-center sm:text-left", className)}
-      {...props}
-    />
-  );
-}
-
-function DialogFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>) {
-  return (
-    <div
-      className={cn("flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2", className)}
-      {...props}
-    />
-  );
-}
-
-function DialogTitle({
-  className,
-  ...props
-}: ComponentPropsWithoutRef<typeof DialogPrimitive.Title>) {
-  return (
-    <DialogPrimitive.Title
-      className={cn("text-lg font-semibold leading-none tracking-tight", className)}
-      {...props}
-    />
-  );
-}
-
-function DialogDescription({
-  className,
-  ...props
-}: ComponentPropsWithoutRef<typeof DialogPrimitive.Description>) {
-  return (
-    <DialogPrimitive.Description
-      className={cn("text-sm text-muted-foreground", className)}
-      {...props}
-    />
-  );
-}
-
-export {
-  Dialog,
-  DialogClose,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogOverlay,
-  DialogPortal,
-  DialogTitle,
-  DialogTrigger,
-};

packages/workflow-dashboard/src/components/ui/input.tsx

@@ -1,17 +0,0 @@
-import type { InputHTMLAttributes } from "react";
-import { cn } from "../../lib/utils.ts";
-
-function Input({ className, type, ...props }: InputHTMLAttributes<HTMLInputElement>) {
-  return (
-    <input
-      type={type}
-      className={cn(
-        "flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50",
-        className,
-      )}
-      {...props}
-    />
-  );
-}
-
-export { Input };

packages/workflow-dashboard/src/components/ui/resizable-panel.tsx

@@ -1,73 +0,0 @@
-import {
-  type CSSProperties,
-  type PointerEvent as ReactPointerEvent,
-  useCallback,
-  useRef,
-  useState,
-} from "react";
-import { cn } from "../../lib/utils.ts";
-
-type Props = {
-  defaultWidth: number;
-  minWidth: number;
-  maxWidth: number;
-  className: string | null;
-  style: CSSProperties | null;
-  children: React.ReactNode;
-};
-
-export function ResizablePanel({
-  defaultWidth,
-  minWidth,
-  maxWidth,
-  className,
-  style,
-  children,
-}: Props) {
-  const [width, setWidth] = useState(defaultWidth);
-  const dragging = useRef(false);
-  const startX = useRef(0);
-  const startW = useRef(0);
-
-  const onPointerDown = useCallback(
-    (e: ReactPointerEvent<HTMLDivElement>) => {
-      e.preventDefault();
-      dragging.current = true;
-      startX.current = e.clientX;
-      startW.current = width;
-      (e.target as HTMLElement).setPointerCapture(e.pointerId);
-    },
-    [width],
-  );
-
-  const onPointerMove = useCallback(
-    (e: ReactPointerEvent<HTMLDivElement>) => {
-      if (!dragging.current) return;
-      const delta = e.clientX - startX.current;
-      const next = Math.min(maxWidth, Math.max(minWidth, startW.current + delta));
-      setWidth(next);
-    },
-    [minWidth, maxWidth],
-  );
-
-  const onPointerUp = useCallback(() => {
-    dragging.current = false;
-  }, []);
-
-  return (
-    <div
-      className={cn("relative shrink-0", className)}
-      style={{ ...style, width }}
-    >
-      {children}
-      <div
-        className="absolute top-0 -right-1 w-2 h-full cursor-col-resize z-10 group"
-        onPointerDown={onPointerDown}
-        onPointerMove={onPointerMove}
-        onPointerUp={onPointerUp}
-      >
-        <div className="absolute inset-y-0 left-1/2 w-px bg-border opacity-0 group-hover:opacity-100 transition-opacity duration-150" />
-      </div>
-    </div>
-  );
-}

packages/workflow-dashboard/src/components/ui/scroll-area.tsx

@@ -1,42 +0,0 @@
-import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
-import type { ComponentPropsWithoutRef } from "react";
-import { cn } from "../../lib/utils.ts";
-
-function ScrollArea({
-  className,
-  children,
-  ...props
-}: ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root>) {
-  return (
-    <ScrollAreaPrimitive.Root className={cn("relative overflow-hidden", className)} {...props}>
-      <ScrollAreaPrimitive.Viewport className="h-full w-full rounded-[inherit]">
-        {children}
-      </ScrollAreaPrimitive.Viewport>
-      <ScrollBar />
-      <ScrollAreaPrimitive.Corner />
-    </ScrollAreaPrimitive.Root>
-  );
-}
-
-function ScrollBar({
-  className,
-  orientation = "vertical",
-  ...props
-}: ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>) {
-  return (
-    <ScrollAreaPrimitive.ScrollAreaScrollbar
-      orientation={orientation}
-      className={cn(
-        "flex touch-none select-none transition-colors",
-        orientation === "vertical" && "h-full w-2.5 border-l border-l-transparent p-[1px]",
-        orientation === "horizontal" && "h-2.5 flex-col border-t border-t-transparent p-[1px]",
-        className,
-      )}
-      {...props}
-    >
-      <ScrollAreaPrimitive.ScrollAreaThumb className="relative flex-1 rounded-full bg-border" />
-    </ScrollAreaPrimitive.ScrollAreaScrollbar>
-  );
-}
-
-export { ScrollArea, ScrollBar };

packages/workflow-dashboard/src/components/ui/select.tsx

@@ -1,148 +0,0 @@
-import * as SelectPrimitive from "@radix-ui/react-select";
-import { Check, ChevronDown, ChevronUp } from "lucide-react";
-import type { ComponentPropsWithoutRef } from "react";
-import { cn } from "../../lib/utils.ts";
-
-const Select = SelectPrimitive.Root;
-const SelectGroup = SelectPrimitive.Group;
-const SelectValue = SelectPrimitive.Value;
-
-function SelectTrigger({
-  className,
-  children,
-  ...props
-}: ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger>) {
-  return (
-    <SelectPrimitive.Trigger
-      className={cn(
-        "flex h-9 w-full items-center justify-between whitespace-nowrap rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-1 focus:ring-ring disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
-        className,
-      )}
-      {...props}
-    >
-      {children}
-      <SelectPrimitive.Icon asChild>
-        <ChevronDown className="h-4 w-4 opacity-50" />
-      </SelectPrimitive.Icon>
-    </SelectPrimitive.Trigger>
-  );
-}
-
-function SelectScrollUpButton({
-  className,
-  ...props
-}: ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollUpButton>) {
-  return (
-    <SelectPrimitive.ScrollUpButton
-      className={cn("flex cursor-default items-center justify-center py-1", className)}
-      {...props}
-    >
-      <ChevronUp className="h-4 w-4" />
-    </SelectPrimitive.ScrollUpButton>
-  );
-}
-
-function SelectScrollDownButton({
-  className,
-  ...props
-}: ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollDownButton>) {
-  return (
-    <SelectPrimitive.ScrollDownButton
-      className={cn("flex cursor-default items-center justify-center py-1", className)}
-      {...props}
-    >
-      <ChevronDown className="h-4 w-4" />
-    </SelectPrimitive.ScrollDownButton>
-  );
-}
-
-function SelectContent({
-  className,
-  children,
-  position = "popper",
-  ...props
-}: ComponentPropsWithoutRef<typeof SelectPrimitive.Content>) {
-  return (
-    <SelectPrimitive.Portal>
-      <SelectPrimitive.Content
-        className={cn(
-          "relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border border-border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
-          position === "popper" &&
-            "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
-          className,
-        )}
-        position={position}
-        {...props}
-      >
-        <SelectScrollUpButton />
-        <SelectPrimitive.Viewport
-          className={cn(
-            "p-1",
-            position === "popper" &&
-              "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]",
-          )}
-        >
-          {children}
-        </SelectPrimitive.Viewport>
-        <SelectScrollDownButton />
-      </SelectPrimitive.Content>
-    </SelectPrimitive.Portal>
-  );
-}
-
-function SelectLabel({
-  className,
-  ...props
-}: ComponentPropsWithoutRef<typeof SelectPrimitive.Label>) {
-  return (
-    <SelectPrimitive.Label
-      className={cn("px-2 py-1.5 text-sm font-semibold", className)}
-      {...props}
-    />
-  );
-}
-
-function SelectItem({
-  className,
-  children,
-  ...props
-}: ComponentPropsWithoutRef<typeof SelectPrimitive.Item>) {
-  return (
-    <SelectPrimitive.Item
-      className={cn(
-        "relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-2 pr-8 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
-        className,
-      )}
-      {...props}
-    >
-      <span className="absolute right-2 flex h-3.5 w-3.5 items-center justify-center">
-        <SelectPrimitive.ItemIndicator>
-          <Check className="h-4 w-4" />
-        </SelectPrimitive.ItemIndicator>
-      </span>
-      <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
-    </SelectPrimitive.Item>
-  );
-}
-
-function SelectSeparator({
-  className,
-  ...props
-}: ComponentPropsWithoutRef<typeof SelectPrimitive.Separator>) {
-  return (
-    <SelectPrimitive.Separator className={cn("-mx-1 my-1 h-px bg-muted", className)} {...props} />
-  );
-}
-
-export {
-  Select,
-  SelectContent,
-  SelectGroup,
-  SelectItem,
-  SelectLabel,
-  SelectScrollDownButton,
-  SelectScrollUpButton,
-  SelectSeparator,
-  SelectTrigger,
-  SelectValue,
-};

packages/workflow-dashboard/src/components/ui/separator.tsx

@@ -1,25 +0,0 @@
-import * as SeparatorPrimitive from "@radix-ui/react-separator";
-import type { ComponentPropsWithoutRef } from "react";
-import { cn } from "../../lib/utils.ts";
-
-function Separator({
-  className,
-  orientation = "horizontal",
-  decorative = true,
-  ...props
-}: ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root>) {
-  return (
-    <SeparatorPrimitive.Root
-      decorative={decorative}
-      orientation={orientation}
-      className={cn(
-        "shrink-0 bg-border",
-        orientation === "horizontal" ? "h-[1px] w-full" : "h-full w-[1px]",
-        className,
-      )}
-      {...props}
-    />
-  );
-}
-
-export { Separator };

packages/workflow-dashboard/src/components/ui/table.tsx

@@ -1,69 +0,0 @@
-import type { HTMLAttributes, TdHTMLAttributes, ThHTMLAttributes } from "react";
-import { cn } from "../../lib/utils.ts";
-
-function Table({ className, ...props }: HTMLAttributes<HTMLTableElement>) {
-  return (
-    <div className="relative w-full overflow-auto">
-      <table className={cn("w-full caption-bottom text-sm", className)} {...props} />
-    </div>
-  );
-}
-
-function TableHeader({ className, ...props }: HTMLAttributes<HTMLTableSectionElement>) {
-  return <thead className={cn("[&_tr]:border-b", className)} {...props} />;
-}
-
-function TableBody({ className, ...props }: HTMLAttributes<HTMLTableSectionElement>) {
-  return <tbody className={cn("[&_tr:last-child]:border-0", className)} {...props} />;
-}
-
-function TableFooter({ className, ...props }: HTMLAttributes<HTMLTableSectionElement>) {
-  return (
-    <tfoot
-      className={cn("border-t bg-muted/50 font-medium [&>tr]:last:border-b-0", className)}
-      {...props}
-    />
-  );
-}
-
-function TableRow({ className, ...props }: HTMLAttributes<HTMLTableRowElement>) {
-  return (
-    <tr
-      className={cn(
-        "border-b border-border transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted",
-        className,
-      )}
-      {...props}
-    />
-  );
-}
-
-function TableHead({ className, ...props }: ThHTMLAttributes<HTMLTableCellElement>) {
-  return (
-    <th
-      className={cn(
-        "h-10 px-2 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]",
-        className,
-      )}
-      {...props}
-    />
-  );
-}
-
-function TableCell({ className, ...props }: TdHTMLAttributes<HTMLTableCellElement>) {
-  return (
-    <td
-      className={cn(
-        "p-2 align-middle [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]",
-        className,
-      )}
-      {...props}
-    />
-  );
-}
-
-function TableCaption({ className, ...props }: HTMLAttributes<HTMLTableCaptionElement>) {
-  return <caption className={cn("mt-4 text-sm text-muted-foreground", className)} {...props} />;
-}
-
-export { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow };

packages/workflow-dashboard/src/components/ui/textarea.tsx

@@ -1,16 +0,0 @@
-import type { TextareaHTMLAttributes } from "react";
-import { cn } from "../../lib/utils.ts";
-
-function Textarea({ className, ...props }: TextareaHTMLAttributes<HTMLTextAreaElement>) {
-  return (
-    <textarea
-      className={cn(
-        "flex min-h-[60px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50",
-        className,
-      )}
-      {...props}
-    />
-  );
-}
-
-export { Textarea };

packages/workflow-dashboard/src/components/ui/tooltip.tsx

@@ -1,28 +0,0 @@
-import * as TooltipPrimitive from "@radix-ui/react-tooltip";
-import type { ComponentPropsWithoutRef } from "react";
-import { cn } from "../../lib/utils.ts";
-
-const TooltipProvider = TooltipPrimitive.Provider;
-const Tooltip = TooltipPrimitive.Root;
-const TooltipTrigger = TooltipPrimitive.Trigger;
-
-function TooltipContent({
-  className,
-  sideOffset = 4,
-  ...props
-}: ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>) {
-  return (
-    <TooltipPrimitive.Portal>
-      <TooltipPrimitive.Content
-        sideOffset={sideOffset}
-        className={cn(
-          "z-50 overflow-hidden rounded-md bg-primary px-3 py-1.5 text-xs text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
-          className,
-        )}
-        {...props}
-      />
-    </TooltipPrimitive.Portal>
-  );
-}
-
-export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

packages/workflow-dashboard/src/components/workflow-detail.tsx

@@ -1,50 +1,22 @@
-import {
-  AlertCircle,
-  ArrowLeft,
-  ChevronDown,
-  GitBranch,
-  Hash,
-  Layers,
-  Loader2,
-  User,
-} from "lucide-react";
 import { useMemo, useRef, useState } from "react";
-import { useNavigate, useParams } from "react-router";
 import type { WorkflowDetail as WorkflowDetailData, WorkflowRoleDescriptor } from "../api.ts";
 import { getWorkflowDetail } from "../api.ts";
 import { useFetch } from "../hooks.ts";
-import { cn } from "../lib/utils.ts";
 import { Markdown } from "./markdown.tsx";
-import { Button } from "./ui/button.tsx";
-import { Card } from "./ui/card.tsx";
-import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "./ui/collapsible.tsx";
-import { ResizablePanel } from "./ui/resizable-panel.tsx";
-import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "./ui/table.tsx";
 import { type NodeState, WorkflowGraph } from "./workflow-graph/index.ts";
 
-const ROLE_BORDER_COLORS = [
-  "border-l-blue-400/60",
-  "border-l-emerald-400/60",
-  "border-l-amber-400/60",
-  "border-l-violet-400/60",
-  "border-l-rose-400/60",
-  "border-l-cyan-400/60",
-  "border-l-orange-400/60",
-  "border-l-teal-400/60",
-];
-
-function roleBorderColor(name: string): string {
-  let hash = 0;
-  for (let i = 0; i < name.length; i++) {
-    hash = (hash * 31 + name.charCodeAt(i)) | 0;
-  }
-  return ROLE_BORDER_COLORS[Math.abs(hash) % ROLE_BORDER_COLORS.length];
-}
+type Props = {
+  client: string;
+  workflowName: string;
+  onBack: () => void;
+};
 
 function versionCount(detail: WorkflowDetailData): number {
   return detail.history.length + 1;
 }
 
+// ── Schema rendering helpers ────────────────────────────────────────
+
 type SchemaRow = {
   key: string;
   name: string;
@@ -67,66 +39,119 @@ function resolveType(prop: Record<string, unknown>): string {
   return String(prop.type ?? "unknown");
 }
 
+function variantLabel(
+  variantProps: Record<string, Record<string, unknown>>,
+  variantIndex: number,
+): string {
+  for (const [pName, pDef] of Object.entries(variantProps)) {
+    if (pDef.const !== undefined) return `${pName}: ${String(pDef.const)}`;
+  }
+  return `Variant ${variantIndex + 1}`;
+}
+
+function childPrefixForDepth(depth: number, parentPrefix: string): string {
+  return depth > 0 ? `${parentPrefix}   ` : "  ";
+}
+
+function flattenOneOfVariants(
+  oneOf: Array<Record<string, unknown>>,
+  depth: number,
+  parentPrefix: string,
+  keyPrefix: string,
+): SchemaRow[] {
+  const rows: SchemaRow[] = [];
+  for (let vi = 0; vi < oneOf.length; vi++) {
+    const variant = oneOf[vi];
+    const variantProps = (variant.properties ?? {}) as Record<string, Record<string, unknown>>;
+    const isLast = vi === oneOf.length - 1;
+    const connector = isLast ? "└" : "├";
+    rows.push({
+      key: `${keyPrefix}variant-${vi}`,
+      name: `${parentPrefix}${connector} ${variantLabel(variantProps, vi)}`,
+      type: "",
+      description: "",
+      depth,
+      prefix: parentPrefix,
+      isVariantHeader: true,
+    });
+    const variantChildPrefix = `${parentPrefix}${isLast ? "  " : "│ "}`;
+    const variantRequired = new Set<string>(
+      Array.isArray(variant.required) ? (variant.required as string[]) : [],
+    );
+    for (const [pName, pDef] of Object.entries(variantProps)) {
+      if (pDef.const !== undefined) continue;
+      rows.push(
+        ...flattenProperty(
+          pName,
+          pDef,
+          depth + 1,
+          variantChildPrefix,
+          `${keyPrefix}v${vi}-`,
+          variantRequired,
+        ),
+      );
+    }
+  }
+  return rows;
+}
+
+function flattenSchemaProperties(
+  schema: Record<string, unknown>,
+  depth: number,
+  parentPrefix: string,
+  keyPrefix: string,
+): SchemaRow[] {
+  const props = (schema.properties ?? {}) as Record<string, Record<string, unknown>>;
+  const required = new Set<string>(
+    Array.isArray(schema.required) ? (schema.required as string[]) : [],
+  );
+  const rows: SchemaRow[] = [];
+  for (const [name, prop] of Object.entries(props)) {
+    rows.push(...flattenProperty(name, prop, depth, parentPrefix, keyPrefix, required));
+  }
+  return rows;
+}
+
 function flattenSchema(
   schema: Record<string, unknown>,
   depth: number,
   parentPrefix: string,
   keyPrefix: string,
 ): SchemaRow[] {
-  const rows: SchemaRow[] = [];
-
   const oneOf = schema.oneOf as Array<Record<string, unknown>> | undefined;
   if (Array.isArray(oneOf) && oneOf.length > 0) {
-    for (let vi = 0; vi < oneOf.length; vi++) {
-      const variant = oneOf[vi];
-      const variantProps = (variant.properties ?? {}) as Record<string, Record<string, unknown>>;
-      let variantLabel = `Variant ${vi + 1}`;
-      for (const [pName, pDef] of Object.entries(variantProps)) {
-        if (pDef.const !== undefined) {
-          variantLabel = `${pName}: ${String(pDef.const)}`;
-          break;
-        }
-      }
-      const isLast = vi === oneOf.length - 1;
-      const connector = isLast ? "└" : "├";
-      rows.push({
-        key: `${keyPrefix}variant-${vi}`,
-        name: `${parentPrefix}${connector} ${variantLabel}`,
-        type: "",
-        description: "",
-        depth,
-        prefix: parentPrefix,
-        isVariantHeader: true,
-      });
-      const childPrefix = `${parentPrefix}${isLast ? "  " : "│ "}`;
-      const variantRequired = new Set<string>(
-        Array.isArray(variant.required) ? (variant.required as string[]) : [],
-      );
-      for (const [pName, pDef] of Object.entries(variantProps)) {
-        if (pDef.const !== undefined) continue;
-        const subRows = flattenProperty(
-          pName,
-          pDef,
-          depth + 1,
-          childPrefix,
-          `${keyPrefix}v${vi}-`,
-          variantRequired,
-        );
-        rows.push(...subRows);
-      }
-    }
-    return rows;
+    return flattenOneOfVariants(oneOf, depth, parentPrefix, keyPrefix);
+  }
+  return flattenSchemaProperties(schema, depth, parentPrefix, keyPrefix);
+}
+
+function flattenNestedPropertyRows(
+  name: string,
+  prop: Record<string, unknown>,
+  depth: number,
+  parentPrefix: string,
+  keyPrefix: string,
+  hasOneOf: boolean,
+): SchemaRow[] {
+  const childPrefix = childPrefixForDepth(depth, parentPrefix);
+  const nestedKeyPrefix = `${keyPrefix}${name}-`;
+
+  if (prop.type === "object" && prop.properties !== undefined) {
+    return flattenSchema(prop as Record<string, unknown>, depth + 1, childPrefix, nestedKeyPrefix);
   }
 
-  const props = (schema.properties ?? {}) as Record<string, Record<string, unknown>>;
-  const required = new Set<string>(
-    Array.isArray(schema.required) ? (schema.required as string[]) : [],
-  );
-  for (const [name, prop] of Object.entries(props)) {
-    const subRows = flattenProperty(name, prop, depth, parentPrefix, keyPrefix, required);
-    rows.push(...subRows);
+  if (prop.type === "array") {
+    const items = prop.items as Record<string, unknown> | undefined;
+    if (items !== undefined && items.type === "object" && items.properties !== undefined) {
+      return flattenSchema(items, depth + 1, childPrefix, nestedKeyPrefix);
+    }
   }
-  return rows;
+
+  if (hasOneOf) {
+    return flattenSchema(prop as Record<string, unknown>, depth + 1, childPrefix, nestedKeyPrefix);
+  }
+
+  return [];
 }
 
 function flattenProperty(
@@ -137,145 +162,139 @@ function flattenProperty(
   keyPrefix: string,
   required: Set<string>,
 ): SchemaRow[] {
-  const rows: SchemaRow[] = [];
   const hasOneOf = Array.isArray(prop.oneOf) && (prop.oneOf as unknown[]).length > 0;
   let type = hasOneOf ? "⊕ oneOf" : resolveType(prop);
   if (!required.has(name)) type += "?";
-  const description = String(prop.description ?? "");
-  const displayName = depth > 0 ? `${parentPrefix}└─ ${name}` : name;
 
-  rows.push({
-    key: `${keyPrefix}${name}`,
-    name: displayName,
-    type,
-    description,
-    depth,
-    prefix: parentPrefix,
-    isVariantHeader: false,
-  });
-
-  if (prop.type === "object" && prop.properties !== undefined) {
-    const childPrefix = depth > 0 ? `${parentPrefix}   ` : "  ";
-    rows.push(
-      ...flattenSchema(
-        prop as Record<string, unknown>,
-        depth + 1,
-        childPrefix,
-        `${keyPrefix}${name}-`,
-      ),
-    );
-  }
-
-  if (prop.type === "array") {
-    const items = prop.items as Record<string, unknown> | undefined;
-    if (items !== undefined && items.type === "object" && items.properties !== undefined) {
-      const childPrefix = depth > 0 ? `${parentPrefix}   ` : "  ";
-      rows.push(...flattenSchema(items, depth + 1, childPrefix, `${keyPrefix}${name}-`));
-    }
-  }
-
-  if (hasOneOf) {
-    const childPrefix = depth > 0 ? `${parentPrefix}   ` : "  ";
-    rows.push(
-      ...flattenSchema(
-        prop as Record<string, unknown>,
-        depth + 1,
-        childPrefix,
-        `${keyPrefix}${name}-`,
-      ),
-    );
-  }
+  const rows: SchemaRow[] = [
+    {
+      key: `${keyPrefix}${name}`,
+      name: depth > 0 ? `${parentPrefix}└─ ${name}` : name,
+      type,
+      description: String(prop.description ?? ""),
+      depth,
+      prefix: parentPrefix,
+      isVariantHeader: false,
+    },
+  ];
 
+  rows.push(...flattenNestedPropertyRows(name, prop, depth, parentPrefix, keyPrefix, hasOneOf));
   return rows;
 }
 
+// ── Components ──────────────────────────────────────────────────────
+
 function RoleCard({ roleName, role }: { roleName: string; role: WorkflowRoleDescriptor }) {
   const rows = flattenSchema(role.schema, 0, "", `${roleName}-`);
-  const [promptOpen, setPromptOpen] = useState(false);
-
   return (
-    <Card id={`role-${roleName}`} className={cn("p-4 border-l-4", roleBorderColor(roleName))}>
-      <h4 className="text-sm font-semibold font-mono mb-1 text-foreground flex items-center gap-1.5">
-        <User className="h-3.5 w-3.5 text-muted-foreground" />
+    <div
+      id={`role-${roleName}`}
+      className="rounded-lg border p-4"
+      style={{ borderColor: "var(--color-border)", background: "var(--color-surface)" }}
+    >
+      <h4 className="text-sm font-semibold font-mono mb-1" style={{ color: "var(--color-text)" }}>
         {roleName}
       </h4>
       {role.description !== "" && (
-        <p className="text-xs mb-3 text-muted-foreground">{role.description}</p>
+        <p className="text-xs mb-3" style={{ color: "var(--color-text-muted)" }}>
+          {role.description}
+        </p>
       )}
       {role.systemPrompt !== "" && (
-        <Collapsible open={promptOpen} onOpenChange={setPromptOpen} className="mb-3">
-          <CollapsibleTrigger asChild>
-            <Button
-              variant="ghost"
-              size="sm"
-              className="gap-1 h-7 px-2 text-[10px] uppercase tracking-wider text-muted-foreground bg-muted/50 rounded-md transition-all duration-200"
-            >
-              <ChevronDown
-                className={cn("h-3 w-3 transition-transform", promptOpen && "rotate-180")}
-              />
-              System Prompt
-            </Button>
-          </CollapsibleTrigger>
-          <CollapsibleContent>
-            <div className="mt-1 p-2 rounded-md overflow-y-auto text-xs bg-background border border-border max-h-[300px]">
-              <Markdown content={role.systemPrompt} />
-            </div>
-          </CollapsibleContent>
-        </Collapsible>
+        <details className="mb-3">
+          <summary
+            className="text-[10px] uppercase tracking-wider font-medium cursor-pointer select-none"
+            style={{ color: "var(--color-text-muted)" }}
+          >
+            System Prompt
+          </summary>
+          <div
+            className="mt-1 p-2 rounded overflow-y-auto text-xs"
+            style={{
+              background: "var(--color-bg)",
+              border: "1px solid var(--color-border)",
+              maxHeight: "300px",
+            }}
+          >
+            <Markdown content={role.systemPrompt} />
+          </div>
+        </details>
       )}
       {rows.length > 0 && (
         <div>
-          <p className="text-[10px] uppercase tracking-wider mb-1 font-medium text-muted-foreground">
+          <p
+            className="text-[10px] uppercase tracking-wider mb-1 font-medium"
+            style={{ color: "var(--color-text-muted)" }}
+          >
             Meta Schema
           </p>
-          <Table>
-            <TableHeader>
-              <TableRow>
-                <TableHead className="text-xs">Field</TableHead>
-                <TableHead className="text-xs">Type</TableHead>
-                <TableHead className="text-xs">Description</TableHead>
-              </TableRow>
-            </TableHeader>
-            <TableBody>
-              {rows.map((r) => (
-                <TableRow
-                  key={r.key}
-                  className={cn(r.isVariantHeader ? "border-b-0" : "", "even:bg-muted/30")}
+          <table className="w-full text-xs" style={{ borderCollapse: "collapse" }}>
+            <thead>
+              <tr style={{ borderBottom: "1px solid var(--color-border)" }}>
+                <th
+                  className="text-left py-1 pr-3 font-medium"
+                  style={{ color: "var(--color-text-muted)" }}
                 >
-                  <TableCell
-                    className={cn(
-                      "font-mono whitespace-pre text-xs",
-                      r.isVariantHeader ? "italic text-muted-foreground" : "text-foreground",
-                    )}
+                  Field
+                </th>
+                <th
+                  className="text-left py-1 pr-3 font-medium"
+                  style={{ color: "var(--color-text-muted)" }}
+                >
+                  Type
+                </th>
+                <th
+                  className="text-left py-1 font-medium"
+                  style={{ color: "var(--color-text-muted)" }}
+                >
+                  Description
+                </th>
+              </tr>
+            </thead>
+            <tbody>
+              {rows.map((r) => (
+                <tr
+                  key={r.key}
+                  style={{
+                    borderBottom: r.isVariantHeader ? "none" : "1px solid var(--color-border)",
+                  }}
+                >
+                  <td
+                    className="py-1 pr-3 font-mono whitespace-pre"
+                    style={{
+                      color: r.isVariantHeader ? "var(--color-text-muted)" : "var(--color-accent)",
+                      fontStyle: r.isVariantHeader ? "italic" : "normal",
+                    }}
                   >
                     {r.name}
-                  </TableCell>
-                  <TableCell className="font-mono text-xs text-muted-foreground">
+                  </td>
+                  <td className="py-1 pr-3 font-mono" style={{ color: "var(--color-text-muted)" }}>
                     {r.type}
-                  </TableCell>
-                  <TableCell className="text-xs">
+                  </td>
+                  <td className="py-1" style={{ color: "var(--color-text)" }}>
                     {r.description || (r.isVariantHeader ? "" : "—")}
-                  </TableCell>
-                </TableRow>
+                  </td>
+                </tr>
               ))}
-            </TableBody>
-          </Table>
+            </tbody>
+          </table>
         </div>
       )}
       {rows.length === 0 && Object.keys(role.schema).length > 0 && (
-        <pre className="text-[10px] font-mono p-2 rounded-md overflow-x-auto bg-background text-muted-foreground">
+        <pre
+          className="text-[10px] font-mono p-2 rounded overflow-x-auto"
+          style={{ background: "var(--color-bg)", color: "var(--color-text-muted)" }}
+        >
           {JSON.stringify(role.schema, null, 2)}
         </pre>
       )}
-    </Card>
+    </div>
   );
 }
 
-export function WorkflowDetail() {
-  const params = useParams();
-  const navigate = useNavigate();
-  const client = params.client as string;
-  const workflowName = params.workflowName as string;
+// ── Main component ──────────────────────────────────────────────────
+
+export function WorkflowDetail({ client, workflowName, onBack }: Props) {
   const { status, data, error } = useFetch(
     () => getWorkflowDetail(client, workflowName),
     [client, workflowName],
@@ -315,52 +334,44 @@ export function WorkflowDetail() {
   return (
     <div>
       <div className="flex items-center justify-between mb-4">
-        <Button
-          variant="ghost"
-          className="gap-1.5 px-2 text-muted-foreground hover:text-foreground transition-all duration-200"
-          onClick={() => navigate(`/${client}/workflows`)}
+        <button
+          type="button"
+          onClick={onBack}
+          className="text-sm hover:underline"
+          style={{ color: "var(--color-accent)" }}
         >
-          <ArrowLeft className="h-4 w-4" />
-          Back to workflows
-        </Button>
+          ← Back to workflows
+        </button>
       </div>
 
-      <h2 className="text-xl font-semibold mb-4 font-mono tracking-tight">{workflowName}</h2>
+      <h2 className="text-xl font-semibold mb-4 font-mono">{workflowName}</h2>
 
-      {status === "loading" && (
-        <div className="flex items-center justify-center gap-2 py-12 text-muted-foreground">
-          <Loader2 className="h-5 w-5 animate-spin" />
-          <span>Loading workflow...</span>
-        </div>
-      )}
-      {status === "error" && (
-        <div className="flex items-center justify-center gap-2 py-12 text-destructive">
-          <AlertCircle className="h-5 w-5" />
-          <span>Error: {error}</span>
-        </div>
-      )}
+      {status === "loading" && <p style={{ color: "var(--color-text-muted)" }}>Loading...</p>}
+      {status === "error" && <p style={{ color: "var(--color-error)" }}>Error: {error}</p>}
 
       {detail !== null && (
         <div className="flex gap-4" style={{ minHeight: "calc(100vh - 160px)" }}>
+          {/* Left: fixed graph sidebar */}
           {hasGraph && (
-            <ResizablePanel
-              defaultWidth={360}
-              minWidth={240}
-              maxWidth={560}
-              className={null}
+            <div
+              className="shrink-0"
               style={{
+                width: 280,
                 position: "sticky",
                 top: 16,
                 height: "calc(100vh - 160px)",
                 alignSelf: "flex-start",
               }}
             >
-              <Card className="h-full flex flex-col overflow-hidden">
-                <div className="flex items-center justify-between px-3 py-2 text-xs text-muted-foreground bg-muted/50">
-                  <span className="font-mono flex items-center gap-1.5">
-                    <Layers className="h-3.5 w-3.5" />
-                    Workflow graph
-                  </span>
+              <div
+                className="rounded-lg border h-full flex flex-col overflow-hidden"
+                style={{ borderColor: "var(--color-border)", background: "var(--color-surface)" }}
+              >
+                <div
+                  className="flex items-center justify-between px-3 py-2 text-xs"
+                  style={{ color: "var(--color-text-muted)" }}
+                >
+                  <span className="font-mono">Workflow graph</span>
                   <span>
                     {edgeCount} edge{edgeCount === 1 ? "" : "s"}
                   </span>
@@ -373,44 +384,52 @@ export function WorkflowDetail() {
                     onNodeClick={handleGraphNodeClick}
                   />
                 </div>
-              </Card>
-            </ResizablePanel>
+              </div>
+            </div>
           )}
 
+          {/* Right: scrollable content */}
           <div className="flex-1 min-w-0 space-y-4">
-            <Card className="p-4">
-              <div className="rounded-md bg-muted/30 px-3 py-2 mb-3">
-                <p className="text-sm whitespace-pre-wrap text-foreground">
-                  {descriptor !== null && descriptor.description !== ""
-                    ? descriptor.description
-                    : "—"}
-                </p>
-              </div>
-              <div className="flex flex-wrap gap-3 text-xs text-muted-foreground">
-                <span className="inline-flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-xs font-mono">
-                  <Hash className="h-3 w-3" />
-                  <span className="text-foreground">{detail.hash}</span>
+            {/* Workflow overview */}
+            <div
+              className="rounded-lg border p-4"
+              style={{ borderColor: "var(--color-border)", background: "var(--color-surface)" }}
+            >
+              <p
+                className="text-sm whitespace-pre-wrap mb-3"
+                style={{ color: "var(--color-text)" }}
+              >
+                {descriptor !== null && descriptor.description !== ""
+                  ? descriptor.description
+                  : "—"}
+              </p>
+              <div className="flex gap-4 text-xs" style={{ color: "var(--color-text-muted)" }}>
+                <span>
+                  Hash:{" "}
+                  <code className="font-mono" style={{ color: "var(--color-accent)" }}>
+                    {detail.hash}
+                  </code>
                 </span>
-                <span className="inline-flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-xs">
-                  <GitBranch className="h-3 w-3" />
+                <span>
                   {versionCount(detail)} version{versionCount(detail) !== 1 ? "s" : ""}
                 </span>
                 {roleEntries.length > 0 && (
-                  <span className="inline-flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-xs">
-                    <User className="h-3 w-3" />
+                  <span>
                     {roleEntries.length} role{roleEntries.length !== 1 ? "s" : ""}
                   </span>
                 )}
               </div>
-            </Card>
+            </div>
 
+            {/* Role cards */}
             {roleEntries.map(([name, role]) => (
               <div
                 key={name}
-                className={cn(
-                  "rounded-lg transition-shadow duration-300",
-                  highlightedRole === name && "ring-2 ring-ring",
-                )}
+                style={{
+                  transition: "box-shadow 0.3s",
+                  boxShadow: highlightedRole === name ? "0 0 0 2px var(--color-accent)" : "none",
+                  borderRadius: 8,
+                }}
               >
                 <RoleCard roleName={name} role={role} />
               </div>

packages/workflow-dashboard/src/components/workflow-graph/condition-edge.tsx

@@ -91,7 +91,7 @@ export function ConditionEdge(props: EdgeProps) {
     defaultLabelY = result[2];
   }
 
-  const stroke = "hsl(var(--ring))";
+  const stroke = "var(--color-accent)";
   const label = isFallback ? "" : (edgeData?.condition ?? "");
 
   // Use pre-computed label position if available, otherwise fall back to default
@@ -107,9 +107,9 @@ export function ConditionEdge(props: EdgeProps) {
             className="absolute px-1.5 py-0.5 rounded text-[10px] font-mono pointer-events-auto"
             style={{
               transform: `translate(-50%, -50%) translate(${labelX}px, ${labelY}px)`,
-              background: "hsl(var(--card))",
-              border: "1px solid hsl(var(--border))",
-              color: "hsl(var(--foreground))",
+              background: "var(--color-surface)",
+              border: "1px solid var(--color-border)",
+              color: "var(--color-text)",
               whiteSpace: "nowrap",
               zIndex: 10,
             }}

packages/workflow-dashboard/src/components/workflow-graph/role-node.tsx

@@ -1,23 +1,29 @@
 import { Handle, type NodeProps, Position } from "@xyflow/react";
-import { Check, Circle } from "lucide-react";
 import type { RoleNodeData } from "./types.ts";
 
 function borderColor(state: RoleNodeData["state"]): string {
   switch (state) {
     case "completed":
-      return "hsl(var(--success))";
+      return "var(--color-success)";
     case "active":
-      return "hsl(var(--ring))";
+      return "var(--color-accent)";
     default:
-      return "hsl(var(--border))";
+      return "var(--color-border)";
   }
 }
 
+function stateIcon(state: RoleNodeData["state"]): string | null {
+  if (state === "completed") return "✓";
+  if (state === "active") return "●";
+  return null;
+}
+
 export function RoleNode(props: NodeProps) {
   const data = props.data as RoleNodeData;
+  const icon = stateIcon(data.state);
   const isActive = data.state === "active";
   const handleStyle = {
-    background: "hsl(var(--muted-foreground))",
+    background: "var(--color-text-muted)",
     width: 6,
     height: 6,
     border: "none",
@@ -29,9 +35,9 @@ export function RoleNode(props: NodeProps) {
       style={{
         width: 180,
         height: 60,
-        background: "hsl(var(--card))",
+        background: "var(--color-surface)",
         borderColor: borderColor(data.state),
-        color: "hsl(var(--foreground))",
+        color: "var(--color-text)",
         display: "flex",
         flexDirection: "column",
         justifyContent: "center",
@@ -75,15 +81,19 @@ export function RoleNode(props: NodeProps) {
         isConnectable={false}
       />
       <div className="flex items-center gap-1.5 font-mono">
-        {data.state === "completed" && <Check className="h-3 w-3 text-success" />}
-        {data.state === "active" && <Circle className="h-3 w-3 fill-current text-ring" />}
+        {icon !== null && (
+          <span
+            style={{
+              color: data.state === "active" ? "var(--color-accent)" : "var(--color-success)",
+            }}
+          >
+            {icon}
+          </span>
+        )}
         <span className="truncate">{data.label}</span>
       </div>
       {data.description !== "" && (
-        <div
-          className="text-[10px] truncate mt-0.5"
-          style={{ color: "hsl(var(--muted-foreground))" }}
-        >
+        <div className="text-[10px] truncate mt-0.5" style={{ color: "var(--color-text-muted)" }}>
           {data.description}
         </div>
       )}

packages/workflow-dashboard/src/components/workflow-graph/terminal-node.tsx

@@ -1,22 +1,21 @@
 import { Handle, type NodeProps, Position } from "@xyflow/react";
-import { Play, Square } from "lucide-react";
 import type { TerminalNodeData } from "./types.ts";
 
 function borderColor(state: TerminalNodeData["state"]): string {
   switch (state) {
     case "completed":
-      return "hsl(var(--success))";
+      return "var(--color-success)";
     case "active":
-      return "hsl(var(--ring))";
+      return "var(--color-accent)";
     default:
-      return "hsl(var(--border))";
+      return "var(--color-border)";
   }
 }
 
 function bgColor(state: TerminalNodeData["state"]): string {
-  if (state === "completed") return "hsl(var(--success))";
-  if (state === "active") return "hsl(var(--ring))";
-  return "hsl(var(--card))";
+  if (state === "completed") return "var(--color-success)";
+  if (state === "active") return "var(--color-accent)";
+  return "var(--color-surface)";
 }
 
 export function TerminalNode(props: NodeProps) {
@@ -24,7 +23,7 @@ export function TerminalNode(props: NodeProps) {
   const isStart = data.kind === "start";
   const isActive = data.state === "active";
   const handleStyle = {
-    background: "hsl(var(--muted-foreground))",
+    background: "var(--color-text-muted)",
     width: 6,
     height: 6,
     border: "none",
@@ -32,16 +31,13 @@ export function TerminalNode(props: NodeProps) {
 
   return (
     <div
-      className={`rounded-full border-2 flex items-center justify-center ${isActive ? "wf-node-pulse" : ""} ${data.state !== "default" ? "cursor-pointer" : ""}`}
+      className={`rounded-full border-2 flex items-center justify-center text-[10px] font-bold ${isActive ? "wf-node-pulse" : ""} ${data.state !== "default" ? "cursor-pointer" : ""}`}
       style={{
         width: 40,
         height: 40,
         background: bgColor(data.state),
         borderColor: borderColor(data.state),
-        color:
-          data.state === "default"
-            ? "hsl(var(--muted-foreground))"
-            : "hsl(var(--primary-foreground))",
+        color: data.state === "default" ? "var(--color-text-muted)" : "var(--color-bg)",
       }}
       title={isStart ? "Start" : "End"}
     >
@@ -78,7 +74,7 @@ export function TerminalNode(props: NodeProps) {
           />
         </>
       )}
-      {isStart ? <Play className="h-3 w-3" /> : <Square className="h-3 w-3" />}
+      {isStart ? "▶" : "■"}
     </div>
   );
 }

packages/workflow-dashboard/src/components/workflow-graph/workflow-graph.tsx

@@ -3,14 +3,13 @@ import {
   type EdgeTypes,
   MarkerType,
   type Node,
-  type NodeMouseHandler,
   type NodeTypes,
+  type OnNodeClick,
   ReactFlow,
 } from "@xyflow/react";
 import "@xyflow/react/dist/style.css";
 import { useMemo } from "react";
 import type { WorkflowGraph as WorkflowGraphData } from "../../api.ts";
-import { useTheme } from "../../hooks/use-theme.tsx";
 import { ConditionEdge } from "./condition-edge.tsx";
 import { RoleNode } from "./role-node.tsx";
 import { TerminalNode } from "./terminal-node.tsx";
@@ -40,12 +39,9 @@ function handleNodeClick(onNodeClick: (nodeId: string) => void, node: Node): voi
 
 export function WorkflowGraph({ graph, roles, nodeStates, onNodeClick }: Props) {
   const layout = useLayout({ edges: graph.edges, roles, nodeStates });
-  const { theme } = useTheme();
 
-  const onNodeClickHandler: NodeMouseHandler | undefined =
-    onNodeClick !== null
-      ? (_e: React.MouseEvent, node: Node) => handleNodeClick(onNodeClick, node)
-      : undefined;
+  const onNodeClickHandler: OnNodeClick | undefined =
+    onNodeClick !== null ? (_e, node) => handleNodeClick(onNodeClick, node) : undefined;
 
   const styledEdges = useMemo(
     () =>
@@ -55,7 +51,7 @@ export function WorkflowGraph({ graph, roles, nodeStates, onNodeClick }: Props)
           type: MarkerType.ArrowClosed,
           width: 14,
           height: 14,
-          color: "hsl(var(--foreground))",
+          color: "var(--color-text)",
         },
       })),
     [layout.edges],
@@ -76,10 +72,10 @@ export function WorkflowGraph({ graph, roles, nodeStates, onNodeClick }: Props)
       nodesConnectable={false}
       elementsSelectable={false}
       proOptions={{ hideAttribution: true }}
-      colorMode={theme}
-      style={{ background: "hsl(var(--background))" }}
+      colorMode="dark"
+      style={{ background: "var(--color-bg)" }}
     >
-      <Background color="hsl(var(--border))" gap={20} size={1} />
+      <Background color="var(--color-border)" gap={20} size={1} />
     </ReactFlow>
   );
 }

packages/workflow-dashboard/src/components/workflow-list.tsx

@@ -1,65 +1,54 @@
-import { AlertCircle, Clock, Hash, Loader2, Package } from "lucide-react";
-import { useNavigate, useParams } from "react-router";
 import { listWorkflows } from "../api.ts";
 import { useFetch } from "../hooks.ts";
-import { Card } from "./ui/card.tsx";
 
-export function WorkflowList() {
-  const params = useParams();
-  const navigate = useNavigate();
-  const client = params.client as string;
+type Props = {
+  client: string;
+  onSelect: (name: string) => void;
+};
+
+export function WorkflowList({ client, onSelect }: Props) {
   const { status, data, error } = useFetch(() => listWorkflows(client), [client]);
 
   if (status === "loading")
-    return (
-      <div className="flex flex-col items-center justify-center py-16 gap-3">
-        <Loader2 className="h-4 w-4 animate-spin text-muted-foreground" />
-        <p className="text-sm text-muted-foreground">Loading workflows...</p>
-      </div>
-    );
-
-  if (status === "error")
-    return (
-      <div className="flex flex-col items-center justify-center py-16 gap-3">
-        <AlertCircle className="h-5 w-5 text-destructive" />
-        <p className="text-sm text-destructive">Error: {error}</p>
-      </div>
-    );
+    return <p style={{ color: "var(--color-text-muted)" }}>Loading workflows...</p>;
+  if (status === "error") return <p style={{ color: "var(--color-error)" }}>Error: {error}</p>;
 
   const workflows = data.workflows;
 
   return (
     <div>
-      <h2 className="text-xl font-semibold tracking-tight mb-4">Workflows</h2>
+      <h2 className="text-xl font-semibold mb-4">Workflows</h2>
       {workflows.length === 0 ? (
-        <div className="flex flex-col items-center justify-center py-16 gap-3">
-          <Package className="h-12 w-12 text-muted-foreground/50" />
-          <p className="text-sm font-medium">No workflows</p>
-          <p className="text-xs text-muted-foreground">Register a workflow to get started.</p>
-        </div>
+        <p style={{ color: "var(--color-text-muted)" }}>No workflows registered.</p>
       ) : (
         <div className="space-y-2">
           {workflows.map((w) => (
-            <Card
+            <button
               key={w.name}
-              className="p-4 cursor-pointer hover:bg-accent/50 hover:shadow-sm transition-all duration-200"
-              onClick={() => navigate(`/${client}/workflows/${w.name}`)}
+              type="button"
+              onClick={() => onSelect(w.name)}
+              className="w-full text-left p-4 rounded-lg border hover:opacity-90"
+              style={{
+                background: "var(--color-surface)",
+                borderColor: "var(--color-border)",
+                color: "var(--color-text)",
+              }}
             >
-              <span className="text-sm font-medium text-foreground flex items-center gap-1.5">
-                <Package className="h-3.5 w-3.5 text-muted-foreground" />
-                {w.name}
-              </span>
-              <code className="text-xs mt-1 font-mono text-muted-foreground flex items-center gap-1.5">
-                <Hash className="h-3 w-3" />
+              <div className="flex items-center gap-2">
+                <span className="font-medium">{w.name}</span>
+              </div>
+              <code
+                className="text-xs mt-1 block font-mono truncate"
+                style={{ color: "var(--color-accent)" }}
+              >
                 {w.hash !== null ? w.hash : "—"}
               </code>
               {w.timestamp !== null ? (
-                <span className="text-xs mt-1 text-muted-foreground flex items-center gap-1.5">
-                  <Clock className="h-3 w-3" />
+                <span className="text-xs mt-1 block" style={{ color: "var(--color-text-muted)" }}>
                   Updated {new Date(w.timestamp).toLocaleString()}
                 </span>
               ) : null}
-            </Card>
+            </button>
           ))}
         </div>
       )}

packages/workflow-dashboard/src/hooks/use-theme.tsx

@@ -1,74 +0,0 @@
-import { createContext, useCallback, useContext, useEffect, useState } from "react";
-
-export type Theme = "light" | "dark";
-
-type ThemeContextValue = {
-  theme: Theme;
-  setTheme: (t: Theme) => void;
-  toggleTheme: () => void;
-};
-
-const ThemeContext = createContext<ThemeContextValue | null>(null);
-
-function getStoredTheme(): Theme | null {
-  const stored = localStorage.getItem("theme");
-  if (stored === "light" || stored === "dark") return stored;
-  return null;
-}
-
-function getSystemTheme(): Theme {
-  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
-}
-
-function applyTheme(theme: Theme): void {
-  if (theme === "dark") {
-    document.documentElement.classList.add("dark");
-  } else {
-    document.documentElement.classList.remove("dark");
-  }
-}
-
-export function ThemeProvider({ children }: { children: React.ReactNode }) {
-  const [theme, setThemeState] = useState<Theme>(() => getStoredTheme() ?? getSystemTheme());
-
-  useEffect(() => {
-    applyTheme(theme);
-  }, [theme]);
-
-  useEffect(() => {
-    const mq = window.matchMedia("(prefers-color-scheme: dark)");
-    function handler() {
-      if (getStoredTheme() === null) {
-        const sys = getSystemTheme();
-        setThemeState(sys);
-        applyTheme(sys);
-      }
-    }
-    mq.addEventListener("change", handler);
-    return () => mq.removeEventListener("change", handler);
-  }, []);
-
-  const setTheme = useCallback((t: Theme) => {
-    localStorage.setItem("theme", t);
-    setThemeState(t);
-  }, []);
-
-  const toggleTheme = useCallback(() => {
-    setThemeState((prev) => {
-      const next = prev === "dark" ? "light" : "dark";
-      localStorage.setItem("theme", next);
-      applyTheme(next);
-      return next;
-    });
-  }, []);
-
-  return <ThemeContext value={{ theme, setTheme, toggleTheme }}>{children}</ThemeContext>;
-}
-
-export function useTheme(): ThemeContextValue {
-  const ctx = useContext(ThemeContext);
-  if (ctx === null) {
-    throw new Error("useTheme must be used within a ThemeProvider");
-  }
-  return ctx;
-}

packages/workflow-dashboard/src/index.css

@@ -1,107 +1,32 @@
 @import "tailwindcss";
 
-@custom-variant dark (&:is(.dark *));
-
-@theme inline {
-  --radius: 0.625rem;
-  --color-background: hsl(var(--background));
-  --color-foreground: hsl(var(--foreground));
-  --color-card: hsl(var(--card));
-  --color-card-foreground: hsl(var(--card-foreground));
-  --color-popover: hsl(var(--popover));
-  --color-popover-foreground: hsl(var(--popover-foreground));
-  --color-primary: hsl(var(--primary));
-  --color-primary-foreground: hsl(var(--primary-foreground));
-  --color-secondary: hsl(var(--secondary));
-  --color-secondary-foreground: hsl(var(--secondary-foreground));
-  --color-muted: hsl(var(--muted));
-  --color-muted-foreground: hsl(var(--muted-foreground));
-  --color-accent: hsl(var(--accent));
-  --color-accent-foreground: hsl(var(--accent-foreground));
-  --color-destructive: hsl(var(--destructive));
-  --color-destructive-foreground: hsl(var(--destructive-foreground));
-  --color-success: hsl(var(--success));
-  --color-success-foreground: hsl(var(--success-foreground));
-  --color-warning: hsl(var(--warning));
-  --color-warning-foreground: hsl(var(--warning-foreground));
-  --color-border: hsl(var(--border));
-  --color-input: hsl(var(--input));
-  --color-ring: hsl(var(--ring));
-  --color-sidebar: hsl(var(--sidebar));
-  --color-sidebar-foreground: hsl(var(--sidebar-foreground));
-}
-
 :root {
-  --radius: 0.625rem;
-  --background: 0 0% 100%;
-  --foreground: 240 10% 3.9%;
-  --card: 0 0% 100%;
-  --card-foreground: 240 10% 3.9%;
-  --popover: 0 0% 100%;
-  --popover-foreground: 240 10% 3.9%;
-  --primary: 240 5.9% 10%;
-  --primary-foreground: 0 0% 98%;
-  --secondary: 240 4.8% 95.9%;
-  --secondary-foreground: 240 5.9% 10%;
-  --muted: 240 4.8% 95.9%;
-  --muted-foreground: 240 3.8% 46.1%;
-  --accent: 240 4.8% 95.9%;
-  --accent-foreground: 240 5.9% 10%;
-  --destructive: 0 84.2% 60.2%;
-  --destructive-foreground: 0 0% 98%;
-  --border: 240 5.9% 90%;
-  --input: 240 5.9% 90%;
-  --ring: 240 5.9% 10%;
-  --success: 160 60% 40%;
-  --success-foreground: 0 0% 98%;
-  --warning: 38 92% 50%;
-  --warning-foreground: 0 0% 0%;
-  --sidebar: 0 0% 98%;
-  --sidebar-foreground: 240 3.8% 46.1%;
-}
-
-.dark {
-  --background: 240 10% 3.9%;
-  --foreground: 0 0% 98%;
-  --card: 240 6% 6.5%;
-  --card-foreground: 0 0% 98%;
-  --popover: 240 6% 6.5%;
-  --popover-foreground: 0 0% 98%;
-  --primary: 0 0% 98%;
-  --primary-foreground: 240 5.9% 10%;
-  --secondary: 240 3.7% 15.9%;
-  --secondary-foreground: 0 0% 98%;
-  --muted: 240 3.7% 15.9%;
-  --muted-foreground: 240 5% 64.9%;
-  --accent: 240 3.7% 15.9%;
-  --accent-foreground: 0 0% 98%;
-  --destructive: 0 62.8% 30.6%;
-  --destructive-foreground: 0 0% 98%;
-  --border: 240 3.7% 15.9%;
-  --input: 240 3.7% 15.9%;
-  --ring: 240 4.9% 83.9%;
-  --success: 160 60% 45%;
-  --success-foreground: 0 0% 98%;
-  --warning: 38 92% 50%;
-  --warning-foreground: 0 0% 0%;
-  --sidebar: 240 6% 6.5%;
-  --sidebar-foreground: 240 5% 64.9%;
+  --color-bg: #0a0a0f;
+  --color-surface: #12121a;
+  --color-border: #1e1e2e;
+  --color-text: #e4e4ef;
+  --color-text-muted: #6b6b8a;
+  --color-accent: #7c6df0;
+  --color-accent-dim: #5a4db8;
+  --color-success: #34d399;
+  --color-warning: #fbbf24;
+  --color-error: #f87171;
 }
 
 body {
   margin: 0;
-  background: hsl(var(--background));
-  color: hsl(var(--foreground));
+  background: var(--color-bg);
+  color: var(--color-text);
   font-family: "Inter", system-ui, -apple-system, sans-serif;
 }
 
 @keyframes wf-node-pulse {
   0%,
   100% {
-    box-shadow: 0 0 0 0 hsl(var(--ring) / 0.55);
+    box-shadow: 0 0 0 0 rgba(124, 109, 240, 0.55);
   }
   50% {
-    box-shadow: 0 0 0 6px hsl(var(--ring) / 0);
+    box-shadow: 0 0 0 6px rgba(124, 109, 240, 0);
   }
 }
 
@@ -111,13 +36,13 @@ body {
 
 @keyframes wf-record-card-highlight {
   0% {
-    border-color: hsl(var(--ring));
+    border-color: var(--color-accent);
   }
   35% {
-    border-color: hsl(var(--ring));
+    border-color: var(--color-accent);
   }
   100% {
-    border-color: hsl(var(--border));
+    border-color: var(--color-border);
   }
 }
 

packages/workflow-dashboard/src/lib/utils.ts

@@ -1,6 +0,0 @@
-import { type ClassValue, clsx } from "clsx";
-import { twMerge } from "tailwind-merge";
-
-export function cn(...inputs: ClassValue[]): string {
-  return twMerge(clsx(inputs));
-}

packages/workflow-dashboard/src/main.tsx

@@ -1,17 +1,13 @@
 import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
-import { RouterProvider } from "react-router";
-import { ThemeProvider } from "./hooks/use-theme.tsx";
 import "./index.css";
-import { router } from "./router.tsx";
+import { App } from "./app.tsx";
 
 const root = document.getElementById("root");
 if (root) {
   createRoot(root).render(
     <StrictMode>
-      <ThemeProvider>
-        <RouterProvider router={router} />
-      </ThemeProvider>
+      <App />
     </StrictMode>,
   );
 }