refactor: remove table output format, keep json and yaml only

Table format adds complexity without readability gain over yaml. Refs #328
fix: table format — horizontal for arrays, vertical for objects
2026-05-18 13:56:53 +00:00 · 2026-05-18 13:43:50 +00:00 · 2026-05-18 13:40:19 +00:00 · 2026-05-18 13:33:41 +00:00 · 2026-05-18 13:25:16 +00:00 · 2026-05-18 13:24:19 +00:00
86 changed files with 6765 additions and 1183 deletions
@@ -1,16 +0,0 @@
-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 });
@@ -0,0 +1,527 @@
+# `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[]>
+```
@@ -0,0 +1,30 @@
+{
+  "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"
+  }
+}
@@ -0,0 +1,281 @@
+#!/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 or yaml", "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);
+});
@@ -0,0 +1,136 @@
+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;
+}
@@ -0,0 +1,332 @@
+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();
+  }
+}
@@ -0,0 +1,465 @@
+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 };
+}
@@ -0,0 +1,153 @@
+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 }));
+}
@@ -0,0 +1,12 @@
+import { stringify } from "yaml";
+
+export type OutputFormat = "json" | "yaml";
+
+export function formatOutput(data: unknown, format: OutputFormat): string {
+  switch (format) {
+    case "json":
+      return JSON.stringify(data);
+    case "yaml":
+      return stringify(data).trimEnd();
+  }
+}
@@ -0,0 +1,26 @@
+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 };
+}
@@ -0,0 +1,212 @@
+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");
+}
@@ -0,0 +1,71 @@
+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;
+}
@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "references": [
+    { "path": "../uwf-protocol" },
+    { "path": "../uwf-moderator" },
+    { "path": "../uwf-agent-kit" }
+  ]
+}
@@ -0,0 +1,32 @@
+{
+  "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"
+  }
+}
@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+
+import { createHermesAgent } from "./hermes.js";
+
+const main = createHermesAgent();
+void main();
@@ -0,0 +1,90 @@
+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,
+  });
+}
@@ -0,0 +1 @@
+export { buildHermesPrompt, createHermesAgent } from "./hermes.js";
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "references": [{ "path": "../uwf-agent-kit" }]
+}
@@ -0,0 +1,42 @@
+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");
+  });
+});
@@ -0,0 +1,33 @@
+{
+  "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"
+  }
+}
@@ -0,0 +1,199 @@
+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 },
+  };
+}
@@ -0,0 +1,181 @@
+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 };
+}
@@ -0,0 +1,11 @@
+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";
@@ -0,0 +1,135 @@
+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`);
+  };
+}
@@ -0,0 +1,26 @@
+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 };
+}
@@ -0,0 +1,227 @@
+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;
+  }
+}
@@ -0,0 +1,17 @@
+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;
+};
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "references": [{ "path": "../uwf-protocol" }]
+}
@@ -0,0 +1,120 @@
+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" });
+  });
+});
@@ -0,0 +1,30 @@
+{
+  "name": "@uncaged/uwf-moderator",
+  "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/uwf-protocol": "workspace:^",
+    "jsonata": "^1.8.7"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
@@ -0,0 +1,82 @@
+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}"`),
+  };
+}
@@ -0,0 +1 @@
+export { evaluate } from "./evaluate.js";
@@ -0,0 +1 @@
+export type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "references": [{ "path": "../uwf-protocol" }]
+}
@@ -0,0 +1,26 @@
+{
+  "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"
+  }
+}
@@ -0,0 +1,32 @@
+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";
@@ -0,0 +1,86 @@
+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,
+};
@@ -0,0 +1,127 @@
+// ── 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>;
@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}
@@ -4,6 +4,14 @@
    <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>
@@ -13,11 +13,23 @@
    "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",
-    "shiki": "^4.0.2"
+    "react-router": "^7.15.1",
+    "shiki": "^4.0.2",
+    "tailwind-merge": "^3.6.0"
  },
  "devDependencies": {
    "@tailwindcss/vite": "^4.2.4",
@@ -0,0 +1,362 @@
+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 };
@@ -1,75 +1,38 @@
 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 { 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";
+import { useTheme } from "./hooks/use-theme.tsx";

-export function App() {
+export function Layout() {
  const [authed, setAuthed] = useState(hasApiKey());
-  const { view, client, threadId, workflowName, setView, setClient, setThreadId, setWorkflowName } =
-    useHashRoute();
+  const { client } = useParams();
  const [showRun, setShowRun] = useState(false);
+  const { theme, toggleTheme } = useTheme();

  if (!authed) {
-    return <LoginPage onLogin={() => setAuthed(true)} />;
+    return <Navigate to="/login" replace />;
  }

  return (
-    <div className="flex h-screen">
+    <div className="flex h-screen bg-background">
      <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} onRun={() => setShowRun(true)} />
+        <StatusBar client={client ?? null} onRun={() => setShowRun(true)} />
        <div className="flex-1 overflow-auto p-6">
-          {!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)}
-            />
-          )}
+          <Outlet />
        </div>
      </main>
-      {showRun && client && (
-        <RunDialog
-          client={client}
-          onClose={() => setShowRun(false)}
-          onCreated={(id) => {
-            setShowRun(false);
-            setThreadId(id);
-          }}
-        />
-      )}
+      {client && <RunDialog client={client} open={showRun} onOpenChange={setShowRun} />}
    </div>
  );
 }
@@ -0,0 +1,31 @@
+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>
+  );
+}
@@ -1,14 +1,18 @@
+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";

-type Props = {
-  onLogin: () => void;
-};
-
-export function LoginPage({ onLogin }: Props) {
+export function LoginPage() {
+  const navigate = useNavigate();
  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();
@@ -17,7 +21,6 @@ export function LoginPage({ onLogin }: Props) {
    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`, {
@@ -40,56 +43,59 @@ export function LoginPage({ onLogin }: Props) {
    }

    setApiKey(key.trim());
-    onLogin();
+    navigate("/", { replace: true });
  }

  return (
-    <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)" }}
+    <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}
      >
-        <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>
+        {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>
    </div>
  );
 }
@@ -52,19 +52,23 @@ function CodeBlock({ className, children }: { className?: string; children?: Rea

  if (html !== null) {
    return (
-      <div
-        className="rounded overflow-x-auto text-xs my-2"
-        // biome-ignore lint/security/noDangerouslySetInnerHtml: shiki output is safe
-        dangerouslySetInnerHTML={{ __html: html }}
-      />
+      <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>
    );
  }

  return (
-    <pre
-      className="rounded overflow-x-auto text-xs my-2 p-3"
-      style={{ background: "var(--color-bg)" }}
-    >
+    <pre className="rounded-lg overflow-x-auto text-xs my-3 p-3 bg-muted/50 border border-border">
      <code>{code}</code>
    </pre>
  );
@@ -80,8 +84,7 @@ export function Markdown({ content }: { content: string }) {
            if (isInline) {
              return (
                <code
-                  className="text-xs px-1 py-0.5 rounded"
-                  style={{ background: "var(--color-border)", color: "var(--color-accent)" }}
+                  className="bg-muted rounded px-1.5 py-0.5 text-[13px] font-mono text-foreground"
                  {...props}
                >
                  {children}
@@ -91,7 +94,7 @@ export function Markdown({ content }: { content: string }) {
            return <CodeBlock className={className}>{children}</CodeBlock>;
          },
          p({ children }) {
-            return <p className="my-1.5 leading-relaxed">{children}</p>;
+            return <p className="my-2 leading-relaxed">{children}</p>;
          },
          ul({ children }) {
            return <ul className="list-disc pl-4 my-1.5">{children}</ul>;
@@ -100,20 +103,25 @@ 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-1">{children}</h1>;
+            return (
+              <h1 className="text-lg font-bold mt-3 mb-2 border-b border-border pb-1">
+                {children}
+              </h1>
+            );
          },
          h2({ children }) {
-            return <h2 className="text-base font-bold mt-2 mb-1">{children}</h2>;
+            return (
+              <h2 className="text-base font-bold mt-2 mb-2 border-b border-border pb-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 pl-3 my-2 text-sm"
-                style={{ borderColor: "var(--color-accent)", color: "var(--color-text-muted)" }}
-              >
+              <blockquote className="border-l-2 border-ring pl-3 my-2 text-sm text-muted-foreground bg-muted/30 rounded-r-md py-2">
                {children}
              </blockquote>
            );
@@ -1,14 +1,26 @@
+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_COLORS: Record<string, string> = {
-  preparer: "#8b5cf6",
-  client: "#3b82f6",
-  extractor: "#f59e0b",
-};
+const ROLE_HUES = [262, 210, 35, 150, 330, 180, 15, 280, 55, 195, 345, 120, 240, 75, 305];

-function roleColor(role: string): string {
-  return ROLE_COLORS[role] ?? "var(--color-accent)";
+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 formatTime(ts: number | null): string | null {
@@ -18,99 +30,86 @@ function formatTime(ts: number | null): string | null {

 function StartCard({ record }: { record: ThreadStartRecord }) {
  return (
-    <div
-      className="p-4 rounded-lg border"
-      style={{ background: "var(--color-surface)", borderColor: "var(--color-border)" }}
-    >
+    <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="flex items-center gap-2 mb-2">
-        <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)",
-          }}
-        >
+        <Rocket className="h-5 w-5 text-primary" />
+        <span className="font-semibold text-foreground">{record.workflow}</span>
+        <Badge variant={record.status === "active" ? "success" : "secondary"}>
          {record.status}
-        </span>
+        </Badge>
      </div>
      {record.prompt !== null && (
-        <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)" }}>
+        <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" />
            Prompt
          </div>
          <Markdown content={record.prompt} />
        </div>
      )}
-    </div>
+    </Card>
  );
 }

 function RoleMessage({ record, highlighted }: { record: RoleRecord; highlighted: boolean }) {
-  const color = roleColor(record.role);
+  const style = roleBadgeStyle(record.role);
  return (
-    <div
-      className={`p-3 rounded-lg border text-sm ${highlighted ? "wf-record-card-highlight" : ""}`}
-      style={{ background: "var(--color-surface)", borderColor: "var(--color-border)" }}
+    <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="flex items-center gap-2 mb-2">
        <span
-          className="text-xs px-2 py-0.5 rounded font-mono font-medium"
-          style={{ background: color, color: "#fff" }}
+          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 }}
        >
+          <User className="h-3 w-3" />
          {record.role}
        </span>
        {formatTime(record.timestamp) !== null && (
-          <span className="text-xs ml-auto" style={{ color: "var(--color-text-muted)" }}>
+          <span className="text-xs ml-auto text-muted-foreground tabular-nums flex items-center gap-1">
+            <Clock className="h-3 w-3" />
            {formatTime(record.timestamp)}
          </span>
        )}
      </div>
      <Markdown content={record.content} />
-    </div>
+    </Card>
  );
 }

 function ResultCard({ record }: { record: WorkflowResultRecord }) {
  const success = record.returnCode === 0;
  return (
-    <div
-      className="p-4 rounded-lg border"
-      style={{
-        background: "var(--color-surface)",
-        borderColor: success ? "var(--color-success)" : "var(--color-error)",
-      }}
+    <Card
+      className={cn(
+        "p-4 transition-all duration-200 border-l-4",
+        success ? "border-l-success" : "border-l-destructive",
+      )}
    >
      <div className="flex items-center gap-2 mb-2">
-        <span className="text-lg">{success ? "✅" : "❌"}</span>
+        {success ? (
+          <CheckCircle2 className="h-5 w-5 text-success" />
+        ) : (
+          <XCircle className="h-5 w-5 text-destructive" />
+        )}
        <span className="font-semibold text-sm">{success ? "Completed" : "Failed"}</span>
-        <span
-          className="text-xs px-2 py-0.5 rounded font-mono"
-          style={{
-            background: success ? "var(--color-success)" : "var(--color-error)",
-            color: "#fff",
-          }}
-        >
+        <Badge variant="outline" className="font-mono">
          exit {record.returnCode}
-        </span>
+        </Badge>
        {formatTime(record.timestamp) !== null && (
-          <span className="text-xs ml-auto" style={{ color: "var(--color-text-muted)" }}>
+          <span className="text-xs ml-auto text-muted-foreground tabular-nums flex items-center gap-1">
+            <Clock className="h-3 w-3" />
            {formatTime(record.timestamp)}
          </span>
        )}
      </div>
      <Markdown content={record.content} />
-    </div>
+    </Card>
  );
 }

@@ -1,14 +1,27 @@
 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;
-  onClose: () => void;
-  onCreated: (threadId: string) => void;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
 };

-export function RunDialog({ client, onClose, onCreated }: Props) {
+export function RunDialog({ client, open, onOpenChange }: Props) {
+  const navigate = useNavigate();
  const workflows = useFetch(() => listWorkflows(client), [client]);
  const [workflow, setWorkflow] = useState("");
  const [prompt, setPrompt] = useState("");
@@ -22,7 +35,8 @@ export function RunDialog({ client, onClose, onCreated }: Props) {
    setError(null);
    try {
      const result = await runThread(client, workflow, prompt);
-      onCreated(result.threadId);
+      onOpenChange(false);
+      navigate(`/${client}/threads/${result.threadId}`);
    } catch (err) {
      setError(err instanceof Error ? err.message : String(err));
      setSubmitting(false);
@@ -30,95 +44,54 @@ export function RunDialog({ client, onClose, onCreated }: Props) {
  }

  return (
-    <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>
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>Run Thread</DialogTitle>
+          <DialogDescription>Start a new thread on {client}</DialogDescription>
+        </DialogHeader>
        <form onSubmit={handleSubmit} className="space-y-4">
          <div>
-            <label
-              htmlFor="run-workflow"
-              className="text-sm block mb-1"
-              style={{ color: "var(--color-text-muted)" }}
-            >
+            <label htmlFor="run-workflow" className="text-sm block mb-1.5 text-muted-foreground">
              Workflow
            </label>
-            <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>
+            <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>
          </div>
          <div>
-            <label
-              htmlFor="run-prompt"
-              className="text-sm block mb-1"
-              style={{ color: "var(--color-text-muted)" }}
-            >
+            <label htmlFor="run-prompt" className="text-sm block mb-1.5 text-muted-foreground">
              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" 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)" }}
-            >
+          {error && <p className="text-sm text-destructive">{error}</p>}
+          <DialogFooter>
+            <Button type="button" variant="outline" onClick={() => onOpenChange(false)}>
              Cancel
-            </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,
-              }}
-            >
+            </Button>
+            <Button type="submit" disabled={submitting || !workflow || !prompt}>
              {submitting ? "Starting..." : "Run"}
-            </button>
-          </div>
+            </Button>
+          </DialogFooter>
        </form>
-      </div>
-    </div>
+      </DialogContent>
+    </Dialog>
  );
 }
@@ -1,109 +1,131 @@
-import { useEffect } from "react";
+import { Loader2, LogOut, Moon, Package, Sun, Zap } from "lucide-react";
+import { useLocation, useNavigate, useParams } from "react-router";
 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({ view, client, onViewChange, onClientChange, onLogout }: Props) {
+export function Sidebar({ onLogout, theme, onToggleTheme }: Props) {
+  const { client } = useParams();
+  const navigate = useNavigate();
+  const location = useLocation();
  const { status, data } = useFetch(() => listClients(), []);

  const clients: ClientEndpoint[] = status === "ok" ? data : [];

-  // Auto-select first client when none is selected
-  useEffect(() => {
-    if (client === null && clients.length > 0) {
-      onClientChange(clients[0].name);
-    }
-  }, [client, clients, onClientChange]);
+  const view = location.pathname.includes("/workflows") ? "workflows" : "threads";

  const viewItems = [
-    { key: "threads" as const, label: "Threads", icon: "⚡" },
-    { key: "workflows" as const, label: "Workflows", icon: "📦" },
+    { key: "threads" as const, label: "Threads", icon: Zap },
+    { key: "workflows" as const, label: "Workflows", icon: Package },
  ];

  return (
-    <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>
+    <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>
      </div>

-      {/* Client selector */}
-      <div className="px-4 py-3 border-b" style={{ borderColor: "var(--color-border)" }}>
+      <div className="px-3 py-3">
        <label
-          className="block text-xs font-medium mb-1"
-          style={{ color: "var(--color-text-muted)" }}
+          className="block text-xs font-medium mb-1.5 text-muted-foreground"
          htmlFor="client-select"
        >
          Client
        </label>
-        <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>
-
-      {/* View navigation */}
-      <nav className="flex-1 p-2 space-y-1">
-        {viewItems.map((item) => (
-          <button
-            type="button"
-            key={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)",
+        {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}`);
            }}
          >
-            {item.icon} {item.label}
-          </button>
+            <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>
+        )}
+      </div>
+
+      <Separator />
+
+      <nav className="flex-1 p-2 space-y-1">
+        {viewItems.map((item) => (
+          <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}`);
+            }}
+          >
+            <item.icon className="h-4 w-4" />
+            {item.label}
+          </Button>
        ))}
      </nav>

-      <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)" }}
+      <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}
        >
-          🚪 Logout
-        </button>
+          {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"
+          onClick={onLogout}
+        >
+          <LogOut className="h-4 w-4" />
+          Logout
+        </Button>
      </div>
    </aside>
  );
@@ -1,5 +1,7 @@
+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";

@@ -8,14 +10,29 @@ type Props = {
  onRun: () => void;
 };

-function statusLabel(status: HealthStatus): { text: string; color: string } {
+function StatusIndicator({ status }: { status: HealthStatus }) {
  if (status === "connected") {
-    return { text: "● Connected", color: "var(--color-success)" };
+    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>
+    );
  }
  if (status === "reconnecting") {
-    return { text: "● Reconnecting...", color: "var(--color-warning, #f59e0b)" };
+    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: "● Offline", color: "var(--color-error)" };
+  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>
+  );
 }

 export function StatusBar({ client, onRun }: Props) {
@@ -48,32 +65,24 @@ 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"
-      style={{ borderColor: "var(--color-border)", background: "var(--color-surface)" }}
-    >
+    <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 gap-4">
-        <span style={{ color: "var(--color-text-muted)" }}>
+        <span className="text-muted-foreground">
          {client ? `Client: ${client}` : "No client selected"}
        </span>
-        <button
-          type="button"
-          onClick={onRun}
+        <Button
+          variant="default"
+          size="sm"
          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,
-          }}
+          onClick={onRun}
+          className="h-7 gap-1.5 transition-all duration-200"
        >
-          ▶ Run Thread
-        </button>
+          <Play className="h-3.5 w-3.5" />
+          Run Thread
+        </Button>
      </div>
-      <span style={{ color: label.color }}>{label.text}</span>
+      <StatusIndicator status={status} />
    </div>
  );
 }
@@ -1,4 +1,6 @@
+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,
@@ -11,14 +13,12 @@ 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,36 +53,11 @@ function computeNodeStates(records: readonly ThreadRecord[]): Map<string, NodeSt
  return states;
 }

-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) {
+export function ThreadDetail() {
+  const params = useParams();
+  const navigate = useNavigate();
+  const client = params.client as string;
+  const threadId = params.threadId as string;
  const sse = useSSE(client, threadId);
  const { status, data, error } = useFetch(() => getThread(client, threadId), [client, threadId]);
  const [actionStatus, setActionStatus] = useState<string | null>(null);
@@ -122,32 +97,42 @@ export function ThreadDetail({ client, threadId, onBack }: Props) {
    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 (!isClickableGraphNode(nodeStates, nodeId)) return;
+      if (nodeStates.get(nodeId) === undefined || nodeStates.get(nodeId) === "default") return;
+
      if (nodeId === "__start__") {
-        scrollToFirstRecord();
+        const firstCard = document.querySelector('[data-record-index="0"]');
+        if (firstCard !== null) firstCard.scrollIntoView({ behavior: "smooth", block: "center" });
        return;
      }
+
      if (nodeId === "__end__") {
        recordsEndRef.current?.scrollIntoView({ behavior: "smooth", block: "end" });
        return;
      }
-      scrollToRoleOccurrence(nodeId, indicesByRole, clickCycleRef, highlightRole);
+
+      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);
+      }
    },
-    [nodeStates, indicesByRole, highlightRole],
+    [nodeStates, indicesByRole],
  );

  useEffect(() => {
@@ -166,7 +151,7 @@ export function ThreadDetail({ client, threadId, onBack }: Props) {
    try {
      const fn = action === "kill" ? killThread : action === "pause" ? pauseThread : resumeThread;
      await fn(client, threadId);
-      setActionStatus(`${action} sent ✓`);
+      setActionStatus(null);
    } catch (e) {
      setActionStatus(`${action} failed: ${e instanceof Error ? e.message : String(e)}`);
    }
@@ -175,88 +160,84 @@ export function ThreadDetail({ client, threadId, onBack }: Props) {
  return (
    <div>
      <div className="flex items-center justify-between mb-4">
-        <button
-          type="button"
-          onClick={onBack}
-          className="text-sm hover:underline"
-          style={{ color: "var(--color-accent)" }}
+        <Button
+          variant="ghost"
+          className="gap-1.5 px-2 text-muted-foreground hover:text-foreground transition-colors duration-200"
+          onClick={() => navigate(`/${client}/threads`)}
        >
-          ← Back to threads
-        </button>
-        <div className="flex gap-2">
-          <button
-            type="button"
+          <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"
            onClick={() => handleAction("pause")}
-            className="px-3 py-1 text-xs rounded border"
-            style={{ borderColor: "var(--color-warning)", color: "var(--color-warning)" }}
          >
-            ⏸ Pause
-          </button>
-          <button
-            type="button"
+            <Pause className="h-3.5 w-3.5 text-warning" />
+            Pause
+          </Button>
+          <Button
+            variant="outline"
+            size="sm"
+            className="transition-colors duration-200"
            onClick={() => handleAction("resume")}
-            className="px-3 py-1 text-xs rounded border"
-            style={{ borderColor: "var(--color-success)", color: "var(--color-success)" }}
          >
-            ▶ Resume
-          </button>
-          <button
-            type="button"
+            <Play className="h-3.5 w-3.5 text-success" />
+            Resume
+          </Button>
+          <Button
+            variant="outline"
+            size="sm"
+            className="transition-colors duration-200"
            onClick={() => handleAction("kill")}
-            className="px-3 py-1 text-xs rounded border"
-            style={{ borderColor: "var(--color-error)", color: "var(--color-error)" }}
          >
-            ✕ Kill
-          </button>
+            <X className="h-3.5 w-3.5 text-destructive" />
+            Kill
+          </Button>
        </div>
      </div>

-      <h2 className="text-xl font-semibold mb-2 font-mono flex items-center gap-2 flex-wrap">
+      <h2 className="text-xl font-semibold mb-2 font-mono tracking-tight flex items-center gap-2 flex-wrap">
        <span>{threadId}</span>
        {sse.connected && !sse.completed && (
-          <span
-            className="text-xs font-medium px-2 py-0.5 rounded"
-            style={{ background: "var(--color-success)", color: "var(--color-bg)" }}
-          >
+          <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" />
            Live
-          </span>
+          </Badge>
        )}
      </h2>
      {actionStatus && (
-        <p className="text-xs mb-4" style={{ color: "var(--color-text-muted)" }}>
+        <Badge variant="secondary" className="mb-4 text-xs font-normal">
          {actionStatus}
-        </p>
+        </Badge>
      )}

      <div className="flex gap-4" style={{ minHeight: "calc(100vh - 120px)" }}>
        {descriptor !== null && descriptor.graph.edges.length > 0 && (
-          <div
-            className="shrink-0"
+          <ResizablePanel
+            defaultWidth={360}
+            minWidth={240}
+            maxWidth={560}
+            className={null}
            style={{
-              width: 280,
              position: "sticky",
              top: 16,
              height: "calc(100vh - 120px)",
              alignSelf: "flex-start",
            }}
          >
-            <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">
+            <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" />
                  Workflow graph
                  {workflowName !== null && (
-                    <span className="ml-2" style={{ color: "var(--color-text)" }}>
-                      {workflowName}
-                    </span>
+                    <span className="ml-2 text-foreground">{workflowName}</span>
                  )}
                </span>
-                <span>
+                <span className="tabular-nums">
                  {descriptor.graph.edges.length} edge
                  {descriptor.graph.edges.length === 1 ? "" : "s"}
                </span>
@@ -269,19 +250,25 @@ export function ThreadDetail({ client, threadId, onBack }: Props) {
                  onNodeClick={handleGraphNodeClick}
                />
              </div>
-            </div>
-          </div>
+            </Card>
+          </ResizablePanel>
        )}

        <div className="flex-1 min-w-0">
          {status === "loading" && !liveActive && records.length === 0 && (
-            <p style={{ color: "var(--color-text-muted)" }}>Loading...</p>
+            <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>
          )}
          {status === "error" && !liveActive && (
-            <p style={{ color: "var(--color-error)" }}>Error: {error}</p>
+            <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>
          )}
          {(status === "ok" || liveActive || records.length > 0) && (
-            <div className="space-y-3">
+            <div className="border-l-2 border-border ml-2 pl-4 space-y-3">
              {records.map((r, i) => {
                const key = `${threadId}-${i}`;
                if (r.type === "role") {
@@ -292,18 +279,21 @@ export function ThreadDetail({ client, threadId, onBack }: Props) {
                    <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}>
+                  <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" />
                    <RecordCard record={r} highlighted={false} />
                  </div>
                );
@@ -1,17 +1,37 @@
+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";

-type Props = {
-  client: string;
-  onSelect: (id: string) => void;
-};
+function statusVariant(status: string): "success" | "destructive" | "secondary" {
+  if (status === "completed") return "success";
+  if (status === "failed") return "destructive";
+  return "secondary";
+}

-export function ThreadList({ client, onSelect }: Props) {
+export function ThreadList() {
+  const params = useParams();
+  const navigate = useNavigate();
+  const client = params.client as string;
  const { status, data, error } = useFetch(() => listThreads(client), [client]);

  if (status === "loading")
-    return <p style={{ color: "var(--color-text-muted)" }}>Loading threads...</p>;
-  if (status === "error") return <p style={{ color: "var(--color-error)" }}>Error: {error}</p>;
+    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>
+    );

  const threads = [...data.threads].sort((a, b) => {
    if (!a.startedAt && !b.startedAt) return 0;
@@ -22,51 +42,44 @@ export function ThreadList({ client, onSelect }: Props) {

  return (
    <div>
-      <h2 className="text-xl font-semibold mb-4">Threads</h2>
+      <h2 className="text-xl font-semibold tracking-tight mb-4">Threads</h2>
      {threads.length === 0 ? (
-        <p style={{ color: "var(--color-text-muted)" }}>No threads found.</p>
+        <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>
      ) : (
        <div className="space-y-2">
          {threads.map((t) => (
-            <button
-              type="button"
+            <Card
              key={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)" }}
+              className="p-4 cursor-pointer hover:bg-accent/50 hover:shadow-sm transition-all duration-200"
+              onClick={() => navigate(`/${client}/threads/${t.threadId}`)}
            >
              <div className="flex items-center justify-between">
-                <code className="text-sm font-mono" style={{ color: "var(--color-accent)" }}>
-                  {t.threadId}
-                </code>
+                <code className="font-mono text-sm text-foreground">{t.threadId}</code>
                {t.status && (
-                  <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",
-                    }}
-                  >
+                  <Badge variant={statusVariant(t.status)} className="text-xs">
                    {t.status}
-                  </span>
+                  </Badge>
                )}
              </div>
              {t.workflow && (
-                <p className="text-sm mt-1" style={{ color: "var(--color-text-muted)" }}>
+                <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" />
                  {t.workflow}
                </p>
              )}
              {t.startedAt && (
-                <p className="text-xs mt-1" style={{ color: "var(--color-text-muted)" }}>
+                <p className="text-xs mt-1 text-muted-foreground flex items-center gap-1.5">
+                  <Clock className="h-3 w-3" />
                  {t.startedAt}
                </p>
              )}
-            </button>
+            </Card>
          ))}
        </div>
      )}
@@ -0,0 +1,30 @@
+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 };
@@ -0,0 +1,45 @@
+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 };
@@ -0,0 +1,36 @@
+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 };
@@ -0,0 +1,7 @@
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+
+const Collapsible = CollapsiblePrimitive.Root;
+const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger;
+const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent;
+
+export { Collapsible, CollapsibleContent, CollapsibleTrigger };
@@ -0,0 +1,104 @@
+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,
+};
@@ -0,0 +1,17 @@
+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 };
@@ -0,0 +1,73 @@
+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>
+  );
+}
@@ -0,0 +1,42 @@
+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 };
@@ -0,0 +1,148 @@
+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,
+};
@@ -0,0 +1,25 @@
+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 };
@@ -0,0 +1,69 @@
+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 };
@@ -0,0 +1,16 @@
+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 };
@@ -0,0 +1,28 @@
+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 };
@@ -1,22 +1,50 @@
+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";

-type Props = {
-  client: string;
-  workflowName: string;
-  onBack: () => void;
-};
+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];
+}

 function versionCount(detail: WorkflowDetailData): number {
  return detail.history.length + 1;
 }

-// ── Schema rendering helpers ────────────────────────────────────────
-
 type SchemaRow = {
  key: string;
  name: string;
@@ -39,119 +67,66 @@ 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) {
-    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);
-  }
-
-  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);
+    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;
  }

-  if (hasOneOf) {
-    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);
  }
-
-  return [];
+  return rows;
 }

 function flattenProperty(
@@ -162,139 +137,145 @@ 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;

-  const rows: SchemaRow[] = [
-    {
-      key: `${keyPrefix}${name}`,
-      name: depth > 0 ? `${parentPrefix}└─ ${name}` : name,
-      type,
-      description: String(prop.description ?? ""),
-      depth,
-      prefix: parentPrefix,
-      isVariantHeader: false,
-    },
-  ];
+  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}-`,
+      ),
+    );
+  }

-  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 (
-    <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)" }}>
+    <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" />
        {roleName}
      </h4>
      {role.description !== "" && (
-        <p className="text-xs mb-3" style={{ color: "var(--color-text-muted)" }}>
-          {role.description}
-        </p>
+        <p className="text-xs mb-3 text-muted-foreground">{role.description}</p>
      )}
      {role.systemPrompt !== "" && (
-        <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>
+        <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>
      )}
      {rows.length > 0 && (
        <div>
-          <p
-            className="text-[10px] uppercase tracking-wider mb-1 font-medium"
-            style={{ color: "var(--color-text-muted)" }}
-          >
+          <p className="text-[10px] uppercase tracking-wider mb-1 font-medium text-muted-foreground">
            Meta Schema
          </p>
-          <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)" }}
-                >
-                  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>
+          <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) => (
-                <tr
+                <TableRow
                  key={r.key}
-                  style={{
-                    borderBottom: r.isVariantHeader ? "none" : "1px solid var(--color-border)",
-                  }}
+                  className={cn(r.isVariantHeader ? "border-b-0" : "", "even:bg-muted/30")}
                >
-                  <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",
-                    }}
+                  <TableCell
+                    className={cn(
+                      "font-mono whitespace-pre text-xs",
+                      r.isVariantHeader ? "italic text-muted-foreground" : "text-foreground",
+                    )}
                  >
                    {r.name}
-                  </td>
-                  <td className="py-1 pr-3 font-mono" style={{ color: "var(--color-text-muted)" }}>
+                  </TableCell>
+                  <TableCell className="font-mono text-xs text-muted-foreground">
                    {r.type}
-                  </td>
-                  <td className="py-1" style={{ color: "var(--color-text)" }}>
+                  </TableCell>
+                  <TableCell className="text-xs">
                    {r.description || (r.isVariantHeader ? "" : "—")}
-                  </td>
-                </tr>
+                  </TableCell>
+                </TableRow>
              ))}
-            </tbody>
-          </table>
+            </TableBody>
+          </Table>
        </div>
      )}
      {rows.length === 0 && Object.keys(role.schema).length > 0 && (
-        <pre
-          className="text-[10px] font-mono p-2 rounded overflow-x-auto"
-          style={{ background: "var(--color-bg)", color: "var(--color-text-muted)" }}
-        >
+        <pre className="text-[10px] font-mono p-2 rounded-md overflow-x-auto bg-background text-muted-foreground">
          {JSON.stringify(role.schema, null, 2)}
        </pre>
      )}
-    </div>
+    </Card>
  );
 }

-// ── Main component ──────────────────────────────────────────────────
-
-export function WorkflowDetail({ client, workflowName, onBack }: Props) {
+export function WorkflowDetail() {
+  const params = useParams();
+  const navigate = useNavigate();
+  const client = params.client as string;
+  const workflowName = params.workflowName as string;
  const { status, data, error } = useFetch(
    () => getWorkflowDetail(client, workflowName),
    [client, workflowName],
@@ -334,44 +315,52 @@ export function WorkflowDetail({ client, workflowName, onBack }: Props) {
  return (
    <div>
      <div className="flex items-center justify-between mb-4">
-        <button
-          type="button"
-          onClick={onBack}
-          className="text-sm hover:underline"
-          style={{ color: "var(--color-accent)" }}
+        <Button
+          variant="ghost"
+          className="gap-1.5 px-2 text-muted-foreground hover:text-foreground transition-all duration-200"
+          onClick={() => navigate(`/${client}/workflows`)}
        >
-          ← Back to workflows
-        </button>
+          <ArrowLeft className="h-4 w-4" />
+          Back to workflows
+        </Button>
      </div>

-      <h2 className="text-xl font-semibold mb-4 font-mono">{workflowName}</h2>
+      <h2 className="text-xl font-semibold mb-4 font-mono tracking-tight">{workflowName}</h2>

-      {status === "loading" && <p style={{ color: "var(--color-text-muted)" }}>Loading...</p>}
-      {status === "error" && <p style={{ color: "var(--color-error)" }}>Error: {error}</p>}
+      {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>
+      )}

      {detail !== null && (
        <div className="flex gap-4" style={{ minHeight: "calc(100vh - 160px)" }}>
-          {/* Left: fixed graph sidebar */}
          {hasGraph && (
-            <div
-              className="shrink-0"
+            <ResizablePanel
+              defaultWidth={360}
+              minWidth={240}
+              maxWidth={560}
+              className={null}
              style={{
-                width: 280,
                position: "sticky",
                top: 16,
                height: "calc(100vh - 160px)",
                alignSelf: "flex-start",
              }}
            >
-              <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>
+              <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>
                  <span>
                    {edgeCount} edge{edgeCount === 1 ? "" : "s"}
                  </span>
@@ -384,52 +373,44 @@ export function WorkflowDetail({ client, workflowName, onBack }: Props) {
                    onNodeClick={handleGraphNodeClick}
                  />
                </div>
-              </div>
-            </div>
+              </Card>
+            </ResizablePanel>
          )}

-          {/* Right: scrollable content */}
          <div className="flex-1 min-w-0 space-y-4">
-            {/* 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>
+            <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>
                </span>
-                <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" />
                  {versionCount(detail)} version{versionCount(detail) !== 1 ? "s" : ""}
                </span>
                {roleEntries.length > 0 && (
-                  <span>
+                  <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" />
                    {roleEntries.length} role{roleEntries.length !== 1 ? "s" : ""}
                  </span>
                )}
              </div>
-            </div>
+            </Card>

-            {/* Role cards */}
            {roleEntries.map(([name, role]) => (
              <div
                key={name}
-                style={{
-                  transition: "box-shadow 0.3s",
-                  boxShadow: highlightedRole === name ? "0 0 0 2px var(--color-accent)" : "none",
-                  borderRadius: 8,
-                }}
+                className={cn(
+                  "rounded-lg transition-shadow duration-300",
+                  highlightedRole === name && "ring-2 ring-ring",
+                )}
              >
                <RoleCard roleName={name} role={role} />
              </div>
@@ -91,7 +91,7 @@ export function ConditionEdge(props: EdgeProps) {
    defaultLabelY = result[2];
  }

-  const stroke = "var(--color-accent)";
+  const stroke = "hsl(var(--ring))";
  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: "var(--color-surface)",
-              border: "1px solid var(--color-border)",
-              color: "var(--color-text)",
+              background: "hsl(var(--card))",
+              border: "1px solid hsl(var(--border))",
+              color: "hsl(var(--foreground))",
              whiteSpace: "nowrap",
              zIndex: 10,
            }}
@@ -1,29 +1,23 @@
 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 "var(--color-success)";
+      return "hsl(var(--success))";
    case "active":
-      return "var(--color-accent)";
+      return "hsl(var(--ring))";
    default:
-      return "var(--color-border)";
+      return "hsl(var(--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: "var(--color-text-muted)",
+    background: "hsl(var(--muted-foreground))",
    width: 6,
    height: 6,
    border: "none",
@@ -35,9 +29,9 @@ export function RoleNode(props: NodeProps) {
      style={{
        width: 180,
        height: 60,
-        background: "var(--color-surface)",
+        background: "hsl(var(--card))",
        borderColor: borderColor(data.state),
-        color: "var(--color-text)",
+        color: "hsl(var(--foreground))",
        display: "flex",
        flexDirection: "column",
        justifyContent: "center",
@@ -81,19 +75,15 @@ export function RoleNode(props: NodeProps) {
        isConnectable={false}
      />
      <div className="flex items-center gap-1.5 font-mono">
-        {icon !== null && (
-          <span
-            style={{
-              color: data.state === "active" ? "var(--color-accent)" : "var(--color-success)",
-            }}
-          >
-            {icon}
-          </span>
-        )}
+        {data.state === "completed" && <Check className="h-3 w-3 text-success" />}
+        {data.state === "active" && <Circle className="h-3 w-3 fill-current text-ring" />}
        <span className="truncate">{data.label}</span>
      </div>
      {data.description !== "" && (
-        <div className="text-[10px] truncate mt-0.5" style={{ color: "var(--color-text-muted)" }}>
+        <div
+          className="text-[10px] truncate mt-0.5"
+          style={{ color: "hsl(var(--muted-foreground))" }}
+        >
          {data.description}
        </div>
      )}
@@ -1,21 +1,22 @@
 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 "var(--color-success)";
+      return "hsl(var(--success))";
    case "active":
-      return "var(--color-accent)";
+      return "hsl(var(--ring))";
    default:
-      return "var(--color-border)";
+      return "hsl(var(--border))";
  }
 }

 function bgColor(state: TerminalNodeData["state"]): string {
-  if (state === "completed") return "var(--color-success)";
-  if (state === "active") return "var(--color-accent)";
-  return "var(--color-surface)";
+  if (state === "completed") return "hsl(var(--success))";
+  if (state === "active") return "hsl(var(--ring))";
+  return "hsl(var(--card))";
 }

 export function TerminalNode(props: NodeProps) {
@@ -23,7 +24,7 @@ export function TerminalNode(props: NodeProps) {
  const isStart = data.kind === "start";
  const isActive = data.state === "active";
  const handleStyle = {
-    background: "var(--color-text-muted)",
+    background: "hsl(var(--muted-foreground))",
    width: 6,
    height: 6,
    border: "none",
@@ -31,13 +32,16 @@ export function TerminalNode(props: NodeProps) {

  return (
    <div
-      className={`rounded-full border-2 flex items-center justify-center text-[10px] font-bold ${isActive ? "wf-node-pulse" : ""} ${data.state !== "default" ? "cursor-pointer" : ""}`}
+      className={`rounded-full border-2 flex items-center justify-center ${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" ? "var(--color-text-muted)" : "var(--color-bg)",
+        color:
+          data.state === "default"
+            ? "hsl(var(--muted-foreground))"
+            : "hsl(var(--primary-foreground))",
      }}
      title={isStart ? "Start" : "End"}
    >
@@ -74,7 +78,7 @@ export function TerminalNode(props: NodeProps) {
          />
        </>
      )}
-      {isStart ? "▶" : "■"}
+      {isStart ? <Play className="h-3 w-3" /> : <Square className="h-3 w-3" />}
    </div>
  );
 }
@@ -3,13 +3,14 @@ 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";
@@ -39,9 +40,12 @@ 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: OnNodeClick | undefined =
-    onNodeClick !== null ? (_e, node) => handleNodeClick(onNodeClick, node) : undefined;
+  const onNodeClickHandler: NodeMouseHandler | undefined =
+    onNodeClick !== null
+      ? (_e: React.MouseEvent, node: Node) => handleNodeClick(onNodeClick, node)
+      : undefined;

  const styledEdges = useMemo(
    () =>
@@ -51,7 +55,7 @@ export function WorkflowGraph({ graph, roles, nodeStates, onNodeClick }: Props)
          type: MarkerType.ArrowClosed,
          width: 14,
          height: 14,
-          color: "var(--color-text)",
+          color: "hsl(var(--foreground))",
        },
      })),
    [layout.edges],
@@ -72,10 +76,10 @@ export function WorkflowGraph({ graph, roles, nodeStates, onNodeClick }: Props)
      nodesConnectable={false}
      elementsSelectable={false}
      proOptions={{ hideAttribution: true }}
-      colorMode="dark"
-      style={{ background: "var(--color-bg)" }}
+      colorMode={theme}
+      style={{ background: "hsl(var(--background))" }}
    >
-      <Background color="var(--color-border)" gap={20} size={1} />
+      <Background color="hsl(var(--border))" gap={20} size={1} />
    </ReactFlow>
  );
 }
@@ -1,54 +1,65 @@
+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";

-type Props = {
-  client: string;
-  onSelect: (name: string) => void;
-};
-
-export function WorkflowList({ client, onSelect }: Props) {
+export function WorkflowList() {
+  const params = useParams();
+  const navigate = useNavigate();
+  const client = params.client as string;
  const { status, data, error } = useFetch(() => listWorkflows(client), [client]);

  if (status === "loading")
-    return <p style={{ color: "var(--color-text-muted)" }}>Loading workflows...</p>;
-  if (status === "error") return <p style={{ color: "var(--color-error)" }}>Error: {error}</p>;
+    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>
+    );

  const workflows = data.workflows;

  return (
    <div>
-      <h2 className="text-xl font-semibold mb-4">Workflows</h2>
+      <h2 className="text-xl font-semibold tracking-tight mb-4">Workflows</h2>
      {workflows.length === 0 ? (
-        <p style={{ color: "var(--color-text-muted)" }}>No workflows registered.</p>
+        <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>
      ) : (
        <div className="space-y-2">
          {workflows.map((w) => (
-            <button
+            <Card
              key={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)",
-              }}
+              className="p-4 cursor-pointer hover:bg-accent/50 hover:shadow-sm transition-all duration-200"
+              onClick={() => navigate(`/${client}/workflows/${w.name}`)}
            >
-              <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)" }}
-              >
+              <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" />
                {w.hash !== null ? w.hash : "—"}
              </code>
              {w.timestamp !== null ? (
-                <span className="text-xs mt-1 block" style={{ color: "var(--color-text-muted)" }}>
+                <span className="text-xs mt-1 text-muted-foreground flex items-center gap-1.5">
+                  <Clock className="h-3 w-3" />
                  Updated {new Date(w.timestamp).toLocaleString()}
                </span>
              ) : null}
-            </button>
+            </Card>
          ))}
        </div>
      )}
@@ -0,0 +1,74 @@
+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;
+}
@@ -1,32 +1,107 @@
@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 {
-  --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;
+  --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%;
 }

 body {
  margin: 0;
-  background: var(--color-bg);
-  color: var(--color-text);
+  background: hsl(var(--background));
+  color: hsl(var(--foreground));
  font-family: "Inter", system-ui, -apple-system, sans-serif;
 }

@keyframes wf-node-pulse {
  0%,
  100% {
-    box-shadow: 0 0 0 0 rgba(124, 109, 240, 0.55);
+    box-shadow: 0 0 0 0 hsl(var(--ring) / 0.55);
  }
  50% {
-    box-shadow: 0 0 0 6px rgba(124, 109, 240, 0);
+    box-shadow: 0 0 0 6px hsl(var(--ring) / 0);
  }
 }

@@ -36,13 +111,13 @@ body {

@keyframes wf-record-card-highlight {
  0% {
-    border-color: var(--color-accent);
+    border-color: hsl(var(--ring));
  }
  35% {
-    border-color: var(--color-accent);
+    border-color: hsl(var(--ring));
  }
  100% {
-    border-color: var(--color-border);
+    border-color: hsl(var(--border));
  }
 }

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]): string {
+  return twMerge(clsx(inputs));
+}
@@ -1,13 +1,17 @@
 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 { App } from "./app.tsx";
+import { router } from "./router.tsx";

 const root = document.getElementById("root");
 if (root) {
  createRoot(root).render(
    <StrictMode>
-      <App />
+      <ThemeProvider>
+        <RouterProvider router={router} />
+      </ThemeProvider>
    </StrictMode>,
  );
 }
@@ -0,0 +1,45 @@
+import { createHashRouter, redirect } from "react-router";
+import { Layout } from "./app.tsx";
+import { ClientRedirect } from "./components/client-redirect.tsx";
+import { LoginPage } from "./components/login.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";
+
+export const router = createHashRouter([
+  {
+    path: "/login",
+    Component: LoginPage,
+  },
+  {
+    path: "/",
+    Component: Layout,
+    children: [
+      {
+        index: true,
+        Component: ClientRedirect,
+      },
+      {
+        path: ":client/threads",
+        Component: ThreadList,
+      },
+      {
+        path: ":client/threads/:threadId",
+        Component: ThreadDetail,
+      },
+      {
+        path: ":client/workflows",
+        Component: WorkflowList,
+      },
+      {
+        path: ":client/workflows/:workflowName",
+        Component: WorkflowDetail,
+      },
+      {
+        path: ":client",
+        loader: ({ params }) => redirect(`/${params.client}/threads`),
+      },
+    ],
+  },
+]);
@@ -1,110 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-
-type View = "threads" | "workflows";
-
-type HashRoute = {
-  view: View;
-  client: string | null;
-  threadId: string | null;
-  workflowName: string | null;
-};
-
-function parseHash(hash: string): HashRoute {
-  const raw = hash.replace(/^#\/?/, "");
-  // Format: #client/threads/id or #client/workflows or #threads or #workflows
-  const parts = raw.split("/");
-
-  // Check if first part is a known view
-  if (parts[0] === "threads" || parts[0] === "workflows") {
-    return {
-      view: parts[0] as View,
-      client: null,
-      threadId: parts[0] === "threads" && parts.length > 1 ? parts.slice(1).join("/") : null,
-      workflowName: parts[0] === "workflows" && parts.length > 1 ? parts.slice(1).join("/") : null,
-    };
-  }
-
-  // First part is client name
-  const client = parts[0] || null;
-  const viewPart = parts[1] ?? "threads";
-  const view: View = viewPart === "workflows" ? "workflows" : "threads";
-  const threadId = view === "threads" && parts.length > 2 ? parts.slice(2).join("/") : null;
-  const workflowName = view === "workflows" && parts.length > 2 ? parts.slice(2).join("/") : null;
-
-  return { view, client, threadId, workflowName };
-}
-
-function buildHash(route: HashRoute): string {
-  const prefix = route.client ? `${route.client}/` : "";
-  if (route.view === "workflows") {
-    if (route.workflowName !== null) {
-      return `#${prefix}workflows/${route.workflowName}`;
-    }
-    return `#${prefix}workflows`;
-  }
-  if (route.threadId !== null) {
-    return `#${prefix}threads/${route.threadId}`;
-  }
-  return `#${prefix}threads`;
-}
-
-export function useHashRoute(): {
-  view: View;
-  client: string | null;
-  threadId: string | null;
-  workflowName: string | null;
-  setView: (v: View) => void;
-  setClient: (a: string | null) => void;
-  setThreadId: (id: string | null) => void;
-  setWorkflowName: (name: string | null) => void;
-} {
-  const [route, setRoute] = useState<HashRoute>(() => parseHash(window.location.hash));
-
-  useEffect(() => {
-    function onHashChange(): void {
-      setRoute(parseHash(window.location.hash));
-    }
-    window.addEventListener("hashchange", onHashChange);
-    return () => window.removeEventListener("hashchange", onHashChange);
-  }, []);
-
-  const navigate = useCallback((next: HashRoute) => {
-    const hash = buildHash(next);
-    window.location.hash = hash;
-    setRoute(next);
-  }, []);
-
-  const setView = useCallback(
-    (v: View) => navigate({ view: v, client: route.client, threadId: null, workflowName: null }),
-    [navigate, route.client],
-  );
-
-  const setClient = useCallback(
-    (a: string | null) =>
-      navigate({ view: route.view, client: a, threadId: null, workflowName: null }),
-    [navigate, route.view],
-  );
-
-  const setThreadId = useCallback(
-    (id: string | null) =>
-      navigate({ view: "threads", client: route.client, threadId: id, workflowName: null }),
-    [navigate, route.client],
-  );
-
-  const setWorkflowName = useCallback(
-    (name: string | null) =>
-      navigate({ view: "workflows", client: route.client, threadId: null, workflowName: name }),
-    [navigate, route.client],
-  );
-
-  return {
-    view: route.view,
-    client: route.client,
-    threadId: route.threadId,
-    workflowName: route.workflowName,
-    setView,
-    setClient,
-    setThreadId,
-    setWorkflowName,
-  };
-}
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
@@ -4,7 +4,9 @@
    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    "module": "ESNext",
    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
    "strict": true,
+    "types": ["vite/client"],
    "jsx": "react-jsx",
    "esModuleInterop": true,
    "skipLibCheck": true,
@@ -13,5 +15,5 @@
    "isolatedModules": true,
    "noEmit": true
  },
-  "include": ["src"]
+  "include": ["src", "plugins"]
 }
@@ -1,10 +1,15 @@
 import tailwindcss from "@tailwindcss/vite";
 import react from "@vitejs/plugin-react";
 import { defineConfig } from "vite";
+import { viteLimitLinePlugin } from "./plugins/vite-limit-line-plugin.js";

 // biome-ignore lint/style/noDefaultExport: Vite loads config from default export.
 export default defineConfig({
-  plugins: [react(), tailwindcss()],
+  plugins: [
+    react(),
+    tailwindcss(),
+    ...viteLimitLinePlugin({ maxReactFCLines: 300, maxFileLines: 600 }),
+  ],
  server: {
    port: 5173,
    proxy: {
@@ -1,100 +0,0 @@
-/**
- * greet workflow — smoke test entry
- * Single role: greeter takes a prompt and returns a structured greeting.
- * 小橘 🍊
- */
-
-import type {
-  AdapterFn,
-  ModeratorTable,
-  RoleFn,
-  RoleResult,
-  ThreadContext,
-  WorkflowDefinition,
-  WorkflowRuntime,
-} from "@uncaged/workflow-runtime";
-import { createWorkflow, END, START } from "@uncaged/workflow-runtime";
-import * as z from "zod/v4";
-
-type GreetMeta = {
-  greeter: { greeting: string; language: string };
-};
-
-const greeterSchema = z.object({
-  greeting: z.string().describe("A friendly greeting message"),
-  language: z.string().describe("The language of the greeting"),
-});
-
-const roles: WorkflowDefinition<GreetMeta>["roles"] = {
-  greeter: {
-    description: "Generates a friendly greeting",
-    systemPrompt:
-      "You are a friendly greeter. Given a user prompt, produce a warm greeting. Respond in valid JSON with keys: greeting (string), language (string).",
-    schema: greeterSchema,
-  },
-};
-
-const table: ModeratorTable<GreetMeta> = {
-  [START]: [{ condition: "FALLBACK", role: "greeter" }],
-  greeter: [{ condition: "FALLBACK", role: END }],
-};
-
-export const descriptor = {
-  name: "greet",
-  description: "A simple greeting workflow for smoke testing",
-  graph: { [START]: ["greeter"], greeter: [END] },
-  roles: { greeter: { description: "Generates a friendly greeting" } },
-};
-
-function createLazyAdapter(): AdapterFn {
-  let cached: { baseUrl: string; apiKey: string; model: string } | null = null;
-  function getProvider() {
-    if (cached !== null) return cached;
-    const apiKey = process.env.DASHSCOPE_API_KEY;
-    if (!apiKey) throw new Error("missing env: DASHSCOPE_API_KEY");
-    cached = {
-      baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
-      apiKey,
-      model: process.env.WORKFLOW_MODEL ?? "qwen-plus",
-    };
-    return cached;
-  }
-
-  return (<T>(prompt: string, schema: z.ZodType<T>): RoleFn<T> => {
-    return async (ctx: ThreadContext, _runtime: WorkflowRuntime): Promise<RoleResult<T>> => {
-      const provider = getProvider();
-      const response = await fetch(`${provider.baseUrl}/chat/completions`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${provider.apiKey}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          model: provider.model,
-          messages: [
-            { role: "system", content: prompt },
-            {
-              role: "user",
-              content: `${ctx.start.content}\n\nRespond with JSON: ${JSON.stringify(z.toJSONSchema(schema))}`,
-            },
-          ],
-          response_format: { type: "json_object" },
-        }),
-      });
-      if (!response.ok) {
-        const body = await response.text();
-        throw new Error(`LLM error ${response.status}: ${body.slice(0, 500)}`);
-      }
-      const data = (await response.json()) as { choices: Array<{ message: { content: string } }> };
-      const text = data.choices[0]?.message?.content;
-      if (!text) throw new Error("Empty LLM response");
-      const parsed = schema.parse(JSON.parse(text));
-      return { meta: parsed, childThread: null };
-    };
-  }) as AdapterFn;
-}
-
-export const run = createWorkflow<GreetMeta>(
-  { roles, table },
-  { adapter: createLazyAdapter(), overrides: null },
-);
@@ -11,15 +11,25 @@ importers:
      '@biomejs/biome':
        specifier: ^2.4.14
        version: 2.4.15
+      '@changesets/cli':
+        specifier: ^2.31.0
+        version: 2.31.0(@types/node@25.8.0)
+      '@types/node':
+        specifier: ^25.7.0
+        version: 25.8.0
      '@types/xxhashjs':
        specifier: ^0.2.4
        version: 0.2.4
      bun-types:
        specifier: ^1.3.13
-        version: 1.3.13
+        version: 1.3.14

 packages:

+  '@babel/runtime@7.29.2':
+    resolution: {integrity: sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==}
+    engines: {node: '>=6.9.0'}
+
  '@biomejs/biome@2.4.15':
    resolution: {integrity: sha512-j5VH3a/h/HXTKBM50MDMxRCzkeLv9S2XJcW2WgnZT1+xyisi+0bISrXR82gCX+8S9lvK0skEvHJRN+3Ktr2hlw==}
    engines: {node: '>=14.21.3'}
@@ -77,20 +87,389 @@ packages:
    cpu: [x64]
    os: [win32]

-  '@types/node@25.6.2':
-    resolution: {integrity: sha512-sokuT28dxf9JT5Kady1fsXOvI4HVpjZa95NKT5y9PNTIrs2AsobR4GFAA90ZG8M+nxVRLysCXsVj6eGC7Vbrlw==}
+  '@changesets/apply-release-plan@7.1.1':
+    resolution: {integrity: sha512-9qPCm/rLx/xoOFXIHGB229+4GOL76S4MC+7tyOuTsR6+1jYlfFDQORdvwR5hDA6y4FL2BPt3qpbcQIS+dW85LA==}
+
+  '@changesets/assemble-release-plan@6.0.10':
+    resolution: {integrity: sha512-rSDcqdJ9KbVyjpBIuCidhvZNIiVt1XaIYp73ycVQRIA5n/j6wQaEk0ChRLMUQ1vkxZe51PTQ9OIhbg6HQMW45A==}
+
+  '@changesets/changelog-git@0.2.1':
+    resolution: {integrity: sha512-x/xEleCFLH28c3bQeQIyeZf8lFXyDFVn1SgcBiR2Tw/r4IAWlk1fzxCEZ6NxQAjF2Nwtczoen3OA2qR+UawQ8Q==}
+
+  '@changesets/cli@2.31.0':
+    resolution: {integrity: sha512-AhI4enNTgHu2IZr6K4WZyf0EPch4XVMn1yOMFmCD9gsfBGqMYaHXls5HyDv6/CL5axVQABz68eG30eCtbr2wFg==}
+    hasBin: true
+
+  '@changesets/config@3.1.4':
+    resolution: {integrity: sha512-pf0bvD/v6WI2cRlZ6hzpjtZdSlXDXMAJ+Iz7xfFzV4ZxJ8OGGAON+1qYc99ZPrijnt4xp3VGG7eNvAOGS24V1Q==}
+
+  '@changesets/errors@0.2.0':
+    resolution: {integrity: sha512-6BLOQUscTpZeGljvyQXlWOItQyU71kCdGz7Pi8H8zdw6BI0g3m43iL4xKUVPWtG+qrrL9DTjpdn8eYuCQSRpow==}
+
+  '@changesets/get-dependents-graph@2.1.4':
+    resolution: {integrity: sha512-ZsS00x6WvmHq3sQv8oCMwL0f/z3wbXCVuSVTJwCnnmbC/iBdNJGFx1EcbMG4PC6sXRyH69liM4A2WKXzn/kRPg==}
+
+  '@changesets/get-release-plan@4.0.16':
+    resolution: {integrity: sha512-2K5Om6CrMPm45rtvckfzWo7e9jOVCKLCnXia5eUPaURH7/LWzri7pK1TycdzAuAtehLkW7VPbWLCSExTHmiI6g==}
+
+  '@changesets/get-version-range-type@0.4.0':
+    resolution: {integrity: sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==}
+
+  '@changesets/git@3.0.4':
+    resolution: {integrity: sha512-BXANzRFkX+XcC1q/d27NKvlJ1yf7PSAgi8JG6dt8EfbHFHi4neau7mufcSca5zRhwOL8j9s6EqsxmT+s+/E6Sw==}
+
+  '@changesets/logger@0.1.1':
+    resolution: {integrity: sha512-OQtR36ZlnuTxKqoW4Sv6x5YIhOmClRd5pWsjZsddYxpWs517R0HkyiefQPIytCVh4ZcC5x9XaG8KTdd5iRQUfg==}
+
+  '@changesets/parse@0.4.3':
+    resolution: {integrity: sha512-ZDmNc53+dXdWEv7fqIUSgRQOLYoUom5Z40gmLgmATmYR9NbL6FJJHwakcCpzaeCy+1D0m0n7mT4jj2B/MQPl7A==}
+
+  '@changesets/pre@2.0.2':
+    resolution: {integrity: sha512-HaL/gEyFVvkf9KFg6484wR9s0qjAXlZ8qWPDkTyKF6+zqjBe/I2mygg3MbpZ++hdi0ToqNUF8cjj7fBy0dg8Ug==}
+
+  '@changesets/read@0.6.7':
+    resolution: {integrity: sha512-D1G4AUYGrBEk8vj8MGwf75k9GpN6XL3wg8i42P2jZZwFLXnlr2Pn7r9yuQNbaMCarP7ZQWNJbV6XLeysAIMhTA==}
+
+  '@changesets/should-skip-package@0.1.2':
+    resolution: {integrity: sha512-qAK/WrqWLNCP22UDdBTMPH5f41elVDlsNyat180A33dWxuUDyNpg6fPi/FyTZwRriVjg0L8gnjJn2F9XAoF0qw==}
+
+  '@changesets/types@4.1.0':
+    resolution: {integrity: sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==}
+
+  '@changesets/types@6.1.0':
+    resolution: {integrity: sha512-rKQcJ+o1nKNgeoYRHKOS07tAMNd3YSN0uHaJOZYjBAgxfV7TUE7JE+z4BzZdQwb5hKaYbayKN5KrYV7ODb2rAA==}
+
+  '@changesets/write@0.4.0':
+    resolution: {integrity: sha512-CdTLvIOPiCNuH71pyDu3rA+Q0n65cmAbXnwWH84rKGiFumFzkmHNT8KHTMEchcxN+Kl8I54xGUhJ7l3E7X396Q==}
+
+  '@inquirer/external-editor@1.0.3':
+    resolution: {integrity: sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@manypkg/find-root@1.1.0':
+    resolution: {integrity: sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==}
+
+  '@manypkg/get-packages@1.1.3':
+    resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==}
+
+  '@nodelib/fs.scandir@2.1.5':
+    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.stat@2.0.5':
+    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.walk@1.2.8':
+    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
+    engines: {node: '>= 8'}
+
+  '@types/node@12.20.55':
+    resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
+
+  '@types/node@25.8.0':
+    resolution: {integrity: sha512-TCFSk8IZh+iLX1xtksoBVtdmgL+1IX0fC9BeU4QqFSuNdN/K+HUlhqOzEmSYYpZUVsLYcPqc9KX+60iDuninSQ==}

  '@types/xxhashjs@0.2.4':
    resolution: {integrity: sha512-E2+ZoJY2JjmVPN0iQM5gJvZkk98O2PYXSi6HrciEk3EKF34+mauEk/HgwTeCz+2r8HXHMKpucrwy4qTT12OPaQ==}

-  bun-types@1.3.13:
-    resolution: {integrity: sha512-QXKeHLlOLqQX9LgYaHJfzdBaV21T63HhFJnvuRCcjZiaUDpbs5ED1MgxbMra71CsryN/1dAoXuJJJwIv/2drVA==}
+  ansi-colors@4.1.3:
+    resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
+    engines: {node: '>=6'}

-  undici-types@7.19.2:
-    resolution: {integrity: sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==}
+  ansi-regex@5.0.1:
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
+
+  argparse@1.0.10:
+    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
+
+  argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+
+  array-union@2.1.0:
+    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
+    engines: {node: '>=8'}
+
+  better-path-resolve@1.0.0:
+    resolution: {integrity: sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==}
+    engines: {node: '>=4'}
+
+  braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+
+  bun-types@1.3.14:
+    resolution: {integrity: sha512-4N0ig0fEomHt5R0KCFWjovxow98rIoRwKolrYdCcknNwMekCXRnWEUvgu5soYV8QXtVsrUD8B95MBOZGPvr6KQ==}
+
+  chardet@2.1.1:
+    resolution: {integrity: sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==}
+
+  cross-spawn@7.0.6:
+    resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
+    engines: {node: '>= 8'}
+
+  detect-indent@6.1.0:
+    resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==}
+    engines: {node: '>=8'}
+
+  dir-glob@3.0.1:
+    resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
+    engines: {node: '>=8'}
+
+  enquirer@2.4.1:
+    resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==}
+    engines: {node: '>=8.6'}
+
+  esprima@4.0.1:
+    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  extendable-error@0.1.7:
+    resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==}
+
+  fast-glob@3.3.3:
+    resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
+    engines: {node: '>=8.6.0'}
+
+  fastq@1.20.1:
+    resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
+
+  fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+
+  find-up@4.1.0:
+    resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
+    engines: {node: '>=8'}
+
+  fs-extra@7.0.1:
+    resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==}
+    engines: {node: '>=6 <7 || >=8'}
+
+  fs-extra@8.1.0:
+    resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
+    engines: {node: '>=6 <7 || >=8'}
+
+  glob-parent@5.1.2:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+
+  globby@11.1.0:
+    resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
+    engines: {node: '>=10'}
+
+  graceful-fs@4.2.11:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
+  human-id@4.1.3:
+    resolution: {integrity: sha512-tsYlhAYpjCKa//8rXZ9DqKEawhPoSytweBC2eNvcaDK+57RZLHGqNs3PZTQO6yekLFSuvA6AlnAfrw1uBvtb+Q==}
+    hasBin: true
+
+  iconv-lite@0.7.2:
+    resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==}
+    engines: {node: '>=0.10.0'}
+
+  ignore@5.3.2:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  is-number@7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+
+  is-subdir@1.2.0:
+    resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==}
+    engines: {node: '>=4'}
+
+  is-windows@1.0.2:
+    resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
+    engines: {node: '>=0.10.0'}
+
+  isexe@2.0.0:
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
+
+  js-yaml@3.14.2:
+    resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
+    hasBin: true
+
+  js-yaml@4.1.1:
+    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
+    hasBin: true
+
+  jsonfile@4.0.0:
+    resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==}
+
+  locate-path@5.0.0:
+    resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
+    engines: {node: '>=8'}
+
+  lodash.startcase@4.4.0:
+    resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==}
+
+  merge2@1.4.1:
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
+
+  micromatch@4.0.8:
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
+
+  mri@1.2.0:
+    resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
+    engines: {node: '>=4'}
+
+  outdent@0.5.0:
+    resolution: {integrity: sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==}
+
+  p-filter@2.1.0:
+    resolution: {integrity: sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==}
+    engines: {node: '>=8'}
+
+  p-limit@2.3.0:
+    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
+    engines: {node: '>=6'}
+
+  p-locate@4.1.0:
+    resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
+    engines: {node: '>=8'}
+
+  p-map@2.1.0:
+    resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==}
+    engines: {node: '>=6'}
+
+  p-try@2.2.0:
+    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
+    engines: {node: '>=6'}
+
+  package-manager-detector@0.2.11:
+    resolution: {integrity: sha512-BEnLolu+yuz22S56CU1SUKq3XC3PkwD5wv4ikR4MfGvnRVcmzXR9DwSlW2fEamyTPyXHomBJRzgapeuBvRNzJQ==}
+
+  path-exists@4.0.0:
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
+
+  path-key@3.1.1:
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
+
+  path-type@4.0.0:
+    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
+    engines: {node: '>=8'}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@2.3.2:
+    resolution: {integrity: sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==}
+    engines: {node: '>=8.6'}
+
+  pify@4.0.1:
+    resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
+    engines: {node: '>=6'}
+
+  prettier@2.8.8:
+    resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
+
+  quansync@0.2.11:
+    resolution: {integrity: sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==}
+
+  queue-microtask@1.2.3:
+    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
+
+  read-yaml-file@1.1.0:
+    resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==}
+    engines: {node: '>=6'}
+
+  resolve-from@5.0.0:
+    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
+    engines: {node: '>=8'}
+
+  reusify@1.1.0:
+    resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
+
+  run-parallel@1.2.0:
+    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
+
+  safer-buffer@2.1.2:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+
+  semver@7.8.0:
+    resolution: {integrity: sha512-AcM7dV/5ul4EekoQ29Agm5vri8JNqRyj39o0qpX6vDF2GZrtutZl5RwgD1XnZjiTAfncsJhMI48QQH3sN87YNA==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  shebang-command@2.0.0:
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
+
+  shebang-regex@3.0.0:
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
+
+  signal-exit@4.1.0:
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
+
+  slash@3.0.0:
+    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
+    engines: {node: '>=8'}
+
+  spawndamnit@3.0.1:
+    resolution: {integrity: sha512-MmnduQUuHCoFckZoWnXsTg7JaiLBJrKFj9UI2MbRPGaJeVpsLcVBu6P/IGZovziM/YBsellCmsprgNA+w0CzVg==}
+
+  sprintf-js@1.0.3:
+    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
+
+  strip-ansi@6.0.1:
+    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+    engines: {node: '>=8'}
+
+  strip-bom@3.0.0:
+    resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==}
+    engines: {node: '>=4'}
+
+  term-size@2.2.1:
+    resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==}
+    engines: {node: '>=8'}
+
+  to-regex-range@5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+
+  undici-types@7.24.6:
+    resolution: {integrity: sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==}
+
+  universalify@0.1.2:
+    resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
+    engines: {node: '>= 4.0.0'}
+
+  which@2.0.2:
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
+    hasBin: true

 snapshots:

+  '@babel/runtime@7.29.2': {}
+
  '@biomejs/biome@2.4.15':
    optionalDependencies:
      '@biomejs/cli-darwin-arm64': 2.4.15
@@ -126,16 +505,433 @@ snapshots:
  '@biomejs/cli-win32-x64@2.4.15':
    optional: true

-  '@types/node@25.6.2':
+  '@changesets/apply-release-plan@7.1.1':
    dependencies:
-      undici-types: 7.19.2
+      '@changesets/config': 3.1.4
+      '@changesets/get-version-range-type': 0.4.0
+      '@changesets/git': 3.0.4
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      detect-indent: 6.1.0
+      fs-extra: 7.0.1
+      lodash.startcase: 4.4.0
+      outdent: 0.5.0
+      prettier: 2.8.8
+      resolve-from: 5.0.0
+      semver: 7.8.0
+
+  '@changesets/assemble-release-plan@6.0.10':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@changesets/get-dependents-graph': 2.1.4
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      semver: 7.8.0
+
+  '@changesets/changelog-git@0.2.1':
+    dependencies:
+      '@changesets/types': 6.1.0
+
+  '@changesets/cli@2.31.0(@types/node@25.8.0)':
+    dependencies:
+      '@changesets/apply-release-plan': 7.1.1
+      '@changesets/assemble-release-plan': 6.0.10
+      '@changesets/changelog-git': 0.2.1
+      '@changesets/config': 3.1.4
+      '@changesets/errors': 0.2.0
+      '@changesets/get-dependents-graph': 2.1.4
+      '@changesets/get-release-plan': 4.0.16
+      '@changesets/git': 3.0.4
+      '@changesets/logger': 0.1.1
+      '@changesets/pre': 2.0.2
+      '@changesets/read': 0.6.7
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@changesets/write': 0.4.0
+      '@inquirer/external-editor': 1.0.3(@types/node@25.8.0)
+      '@manypkg/get-packages': 1.1.3
+      ansi-colors: 4.1.3
+      enquirer: 2.4.1
+      fs-extra: 7.0.1
+      mri: 1.2.0
+      package-manager-detector: 0.2.11
+      picocolors: 1.1.1
+      resolve-from: 5.0.0
+      semver: 7.8.0
+      spawndamnit: 3.0.1
+      term-size: 2.2.1
+    transitivePeerDependencies:
+      - '@types/node'
+
+  '@changesets/config@3.1.4':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@changesets/get-dependents-graph': 2.1.4
+      '@changesets/logger': 0.1.1
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      fs-extra: 7.0.1
+      micromatch: 4.0.8
+
+  '@changesets/errors@0.2.0':
+    dependencies:
+      extendable-error: 0.1.7
+
+  '@changesets/get-dependents-graph@2.1.4':
+    dependencies:
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      picocolors: 1.1.1
+      semver: 7.8.0
+
+  '@changesets/get-release-plan@4.0.16':
+    dependencies:
+      '@changesets/assemble-release-plan': 6.0.10
+      '@changesets/config': 3.1.4
+      '@changesets/pre': 2.0.2
+      '@changesets/read': 0.6.7
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+
+  '@changesets/get-version-range-type@0.4.0': {}
+
+  '@changesets/git@3.0.4':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@manypkg/get-packages': 1.1.3
+      is-subdir: 1.2.0
+      micromatch: 4.0.8
+      spawndamnit: 3.0.1
+
+  '@changesets/logger@0.1.1':
+    dependencies:
+      picocolors: 1.1.1
+
+  '@changesets/parse@0.4.3':
+    dependencies:
+      '@changesets/types': 6.1.0
+      js-yaml: 4.1.1
+
+  '@changesets/pre@2.0.2':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      fs-extra: 7.0.1
+
+  '@changesets/read@0.6.7':
+    dependencies:
+      '@changesets/git': 3.0.4
+      '@changesets/logger': 0.1.1
+      '@changesets/parse': 0.4.3
+      '@changesets/types': 6.1.0
+      fs-extra: 7.0.1
+      p-filter: 2.1.0
+      picocolors: 1.1.1
+
+  '@changesets/should-skip-package@0.1.2':
+    dependencies:
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+
+  '@changesets/types@4.1.0': {}
+
+  '@changesets/types@6.1.0': {}
+
+  '@changesets/write@0.4.0':
+    dependencies:
+      '@changesets/types': 6.1.0
+      fs-extra: 7.0.1
+      human-id: 4.1.3
+      prettier: 2.8.8
+
+  '@inquirer/external-editor@1.0.3(@types/node@25.8.0)':
+    dependencies:
+      chardet: 2.1.1
+      iconv-lite: 0.7.2
+    optionalDependencies:
+      '@types/node': 25.8.0
+
+  '@manypkg/find-root@1.1.0':
+    dependencies:
+      '@babel/runtime': 7.29.2
+      '@types/node': 12.20.55
+      find-up: 4.1.0
+      fs-extra: 8.1.0
+
+  '@manypkg/get-packages@1.1.3':
+    dependencies:
+      '@babel/runtime': 7.29.2
+      '@changesets/types': 4.1.0
+      '@manypkg/find-root': 1.1.0
+      fs-extra: 8.1.0
+      globby: 11.1.0
+      read-yaml-file: 1.1.0
+
+  '@nodelib/fs.scandir@2.1.5':
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      run-parallel: 1.2.0
+
+  '@nodelib/fs.stat@2.0.5': {}
+
+  '@nodelib/fs.walk@1.2.8':
+    dependencies:
+      '@nodelib/fs.scandir': 2.1.5
+      fastq: 1.20.1
+
+  '@types/node@12.20.55': {}
+
+  '@types/node@25.8.0':
+    dependencies:
+      undici-types: 7.24.6

  '@types/xxhashjs@0.2.4':
    dependencies:
-      '@types/node': 25.6.2
+      '@types/node': 25.8.0

-  bun-types@1.3.13:
+  ansi-colors@4.1.3: {}
+
+  ansi-regex@5.0.1: {}
+
+  argparse@1.0.10:
    dependencies:
-      '@types/node': 25.6.2
+      sprintf-js: 1.0.3

-  undici-types@7.19.2: {}
+  argparse@2.0.1: {}
+
+  array-union@2.1.0: {}
+
+  better-path-resolve@1.0.0:
+    dependencies:
+      is-windows: 1.0.2
+
+  braces@3.0.3:
+    dependencies:
+      fill-range: 7.1.1
+
+  bun-types@1.3.14:
+    dependencies:
+      '@types/node': 25.8.0
+
+  chardet@2.1.1: {}
+
+  cross-spawn@7.0.6:
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+
+  detect-indent@6.1.0: {}
+
+  dir-glob@3.0.1:
+    dependencies:
+      path-type: 4.0.0
+
+  enquirer@2.4.1:
+    dependencies:
+      ansi-colors: 4.1.3
+      strip-ansi: 6.0.1
+
+  esprima@4.0.1: {}
+
+  extendable-error@0.1.7: {}
+
+  fast-glob@3.3.3:
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      '@nodelib/fs.walk': 1.2.8
+      glob-parent: 5.1.2
+      merge2: 1.4.1
+      micromatch: 4.0.8
+
+  fastq@1.20.1:
+    dependencies:
+      reusify: 1.1.0
+
+  fill-range@7.1.1:
+    dependencies:
+      to-regex-range: 5.0.1
+
+  find-up@4.1.0:
+    dependencies:
+      locate-path: 5.0.0
+      path-exists: 4.0.0
+
+  fs-extra@7.0.1:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+
+  fs-extra@8.1.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+
+  glob-parent@5.1.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  globby@11.1.0:
+    dependencies:
+      array-union: 2.1.0
+      dir-glob: 3.0.1
+      fast-glob: 3.3.3
+      ignore: 5.3.2
+      merge2: 1.4.1
+      slash: 3.0.0
+
+  graceful-fs@4.2.11: {}
+
+  human-id@4.1.3: {}
+
+  iconv-lite@0.7.2:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  ignore@5.3.2: {}
+
+  is-extglob@2.1.1: {}
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+
+  is-number@7.0.0: {}
+
+  is-subdir@1.2.0:
+    dependencies:
+      better-path-resolve: 1.0.0
+
+  is-windows@1.0.2: {}
+
+  isexe@2.0.0: {}
+
+  js-yaml@3.14.2:
+    dependencies:
+      argparse: 1.0.10
+      esprima: 4.0.1
+
+  js-yaml@4.1.1:
+    dependencies:
+      argparse: 2.0.1
+
+  jsonfile@4.0.0:
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
+  locate-path@5.0.0:
+    dependencies:
+      p-locate: 4.1.0
+
+  lodash.startcase@4.4.0: {}
+
+  merge2@1.4.1: {}
+
+  micromatch@4.0.8:
+    dependencies:
+      braces: 3.0.3
+      picomatch: 2.3.2
+
+  mri@1.2.0: {}
+
+  outdent@0.5.0: {}
+
+  p-filter@2.1.0:
+    dependencies:
+      p-map: 2.1.0
+
+  p-limit@2.3.0:
+    dependencies:
+      p-try: 2.2.0
+
+  p-locate@4.1.0:
+    dependencies:
+      p-limit: 2.3.0
+
+  p-map@2.1.0: {}
+
+  p-try@2.2.0: {}
+
+  package-manager-detector@0.2.11:
+    dependencies:
+      quansync: 0.2.11
+
+  path-exists@4.0.0: {}
+
+  path-key@3.1.1: {}
+
+  path-type@4.0.0: {}
+
+  picocolors@1.1.1: {}
+
+  picomatch@2.3.2: {}
+
+  pify@4.0.1: {}
+
+  prettier@2.8.8: {}
+
+  quansync@0.2.11: {}
+
+  queue-microtask@1.2.3: {}
+
+  read-yaml-file@1.1.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      js-yaml: 3.14.2
+      pify: 4.0.1
+      strip-bom: 3.0.0
+
+  resolve-from@5.0.0: {}
+
+  reusify@1.1.0: {}
+
+  run-parallel@1.2.0:
+    dependencies:
+      queue-microtask: 1.2.3
+
+  safer-buffer@2.1.2: {}
+
+  semver@7.8.0: {}
+
+  shebang-command@2.0.0:
+    dependencies:
+      shebang-regex: 3.0.0
+
+  shebang-regex@3.0.0: {}
+
+  signal-exit@4.1.0: {}
+
+  slash@3.0.0: {}
+
+  spawndamnit@3.0.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      signal-exit: 4.1.0
+
+  sprintf-js@1.0.3: {}
+
+  strip-ansi@6.0.1:
+    dependencies:
+      ansi-regex: 5.0.1
+
+  strip-bom@3.0.0: {}
+
+  term-size@2.2.1: {}
+
+  to-regex-range@5.0.1:
+    dependencies:
+      is-number: 7.0.0
+
+  undici-types@7.24.6: {}
+
+  universalify@0.1.2: {}
+
+  which@2.0.2:
+    dependencies:
+      isexe: 2.0.0
@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+// Mock agent for smoke testing
+import { createAgent } from "../packages/uwf-agent-kit/src/index.js";
+
+const agent = createAgent({
+  name: "mock",
+  run: async (ctx) => {
+    return `Mock output for role ${ctx.role}: task was "${ctx.prompt}"`;
+  },
+});
+
+await agent();
@@ -1,100 +0,0 @@
-/**
- * greet workflow — smoke test entry
- * Single role: greeter takes a prompt and returns a structured greeting.
- * 小橘 🍊
- */
-
-import type {
-  AdapterFn,
-  ModeratorTable,
-  RoleFn,
-  RoleResult,
-  ThreadContext,
-  WorkflowDefinition,
-  WorkflowRuntime,
-} from "@uncaged/workflow-runtime";
-import { createWorkflow, END, START } from "@uncaged/workflow-runtime";
-import * as z from "zod/v4";
-
-type GreetMeta = {
-  greeter: { greeting: string; language: string };
-};
-
-const greeterSchema = z.object({
-  greeting: z.string().describe("A friendly greeting message"),
-  language: z.string().describe("The language of the greeting"),
-});
-
-const roles: WorkflowDefinition<GreetMeta>["roles"] = {
-  greeter: {
-    description: "Generates a friendly greeting",
-    systemPrompt:
-      "You are a friendly greeter. Given a user prompt, produce a warm greeting. Respond in valid JSON with keys: greeting (string), language (string).",
-    schema: greeterSchema,
-  },
-};
-
-const table: ModeratorTable<GreetMeta> = {
-  [START]: [{ condition: "FALLBACK", role: "greeter" }],
-  greeter: [{ condition: "FALLBACK", role: END }],
-};
-
-export const descriptor = {
-  name: "greet",
-  description: "A simple greeting workflow for smoke testing",
-  graph: { [START]: ["greeter"], greeter: [END] },
-  roles: { greeter: { description: "Generates a friendly greeting" } },
-};
-
-function createLazyAdapter(): AdapterFn {
-  let cached: { baseUrl: string; apiKey: string; model: string } | null = null;
-  function getProvider() {
-    if (cached !== null) return cached;
-    const apiKey = process.env.DASHSCOPE_API_KEY;
-    if (!apiKey) throw new Error("missing env: DASHSCOPE_API_KEY");
-    cached = {
-      baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
-      apiKey,
-      model: process.env.WORKFLOW_MODEL ?? "qwen-plus",
-    };
-    return cached;
-  }
-
-  return (<T>(prompt: string, schema: z.ZodType<T>): RoleFn<T> => {
-    return async (ctx: ThreadContext, _runtime: WorkflowRuntime): Promise<RoleResult<T>> => {
-      const provider = getProvider();
-      const response = await fetch(`${provider.baseUrl}/chat/completions`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${provider.apiKey}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          model: provider.model,
-          messages: [
-            { role: "system", content: prompt },
-            {
-              role: "user",
-              content: `${ctx.start.content}\n\nRespond with JSON: ${JSON.stringify(z.toJSONSchema(schema))}`,
-            },
-          ],
-          response_format: { type: "json_object" },
-        }),
-      });
-      if (!response.ok) {
-        const body = await response.text();
-        throw new Error(`LLM error ${response.status}: ${body.slice(0, 500)}`);
-      }
-      const data = (await response.json()) as { choices: Array<{ message: { content: string } }> };
-      const text = data.choices[0]?.message?.content;
-      if (!text) throw new Error("Empty LLM response");
-      const parsed = schema.parse(JSON.parse(text));
-      return { meta: parsed, childThread: null };
-    };
-  }) as AdapterFn;
-}
-
-export const run = createWorkflow<GreetMeta>(
-  { roles, table },
-  { adapter: createLazyAdapter(), overrides: null },
-);
@@ -0,0 +1,59 @@
+name: "solve-issue"
+description: "End-to-end issue resolution"
+roles:
+  planner:
+    description: "Creates implementation plan"
+    systemPrompt: "You are a planning agent. Analyze the issue and create a step-by-step plan."
+    outputSchema:
+      type: object
+      properties:
+        plan:
+          type: string
+        steps:
+          type: array
+          items:
+            type: string
+      required: [plan, steps]
+  developer:
+    description: "Implements code changes"
+    systemPrompt: "You are a developer agent. Implement the plan."
+    outputSchema:
+      type: object
+      properties:
+        filesChanged:
+          type: array
+          items:
+            type: string
+        summary:
+          type: string
+      required: [filesChanged, summary]
+  reviewer:
+    description: "Reviews code changes"
+    systemPrompt: "You are a code reviewer. Review the implementation."
+    outputSchema:
+      type: object
+      properties:
+        approved:
+          type: boolean
+        comments:
+          type: string
+      required: [approved, comments]
+conditions:
+  notApproved:
+    description: "Reviewer rejected the implementation"
+    expression: "steps[-1].output.approved = false"
+graph:
+  $START:
+    - role: "planner"
+      condition: null
+  planner:
+    - role: "developer"
+      condition: null
+  developer:
+    - role: "reviewer"
+      condition: null
+  reviewer:
+    - role: "developer"
+      condition: "notApproved"
+    - role: "$END"
+      condition: null
@@ -32,6 +32,11 @@
    { "path": "packages/workflow-agent-react" },
    { "path": "packages/cli-workflow" },
    { "path": "packages/workflow-template-solve-issue" },
-    { "path": "packages/workflow-template-develop" }
+    { "path": "packages/workflow-template-develop" },
+    { "path": "packages/uwf-protocol" },
+    { "path": "packages/uwf-moderator" },
+    { "path": "packages/cli-uwf" },
+    { "path": "packages/uwf-agent-kit" },
+    { "path": "packages/uwf-agent-hermes" }
  ]
 }
Author	SHA1	Message	Date
xiaoju	5643a06a39	refactor: remove table output format, keep json and yaml only Table format adds complexity without readability gain over yaml. Refs #328	2026-05-18 13:56:53 +00:00
xiaoju	36d120b745	fix: table format — horizontal for arrays, vertical for objects Arrays: horizontal table with HEADER row Objects: vertical KEY/VALUE table Primitives: fall back to yaml 小橘 🍊（NEKO Team）	2026-05-18 13:43:50 +00:00
xiaomo	bb0f2ca678	Merge pull request 'feat: --format json/yaml/table for all non-interactive commands' (#329 ) from feat/328-format-option into main	2026-05-18 13:40:19 +00:00
xiaoju	7dd6ab5328	feat: --format json/yaml/table for all non-interactive commands Add program-level --format option (default: json) inherited by all subcommands. json output unchanged, yaml via yaml package, table renders aligned columns for arrays, falls back to yaml for objects. Closes #328 小橘 🍊（NEKO Team）	2026-05-18 13:33:41 +00:00
xiaomo	7c955fa749	Merge pull request 'fix: uwf cas — JSON output + meta-schema in schema list' (#326 ) from fix/319-cas-json-output into main	2026-05-18 13:25:16 +00:00
xiaoju	c4c9f96117	fix: uwf cas commands output JSON, include meta-schema in schema list All cas subcommands now output JSON via writeJson(), consistent with other uwf commands. schema list includes meta-schema. Removed --json flag and --format tree (tree is human-only, not machine-friendly). Refs #319 小橘 🍊（NEKO Team）	2026-05-18 13:24:19 +00:00
xiaomo	633d5aeafe	Merge pull request 'refactor: outputSchema only accepts inline JSON Schema' (#325 ) from fix/319-validate-schema-only-inline into main	2026-05-18 13:18:17 +00:00
xiaoju	17103c1ee1	refactor: outputSchema only accepts inline JSON Schema - Remove CAS ref string support from workflow YAML outputSchema - Simplify validate.ts: no string check for outputSchema - Auto-set title from role name (workflow.role format) Refs #319 小橘 🍊（NEKO Team）	2026-05-18 13:17:29 +00:00
xiaomo	c8a39be9bd	Merge pull request 'fix: remove cas list, add schema titles' (#324 ) from fix/319-schema-titles into main	2026-05-18 13:07:15 +00:00
xiaoju	b304f65876	feat: auto-set outputSchema title from role name When uwf workflow put processes inline JSON Schema for a role, auto-inject title=roleName if not already set. Makes uwf cas schema list show meaningful names like 'planner', 'coder' instead of (unnamed). 小橘 🍊（NEKO Team）	2026-05-18 13:05:28 +00:00
xiaoju	c9010a024f	fix: remove cas list, add title to schemas - Remove uwf cas list (CAS grows unbounded, listing all hashes is useless) - Add title to Workflow/StartNode/StepNode schemas so schema list shows names 小橘 🍊（NEKO Team）	2026-05-18 13:01:17 +00:00
xiaomo	3434e2b2be	Merge pull request 'feat: built-in uwf cas commands replacing json-cas passthrough' (#323 ) from feat/319-uwf-cas-builtin into main	2026-05-18 12:49:18 +00:00
xiaoju	52282e1960	feat: built-in uwf cas commands replacing json-cas passthrough - get, cat, put, has, list, refs, walk, schema list, schema get - All commands auto-resolve store to ~/.uncaged/workflow/cas - No external json-cas CLI dependency needed - Agent-friendly: uwf cas --help shows all available subcommands Refs #319, Closes #320 小橘 🍊（NEKO Team）	2026-05-18 12:40:15 +00:00
Scott Wei	7a579ee67a	feat: uwf cas — passthrough to json-cas with uwf store path uwf cas get <hash>, uwf cas list, etc. all auto-set --store to ~/.uncaged/workflow/cas so agents don't need to remember the path. 小橘 🍊（NEKO Team）	2026-05-18 20:14:59 +08:00
Scott Wei	7c230383ad	improve: multi-column model list + friendly post-setup message - Model list now renders in columns to fit terminal width - Interactive setup ends with usage hints instead of JSON dump 小橘 🍊（NEKO Team）	2026-05-18 19:56:09 +08:00
xiaoju	e604fa5f47	feat: add uwf setup command - Interactive mode: prompts for provider, API key, model (with /models discovery) - Non-interactive mode: --provider --base-url --api-key --model flags - Writes config.yaml (providers, models, agents, defaults) - Writes .env (API keys with auto-generated env var names) - Merges into existing config non-destructively - Includes 13 preset providers (international + China + local) 小橘 🍊（NEKO Team）	2026-05-18 11:49:42 +00:00
xiaoju	5580791686	chore: remove stale develop-entry.ts	2026-05-18 11:43:09 +00:00
xiaoju	3afd7a5319	chore: remove leftover smoke test files	2026-05-18 11:41:49 +00:00
xiaoju	3d1b2268b4	chore: bump json-cas deps to ^0.1.3	2026-05-18 10:48:06 +00:00
xiaoju	8bebe9da0f	chore: bump json-cas-fs to ^0.1.2 (fix workspace:^ in published pkg)	2026-05-18 10:44:30 +00:00
xiaoju	53a7355f0b	chore: fix json-cas workspace:^ refs to ^0.1.1	2026-05-18 10:30:31 +00:00
xiaoju	d99c285725	chore: remove cross-repo json-cas workspace deps from root	2026-05-18 10:28:22 +00:00
xiaoju	2505dd8d6a	chore: remove stale pnpm-lock.yaml	2026-05-18 10:25:45 +00:00
xiaomo	1121dfa48b	Merge pull request 'feat: uwf — Stateless Workflow CLI' (#317 ) from feat/309-uwf-stateless into main	2026-05-18 10:07:55 +00:00
xiaoju	d90e29ad05	fix: address 3 critical PR review issues 1. threads.yaml race condition: reload threads index after agent subprocess completes before updating head pointer (cli-uwf/commands/thread.ts) 2. evaluateJsonata not awaited: jsonata evaluate() returns Promise for async expressions — now properly awaited (uwf-moderator/evaluate.ts) 3. resolveWorkflowHash dead code: function always returns a value, removed impossible null return type and dead null-check branches at call sites (cli-uwf/store.ts, commands/thread.ts, commands/workflow.ts)	2026-05-18 10:05:11 +00:00
xiaoju	0727e0e8d5	fix: reload CAS store after agent spawn + share schemas via uwf-protocol The agent subprocess writes StepNode to CAS on disk, but the parent process had an in-memory cache from createFsStore init. Fix: re-create store after agent spawn to pick up new nodes. Also centralized JSON Schemas in uwf-protocol so cli-uwf and agent-kit produce identical type hashes. E2E smoke test passing: workflow put → thread start → 3x step → done Refs #309	2026-05-18 09:33:52 +00:00
xiaoju	ba012d98bc	feat: add @uncaged/uwf-agent-hermes — Hermes agent CLI adapter Spawns 'hermes chat' with assembled prompt from agent-kit context. Agent-kit handles extract, StepNode write, and stdout output. Refs #309, #316	2026-05-18 09:22:12 +00:00
xiaoju	b165049a13	feat: implement thread step — moderator → agent → update head - Walk CAS chain to build ModeratorContext with expanded output - Call uwf-moderator evaluate() for role decision - Agent resolution: --agent > config overrides > default - Spawn agent CLI, capture StepNode hash - Update threads.yaml, check done via second evaluate - Archive on $END Refs #309, #315	2026-05-18 09:19:37 +00:00
xiaoju	4d477c67c0	feat: add @uncaged/uwf-agent-kit — agent CLI framework - createAgent() API for building agent CLIs - Context builder: reads CAS chain, builds AgentContext - Extract: LLM-based structured output extraction - StepNode writer: writes to CAS without touching threads.yaml - Stdout: outputs StepNode hash Refs #309, #314	2026-05-18 09:15:25 +00:00
xiaoju	0d5678c961	feat: add thread start/show/list/kill commands - thread start: ULID generation, StartNode to CAS, threads.yaml - thread show: active (done:false) or archived (done:true) - thread list: active threads, --all includes history - thread kill: archive to history.jsonl Refs #309, #313	2026-05-18 09:09:10 +00:00
xiaoju	a8e2aa85f8	feat: add @uncaged/cli-uwf with workflow put/show/list commands Refs #309, #312	2026-05-18 09:03:55 +00:00
xiaoju	2a4d35399b	feat: add @uncaged/uwf-moderator with JSONata evaluation engine 5 tests passing: transition, condition match, fallback, missing role error, output expansion. Refs #309, #311	2026-05-18 08:58:21 +00:00
xiaoju	391915411e	feat: add @uncaged/uwf-protocol with all shared types Refs #309, #310	2026-05-18 08:53:37 +00:00
scottwei	4aaf49bfc6	Merge pull request 'jshang/optimize-dashboard-ui' (#308 ) from jshang/optimize-dashboard-ui into main Reviewed-on: #308	2026-05-18 08:45:46 +00:00
xiaoju	08de1ae5eb	docs: fresh uwf-* packages, depend on @uncaged/json-cas, no reuse	2026-05-18 08:44:04 +00:00
xiaoju	c91a3d1ec6	docs: add description to condition definitions	2026-05-18 08:41:29 +00:00
xiaoju	13d932f69c	docs: config with provider/model/agent registries and alias-based overrides	2026-05-18 08:38:08 +00:00
jiashuang	f705d9b8ea	refactor: optimize ui for dashboard	2026-05-18 16:20:05 +08:00
xiaoju	f84d327410	docs: add .env for API keys, separate from config.yaml	2026-05-18 08:19:48 +00:00
xiaoju	9c2f93629b	docs: add models config (default + extract LLM)	2026-05-18 08:16:03 +00:00
xiaoju	bcefcb9af7	docs: add section 4 — key data types with shared StepRecord	2026-05-18 08:13:18 +00:00
xiaoju	b14dce2bc6	docs: fix inconsistencies — title, terminology, threads.yaml, JSONata context	2026-05-18 08:09:40 +00:00
xiaoju	85c572e770	docs: inline roles/moderator into Workflow, output as cas_ref, detail polymorphic	2026-05-18 08:07:20 +00:00
xiaoju	9a89885ce6	docs: rewrite CAS structure — flatten refs, named conditions, config.yaml, output naming	2026-05-18 07:55:04 +00:00
xiaoju	d095ceaafa	docs: agent CLI takes thread-id + role, outputs CAS hash, step owns pointer	2026-05-18 07:24:14 +00:00
xiaoju	2a0346f48b	docs: simplify show to pure thread-id → head query, all output JSON	2026-05-18 07:18:29 +00:00
xiaoju	b4e25ea002	docs: add done field to step output	2026-05-18 07:12:38 +00:00
xiaoju	77f2060e6b	docs: step on ended thread is an error, not null head	2026-05-18 07:11:50 +00:00
xiaoju	8f9a925179	docs: simplify step output to workflow/thread/head	2026-05-18 07:10:11 +00:00
jiashuang	2f3fff3536	refactor: introduce react-router	2026-05-18 15:06:16 +08:00
xiaoju	a7eb9814ae	docs: fix agent invocation format in thread step	2026-05-18 07:05:35 +00:00
xiaoju	a8024e6d42	docs: use full 26-char Crockford Base32 ULIDs for thread IDs	2026-05-18 07:03:40 +00:00
xiaoju	6d94d9c85a	docs: fix hash format to 13-char Crockford Base32 (XXH64)	2026-05-18 07:03:02 +00:00
xiaoju	49a4d08c04	docs: add thread list --all and thread kill	2026-05-18 06:59:47 +00:00
xiaoju	d5773369af	docs: uwf thread subcommands, simplify start output	2026-05-18 06:58:35 +00:00
xiaoju	f49e014f41	docs: update CLI design — uwf naming, simplify commands and agent protocol	2026-05-18 06:56:55 +00:00
xiaoju	ab48a8169d	docs: add stateless workflow CLI design Refs #297	2026-05-18 06:37:25 +00:00
				`@@ -0,0 +1 @@`
				`export { buildHermesPrompt, createHermesAgent } from "./hermes.js";`
				`@@ -0,0 +1 @@`
				`export type Result<T, E> = { ok: true; value: T } \| { ok: false; error: E };`