fix: add workspace path sandboxing and UWF_BUILTIN_ALLOW_SHELL check

- Add resolvePathInWorkspace() to reject paths escaping workspace root
- Apply sandboxing to read_file, write_file, and run_command tools
- Gate run_command behind UWF_BUILTIN_ALLOW_SHELL=1 env var
- Add tests for resolvePathInWorkspace escape detection

.workflows/solve-issue.yaml

@@ -41,8 +41,7 @@ roles:
       Before starting any work, ensure a clean worktree:
       1. `git checkout main && git pull` to get the latest code
       2. `git checkout -b fix/<issue-number>-<short-description>` to create a fresh branch
-         - If bounced back from reviewer or tester, reuse the existing branch and rebase onto latest main:
-           `git checkout main && git pull && git checkout <branch> && git rebase main`
+         - If bounced back from reviewer or tester, reuse the existing branch instead
 
       Then implement TDD:
       3. Read the test spec from CAS: `uwf cas get <plan hash>` (find the hash from the latest planner step's frontmatter.plan)

biome.json

@@ -17,15 +17,6 @@
     "indentWidth": 2,
     "lineWidth": 100
   },
-  "css": {
-    "parser": {
-      "cssModules": true,
-      "tailwindDirectives": true
-    },
-    "linter": {
-      "enabled": false
-    }
-  },
   "javascript": {
     "formatter": {
       "quoteStyle": "double",

docs/investigations/issue-418-acp-resume.md

@@ -1,73 +0,0 @@
-# Issue #418: ACP session/resume 返回空文本
-
-## 调研日期: 2026-05-23
-
-## 根因
-
-`session/resume` 在 restore 路径下 `_make_agent()` 失败，异常被静默吞掉。
-
-### 完整调用链
-
-```
-resume_session(sid)
-  → update_cwd(sid)
-    → get_session(sid) → _restore(sid)
-      → _make_agent()
-        → resolve_runtime_provider("custom") 失败（line 548-561）
-        → AIAgent() 抛出 "No LLM provider configured"（line 564）
-      → except Exception 静默吞掉（line 482-484）→ return None
-    → return None
-  → state is None → fallback: create_session()（新 sid，无历史）
-```
-
-### 关键代码位置（acp_adapter/session.py）
-
-- `_restore()` line 426-498: 从 DB 恢复 session，但 except 太宽泛
-- `_make_agent()` line 520-568: provider 解析在 restore 路径下不完整
-- Line 548-561: `resolve_runtime_provider("custom")` 失败后，`base_url` 虽然从 DB 取到了但没传给 AIAgent
-
-### 实测行为
-
-1. Phase 1: `session/new` + `prompt` → 正常，有 `agent_message_chunk`
-2. Phase 2: `session/resume` + `prompt`
-   - resume 返回成功，但 `available_commands_update` 里 sessionId 是新的（create_session fallback）
-   - 用原始 sid 发 prompt → `stopReason: "refusal"`（session 不在内存中）
-   - 用新 sid 发 prompt → 能跑但无历史（agent 回答"不知道 secret code"）
-
-### 验证脚本
-
-```python
-# 直接调用 _restore 验证
-cd ~/.hermes/hermes-agent
-python3 -c "
-import sys; sys.path.insert(0, '.')
-from acp_adapter.session import SessionManager
-sm = SessionManager()
-result = sm._restore('SESSION_ID_HERE')
-print(result)  # None — _make_agent 抛异常被吞掉
-"
-```
-
-### 两个 bug
-
-1. **`_make_agent` provider fallback 不完整**: restore 时 DB 里有 `base_url` 和 `api_mode`，但 `resolve_runtime_provider` 失败后这些值没被正确传递给 AIAgent
-2. **`_restore` 的 except 太宽泛**: 静默吞掉所有异常，连 warning 都只在 debug 级别，导致 resume 失败完全无感知
-
-### Hermes 版本
-
-- v0.10.0 (2026.4.16) — 初始测试
-- v0.14.0 (2026.5.16) — 更新后重新测试，bug 仍在
-- 代码路径: ~/.hermes/hermes-agent/acp_adapter/session.py
-
-### v0.14.0 测试结果 (2026-05-23)
-
-- `_restore` 仍因 `custom` provider 解析失败返回 None
-- 日志更清晰了：`WARNING: Failed to recreate agent for ACP session ...`
-- resume fallback 创建新 session（新 sid），但 agent 居然能回答之前的问题（可能通过 memory/session search）
-- 核心问题不变：sessionId 变了，client 用旧 sid 发 prompt → refusal
-
-### 上游 Issue
-
-- https://github.com/NousResearch/hermes-agent/issues/13489 — 已评论根因分析
-- https://github.com/NousResearch/hermes-agent/issues/8083 — resume 静默创建新 session
-- https://github.com/NousResearch/hermes-agent/issues/18452 — _make_agent fallback 不完整

examples/debate.yaml

@@ -1,77 +0,0 @@
-name: "debate"
-description: "Structured debate between two sides. Tests cross-process session resume."
-roles:
-  against:
-    description: "Argues against the proposition"
-    goal: |
-      You are a skilled debater arguing AGAINST the proposition.
-      Be logical, cite evidence, and directly address your opponent's points.
-      Keep each argument concise (under 200 words).
-    capabilities:
-      - argumentation
-      - critical-thinking
-    procedure: |
-      1. If this is the opening, present your strongest argument against the proposition.
-      2. If responding to the other side, directly counter their points with evidence and logic.
-      3. If you find yourself genuinely convinced by the other side, you may concede.
-    output: |
-      Provide your argument in the frontmatter.
-      Set conceded to true ONLY if you are genuinely convinced and wish to stop debating.
-    frontmatter:
-      type: object
-      properties:
-        argument:
-          type: string
-        conceded:
-          type: boolean
-      required: [argument, conceded]
-  for:
-    description: "Argues for the proposition"
-    goal: |
-      You are a skilled debater arguing FOR the proposition.
-      Be logical, cite evidence, and directly address your opponent's points.
-      Keep each argument concise (under 200 words).
-    capabilities:
-      - argumentation
-      - critical-thinking
-    procedure: |
-      1. Read the opposing side's latest argument carefully.
-      2. Counter their points with evidence and logic.
-      3. If you find yourself genuinely convinced by the other side, you may concede.
-    output: |
-      Provide your argument in the frontmatter.
-      Set conceded to true ONLY if you are genuinely convinced and wish to stop debating.
-    frontmatter:
-      type: object
-      properties:
-        argument:
-          type: string
-        conceded:
-          type: boolean
-      required: [argument, conceded]
-conditions:
-  againstConceded:
-    description: "The against side conceded"
-    expression: "$last('against').conceded = true"
-  forConceded:
-    description: "The for side conceded"
-    expression: "$last('for').conceded = true"
-graph:
-  $START:
-    - role: "against"
-      condition: null
-      prompt: "Present your opening argument against the proposition."
-  against:
-    - role: "$END"
-      condition: "againstConceded"
-      prompt: "The against side conceded. Debate over."
-    - role: "for"
-      condition: null
-      prompt: "Counter the opposing argument. Address their points directly."
-  for:
-    - role: "$END"
-      condition: "forConceded"
-      prompt: "The for side conceded. Debate over."
-    - role: "against"
-      condition: null
-      prompt: "Counter the opposing argument. Address their points directly."

examples/solve-issue.yaml

@@ -3,35 +3,22 @@ description: "End-to-end issue resolution"
 roles:
   planner:
     description: "Creates implementation plan"
-    goal: "You are a planning agent. You analyze issues and create implementation plans grounded in the actual codebase."
+    goal: "You are a planning agent. You analyze issues and create step-by-step plans."
     capabilities:
       - issue-analysis
       - planning
-      - file-read
-      - shell
-    procedure: |
-      1. Locate the code repository:
-         - Check if the current working directory is the repo (look for package.json, .git, etc.)
-         - If the task mentions a repo URL, clone it first.
-         - If this is a new project, create the repo and note the path.
-      2. Explore the codebase — read the relevant source files mentioned in the issue. Understand the current architecture, types, and conventions (check CLAUDE.md, CONTRIBUTING.md, .cursor/rules/).
-      3. Identify which files need changes and what the changes should be, with specific code references.
-      4. Output the plan with:
-         - `repoPath`: absolute path to the repository root
-         - `plan`: detailed implementation plan with file paths and code references
-         - `steps`: concrete action items for the developer
-    output: |
-      Provide repoPath, plan summary, and steps in the frontmatter.
-      The plan MUST reference actual file paths and code structures you found by reading the source.
-      Do NOT guess — if you haven't read a file, read it before referencing it.
+    procedure: "Analyze the issue and create a detailed, actionable implementation plan."
+    output: "Output the plan summary and list of concrete steps."
     frontmatter:
       type: object
       properties:
-        repoPath:
-          type: string
         plan:
           type: string
-      required: [repoPath, plan]
+        steps:
+          type: array
+          items:
+            type: string
+      required: [plan, steps]
   developer:
     description: "Implements code changes"
     goal: "You are a developer agent. You implement code changes according to plans."
@@ -39,12 +26,7 @@ roles:
       - file-edit
       - shell
       - testing
-    procedure: |
-      1. Read the planner's output to get the repoPath and implementation plan.
-      2. cd to the repoPath before making any changes.
-      3. Create a feature branch from the default branch.
-      4. Implement the plan — write code, tests, and ensure existing tests pass.
-      5. Commit your changes with a descriptive message referencing the issue.
+    procedure: "Implement the plan. Write code, tests, and ensure existing tests pass."
     output: "List all files changed and provide a summary of the implementation."
     frontmatter:
       type: object

packages/cli-workflow/src/__tests__/log.test.ts

@@ -62,9 +62,9 @@ const olderEntry = JSON.stringify({
 
 async function writeLogFiles(): Promise<void> {
   const logsDir = join(storageRoot, "logs");
-  await writeFile(join(logsDir, "2026-05-20.jsonl"), `${[entry1, entry2, entry3].join("\n")}\n`);
-  await writeFile(join(logsDir, "2026-05-19.jsonl"), `${oldEntry}\n`);
-  await writeFile(join(logsDir, "2026-05-18.jsonl"), `${olderEntry}\n`);
+  await writeFile(join(logsDir, "2026-05-20.jsonl"), [entry1, entry2, entry3].join("\n") + "\n");
+  await writeFile(join(logsDir, "2026-05-19.jsonl"), oldEntry + "\n");
+  await writeFile(join(logsDir, "2026-05-18.jsonl"), olderEntry + "\n");
 }
 
 describe("cmdLogList", () => {

packages/cli-workflow/src/__tests__/workflow-resolution.test.ts

@@ -1,367 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createFsStore } from "@uncaged/json-cas-fs";
-import type { CasRef, WorkflowPayload } from "@uncaged/workflow-protocol";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { stringify } from "yaml";
-import { cmdThreadStart } from "../commands/thread.js";
-import { registerUwfSchemas } from "../schemas.js";
-import type { UwfStore } from "../store.js";
-import { loadWorkflowRegistry, saveWorkflowRegistry } from "../store.js";
-
-// ── helpers ───────────────────────────────────────────────────────────────────
-
-async function makeUwfStore(storageRoot: string): Promise<UwfStore> {
-  const casDir = join(storageRoot, "cas");
-  await mkdir(casDir, { recursive: true });
-  const store = createFsStore(casDir);
-  const schemas = await registerUwfSchemas(store);
-  return { storageRoot, store, schemas };
-}
-
-async function storeWorkflow(uwf: UwfStore, name: string): Promise<CasRef> {
-  const payload: WorkflowPayload = {
-    name,
-    description: "Test workflow",
-    roles: {},
-    conditions: {},
-    graph: {},
-  };
-  return await uwf.store.put(uwf.schemas.workflow, payload);
-}
-
-async function createWorkflowYaml(name: string, version: string | null = null): Promise<string> {
-  const payload: WorkflowPayload = {
-    name,
-    description: version !== null ? `Test workflow (${version})` : "Test workflow",
-    roles: {},
-    conditions: {},
-    graph: {},
-  };
-  const yaml = stringify(payload);
-  return yaml;
-}
-
-// ── fixture ───────────────────────────────────────────────────────────────────
-
-let tmpDir: string;
-let storageRoot: string;
-let projectRoot: string;
-
-beforeEach(async () => {
-  tmpDir = await mkdtemp(join(tmpdir(), "cli-uwf-wf-resolve-test-"));
-  storageRoot = join(tmpDir, "storage");
-  projectRoot = join(tmpDir, "project");
-  await mkdir(storageRoot, { recursive: true });
-  await mkdir(projectRoot, { recursive: true });
-});
-
-afterEach(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-// ── Strategy 1: CAS Hash Resolution ───────────────────────────────────────────
-
-describe("Strategy 1: CAS Hash Resolution", () => {
-  test("should resolve valid 13-char Crockford Base32 hash", async () => {
-    const uwf = await makeUwfStore(storageRoot);
-    const hash = await storeWorkflow(uwf, "test-workflow");
-
-    const result = await cmdThreadStart(storageRoot, hash, "test prompt", projectRoot);
-
-    expect(result.workflow).toBe(hash);
-    expect(result.thread).toMatch(/^[0-9A-HJKMNP-TV-Z]{26}$/);
-  });
-
-  test("should fail on invalid hash format (non-Crockford characters)", async () => {
-    await makeUwfStore(storageRoot);
-
-    await expect(
-      cmdThreadStart(storageRoot, "123456789ABCD", "prompt", projectRoot),
-    ).rejects.toThrow();
-  });
-
-  test("should fail on valid-format hash not present in CAS", async () => {
-    await makeUwfStore(storageRoot);
-    const fakeHash = "0000000000000"; // valid format, doesn't exist
-
-    await expect(cmdThreadStart(storageRoot, fakeHash, "prompt", projectRoot)).rejects.toThrow();
-  });
-
-  test("should reject 40-char hex hash (legacy format not supported)", async () => {
-    await makeUwfStore(storageRoot);
-    const hexHash = "a".repeat(40);
-
-    await expect(cmdThreadStart(storageRoot, hexHash, "prompt", projectRoot)).rejects.toThrow();
-  });
-});
-
-// ── Strategy 2: File Path Resolution ──────────────────────────────────────────
-
-describe("Strategy 2: File Path Resolution", () => {
-  test("should load workflow from absolute file path", async () => {
-    await makeUwfStore(storageRoot);
-    const yamlPath = join(tmpDir, "test-workflow.yaml");
-    await writeFile(yamlPath, await createWorkflowYaml("test-workflow"));
-
-    const result = await cmdThreadStart(storageRoot, yamlPath, "prompt", projectRoot);
-
-    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
-    const uwf = await makeUwfStore(storageRoot);
-    const node = uwf.store.get(result.workflow);
-    expect(node).not.toBeNull();
-    if (node !== null) {
-      expect((node.payload as WorkflowPayload).name).toBe("test-workflow");
-    }
-  });
-
-  test("should load workflow from relative file path", async () => {
-    await makeUwfStore(storageRoot);
-    const yamlPath = "test-workflow.yaml";
-    await writeFile(join(projectRoot, yamlPath), await createWorkflowYaml("test-workflow"));
-
-    const result = await cmdThreadStart(storageRoot, yamlPath, "prompt", projectRoot);
-
-    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
-  });
-
-  test("should fail when file path does not exist", async () => {
-    await makeUwfStore(storageRoot);
-
-    await expect(
-      cmdThreadStart(storageRoot, "./nonexistent.yaml", "prompt", projectRoot),
-    ).rejects.toThrow();
-  });
-
-  test("should fail on invalid YAML syntax in file", async () => {
-    await makeUwfStore(storageRoot);
-    const yamlPath = join(tmpDir, "bad-syntax.yaml");
-    await writeFile(yamlPath, "invalid: yaml: : :");
-
-    await expect(cmdThreadStart(storageRoot, yamlPath, "prompt", projectRoot)).rejects.toThrow();
-  });
-
-  test("should fail on valid YAML with invalid WorkflowPayload shape", async () => {
-    await makeUwfStore(storageRoot);
-    const yamlPath = join(tmpDir, "invalid-workflow.yaml");
-    await writeFile(yamlPath, "name: test\n# missing roles, conditions, and graph");
-
-    await expect(cmdThreadStart(storageRoot, yamlPath, "prompt", projectRoot)).rejects.toThrow();
-  });
-
-  test("should enforce filename matches workflow name", async () => {
-    await makeUwfStore(storageRoot);
-    const yamlPath = join(tmpDir, "solve-issue.yaml");
-    await writeFile(yamlPath, await createWorkflowYaml("wrong-name"));
-
-    await expect(cmdThreadStart(storageRoot, yamlPath, "prompt", projectRoot)).rejects.toThrow();
-  });
-});
-
-// ── Strategy 3: Local Discovery (Parent Traversal) ────────────────────────────
-
-describe("Strategy 3: Local Discovery", () => {
-  test("should find workflow in current directory .workflow/", async () => {
-    await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow");
-    await mkdir(workflowDir, { recursive: true });
-    await writeFile(join(workflowDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
-
-    const result = await cmdThreadStart(storageRoot, "solve-issue", "prompt", projectRoot);
-
-    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
-    const uwf = await makeUwfStore(storageRoot);
-    const node = uwf.store.get(result.workflow);
-    expect(node).not.toBeNull();
-    if (node !== null) {
-      expect((node.payload as WorkflowPayload).name).toBe("solve-issue");
-    }
-  });
-
-  test("should find workflow in parent directory .workflow/", async () => {
-    await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow");
-    await mkdir(workflowDir, { recursive: true });
-    await writeFile(join(workflowDir, "solve-issue.yaml"), await createWorkflowYaml("solve-issue"));
-
-    const subdir = join(projectRoot, "packages", "cli-workflow", "src");
-    await mkdir(subdir, { recursive: true });
-
-    const result = await cmdThreadStart(storageRoot, "solve-issue", "prompt", subdir);
-
-    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
-  });
-
-  test("should stop at filesystem root when traversing", async () => {
-    await makeUwfStore(storageRoot);
-    const deepPath = join(tmpDir, "deep", "path", "that", "does", "not", "have", "workflow");
-    await mkdir(deepPath, { recursive: true });
-
-    await expect(cmdThreadStart(storageRoot, "nonexistent", "prompt", deepPath)).rejects.toThrow();
-  });
-
-  test("should prefer .workflow/ over .workflows/ directory", async () => {
-    await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow");
-    const workflowsDir = join(projectRoot, ".workflows");
-    await mkdir(workflowDir, { recursive: true });
-    await mkdir(workflowsDir, { recursive: true });
-
-    await writeFile(
-      join(workflowDir, "solve-issue.yaml"),
-      await createWorkflowYaml("solve-issue", "1"),
-    );
-    await writeFile(
-      join(workflowsDir, "solve-issue.yaml"),
-      await createWorkflowYaml("solve-issue", "2"),
-    );
-
-    const result = await cmdThreadStart(storageRoot, "solve-issue", "prompt", projectRoot);
-
-    const uwf = await makeUwfStore(storageRoot);
-    const node = uwf.store.get(result.workflow);
-    expect(node).not.toBeNull();
-    if (node !== null) {
-      expect((node.payload as WorkflowPayload).description).toBe("Test workflow (1)");
-    }
-  });
-
-  test("should support .yml extension in local discovery", async () => {
-    await makeUwfStore(storageRoot);
-    const workflowDir = join(projectRoot, ".workflow");
-    await mkdir(workflowDir, { recursive: true });
-    await writeFile(join(workflowDir, "solve-issue.yml"), await createWorkflowYaml("solve-issue"));
-
-    const result = await cmdThreadStart(storageRoot, "solve-issue", "prompt", projectRoot);
-
-    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
-  });
-});
-
-// ── Strategy 4: Global Registry Fallback ──────────────────────────────────────
-
-describe("Strategy 4: Global Registry Resolution", () => {
-  test("should resolve workflow from global registry when not found locally", async () => {
-    const uwf = await makeUwfStore(storageRoot);
-    const hash = await storeWorkflow(uwf, "deploy-pipeline");
-    const registry = await loadWorkflowRegistry(storageRoot);
-    registry["deploy-pipeline"] = hash;
-    await saveWorkflowRegistry(storageRoot, registry);
-
-    const isolatedRoot = join(tmpDir, "isolated");
-    await mkdir(isolatedRoot, { recursive: true });
-
-    const result = await cmdThreadStart(storageRoot, "deploy-pipeline", "prompt", isolatedRoot);
-
-    expect(result.workflow).toBe(hash);
-  });
-
-  test("should fail when workflow not found in any strategy", async () => {
-    await makeUwfStore(storageRoot);
-
-    await expect(cmdThreadStart(storageRoot, "nonexistent", "prompt", tmpDir)).rejects.toThrow();
-  });
-});
-
-// ── Strategy Priority Order ───────────────────────────────────────────────────
-
-describe("Resolution Priority", () => {
-  test("should use explicit file path over local discovery", async () => {
-    await makeUwfStore(storageRoot);
-
-    // Setup: Create workflow in .workflow/ AND as explicit file
-    const workflowDir = join(projectRoot, ".workflow");
-    await mkdir(workflowDir, { recursive: true });
-    await writeFile(
-      join(workflowDir, "solve-issue.yaml"),
-      await createWorkflowYaml("solve-issue", "discovery"),
-    );
-
-    const explicitPath = join(projectRoot, "custom-solve-issue.yaml");
-    await writeFile(explicitPath, await createWorkflowYaml("custom-solve-issue", "explicit"));
-
-    // Execute with explicit path
-    const result = await cmdThreadStart(storageRoot, explicitPath, "prompt", projectRoot);
-
-    const uwf = await makeUwfStore(storageRoot);
-    const node = uwf.store.get(result.workflow);
-    expect(node).not.toBeNull();
-    if (node !== null) {
-      expect((node.payload as WorkflowPayload).description).toBe("Test workflow (explicit)");
-    }
-  });
-
-  test("should use local discovery over global registry", async () => {
-    const uwf = await makeUwfStore(storageRoot);
-
-    // Setup: Register globally
-    const globalHash = await storeWorkflow(uwf, "solve-issue");
-    const registry = await loadWorkflowRegistry(storageRoot);
-    registry["solve-issue"] = globalHash;
-    await saveWorkflowRegistry(storageRoot, registry);
-
-    // Setup: Create local .workflow/
-    const workflowDir = join(projectRoot, ".workflow");
-    await mkdir(workflowDir, { recursive: true });
-    const localYaml = await createWorkflowYaml("solve-issue", "local");
-    await writeFile(join(workflowDir, "solve-issue.yaml"), localYaml);
-
-    const result = await cmdThreadStart(storageRoot, "solve-issue", "prompt", projectRoot);
-
-    const uwf2 = await makeUwfStore(storageRoot);
-    const node = uwf2.store.get(result.workflow);
-    expect(node).not.toBeNull();
-    if (node !== null) {
-      expect((node.payload as WorkflowPayload).description).toBe("Test workflow (local)");
-    }
-  });
-});
-
-// ── Edge Cases ────────────────────────────────────────────────────────────────
-
-describe("Edge Cases", () => {
-  test("should treat '13-char-string.yaml' as file path, not CAS hash", async () => {
-    await makeUwfStore(storageRoot);
-    const fileName = "0123456789ABC.yaml"; // 13 chars + .yaml
-    await writeFile(join(projectRoot, fileName), await createWorkflowYaml("0123456789ABC"));
-
-    const result = await cmdThreadStart(storageRoot, fileName, "prompt", projectRoot);
-
-    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
-  });
-
-  test("should handle workflow names containing slashes as file paths", async () => {
-    await makeUwfStore(storageRoot);
-    const filePath = "subdir/solve-issue.yaml";
-    const fullPath = join(projectRoot, filePath);
-    await mkdir(join(projectRoot, "subdir"), { recursive: true });
-    await writeFile(fullPath, await createWorkflowYaml("solve-issue"));
-
-    const result = await cmdThreadStart(storageRoot, filePath, "prompt", projectRoot);
-
-    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
-  });
-
-  test("should handle absolute paths correctly", async () => {
-    await makeUwfStore(storageRoot);
-    const absPath = join(tmpDir, "abs-workflow.yaml");
-    await writeFile(absPath, await createWorkflowYaml("abs-workflow"));
-
-    const result = await cmdThreadStart(storageRoot, absPath, "prompt", projectRoot);
-
-    expect(result.workflow).toMatch(/^[0-9A-HJKMNP-TV-Z]{13}$/);
-  });
-
-  test("should fail on empty workflow ID", async () => {
-    await makeUwfStore(storageRoot);
-
-    await expect(cmdThreadStart(storageRoot, "", "prompt", projectRoot)).rejects.toThrow();
-  });
-
-  test("should fail on whitespace-only workflow ID", async () => {
-    await makeUwfStore(storageRoot);
-
-    await expect(cmdThreadStart(storageRoot, "   ", "prompt", projectRoot)).rejects.toThrow();
-  });
-});

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

@@ -137,72 +137,6 @@ function apiKeyEnvName(providerName: string): string {
   return `${providerName.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
 }
 
-/**
- * Discover uwf-* agent binaries in PATH.
- * Returns sorted list of binary names (e.g., ["uwf-hermes", "uwf-claude-code"]).
- */
-async function discoverAgents(): Promise<string[]> {
-  try {
-    // Use which -a to find all uwf-* binaries in PATH
-    const proc = Bun.spawn(["which", "-a", "uwf-hermes", "uwf-claude-code", "uwf-cursor"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    const text = await new Response(proc.stdout).text();
-    await proc.exited;
-
-    if (proc.exitCode !== 0) {
-      // Try alternative approach: search PATH directories manually
-      const pathEnv = process.env.PATH || "";
-      const pathDirs = pathEnv.split(":").filter((d) => d.length > 0);
-      const agents = new Set<string>();
-
-      for (const dir of pathDirs) {
-        try {
-          if (!existsSync(dir)) continue;
-          const { readdirSync, statSync } = await import("node:fs");
-          const entries = readdirSync(dir);
-
-          for (const entry of entries) {
-            if (!entry.startsWith("uwf-") || entry === "uwf") continue;
-            const fullPath = join(dir, entry);
-            try {
-              const stat = statSync(fullPath);
-              // Check if executable (owner, group, or other has execute bit)
-              if (stat.isFile() && (stat.mode & 0o111) !== 0) {
-                agents.add(entry);
-              }
-            } catch {
-              // Skip if can't stat
-            }
-          }
-        } catch {
-          // Skip inaccessible directories
-        }
-      }
-
-      return Array.from(agents).sort();
-    }
-
-    // Parse which output - each line is a path to a binary
-    const paths = text.trim().split("\n").filter((line) => line.length > 0);
-    const agents = new Set<string>();
-
-    for (const path of paths) {
-      const basename = path.split("/").pop();
-      if (basename && basename.startsWith("uwf-") && basename !== "uwf") {
-        agents.add(basename);
-      }
-    }
-
-    return Array.from(agents).sort();
-  } catch {
-    // If all fails, return empty array
-    return [];
-  }
-}
-
 /**
  * Merge setup args into config.yaml structure. Non-destructive — preserves existing entries.
  */

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

@@ -1,6 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { access, readFile } from "node:fs/promises";
-import { dirname, isAbsolute, resolve as resolvePath } from "node:path";
+import { readFile } from "node:fs/promises";
 import type { Store as CasStore, JSONSchema } from "@uncaged/json-cas";
 import { getSchema, validate } from "@uncaged/json-cas";
 import { getEnvPath, loadWorkflowConfig } from "@uncaged/workflow-agent-kit";
@@ -31,10 +30,12 @@ import { parse, stringify } from "yaml";
 import {
   appendThreadHistory,
   createUwfStore,
+  discoverProjectWorkflows,
   findThreadInHistory,
   loadThreadHistory,
   loadThreadsIndex,
   loadWorkflowRegistry,
+  resolveProjectWorkflowFile,
   resolveWorkflowHash,
   saveThreadsIndex,
   type ThreadHistoryLine,
@@ -81,83 +82,6 @@ function fail(message: string): never {
   process.exit(1);
 }
 
-/**
- * Check if a string looks like a file path (contains path separators or has .yaml/.yml extension).
- */
-function isFilePath(input: string): boolean {
-  return (
-    input.includes("/") || input.includes("\\") || input.endsWith(".yaml") || input.endsWith(".yml")
-  );
-}
-
-/**
- * Check if a workflow file exists at the given path.
- */
-async function workflowFileExists(dir: string, name: string, ext: string): Promise<string | null> {
-  const candidate = resolvePath(dir, `${name}${ext}`);
-  try {
-    await access(candidate);
-    return candidate;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Search for a workflow file in a given directory (checks both .workflow/ and .workflows/).
- */
-async function findWorkflowInDir(dir: string, name: string): Promise<string | null> {
-  // Check .workflow/ directory first (preferred)
-  for (const ext of [".yaml", ".yml"]) {
-    const result = await workflowFileExists(resolvePath(dir, ".workflow"), name, ext);
-    if (result !== null) {
-      return result;
-    }
-  }
-
-  // Check .workflows/ directory as fallback (legacy)
-  for (const ext of [".yaml", ".yml"]) {
-    const result = await workflowFileExists(resolvePath(dir, ".workflows"), name, ext);
-    if (result !== null) {
-      return result;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Traverse parent directories looking for `.workflow/<name>.yaml` or `.workflow/<name>.yml`.
- * Returns the absolute path if found, otherwise null.
- * Stops at filesystem root or .git directory.
- */
-async function findWorkflowInParents(startDir: string, name: string): Promise<string | null> {
-  let currentDir = resolvePath(startDir);
-  const root = resolvePath("/");
-
-  while (true) {
-    const found = await findWorkflowInDir(currentDir, name);
-    if (found !== null) {
-      return found;
-    }
-
-    // Stop at filesystem root
-    if (currentDir === root) {
-      break;
-    }
-
-    // Move to parent directory
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir) {
-      // Reached filesystem root
-      break;
-    }
-    currentDir = parentDir;
-  }
-
-  return null;
-}
-
 async function materializeLocalWorkflow(uwf: UwfStore, filePath: string): Promise<CasRef> {
   let text: string;
   try {
@@ -199,41 +123,18 @@ async function resolveWorkflowCasRef(
   workflowId: string,
   projectRoot: string,
 ): Promise<CasRef> {
-  // Validate input
-  const trimmed = workflowId.trim();
-  if (trimmed === "") {
-    fail("workflow ID cannot be empty");
+  // Project-local resolution: check .workflows/<workflowId>.yaml first
+  const localEntries = await discoverProjectWorkflows(projectRoot);
+  const localFile = resolveProjectWorkflowFile(localEntries, workflowId);
+  if (localFile !== null) {
+    return materializeLocalWorkflow(uwf, localFile);
   }
 
-  // Strategy 1: Direct CAS hash
-  if (isCasRef(trimmed)) {
-    const node = uwf.store.get(trimmed);
-    if (node === null) {
-      fail(`CAS node not found: ${trimmed}`);
-    }
-    if (node.type !== uwf.schemas.workflow) {
-      fail(`node ${trimmed} is not a Workflow (type ${node.type})`);
-    }
-    return trimmed;
-  }
-
-  // Strategy 2: Explicit file path (relative or absolute)
-  if (isFilePath(trimmed)) {
-    const absolutePath = isAbsolute(trimmed) ? trimmed : resolvePath(projectRoot, trimmed);
-    return materializeLocalWorkflow(uwf, absolutePath);
-  }
-
-  // Strategy 3: Local discovery (parent directory traversal)
-  const localPath = await findWorkflowInParents(projectRoot, trimmed);
-  if (localPath !== null) {
-    return materializeLocalWorkflow(uwf, localPath);
-  }
-
-  // Strategy 4: Global registry fallback
+  // Global registry fallback
   const registry = await loadWorkflowRegistry(storageRoot);
-  const hash = resolveWorkflowHash(registry, trimmed);
+  const hash = resolveWorkflowHash(registry, workflowId);
   if (!isCasRef(hash)) {
-    fail(`workflow not found: ${trimmed}`);
+    fail(`workflow not found: ${workflowId}`);
   }
   const node = uwf.store.get(hash);
   if (node === null) {
@@ -693,7 +594,6 @@ function buildModeratorContext(uwf: UwfStore, chain: ChainState): ModeratorConte
     output: expandOutput(uwf, step.output),
     detail: step.detail,
     agent: step.agent,
-    edgePrompt: step.edgePrompt ?? "",
   }));
   return { start: chain.start, steps };
 }
@@ -761,12 +661,11 @@ function spawnAgent(
       encoding: "utf8",
       env,
       stdio: ["ignore", "pipe", "pipe"],
-      maxBuffer: 50 * 1024 * 1024, // 50 MB — stream-json output can be large
     });
   } catch (e) {
-    const err = e as NodeJS.ErrnoException & { stderr?: Buffer | string | null };
+    const err = e as NodeJS.ErrnoException & { stderr?: Buffer | string };
     const stderr =
-      err.stderr == null
+      err.stderr === undefined
         ? ""
         : typeof err.stderr === "string"
           ? err.stderr

packages/workflow-agent-builtin/__tests__/path.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { resolve } from "node:path";
-import { resolvePath } from "../src/tools/path.js";
+import { resolvePath, resolvePathInWorkspace } from "../src/tools/path.js";
 
 describe("resolvePath", () => {
   test("resolves relative paths against cwd", () => {
@@ -19,3 +19,25 @@ describe("resolvePath", () => {
     expect(resolved).toBe(resolve("/workspace/project", "../other/file.ts"));
   });
 });
+
+describe("resolvePathInWorkspace", () => {
+  test("allows relative paths within workspace", () => {
+    const resolved = resolvePathInWorkspace("/workspace", "src/foo.ts");
+    expect(resolved).toBe(resolve("/workspace", "src/foo.ts"));
+  });
+
+  test("rejects path that escapes workspace root", () => {
+    const resolved = resolvePathInWorkspace("/workspace", "../etc/passwd");
+    expect(resolved).toBeNull();
+  });
+
+  test("rejects absolute path escape via double-dot", () => {
+    const resolved = resolvePathInWorkspace("/workspace/project", "../../outside");
+    expect(resolved).toBeNull();
+  });
+
+  test("allows deep nested path", () => {
+    const resolved = resolvePathInWorkspace("/workspace", "a/b/c/file.txt");
+    expect(resolved).toBe(resolve("/workspace", "a/b/c/file.txt"));
+  });
+});

packages/workflow-agent-builtin/__tests__/prompt.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import type { AgentContext } from "@uncaged/workflow-agent-kit";
 
-import { buildBuiltinMessages } from "../src/prompt.js";
+import { buildBuiltinPrompt } from "../src/prompt.js";
 
 function minimalContext(overrides: Partial<AgentContext> = {}): AgentContext {
   return {
@@ -11,13 +11,11 @@ function minimalContext(overrides: Partial<AgentContext> = {}): AgentContext {
     store: {} as AgentContext["store"],
     workflow: {
       name: "test",
-      description: "test workflow",
       roles: {
         developer: {
-          description: "Developer role",
           goal: "Ship the fix",
           capabilities: ["file-edit"],
-          procedure: "Edit files",
+          procedure: ["Edit files"],
           output: "A patch",
           frontmatter: "schema-hash",
         },
@@ -28,36 +26,22 @@ function minimalContext(overrides: Partial<AgentContext> = {}): AgentContext {
     start: { workflow: "wf-hash", prompt: "Fix the bug" },
     steps: [],
     outputFormatInstruction: "---\nstatus: done\n---",
-    edgePrompt: "Implement the fix described in the plan.",
-    isFirstVisit: true,
     ...overrides,
   };
 }
 
-describe("buildBuiltinMessages", () => {
-  test("system includes output format and role goal", () => {
-    const messages = buildBuiltinMessages(minimalContext());
-    const system = messages[0];
-    expect(system?.role).toBe("system");
-    if (system?.role === "system") {
-      expect(system.content).toContain("status: done");
-      expect(system.content).toContain("## Goal");
-      expect(system.content).toContain("Ship the fix");
-    }
+describe("buildBuiltinPrompt", () => {
+  test("includes output format, task, and role goal", () => {
+    const prompt = buildBuiltinPrompt(minimalContext());
+    expect(prompt).toContain("status: done");
+    expect(prompt).toContain("## Goal");
+    expect(prompt).toContain("Ship the fix");
+    expect(prompt).toContain("## Task");
+    expect(prompt).toContain("Fix the bug");
   });
 
-  test("first visit produces system + single user message with edge prompt", () => {
-    const messages = buildBuiltinMessages(minimalContext());
-    expect(messages).toHaveLength(2);
-    expect(messages[1]?.role).toBe("user");
-    if (messages[1]?.role === "user") {
-      expect(messages[1].content).toContain("Implement the fix");
-      expect(messages[1].content).not.toContain("## What Happened Since Your Last Turn");
-    }
-  });
-
-  test("first visit with prior steps includes inter-step summary in final user message", () => {
-    const messages = buildBuiltinMessages(
+  test("includes history when steps exist", () => {
+    const prompt = buildBuiltinPrompt(
       minimalContext({
         steps: [
           {
@@ -65,172 +49,11 @@ describe("buildBuiltinMessages", () => {
             output: { plan: "step 1" },
             agent: "uwf-builtin",
             detail: "detail-hash",
-            edgePrompt: "Create a plan.",
           },
         ],
       }),
     );
-    expect(messages).toHaveLength(2);
-    const finalUser = messages[1];
-    if (finalUser?.role === "user") {
-      expect(finalUser.content).toContain("Implement the fix");
-      expect(finalUser.content).toContain("## What Happened Since Your Last Turn");
-      expect(finalUser.content).toContain("planner");
-    }
-  });
-
-  test("re-entry reconstructs prior user/assistant turns plus current user message", () => {
-    const messages = buildBuiltinMessages(
-      minimalContext({
-        isFirstVisit: false,
-        edgePrompt: "Fix the reviewer's feedback.",
-        steps: [
-          {
-            role: "developer",
-            output: { summary: "Initial fix" },
-            agent: "uwf-builtin",
-            detail: "detail-1",
-            edgePrompt: "Implement the fix.",
-          },
-          {
-            role: "reviewer",
-            output: { approved: false, comments: "Missing tests" },
-            agent: "uwf-builtin",
-            detail: "detail-2",
-            edgePrompt: "Review the implementation.",
-          },
-        ],
-      }),
-    );
-
-    expect(messages).toHaveLength(4);
-    expect(messages[0]?.role).toBe("system");
-    expect(messages[1]?.role).toBe("user");
-    expect(messages[2]?.role).toBe("assistant");
-    expect(messages[3]?.role).toBe("user");
-
-    if (messages[1]?.role === "user") {
-      expect(messages[1].content).toBe("Implement the fix.");
-    }
-    if (messages[2]?.role === "assistant") {
-      expect(messages[2].content).toBe(JSON.stringify({ summary: "Initial fix" }));
-    }
-    if (messages[3]?.role === "user") {
-      expect(messages[3].content).toContain("Fix the reviewer's feedback.");
-      expect(messages[3].content).toContain("## What Happened Since Your Last Turn");
-      expect(messages[3].content).toContain("reviewer");
-      expect(messages[3].content).toContain("Missing tests");
-    }
-  });
-
-  test("prefix is stable across re-entry for LLM cache hits", () => {
-    const firstVisitMessages = buildBuiltinMessages(
-      minimalContext({
-        edgePrompt: "Implement the fix.",
-        steps: [],
-      }),
-    );
-
-    const reEntryMessages = buildBuiltinMessages(
-      minimalContext({
-        isFirstVisit: false,
-        edgePrompt: "Fix the reviewer's feedback.",
-        steps: [
-          {
-            role: "developer",
-            output: { summary: "Initial fix" },
-            agent: "uwf-builtin",
-            detail: "detail-1",
-            edgePrompt: "Implement the fix.",
-          },
-          {
-            role: "reviewer",
-            output: { approved: false },
-            agent: "uwf-builtin",
-            detail: "detail-2",
-            edgePrompt: "Review the code.",
-          },
-        ],
-      }),
-    );
-
-    expect(reEntryMessages[0]).toEqual(firstVisitMessages[0]);
-    expect(reEntryMessages[1]).toEqual(firstVisitMessages[1]);
-    expect(reEntryMessages[2]?.role).toBe("assistant");
-    if (reEntryMessages[2]?.role === "assistant") {
-      expect(reEntryMessages[2].content).toBe(JSON.stringify({ summary: "Initial fix" }));
-    }
-    expect(reEntryMessages[3]?.role).toBe("user");
-    if (reEntryMessages[3]?.role === "user") {
-      expect(reEntryMessages[3].content).toContain("Fix the reviewer's feedback.");
-    }
-  });
-
-  test("multiple prior visits emit one user/assistant pair per visit", () => {
-    const messages = buildBuiltinMessages(
-      minimalContext({
-        isFirstVisit: false,
-        edgePrompt: "Third round fix.",
-        steps: [
-          {
-            role: "developer",
-            output: { round: 1 },
-            agent: "uwf-builtin",
-            detail: "d1",
-            edgePrompt: "First attempt.",
-          },
-          {
-            role: "reviewer",
-            output: { approved: false },
-            agent: "uwf-builtin",
-            detail: "d2",
-            edgePrompt: "Review round 1.",
-          },
-          {
-            role: "developer",
-            output: { round: 2 },
-            agent: "uwf-builtin",
-            detail: "d3",
-            edgePrompt: "Second attempt.",
-          },
-          {
-            role: "reviewer",
-            output: { approved: false },
-            agent: "uwf-builtin",
-            detail: "d4",
-            edgePrompt: "Review round 2.",
-          },
-        ],
-      }),
-    );
-
-    expect(messages).toHaveLength(6);
-    expect(messages.map((m) => m.role)).toEqual([
-      "system",
-      "user",
-      "assistant",
-      "user",
-      "assistant",
-      "user",
-    ]);
-
-    if (messages[1]?.role === "user") {
-      expect(messages[1].content).toBe("First attempt.");
-    }
-    if (messages[2]?.role === "assistant") {
-      expect(messages[2].content).toBe(JSON.stringify({ round: 1 }));
-    }
-    if (messages[3]?.role === "user") {
-      expect(messages[3].content).toContain("Second attempt.");
-      expect(messages[3].content).toContain("reviewer");
-    }
-    if (messages[4]?.role === "assistant") {
-      expect(messages[4].content).toBe(JSON.stringify({ round: 2 }));
-    }
-    if (messages[5]?.role === "user") {
-      expect(messages[5].content).toContain("Third round fix.");
-      expect(messages[5].content).toContain("### Step 4: reviewer");
-      expect(messages[5].content).toContain('"approved":false');
-    }
+    expect(prompt).toContain("## Previous Steps");
+    expect(prompt).toContain("planner");
   });
 });

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

@@ -7,26 +7,17 @@ import {
   resolveModel,
   resolveStorageRoot,
 } from "@uncaged/workflow-agent-kit";
-import { createLogger, generateUlid } from "@uncaged/workflow-util";
+import { generateUlid } from "@uncaged/workflow-util";
 
 import { storeBuiltinDetail } from "./detail.js";
 import type { ChatMessage } from "./llm/index.js";
 import { BUILTIN_CONTINUE_MAX_TURNS, BUILTIN_MAX_TURNS, runBuiltinLoop } from "./loop.js";
-import { buildBuiltinMessages } from "./prompt.js";
-import { initSessionDir, removeSession } from "./session.js";
+import { buildBuiltinPrompt } from "./prompt.js";
+import type { BuiltinSessionState } from "./types.js";
 
-const log = createLogger({ sink: { kind: "stderr" } });
+const sessions = new Map<string, BuiltinSessionState>();
 
-type SessionRecord = {
-  sessionId: string;
-  model: string;
-  startedAtMs: number;
-  messages: ChatMessage[];
-};
-
-const sessions = new Map<string, SessionRecord>();
-
-function getSession(sessionId: string): SessionRecord {
+function getSession(sessionId: string): BuiltinSessionState {
   const session = sessions.get(sessionId);
   if (session === undefined) {
     throw new Error(`builtin session not found: ${sessionId}`);
@@ -45,7 +36,7 @@ async function runBuiltinWithMessages(
   storageRoot: string,
   provider: ReturnType<typeof resolveModel>,
   messages: ChatMessage[],
-  session: SessionRecord,
+  session: BuiltinSessionState,
   store: Store,
   maxTurns: number,
 ): Promise<AgentRunResult> {
@@ -54,31 +45,22 @@ async function runBuiltinWithMessages(
     messages,
     toolCtx: buildToolContext(storageRoot),
     maxTurns,
-    storageRoot,
-    sessionId: session.sessionId,
+    existingTurns: session.turns,
   });
 
   session.messages = loopResult.messages;
+  session.turns = loopResult.turns;
 
-  if (loopResult.turnCount === 0) {
-    log("5RWTK9NB", "no turns produced, returning empty output");
-    await removeSession(storageRoot, session.sessionId);
-    return { output: "", detailHash: "", sessionId: session.sessionId };
-  }
-
-  // Read jsonl → persist turns to CAS → store detail
-  const { detailHash } = await storeBuiltinDetail(
+  const { detailHash, output } = await storeBuiltinDetail(
     store,
-    storageRoot,
     session.sessionId,
     session.model,
     session.startedAtMs,
+    session.turns,
   );
 
-  // Clean up session jsonl
-  await removeSession(storageRoot, session.sessionId);
-
-  return { output: loopResult.finalText, detailHash, sessionId: session.sessionId };
+  const finalOutput = output !== "" ? output : loopResult.finalText;
+  return { output: finalOutput, detailHash, sessionId: session.sessionId };
 }
 
 async function runBuiltin(ctx: AgentContext): Promise<AgentRunResult> {
@@ -87,14 +69,15 @@ async function runBuiltin(ctx: AgentContext): Promise<AgentRunResult> {
   const provider = resolveModel(config, config.defaultModel);
 
   const sessionId = generateUlid(Date.now());
-  await initSessionDir(storageRoot);
-  const messages = buildBuiltinMessages(ctx);
+  const systemPrompt = buildBuiltinPrompt(ctx);
+  const messages: ChatMessage[] = [{ role: "system", content: systemPrompt }];
 
-  const session: SessionRecord = {
+  const session: BuiltinSessionState = {
     sessionId,
     model: provider.model,
     startedAtMs: Date.now(),
     messages,
+    turns: [],
   };
   sessions.set(sessionId, session);
 

packages/workflow-agent-builtin/src/detail.ts

@@ -1,15 +1,72 @@
 import { bootstrap, putSchema, type Store } from "@uncaged/json-cas";
 
 import { BUILTIN_DETAIL_SCHEMA, BUILTIN_TURN_SCHEMA } from "./schemas.js";
-import { readSessionTurns } from "./session.js";
-import type { BuiltinDetailPayload } from "./types.js";
+import type {
+  BuiltinDetailPayload,
+  BuiltinLoopTurn,
+  BuiltinToolCall,
+  BuiltinTurnPayload,
+  BuiltinTurnRole,
+} from "./types.js";
+
+function mapToolCalls(calls: NonNullable<BuiltinLoopTurn["toolCalls"]>): BuiltinToolCall[] {
+  return calls.map((call) => ({
+    name: call.name,
+    args: call.args,
+  }));
+}
+
+function loopTurnToAssistantPayload(turn: BuiltinLoopTurn, index: number): BuiltinTurnPayload {
+  return {
+    index,
+    role: "assistant",
+    content: turn.assistantContent ?? "",
+    toolCalls:
+      turn.toolCalls !== null && turn.toolCalls.length > 0 ? mapToolCalls(turn.toolCalls) : null,
+    reasoning: null,
+  };
+}
+
+function loopTurnToToolPayloads(turn: BuiltinLoopTurn, startIndex: number): BuiltinTurnPayload[] {
+  if (turn.toolResults === null || turn.toolResults.length === 0) {
+    return [];
+  }
+  const payloads: BuiltinTurnPayload[] = [];
+  let index = startIndex;
+  for (const result of turn.toolResults) {
+    payloads.push({
+      index,
+      role: "tool" as BuiltinTurnRole,
+      content: result.content,
+      toolCalls: null,
+      reasoning: null,
+    });
+    index += 1;
+  }
+  return payloads;
+}
+
+/** Last assistant message with non-empty text. */
+export function extractFinalAssistantText(turns: BuiltinLoopTurn[]): string {
+  for (let i = turns.length - 1; i >= 0; i--) {
+    const turn = turns[i];
+    if (turn === undefined) {
+      continue;
+    }
+    const text = turn.assistantContent;
+    if (text !== null && text.trim() !== "") {
+      return text;
+    }
+  }
+  return "";
+}
 
 type BuiltinSchemaHashes = {
   turn: string;
   detail: string;
 };
 
-export async function registerBuiltinSchemas(store: Store): Promise<BuiltinSchemaHashes> {
+async function registerBuiltinSchemas(store: Store): Promise<BuiltinSchemaHashes> {
   await bootstrap(store);
   const [turn, detail] = await Promise.all([
     putSchema(store, BUILTIN_TURN_SCHEMA),
@@ -18,22 +75,30 @@ export async function registerBuiltinSchemas(store: Store): Promise<BuiltinSchem
   return { turn, detail };
 }
 
-/** Read session jsonl, persist each turn to CAS, return detail hash. */
 export async function storeBuiltinDetail(
   store: Store,
-  storageRoot: string,
   sessionId: string,
   model: string,
   startedAtMs: number,
+  turns: BuiltinLoopTurn[],
   nowMs: number = Date.now(),
-): Promise<{ detailHash: string; turnCount: number }> {
+): Promise<{ detailHash: string; output: string }> {
   const schemas = await registerBuiltinSchemas(store);
-  const turns = await readSessionTurns(storageRoot, sessionId);
-
   const turnHashes: string[] = [];
-  for (const turn of turns) {
-    const hash = await store.put(schemas.turn, turn);
-    turnHashes.push(hash);
+  let turnIndex = 0;
+
+  for (const loopTurn of turns) {
+    const assistant = loopTurnToAssistantPayload(loopTurn, turnIndex);
+    const assistantHash = await store.put(schemas.turn, assistant);
+    turnHashes.push(assistantHash);
+    turnIndex += 1;
+
+    const toolPayloads = loopTurnToToolPayloads(loopTurn, turnIndex);
+    for (const toolPayload of toolPayloads) {
+      const toolHash = await store.put(schemas.turn, toolPayload);
+      turnHashes.push(toolHash);
+      turnIndex += 1;
+    }
   }
 
   const duration = Math.max(0, nowMs - startedAtMs);
@@ -45,5 +110,6 @@ export async function storeBuiltinDetail(
     turns: turnHashes,
   };
   const detailHash = await store.put(schemas.detail, detail);
-  return { detailHash, turnCount: turnHashes.length };
+  const output = extractFinalAssistantText(turns);
+  return { detailHash, output };
 }

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

@@ -1,16 +1,14 @@
 export { createBuiltinAgent } from "./agent.js";
-export { registerBuiltinSchemas, storeBuiltinDetail } from "./detail.js";
+export { extractFinalAssistantText, storeBuiltinDetail } from "./detail.js";
 export type { ChatMessage, LlmAssistantResponse, LlmToolCall } from "./llm/index.js";
 export { chatCompletionWithTools } from "./llm/index.js";
 export { BUILTIN_CONTINUE_MAX_TURNS, BUILTIN_MAX_TURNS, runBuiltinLoop } from "./loop.js";
-export { buildBuiltinMessages } from "./prompt.js";
-export { appendSessionTurn, initSessionDir, readSessionTurns, removeSession } from "./session.js";
+export { buildBuiltinPrompt } from "./prompt.js";
 export type { BuiltinTool, ToolContext } from "./tools/index.js";
 export { executeBuiltinTool, getBuiltinTools } from "./tools/index.js";
 export type {
   BuiltinDetailPayload,
   BuiltinLoopTurn,
-  BuiltinToolCallRecord,
-  BuiltinToolResultRecord,
+  BuiltinSessionState,
   BuiltinTurnPayload,
 } from "./types.js";

packages/workflow-agent-builtin/src/loop.ts

@@ -2,14 +2,13 @@ import type { ResolvedLlmProvider } from "@uncaged/workflow-agent-kit";
 import { createLogger } from "@uncaged/workflow-util";
 
 import { type ChatMessage, chatCompletionWithTools, type LlmToolCall } from "./llm/index.js";
-import { appendSessionTurn } from "./session.js";
 import {
   builtinToolsToOpenAi,
   executeBuiltinTool,
   getBuiltinTools,
   type ToolContext,
 } from "./tools/index.js";
-import type { BuiltinToolCall, BuiltinTurnPayload } from "./types.js";
+import type { BuiltinLoopTurn, BuiltinToolCallRecord, BuiltinToolResultRecord } from "./types.js";
 
 const log = createLogger({ sink: { kind: "stderr" } });
 
@@ -21,61 +20,31 @@ export type RunBuiltinLoopOptions = {
   messages: ChatMessage[];
   toolCtx: ToolContext;
   maxTurns: number;
-  storageRoot: string;
-  sessionId: string;
+  existingTurns: BuiltinLoopTurn[];
 };
 
 export type RunBuiltinLoopResult = {
   finalText: string;
   messages: ChatMessage[];
-  turnCount: number;
+  turns: BuiltinLoopTurn[];
 };
 
-function mapToolCallsForPayload(calls: LlmToolCall[]): BuiltinToolCall[] {
+function mapToolCalls(calls: LlmToolCall[]): BuiltinToolCallRecord[] {
   return calls.map((call) => ({
+    id: call.id,
     name: call.name,
     args: call.arguments,
   }));
 }
 
-async function appendTurn(
-  storageRoot: string,
-  sessionId: string,
-  payload: BuiltinTurnPayload,
-): Promise<void> {
-  await appendSessionTurn(storageRoot, sessionId, payload);
-}
-
-async function executeTurnTools(
-  calls: Array<{ id: string; name: string; arguments: string }>,
-  toolCtx: ToolContext,
-  messages: ChatMessage[],
-  storageRoot: string,
-  sessionId: string,
-): Promise<number> {
-  let turnCount = 0;
-  for (const call of calls) {
-    const result = await executeBuiltinTool(call.name, call.arguments, toolCtx);
-    messages.push({ role: "tool", tool_call_id: call.id, content: result });
-    await appendTurn(storageRoot, sessionId, {
-      role: "tool",
-      content: result,
-      toolCalls: null,
-      reasoning: null,
-    });
-    turnCount += 1;
-  }
-  return turnCount;
-}
-
 /** Agent run loop: LLM ↔ tools until no tool_calls or maxTurns. */
 export async function runBuiltinLoop(
   options: RunBuiltinLoopOptions,
 ): Promise<RunBuiltinLoopResult> {
   const messages = [...options.messages];
+  const turns = [...options.existingTurns];
   const openAiTools = builtinToolsToOpenAi(getBuiltinTools());
   let finalText = "";
-  let turnCount = 0;
 
   for (let turn = 0; turn < options.maxTurns; turn++) {
     log("8K2M4N7P", `builtin loop turn ${turn + 1}/${options.maxTurns}`);
@@ -90,33 +59,36 @@ export async function runBuiltinLoop(
 
     if (response.toolCalls === null || response.toolCalls.length === 0) {
       finalText = response.content ?? "";
-      await appendTurn(options.storageRoot, options.sessionId, {
-        role: "assistant",
-        content: response.content ?? "",
+      turns.push({
+        assistantContent: response.content,
         toolCalls: null,
-        reasoning: null,
+        toolResults: null,
       });
-      turnCount += 1;
       break;
     }
 
-    // Assistant turn with tool calls
-    await appendTurn(options.storageRoot, options.sessionId, {
-      role: "assistant",
-      content: response.content ?? "",
-      toolCalls: mapToolCallsForPayload(response.toolCalls),
-      reasoning: null,
-    });
-    turnCount += 1;
+    const toolCallRecords = mapToolCalls(response.toolCalls);
+    const toolResults: BuiltinToolResultRecord[] = [];
 
-    // Execute tools
-    turnCount += await executeTurnTools(
-      response.toolCalls,
-      options.toolCtx,
-      messages,
-      options.storageRoot,
-      options.sessionId,
-    );
+    for (const call of response.toolCalls) {
+      const result = await executeBuiltinTool(call.name, call.arguments, options.toolCtx);
+      toolResults.push({
+        toolCallId: call.id,
+        name: call.name,
+        content: result,
+      });
+      messages.push({
+        role: "tool",
+        tool_call_id: call.id,
+        content: result,
+      });
+    }
+
+    turns.push({
+      assistantContent: response.content,
+      toolCalls: toolCallRecords,
+      toolResults,
+    });
   }
 
   if (finalText === "" && messages.length > 0) {
@@ -134,5 +106,5 @@ export async function runBuiltinLoop(
     }
   }
 
-  return { finalText, messages, turnCount };
+  return { finalText, messages, turns };
 }

packages/workflow-agent-builtin/src/prompt.ts

@@ -1,99 +1,36 @@
 import { type AgentContext, buildRolePrompt } from "@uncaged/workflow-agent-kit";
 
-import type { ChatMessage } from "./llm/index.js";
-
-type StepContext = AgentContext["steps"][number];
-
-function formatStep(step: StepContext, stepNumber: number): string {
-  return [
-    `### Step ${stepNumber}: ${step.role}`,
-    `Output: ${JSON.stringify(step.output)}`,
-    `Agent: ${step.agent}`,
-  ].join("\n");
-}
-
-function buildStepsSummary(steps: StepContext[], fromIndex: number, toIndex: number): string {
-  if (fromIndex >= toIndex) {
+function buildHistorySummary(steps: AgentContext["steps"]): string {
+  if (steps.length === 0) {
     return "";
   }
 
-  const lines: string[] = ["## What Happened Since Your Last Turn"];
-  for (let i = fromIndex; i < toIndex; i++) {
+  const lines: string[] = ["## Previous Steps"];
+  for (let i = 0; i < steps.length; i++) {
     const step = steps[i];
     if (step === undefined) {
       continue;
     }
     lines.push("");
-    lines.push(formatStep(step, i + 1));
+    lines.push(`### Step ${i + 1}: ${step.role}`);
+    lines.push(`Output: ${JSON.stringify(step.output)}`);
+    lines.push(`Agent: ${step.agent}`);
   }
   return lines.join("\n");
 }
 
-function buildUserTurnContent(edgePrompt: string, summary: string): string {
+/** Assemble output format, role prompt, task, and history (aligned with buildHermesPrompt). */
+export function buildBuiltinPrompt(ctx: AgentContext): string {
+  const roleDef = ctx.workflow.roles[ctx.role];
+  const rolePrompt = roleDef !== undefined ? buildRolePrompt(roleDef) : "";
   const parts: string[] = [];
-  if (edgePrompt !== "") {
-    parts.push(edgePrompt);
+  if (ctx.outputFormatInstruction !== "") {
+    parts.push(ctx.outputFormatInstruction, "");
   }
-  if (summary !== "") {
-    if (parts.length > 0) {
-      parts.push("");
-    }
-    parts.push(summary);
+  parts.push(rolePrompt, "", "## Task", ctx.start.prompt);
+  const historyBlock = buildHistorySummary(ctx.steps);
+  if (historyBlock !== "") {
+    parts.push("", historyBlock);
   }
   return parts.join("\n");
 }
-
-/**
- * Reconstruct multi-turn chat messages from thread history for cache-friendly session resume.
- *
- * - system: role prompt + output format (stable prefix)
- * - For each prior visit of this role: user (edgePrompt + inter-step summary) + assistant (output JSON)
- * - Final user: current edgePrompt + summary since last visit of this role
- */
-export function buildBuiltinMessages(ctx: AgentContext): ChatMessage[] {
-  const roleDef = ctx.workflow.roles[ctx.role];
-  const rolePrompt = roleDef !== undefined ? buildRolePrompt(roleDef) : "";
-  const systemParts: string[] = [];
-  if (ctx.outputFormatInstruction !== "") {
-    systemParts.push(ctx.outputFormatInstruction, "");
-  }
-  systemParts.push(rolePrompt);
-
-  const messages: ChatMessage[] = [{ role: "system", content: systemParts.join("\n") }];
-
-  const roleVisitIndices: number[] = [];
-  for (let i = 0; i < ctx.steps.length; i++) {
-    const step = ctx.steps[i];
-    if (step !== undefined && step.role === ctx.role) {
-      roleVisitIndices.push(i);
-    }
-  }
-
-  let prevVisitIndex = -1;
-  for (const visitIndex of roleVisitIndices) {
-    const visitStep = ctx.steps[visitIndex];
-    if (visitStep === undefined) {
-      continue;
-    }
-
-    const summary = buildStepsSummary(ctx.steps, prevVisitIndex + 1, visitIndex);
-    messages.push({
-      role: "user",
-      content: buildUserTurnContent(visitStep.edgePrompt, summary),
-    });
-    messages.push({
-      role: "assistant",
-      content: JSON.stringify(visitStep.output),
-      tool_calls: null,
-    });
-    prevVisitIndex = visitIndex;
-  }
-
-  const finalSummary = buildStepsSummary(ctx.steps, prevVisitIndex + 1, ctx.steps.length);
-  messages.push({
-    role: "user",
-    content: buildUserTurnContent(ctx.edgePrompt, finalSummary),
-  });
-
-  return messages;
-}

packages/workflow-agent-builtin/src/schemas.ts

@@ -13,8 +13,9 @@ const BUILTIN_TOOL_CALL_SCHEMA: JSONSchema = {
 export const BUILTIN_TURN_SCHEMA: JSONSchema = {
   title: "builtin-turn",
   type: "object",
-  required: ["role", "content"],
+  required: ["index", "role", "content"],
   properties: {
+    index: { type: "integer" },
     role: { type: "string", enum: ["assistant", "tool"] },
     content: { type: "string" },
     toolCalls: {

packages/workflow-agent-builtin/src/session.ts

@@ -1,59 +0,0 @@
-import { appendFile, mkdir, readFile, rm } from "node:fs/promises";
-import { join } from "node:path";
-
-import { createLogger } from "@uncaged/workflow-util";
-
-import type { BuiltinTurnPayload } from "./types.js";
-
-const log = createLogger({ sink: { kind: "stderr" } });
-
-function sessionsDir(storageRoot: string): string {
-  return join(storageRoot, "sessions");
-}
-
-function sessionFile(storageRoot: string, sessionId: string): string {
-  return join(sessionsDir(storageRoot), `${sessionId}.jsonl`);
-}
-
-/** Ensure sessions directory exists. */
-export async function initSessionDir(storageRoot: string): Promise<void> {
-  await mkdir(sessionsDir(storageRoot), { recursive: true });
-}
-
-/** Append a turn to the session jsonl file. */
-export async function appendSessionTurn(
-  storageRoot: string,
-  sessionId: string,
-  turn: BuiltinTurnPayload,
-): Promise<void> {
-  const line = `${JSON.stringify(turn)}\n`;
-  await appendFile(sessionFile(storageRoot, sessionId), line, "utf-8");
-  log("3XQVN8KR", `session ${sessionId} appended ${turn.role} turn`);
-}
-
-/** Read all turns from session jsonl. Returns empty array if file does not exist. */
-export async function readSessionTurns(
-  storageRoot: string,
-  sessionId: string,
-): Promise<BuiltinTurnPayload[]> {
-  try {
-    const content = await readFile(sessionFile(storageRoot, sessionId), "utf-8");
-    const lines = content
-      .trim()
-      .split("\n")
-      .filter((l) => l.length > 0);
-    return lines.map((l) => JSON.parse(l) as BuiltinTurnPayload);
-  } catch {
-    return [];
-  }
-}
-
-/** Remove session jsonl file (called after detail is persisted to step CAS). */
-export async function removeSession(storageRoot: string, sessionId: string): Promise<void> {
-  try {
-    await rm(sessionFile(storageRoot, sessionId));
-    log("7FWDP2MJ", `session ${sessionId} removed`);
-  } catch {
-    // already gone — fine
-  }
-}

packages/workflow-agent-builtin/src/tools/path.ts

@@ -1,6 +1,17 @@
-import { resolve } from "node:path";
+import { isAbsolute, relative, resolve } from "node:path";
 
 /** Resolve a path relative to the working directory. */
 export function resolvePath(cwd: string, inputPath: string): string {
   return resolve(cwd, inputPath);
 }
+
+/** Reject paths that escape the workspace root via `..` segments. */
+export function resolvePathInWorkspace(cwd: string, inputPath: string): string | null {
+  const root = resolve(cwd);
+  const target = resolve(root, inputPath);
+  const rel = relative(root, target);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    return null;
+  }
+  return target;
+}

packages/workflow-agent-builtin/src/tools/read-file.ts

@@ -1,5 +1,5 @@
 import { readFile, stat } from "node:fs/promises";
-import { resolvePath } from "./path.js";
+import { resolvePathInWorkspace } from "./path.js";
 import type { BuiltinTool } from "./types.js";
 
 const MAX_READ_BYTES = 512 * 1024;
@@ -23,7 +23,10 @@ export const readFileTool: BuiltinTool = {
     if (!isRecord(args) || typeof args.path !== "string") {
       return "Error: path must be a string";
     }
-    const resolved = resolvePath(ctx.cwd, args.path);
+    const resolved = resolvePathInWorkspace(ctx.cwd, args.path);
+    if (resolved === null) {
+      return "Error: path escapes workspace root";
+    }
     try {
       const info = await stat(resolved);
       if (!info.isFile()) {

packages/workflow-agent-builtin/src/tools/run-command.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { resolvePath } from "./path.js";
+import { resolvePathInWorkspace } from "./path.js";
 import type { BuiltinTool } from "./types.js";
 
 const COMMAND_TIMEOUT_MS = 60_000;
@@ -56,7 +56,8 @@ function runShell(
 
 export const runCommandTool: BuiltinTool = {
   name: "run_command",
-  description: "Run a shell command. Output is truncated to 32KB.",
+  description:
+    "Run a shell command in the workspace. Requires UWF_BUILTIN_ALLOW_SHELL=1. Output is truncated.",
   parameters: {
     type: "object",
     required: ["command"],
@@ -70,6 +71,9 @@ export const runCommandTool: BuiltinTool = {
     additionalProperties: false,
   },
   execute: async (args, ctx) => {
+    if (process.env.UWF_BUILTIN_ALLOW_SHELL !== "1") {
+      return "Error: run_command disabled. Set UWF_BUILTIN_ALLOW_SHELL=1 to enable.";
+    }
     if (!isRecord(args) || typeof args.command !== "string") {
       return "Error: command must be a string";
     }
@@ -78,7 +82,11 @@ export const runCommandTool: BuiltinTool = {
       if (typeof args.cwd !== "string") {
         return "Error: cwd must be a string";
       }
-      workDir = resolvePath(ctx.cwd, args.cwd);
+      const resolved = resolvePathInWorkspace(ctx.cwd, args.cwd);
+      if (resolved === null) {
+        return "Error: cwd escapes workspace root";
+      }
+      workDir = resolved;
     }
     try {
       const { stdout, stderr, code } = await runShell(args.command, workDir);

packages/workflow-agent-builtin/src/tools/write-file.ts

@@ -1,6 +1,6 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { resolvePath } from "./path.js";
+import { resolvePathInWorkspace } from "./path.js";
 import type { BuiltinTool } from "./types.js";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -23,7 +23,10 @@ export const writeFileTool: BuiltinTool = {
     if (!isRecord(args) || typeof args.path !== "string" || typeof args.content !== "string") {
       return "Error: path and content must be strings";
     }
-    const resolved = resolvePath(ctx.cwd, args.path);
+    const resolved = resolvePathInWorkspace(ctx.cwd, args.path);
+    if (resolved === null) {
+      return "Error: path escapes workspace root";
+    }
     try {
       await mkdir(dirname(resolved), { recursive: true });
       await writeFile(resolved, args.content, "utf8");

packages/workflow-agent-builtin/src/types.ts

@@ -34,6 +34,7 @@ export type BuiltinToolCall = {
 };
 
 export type BuiltinTurnPayload = {
+  index: number;
   role: BuiltinTurnRole;
   content: string;
   toolCalls: BuiltinToolCall[] | null;

packages/workflow-agent-claude-code/__tests__/claude-code.test.ts

@@ -41,15 +41,7 @@ describe("buildClaudeCodePrompt", () => {
 
   test("includes previous steps as history summary", () => {
     const ctx = makeCtx({
-      steps: [
-        {
-          role: "planner",
-          output: '{"plan":"do X"}',
-          agent: "hermes",
-          detail: "detail-1",
-          edgePrompt: "Create a plan.",
-        },
-      ],
+      steps: [{ role: "planner", output: '{"plan":"do X"}', agent: "hermes" }],
     });
     const result = buildClaudeCodePrompt(ctx);
     expect(result).toContain("## Previous Steps");

packages/workflow-agent-claude-code/__tests__/session-detail.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test";
 import { createMemoryStore, walk } from "@uncaged/json-cas";
 import {
   parseClaudeCodeJsonOutput,
-  parseClaudeCodeStreamOutput,
   storeClaudeCodeDetail,
   storeClaudeCodeRawOutput,
 } from "../src/session-detail.js";
@@ -18,8 +17,6 @@ describe("parseClaudeCodeJsonOutput", () => {
       num_turns: 3,
       total_cost_usd: 0.08,
       duration_ms: 10276,
-      stop_reason: "end_turn",
-      usage: { input_tokens: 100, output_tokens: 50 },
     });
     const parsed = parseClaudeCodeJsonOutput(stdout);
     expect(parsed).not.toBeNull();
@@ -30,10 +27,22 @@ describe("parseClaudeCodeJsonOutput", () => {
     expect(parsed!.numTurns).toBe(3);
     expect(parsed!.totalCostUsd).toBe(0.08);
     expect(parsed!.durationMs).toBe(10276);
-    expect(parsed!.stopReason).toBe("end_turn");
-    expect(parsed!.usage.inputTokens).toBe(100);
-    expect(parsed!.usage.outputTokens).toBe(50);
-    expect(parsed!.turns).toEqual([]);
+  });
+
+  test("parses error_max_turns result", () => {
+    const stdout = JSON.stringify({
+      type: "result",
+      subtype: "error_max_turns",
+      result: "Ran out of turns",
+      session_id: "abc-def",
+      num_turns: 90,
+      total_cost_usd: 1.5,
+      duration_ms: 50000,
+    });
+    const parsed = parseClaudeCodeJsonOutput(stdout);
+    expect(parsed).not.toBeNull();
+    expect(parsed!.subtype).toBe("error_max_turns");
+    expect(parsed!.result).toBe("Ran out of turns");
   });
 
   test("returns null for non-JSON output", () => {
@@ -48,160 +57,45 @@ describe("parseClaudeCodeJsonOutput", () => {
   });
 });
 
-describe("parseClaudeCodeStreamOutput", () => {
-  test("parses stream-json output with turns", () => {
-    const lines = [
-      JSON.stringify({
-        type: "system",
-        subtype: "init",
-        session_id: "sess-123",
-        model: "claude-sonnet-4.5",
-        tools: ["Bash", "Read"],
-      }),
-      JSON.stringify({
-        type: "assistant",
-        message: {
-          role: "assistant",
-          content: [
-            { type: "text", text: "I'll list the files." },
-            { type: "tool_use", id: "tool_1", name: "Bash", input: { command: "ls" } },
-          ],
-        },
-        session_id: "sess-123",
-      }),
-      JSON.stringify({
-        type: "user",
-        message: {
-          role: "user",
-          content: [{ type: "tool_result", tool_use_id: "tool_1", content: "file1.ts\nfile2.ts" }],
-        },
-        session_id: "sess-123",
-      }),
-      JSON.stringify({
-        type: "assistant",
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text: "There are 2 files." }],
-        },
-        session_id: "sess-123",
-      }),
-      JSON.stringify({
-        type: "result",
-        subtype: "success",
-        result: "There are 2 files.",
-        session_id: "sess-123",
-        num_turns: 2,
-        total_cost_usd: 0.05,
-        duration_ms: 5000,
-        stop_reason: "end_turn",
-        usage: {
-          input_tokens: 200,
-          output_tokens: 30,
-          cache_read_input_tokens: 100,
-          cache_creation_input_tokens: 0,
-        },
-      }),
-    ];
-    const stdout = lines.join("\n");
-    const parsed = parseClaudeCodeStreamOutput(stdout);
-
-    expect(parsed).not.toBeNull();
-    expect(parsed!.model).toBe("claude-sonnet-4.5");
-    expect(parsed!.sessionId).toBe("sess-123");
-    expect(parsed!.result).toBe("There are 2 files.");
-    expect(parsed!.stopReason).toBe("end_turn");
-    expect(parsed!.usage.inputTokens).toBe(200);
-    expect(parsed!.usage.outputTokens).toBe(30);
-    expect(parsed!.usage.cacheReadInputTokens).toBe(100);
-
-    // Turns: assistant(text+tool), tool_result, assistant(text)
-    expect(parsed!.turns).toHaveLength(3);
-    expect(parsed!.turns[0]!.role).toBe("assistant");
-    expect(parsed!.turns[0]!.content).toBe("I'll list the files.");
-    expect(parsed!.turns[0]!.toolCalls).toHaveLength(1);
-    expect(parsed!.turns[0]!.toolCalls![0]!.name).toBe("Bash");
-    expect(parsed!.turns[1]!.role).toBe("tool_result");
-    expect(parsed!.turns[1]!.content).toBe("file1.ts\nfile2.ts");
-    expect(parsed!.turns[2]!.role).toBe("assistant");
-    expect(parsed!.turns[2]!.content).toBe("There are 2 files.");
-    expect(parsed!.turns[2]!.toolCalls).toBeNull();
-  });
-
-  test("returns null when no result line", () => {
-    const stdout = JSON.stringify({ type: "system", model: "test" });
-    expect(parseClaudeCodeStreamOutput(stdout)).toBeNull();
-  });
-
-  test("skips invalid JSON lines gracefully", () => {
-    const lines = [
-      "not json",
-      JSON.stringify({
-        type: "result",
-        subtype: "success",
-        result: "ok",
-        session_id: "s1",
-        num_turns: 1,
-        total_cost_usd: 0.01,
-        duration_ms: 1000,
-        stop_reason: "end_turn",
-        usage: {},
-      }),
-    ];
-    const parsed = parseClaudeCodeStreamOutput(lines.join("\n"));
-    expect(parsed).not.toBeNull();
-    expect(parsed!.result).toBe("ok");
-    expect(parsed!.turns).toHaveLength(0);
-  });
-});
-
 describe("storeClaudeCodeDetail", () => {
-  const baseParsed: ClaudeCodeParsedResult = {
-    type: "result",
-    subtype: "success",
-    result: "The answer",
-    sessionId: "abc-123",
-    numTurns: 5,
-    totalCostUsd: 0.12,
-    durationMs: 15000,
-    model: "claude-sonnet-4.5",
-    stopReason: "end_turn",
-    usage: {
-      inputTokens: 100,
-      outputTokens: 50,
-      cacheReadInputTokens: 0,
-      cacheCreationInputTokens: 0,
-    },
-    turns: [
-      { index: 0, role: "assistant", content: "hello", toolCalls: null },
-      { index: 1, role: "tool_result", content: "world", toolCalls: null },
-    ],
-  };
-
-  test("stores detail with per-turn CAS nodes", async () => {
+  test("stores claude-code-detail CAS node and returns output + detailHash", async () => {
     const store = createMemoryStore();
-    const { detailHash, output, sessionId } = await storeClaudeCodeDetail(store, baseParsed);
+    const parsed: ClaudeCodeParsedResult = {
+      type: "result",
+      subtype: "success",
+      result: "The answer",
+      sessionId: "abc-123",
+      numTurns: 5,
+      totalCostUsd: 0.12,
+      durationMs: 15000,
+    };
 
+    const { detailHash, output, sessionId } = await storeClaudeCodeDetail(store, parsed);
     expect(detailHash).toHaveLength(13);
     expect(output).toBe("The answer");
     expect(sessionId).toBe("abc-123");
 
     const node = await store.get(detailHash);
     expect(node).not.toBeNull();
-    expect(node!.payload.model).toBe("claude-sonnet-4.5");
-    expect(node!.payload.stopReason).toBe("end_turn");
-    expect(node!.payload.usage.inputTokens).toBe(100);
-    expect(node!.payload.turns).toHaveLength(2);
-
-    // Verify turn CAS nodes
-    const turn0 = await store.get(node!.payload.turns[0]);
-    expect(turn0).not.toBeNull();
-    expect(turn0!.payload.role).toBe("assistant");
-    expect(turn0!.payload.content).toBe("hello");
+    expect(node!.payload.sessionId).toBe("abc-123");
+    expect(node!.payload.numTurns).toBe(5);
+    expect(node!.payload.totalCostUsd).toBe(0.12);
+    expect(node!.payload.durationMs).toBe(15000);
   });
 
   test("detail node is walkable from root", async () => {
     const store = createMemoryStore();
-    const { detailHash } = await storeClaudeCodeDetail(store, baseParsed);
+    const parsed: ClaudeCodeParsedResult = {
+      type: "result",
+      subtype: "success",
+      result: "walkable test",
+      sessionId: "walk-123",
+      numTurns: 1,
+      totalCostUsd: 0.01,
+      durationMs: 1000,
+    };
+
+    const { detailHash } = await storeClaudeCodeDetail(store, parsed);
     const visited: string[] = [];
     walk(store, detailHash, (hash) => visited.push(hash));
     expect(visited.length).toBeGreaterThan(0);

packages/workflow-agent-claude-code/src/claude-code.ts

@@ -1,18 +1,14 @@
 import { spawn } from "node:child_process";
 import type { Store } from "@uncaged/json-cas";
+
 import {
   type AgentContext,
   type AgentRunResult,
   buildRolePrompt,
   createAgent,
-  getCachedSessionId,
-  setCachedSessionId,
 } from "@uncaged/workflow-agent-kit";
-import { createLogger } from "@uncaged/workflow-util";
 
-import { parseClaudeCodeStreamOutput, storeClaudeCodeDetail } from "./session-detail.js";
-
-const log = createLogger({ sink: { kind: "stderr" } });
+import { parseClaudeCodeJsonOutput, storeClaudeCodeDetail } from "./session-detail.js";
 
 const CLAUDE_COMMAND = "claude";
 const CLAUDE_MAX_TURNS = 90;
@@ -49,7 +45,6 @@ export function buildClaudeCodePrompt(ctx: AgentContext): string {
   if (historyBlock !== "") {
     parts.push("", historyBlock);
   }
-  parts.push("", "## Current Instruction", "", ctx.edgePrompt);
   return parts.join("\n");
 }
 
@@ -91,8 +86,7 @@ function spawnClaudeRun(prompt: string): Promise<{ stdout: string; stderr: strin
     "-p",
     prompt,
     "--output-format",
-    "stream-json",
-    "--verbose",
+    "json",
     "--dangerously-skip-permissions",
     "--max-turns",
     String(CLAUDE_MAX_TURNS),
@@ -109,8 +103,7 @@ function spawnClaudeResume(
     "--resume",
     sessionId,
     "--output-format",
-    "stream-json",
-    "--verbose",
+    "json",
     "--dangerously-skip-permissions",
     "--max-turns",
     String(CLAUDE_MAX_TURNS),
@@ -118,7 +111,7 @@ function spawnClaudeResume(
 }
 
 async function processClaudeOutput(stdout: string, store: Store): Promise<AgentRunResult> {
-  const parsed = parseClaudeCodeStreamOutput(stdout);
+  const parsed = parseClaudeCodeJsonOutput(stdout);
 
   if (parsed !== null) {
     const { detailHash, output, sessionId } = await storeClaudeCodeDetail(store, parsed);
@@ -126,43 +119,14 @@ async function processClaudeOutput(stdout: string, store: Store): Promise<AgentR
   }
 
   throw new Error(
-    `Claude Code returned unparseable output (first 200 chars): ${stdout.slice(0, 200)}`,
+    `Claude Code returned non-JSON output (first 200 chars): ${stdout.slice(0, 200)}`,
   );
 }
 
 async function runClaudeCode(ctx: AgentContext): Promise<AgentRunResult> {
   const fullPrompt = buildClaudeCodePrompt(ctx);
-
-  log("K7R2M4N8", `prompt for role=${ctx.role} (length=${fullPrompt.length}):\n${fullPrompt}`);
-
-  // Try resuming a cached session for re-entry scenarios (e.g. reviewer reject → developer re-entry).
-  if (!ctx.isFirstVisit) {
-    const cachedSessionId = await getCachedSessionId(ctx.threadId, ctx.role);
-    if (cachedSessionId !== null) {
-      try {
-        const { stdout } = await spawnClaudeResume(cachedSessionId, fullPrompt);
-        const result = await processClaudeOutput(stdout, ctx.store);
-        if (result.sessionId !== undefined && result.sessionId !== "") {
-          await setCachedSessionId(ctx.threadId, ctx.role, result.sessionId);
-        }
-        return result;
-      } catch (err) {
-        log(
-          "5VKR8N3Q",
-          "resume failed for session %s, falling back to fresh run: %s",
-          cachedSessionId,
-          err,
-        );
-      }
-    }
-  }
-
   const { stdout } = await spawnClaudeRun(fullPrompt);
-  const result = await processClaudeOutput(stdout, ctx.store);
-  if (result.sessionId !== undefined && result.sessionId !== "") {
-    await setCachedSessionId(ctx.threadId, ctx.role, result.sessionId);
-  }
-  return result;
+  return processClaudeOutput(stdout, ctx.store);
 }
 
 async function continueClaudeCode(

packages/workflow-agent-claude-code/src/index.ts

@@ -1,7 +1,6 @@
 export { buildClaudeCodePrompt, createClaudeCodeAgent } from "./claude-code.js";
 export {
   parseClaudeCodeJsonOutput,
-  parseClaudeCodeStreamOutput,
   storeClaudeCodeDetail,
   storeClaudeCodeRawOutput,
 } from "./session-detail.js";

packages/workflow-agent-claude-code/src/schemas.ts

@@ -3,52 +3,13 @@ import type { JSONSchema } from "@uncaged/json-cas";
 export const CLAUDE_CODE_DETAIL_SCHEMA: JSONSchema = {
   title: "claude-code-detail",
   type: "object",
-  required: [
-    "sessionId",
-    "model",
-    "subtype",
-    "durationMs",
-    "numTurns",
-    "totalCostUsd",
-    "stopReason",
-    "usage",
-    "turns",
-  ],
+  required: ["sessionId", "numTurns", "totalCostUsd", "durationMs", "subtype"],
   properties: {
     sessionId: { type: "string" },
-    model: { type: "string" },
-    subtype: { type: "string" },
-    durationMs: { type: "integer" },
     numTurns: { type: "integer" },
     totalCostUsd: { type: "number" },
-    stopReason: { type: "string" },
-    usage: {
-      type: "object",
-      properties: {
-        inputTokens: { type: "integer" },
-        outputTokens: { type: "integer" },
-        cacheReadInputTokens: { type: "integer" },
-        cacheCreationInputTokens: { type: "integer" },
-      },
-      required: ["inputTokens", "outputTokens", "cacheReadInputTokens", "cacheCreationInputTokens"],
-    },
-    turns: {
-      type: "array",
-      items: { type: "string" },
-    },
-  },
-  additionalProperties: false,
-};
-
-export const CLAUDE_CODE_TURN_SCHEMA: JSONSchema = {
-  title: "claude-code-turn",
-  type: "object",
-  required: ["index", "role", "content", "toolCalls"],
-  properties: {
-    index: { type: "integer" },
-    role: { type: "string" },
-    content: { type: "string" },
-    toolCalls: {},
+    durationMs: { type: "integer" },
+    subtype: { type: "string" },
   },
   additionalProperties: false,
 };

packages/workflow-agent-claude-code/src/session-detail.ts

@@ -1,171 +1,13 @@
 import { bootstrap, putSchema, type Store } from "@uncaged/json-cas";
 
-import {
-  CLAUDE_CODE_DETAIL_SCHEMA,
-  CLAUDE_CODE_RAW_OUTPUT_SCHEMA,
-  CLAUDE_CODE_TURN_SCHEMA,
-} from "./schemas.js";
-import type {
-  ClaudeCodeDetailPayload,
-  ClaudeCodeParsedResult,
-  ClaudeCodeToolCall,
-  ClaudeCodeTurnPayload,
-} from "./types.js";
+import { CLAUDE_CODE_DETAIL_SCHEMA, CLAUDE_CODE_RAW_OUTPUT_SCHEMA } from "./schemas.js";
+import type { ClaudeCodeDetailPayload, ClaudeCodeParsedResult } from "./types.js";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function safeNumber(v: unknown, fallback = 0): number {
-  return typeof v === "number" ? v : fallback;
-}
-
-function safeString(v: unknown, fallback = ""): string {
-  return typeof v === "string" ? v : fallback;
-}
-
-/**
- * Extract tool calls from an assistant message content array.
- */
-function extractToolCalls(content: unknown[]): ClaudeCodeToolCall[] {
-  const calls: ClaudeCodeToolCall[] = [];
-  for (const item of content) {
-    if (isRecord(item) && item.type === "tool_use" && typeof item.name === "string") {
-      calls.push({
-        name: item.name,
-        input: typeof item.input === "string" ? item.input : JSON.stringify(item.input ?? {}),
-      });
-    }
-  }
-  return calls;
-}
-
-/**
- * Extract text content from a message content array.
- */
-function extractTextContent(content: unknown[]): string {
-  const texts: string[] = [];
-  for (const item of content) {
-    if (isRecord(item) && item.type === "text" && typeof item.text === "string") {
-      texts.push(item.text);
-    }
-  }
-  return texts.join("\n");
-}
-
-/**
- * Extract tool result content from a user message content array.
- */
-function extractToolResultContent(content: unknown[]): string {
-  const results: string[] = [];
-  for (const item of content) {
-    if (isRecord(item) && item.type === "tool_result") {
-      const text = typeof item.content === "string" ? item.content : "";
-      results.push(text);
-    }
-  }
-  return results.join("\n");
-}
-
-/**
- * Parse Claude Code stream-json (NDJSON) output.
- * Each line is a JSON object with type: "system" | "assistant" | "user" | "result".
- */
-export function parseClaudeCodeStreamOutput(stdout: string): ClaudeCodeParsedResult | null {
-  const lines = stdout.trim().split("\n");
-  const turns: ClaudeCodeTurnPayload[] = [];
-  let resultLine: Record<string, unknown> | null = null;
-  let model = "";
-  let turnIndex = 0;
-
-  for (const line of lines) {
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (!isRecord(parsed)) continue;
-
-    const type = parsed.type;
-
-    if (type === "system" && typeof parsed.model === "string") {
-      model = parsed.model;
-    }
-
-    if (type === "assistant" && isRecord(parsed.message)) {
-      const msg = parsed.message;
-      const content = Array.isArray(msg.content) ? msg.content : [];
-      const textContent = extractTextContent(content as unknown[]);
-      const toolCalls = extractToolCalls(content as unknown[]);
-
-      // Only record turns that have actual content
-      if (textContent !== "" || toolCalls.length > 0) {
-        turns.push({
-          index: turnIndex++,
-          role: "assistant",
-          content: textContent,
-          toolCalls: toolCalls.length > 0 ? toolCalls : null,
-        });
-      }
-    }
-
-    if (type === "user" && isRecord(parsed.message)) {
-      const msg = parsed.message;
-      const content = Array.isArray(msg.content) ? msg.content : [];
-      const resultContent = extractToolResultContent(content as unknown[]);
-
-      if (resultContent !== "") {
-        turns.push({
-          index: turnIndex++,
-          role: "tool_result",
-          content: resultContent,
-          toolCalls: null,
-        });
-      }
-    }
-
-    if (type === "result") {
-      resultLine = parsed;
-    }
-  }
-
-  if (resultLine === null) return null;
-
-  const sessionId = resultLine.session_id;
-  const result = resultLine.result;
-  const subtype = resultLine.subtype;
-
-  if (typeof sessionId !== "string" || typeof result !== "string" || typeof subtype !== "string") {
-    return null;
-  }
-
-  const usage = isRecord(resultLine.usage) ? resultLine.usage : {};
-
-  return {
-    type: safeString(resultLine.type, "result"),
-    subtype: subtype as ClaudeCodeParsedResult["subtype"],
-    result,
-    sessionId,
-    numTurns: safeNumber(resultLine.num_turns),
-    totalCostUsd: safeNumber(resultLine.total_cost_usd),
-    durationMs: safeNumber(resultLine.duration_ms),
-    model,
-    stopReason: safeString(resultLine.stop_reason),
-    usage: {
-      inputTokens: safeNumber(usage.input_tokens),
-      outputTokens: safeNumber(usage.output_tokens),
-      cacheReadInputTokens: safeNumber(usage.cache_read_input_tokens),
-      cacheCreationInputTokens: safeNumber(usage.cache_creation_input_tokens),
-    },
-    turns,
-  };
-}
-
-/**
- * Legacy: parse Claude Code plain JSON output (non-streaming).
- * Falls back when stream-json is not available.
- */
+/** Parse Claude Code JSON stdout (`claude -p --output-format json`). */
 export function parseClaudeCodeJsonOutput(stdout: string): ClaudeCodeParsedResult | null {
   let parsed: unknown;
   try {
@@ -174,7 +16,9 @@ export function parseClaudeCodeJsonOutput(stdout: string): ClaudeCodeParsedResul
     return null;
   }
 
-  if (!isRecord(parsed)) return null;
+  if (!isRecord(parsed)) {
+    return null;
+  }
 
   const sessionId = parsed.session_id;
   const result = parsed.result;
@@ -184,68 +28,44 @@ export function parseClaudeCodeJsonOutput(stdout: string): ClaudeCodeParsedResul
     return null;
   }
 
-  const usage = isRecord(parsed.usage) ? parsed.usage : {};
-
   return {
-    type: safeString(parsed.type, "result"),
+    type: typeof parsed.type === "string" ? parsed.type : "result",
     subtype: subtype as ClaudeCodeParsedResult["subtype"],
     result,
     sessionId,
-    numTurns: safeNumber(parsed.num_turns),
-    totalCostUsd: safeNumber(parsed.total_cost_usd),
-    durationMs: safeNumber(parsed.duration_ms),
-    model: "",
-    stopReason: safeString(parsed.stop_reason),
-    usage: {
-      inputTokens: safeNumber(usage.input_tokens),
-      outputTokens: safeNumber(usage.output_tokens),
-      cacheReadInputTokens: safeNumber(usage.cache_read_input_tokens),
-      cacheCreationInputTokens: safeNumber(usage.cache_creation_input_tokens),
-    },
-    turns: [],
+    numTurns: typeof parsed.num_turns === "number" ? parsed.num_turns : 0,
+    totalCostUsd: typeof parsed.total_cost_usd === "number" ? parsed.total_cost_usd : 0,
+    durationMs: typeof parsed.duration_ms === "number" ? parsed.duration_ms : 0,
   };
 }
 
 type ClaudeCodeSchemaHashes = {
   detail: string;
-  turn: string;
   rawOutput: string;
 };
 
 async function registerSchemas(store: Store): Promise<ClaudeCodeSchemaHashes> {
   await bootstrap(store);
-  const [detail, turn, rawOutput] = await Promise.all([
+  const [detail, rawOutput] = await Promise.all([
     putSchema(store, CLAUDE_CODE_DETAIL_SCHEMA),
-    putSchema(store, CLAUDE_CODE_TURN_SCHEMA),
     putSchema(store, CLAUDE_CODE_RAW_OUTPUT_SCHEMA),
   ]);
-  return { detail, turn, rawOutput };
+  return { detail, rawOutput };
 }
 
-/** Store parsed Claude Code result with per-turn breakdown as CAS detail nodes. */
+/** Store parsed Claude Code result as a CAS detail node. */
 export async function storeClaudeCodeDetail(
   store: Store,
   parsed: ClaudeCodeParsedResult,
 ): Promise<{ detailHash: string; output: string; sessionId: string }> {
   const schemas = await registerSchemas(store);
 
-  // Store each turn as an individual CAS node
-  const turnHashes: string[] = [];
-  for (const turn of parsed.turns) {
-    const hash = await store.put(schemas.turn, turn);
-    turnHashes.push(hash);
-  }
-
   const detail: ClaudeCodeDetailPayload = {
     sessionId: parsed.sessionId,
-    model: parsed.model,
-    subtype: parsed.subtype,
-    durationMs: parsed.durationMs,
     numTurns: parsed.numTurns,
     totalCostUsd: parsed.totalCostUsd,
-    stopReason: parsed.stopReason,
-    usage: parsed.usage,
-    turns: turnHashes,
+    durationMs: parsed.durationMs,
+    subtype: parsed.subtype,
   };
 
   const detailHash = await store.put(schemas.detail, detail);

packages/workflow-agent-claude-code/src/types.ts

@@ -1,38 +1,5 @@
 export type ClaudeCodeResultSubtype = "success" | "error_max_turns" | "error_budget";
 
-/** A single tool call within an assistant turn. */
-export type ClaudeCodeToolCall = {
-  name: string;
-  input: string;
-};
-
-/** A single turn (assistant text, tool use, or tool result). */
-export type ClaudeCodeTurnPayload = {
-  index: number;
-  role: "assistant" | "tool_result";
-  content: string;
-  toolCalls: ClaudeCodeToolCall[] | null;
-};
-
-/** Top-level detail stored as CAS node. */
-export type ClaudeCodeDetailPayload = {
-  sessionId: string;
-  model: string;
-  subtype: string;
-  durationMs: number;
-  numTurns: number;
-  totalCostUsd: number;
-  stopReason: string;
-  usage: {
-    inputTokens: number;
-    outputTokens: number;
-    cacheReadInputTokens: number;
-    cacheCreationInputTokens: number;
-  };
-  turns: string[]; // CAS hashes of ClaudeCodeTurnPayload
-};
-
-/** Intermediate parsed result from stream-json output. */
 export type ClaudeCodeParsedResult = {
   type: string;
   subtype: ClaudeCodeResultSubtype;
@@ -41,13 +8,12 @@ export type ClaudeCodeParsedResult = {
   numTurns: number;
   totalCostUsd: number;
   durationMs: number;
-  model: string;
-  stopReason: string;
-  usage: {
-    inputTokens: number;
-    outputTokens: number;
-    cacheReadInputTokens: number;
-    cacheCreationInputTokens: number;
-  };
-  turns: ClaudeCodeTurnPayload[];
+};
+
+export type ClaudeCodeDetailPayload = {
+  sessionId: string;
+  numTurns: number;
+  totalCostUsd: number;
+  durationMs: number;
+  subtype: string;
 };

packages/workflow-agent-hermes/__tests__/acp-client.test.ts

@@ -54,8 +54,7 @@ describe("HermesAcpClient", () => {
     { timeout: 2 * 60 * 1000 },
   );
 
-  // TODO(#435): flaky — depends on live LLM; mock or move to integration suite
-  it.skip(
+  it(
     "prompt() collects structured messages including tool calls",
     async () => {
       await client.connect(process.cwd());

packages/workflow-agent-hermes/__tests__/hermes-prompt.test.ts

@@ -49,20 +49,8 @@ describe("buildHermesPrompt", () => {
       isFirstVisit: false,
       edgePrompt: "The reviewer rejected your work. Fix the issues.",
       steps: [
-        {
-          role: "developer",
-          output: { summary: "Initial fix" },
-          agent: "uwf-hermes",
-          detail: "detail-1",
-          edgePrompt: "Implement the fix.",
-        },
-        {
-          role: "reviewer",
-          output: { approved: false },
-          agent: "uwf-hermes",
-          detail: "detail-2",
-          edgePrompt: "Review the code.",
-        },
+        { role: "developer", output: { summary: "Initial fix" }, agent: "uwf-hermes" },
+        { role: "reviewer", output: { approved: false }, agent: "uwf-hermes" },
       ],
     });
 
@@ -78,15 +66,7 @@ describe("buildHermesPrompt", () => {
     const result = buildHermesPrompt(
       makeCtx({
         isFirstVisit: true,
-        steps: [
-          {
-            role: "developer",
-            output: { done: true },
-            agent: "uwf-hermes",
-            detail: "detail-1",
-            edgePrompt: "First attempt.",
-          },
-        ],
+        steps: [{ role: "developer", output: { done: true }, agent: "uwf-hermes" }],
         edgePrompt: "Retry with a fresh approach.",
       }),
     );

packages/workflow-agent-hermes/__tests__/resume-e2e.test.ts

@@ -21,8 +21,7 @@ describe("HermesAcpClient cross-process resume", () => {
     clients.length = 0;
   });
 
-  // TODO(#435): flaky — depends on live LLM; mock or move to integration suite
-  it.skip(
+  it(
     "resume() after close — second prompt returns non-empty text",
     async () => {
       // --- Client A: first run ---

packages/workflow-agent-hermes/src/acp-client.ts

@@ -267,7 +267,8 @@ export class HermesAcpClient {
       case "tool_call": {
         const title = (update.title as string) ?? "";
         const rawInput = update.rawInput;
-        const args = rawInput !== undefined && rawInput !== null ? JSON.stringify(rawInput) : "";
+        const args =
+          rawInput !== undefined && rawInput !== null ? JSON.stringify(rawInput) : "";
         const toolCallId = update.toolCallId as string;
         this.pendingTools.set(toolCallId, { name: title, args });
 

packages/workflow-agent-hermes/src/session-cache.ts

@@ -1,17 +1,70 @@
-// Re-export session cache from the shared agent-kit package.
-export { getCachedSessionId, setCachedSessionId } from "@uncaged/workflow-agent-kit";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import { resolveStorageRoot } from "@uncaged/workflow-agent-kit";
+import type { ThreadId } from "@uncaged/workflow-protocol";
+
+type HermesSessionCache = Record<string, string>;
+
+function getCachePath(): string {
+  return join(resolveStorageRoot(), "cache", "hermes-sessions.json");
+}
+
+function cacheKey(threadId: ThreadId, role: string): string {
+  return `${threadId}:${role}`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function readCache(): Promise<HermesSessionCache> {
+  const path = getCachePath();
+  try {
+    const text = await readFile(path, "utf8");
+    const raw = JSON.parse(text) as unknown;
+    if (!isRecord(raw)) {
+      return {};
+    }
+    const cache: HermesSessionCache = {};
+    for (const [key, value] of Object.entries(raw)) {
+      if (typeof value === "string" && value !== "") {
+        cache[key] = value;
+      }
+    }
+    return cache;
+  } catch (e) {
+    const err = e as NodeJS.ErrnoException;
+    if (err.code === "ENOENT") {
+      return {};
+    }
+    throw e;
+  }
+}
+
+async function writeCache(cache: HermesSessionCache): Promise<void> {
+  const path = getCachePath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(cache, null, 2)}\n`, "utf8");
+}
 
 export function isResumeDisabled(): boolean {
-  // Hermes ACP session/resume is broken: _restore fails for custom providers
-  // because resolve_runtime_provider("custom") throws and base_url/api_mode
-  // are lost in the fallback path.  Resume silently creates a new session
-  // (different sessionId, no history), causing empty-text responses.
-  // See: https://github.com/NousResearch/hermes-agent/issues/13489
-  // Disable by default until upstream fixes the bug.  Set UWF_HERMES_RESUME=1
-  // to opt back in.
-  const enableFlag = process.env.UWF_HERMES_RESUME;
-  if (enableFlag === "1" || enableFlag === "true") {
-    return false;
-  }
-  return true;
+  const flag = process.env.UWF_NO_RESUME;
+  return flag !== undefined && flag !== "";
+}
+
+export async function getCachedSessionId(threadId: ThreadId, role: string): Promise<string | null> {
+  const cache = await readCache();
+  const sessionId = cache[cacheKey(threadId, role)];
+  return sessionId ?? null;
+}
+
+export async function setCachedSessionId(
+  threadId: ThreadId,
+  role: string,
+  sessionId: string,
+): Promise<void> {
+  const cache = await readCache();
+  cache[cacheKey(threadId, role)] = sessionId;
+  await writeCache(cache);
 }

packages/workflow-agent-kit/__tests__/build-continuation-prompt.test.ts

@@ -7,7 +7,6 @@ const reviewerStep: StepContext = {
   output: { approved: false, comments: "Missing tests" },
   detail: "2MXBG6PN4A8JR",
   agent: "uwf-hermes",
-  edgePrompt: "Review the developer's work.",
 };
 
 const developerStep: StepContext = {
@@ -15,7 +14,6 @@ const developerStep: StepContext = {
   output: { filesChanged: ["src/app.ts"], summary: "Initial fix" },
   detail: "1VPBG9SM5E7WK",
   agent: "uwf-hermes",
-  edgePrompt: "Implement the fix.",
 };
 
 describe("buildContinuationPrompt", () => {
@@ -28,7 +26,6 @@ describe("buildContinuationPrompt", () => {
         output: { plan: "revise approach" },
         detail: "7BQST3VW9F2MA",
         agent: "uwf-hermes",
-        edgePrompt: "Revise the plan.",
       },
     ];
 

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

@@ -102,7 +102,6 @@ async function buildHistory(
       output: expandOutput(store, step.output),
       detail: step.detail,
       agent: step.agent,
-      edgePrompt: step.edgePrompt ?? "",
     });
   }
   return history;

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

@@ -12,7 +12,6 @@ export {
 export type { FrontmatterFastPathResult } from "./frontmatter.js";
 export { tryFrontmatterFastPath } from "./frontmatter.js";
 export { createAgent } from "./run.js";
-export { getCachedSessionId, setCachedSessionId } from "./session-cache.js";
 export { getConfigPath, getEnvPath, loadWorkflowConfig, resolveStorageRoot } from "./storage.js";
 export type {
   AgentContext,

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

@@ -50,7 +50,6 @@ async function writeStepNode(options: {
   outputHash: CasRef;
   detailHash: CasRef;
   agentName: string;
-  edgePrompt: string;
 }): Promise<CasRef> {
   const payload: StepNodePayload = {
     start: options.startHash,
@@ -59,7 +58,6 @@ async function writeStepNode(options: {
     output: options.outputHash,
     detail: options.detailHash,
     agent: options.agentName,
-    edgePrompt: options.edgePrompt,
   };
   const hash = await options.store.put(options.schemas.stepNode, payload);
   const node = options.store.get(hash);
@@ -97,7 +95,6 @@ async function persistStep(options: {
     outputHash: options.outputHash,
     detailHash: options.detailHash,
     agentName: options.agentName,
-    edgePrompt: options.ctx.edgePrompt,
   });
 }
 

packages/workflow-agent-kit/src/session-cache.ts

@@ -1,75 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-import type { ThreadId } from "@uncaged/workflow-protocol";
-
-import { resolveStorageRoot } from "./storage.js";
-
-type SessionCache = Record<string, string>;
-
-function getCachePath(): string {
-  return join(resolveStorageRoot(), "cache", "agent-sessions.json");
-}
-
-function cacheKey(threadId: ThreadId, role: string): string {
-  return `${threadId}:${role}`;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-async function readCache(): Promise<SessionCache> {
-  const path = getCachePath();
-  try {
-    const text = await readFile(path, "utf8");
-    const raw = JSON.parse(text) as unknown;
-    if (!isRecord(raw)) {
-      return {};
-    }
-    const cache: SessionCache = {};
-    for (const [key, value] of Object.entries(raw)) {
-      if (typeof value === "string" && value !== "") {
-        cache[key] = value;
-      }
-    }
-    return cache;
-  } catch (e) {
-    const err = e as NodeJS.ErrnoException;
-    if (err.code === "ENOENT") {
-      return {};
-    }
-    throw e;
-  }
-}
-
-async function writeCache(cache: SessionCache): Promise<void> {
-  const path = getCachePath();
-  const dir = dirname(path);
-  await mkdir(dir, { recursive: true });
-  // Atomic write: write to temp file then rename to avoid partial reads on concurrent access.
-  // NOTE: Current workflow execution is serial (execFileSync), so true concurrency doesn't occur.
-  // This is a safety net for future parallel execution.
-  const tmpPath = join(dir, `.agent-sessions.${randomBytes(4).toString("hex")}.tmp`);
-  await writeFile(tmpPath, `${JSON.stringify(cache, null, 2)}\n`, "utf8");
-  await rename(tmpPath, path);
-}
-
-/** Read the cached session ID for a thread+role pair. */
-export async function getCachedSessionId(threadId: ThreadId, role: string): Promise<string | null> {
-  const cache = await readCache();
-  const sessionId = cache[cacheKey(threadId, role)];
-  return sessionId ?? null;
-}
-
-/** Write the session ID for a thread+role pair into the cache. */
-export async function setCachedSessionId(
-  threadId: ThreadId,
-  role: string,
-  sessionId: string,
-): Promise<void> {
-  const cache = await readCache();
-  cache[cacheKey(threadId, role)] = sessionId;
-  await writeCache(cache);
-}

packages/workflow-dashboard/index.html

@@ -6,8 +6,8 @@
     <title>Workflow UI</title>
     <link rel="stylesheet" href="./src/index.css" />
     <script>
-      (() => {
-        const t = localStorage.getItem("theme");
+      (function () {
+        var t = localStorage.getItem("theme");
         if (t === "dark" || (!t && matchMedia("(prefers-color-scheme: dark)").matches)) {
           document.documentElement.classList.add("dark");
         }

packages/workflow-dashboard/server.ts

@@ -7,3 +7,6 @@ const server = await createServer({
 });
 
 await server.listen();
+
+// biome-ignore lint/nursery/noConsole: CLI user-facing output
+console.log(`Workflow UI running at http://localhost:${PORT}`);

packages/workflow-dashboard/server/api.ts

@@ -1,11 +1,11 @@
 import { Elysia, t } from "elysia";
 import type { WorkFlowSteps } from "../shared/types.ts";
 import {
-  createWorkflow,
-  deleteWorkflow,
-  getWorkflow,
   listWorkflows,
+  getWorkflow,
+  createWorkflow,
   saveWorkflow,
+  deleteWorkflow,
 } from "./workflow.ts";
 
 export function createApi() {

packages/workflow-dashboard/server/workflow.ts

@@ -1,7 +1,11 @@
-import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { readdir, readFile, writeFile, unlink, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import type { RoleDefinition, Transition, WorkflowPayload } from "@uncaged/workflow-protocol";
 import YAML from "yaml";
+import type {
+  WorkflowPayload,
+  RoleDefinition,
+  Transition,
+} from "@uncaged/workflow-protocol";
 import type { WorkFlowSteps, WorkFlowTransition, WorkflowSummary } from "../shared/types.ts";
 
 const WORKFLOW_DIR = join(import.meta.dirname, "..", "tmp", "workflow");
@@ -63,7 +67,7 @@ function stepsToPayload(name: string, description: string, steps: WorkFlowSteps)
       let condName: string | null = null;
       if (t.condition) {
         if (expressionToName.has(t.condition)) {
-          condName = expressionToName.get(t.condition) ?? null;
+          condName = expressionToName.get(t.condition)!;
         } else {
           condName = `cond${condIdx++}`;
           expressionToName.set(t.condition, condName);
@@ -86,7 +90,7 @@ function stepsToPayload(name: string, description: string, steps: WorkFlowSteps)
 
   if (steps.length > 0) {
     const firstRole = steps[0].role.name;
-    graph.$START = [
+    graph["$START"] = [
       {
         role: firstRole,
         condition: null,

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

@@ -1,7 +1,7 @@
-import { Button as ButtonPrimitive } from "@base-ui/react/button";
-import { cva, type VariantProps } from "class-variance-authority";
+import { Button as ButtonPrimitive } from "@base-ui/react/button"
+import { cva, type VariantProps } from "class-variance-authority"
 
-import { cn } from "@/lib/utils";
+import { cn } from "@/lib/utils"
 
 const buttonVariants = cva(
   "group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
@@ -37,8 +37,8 @@ const buttonVariants = cva(
       variant: "default",
       size: "default",
     },
-  },
-);
+  }
+)
 
 function Button({
   className,
@@ -52,7 +52,7 @@ function Button({
       className={cn(buttonVariants({ variant, size, className }))}
       {...props}
     />
-  );
+  )
 }
 
-export { Button, buttonVariants };
+export { Button, buttonVariants }

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

@@ -1,6 +1,6 @@
-import type * as React from "react";
+import * as React from "react"
 
-import { cn } from "@/lib/utils";
+import { cn } from "@/lib/utils"
 
 function Card({
   className,
@@ -13,11 +13,11 @@ function Card({
       data-size={size}
       className={cn(
         "group/card flex flex-col gap-4 overflow-hidden rounded-xl bg-card py-4 text-sm text-card-foreground ring-1 ring-foreground/10 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
 function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
@@ -26,11 +26,11 @@ function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
       data-slot="card-header"
       className={cn(
         "group/card-header @container/card-header grid auto-rows-min items-start gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto] [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
 function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
@@ -39,11 +39,11 @@ function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
       data-slot="card-title"
       className={cn(
         "font-heading text-base leading-snug font-medium group-data-[size=sm]/card:text-sm",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
 function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
@@ -53,17 +53,20 @@ function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
       className={cn("text-sm text-muted-foreground", className)}
       {...props}
     />
-  );
+  )
 }
 
 function CardAction({ className, ...props }: React.ComponentProps<"div">) {
   return (
     <div
       data-slot="card-action"
-      className={cn("col-start-2 row-span-2 row-start-1 self-start justify-self-end", className)}
+      className={cn(
+        "col-start-2 row-span-2 row-start-1 self-start justify-self-end",
+        className
+      )}
       {...props}
     />
-  );
+  )
 }
 
 function CardContent({ className, ...props }: React.ComponentProps<"div">) {
@@ -73,7 +76,7 @@ function CardContent({ className, ...props }: React.ComponentProps<"div">) {
       className={cn("px-4 group-data-[size=sm]/card:px-3", className)}
       {...props}
     />
-  );
+  )
 }
 
 function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
@@ -82,11 +85,19 @@ function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
       data-slot="card-footer"
       className={cn(
         "flex items-center rounded-b-xl border-t bg-muted/50 p-4 group-data-[size=sm]/card:p-3",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
-export { Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle };
+export {
+  Card,
+  CardHeader,
+  CardFooter,
+  CardTitle,
+  CardAction,
+  CardDescription,
+  CardContent,
+}

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

@@ -1,36 +1,40 @@
-import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
-import { XIcon } from "lucide-react";
-import type * as React from "react";
-import { Button } from "@/components/ui/button";
-import { cn } from "@/lib/utils";
+import * as React from "react"
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog"
+
+import { cn } from "@/lib/utils"
+import { Button } from "@/components/ui/button"
+import { XIcon } from "lucide-react"
 
 function Dialog({ ...props }: DialogPrimitive.Root.Props) {
-  return <DialogPrimitive.Root data-slot="dialog" {...props} />;
+  return <DialogPrimitive.Root data-slot="dialog" {...props} />
 }
 
 function DialogTrigger({ ...props }: DialogPrimitive.Trigger.Props) {
-  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />;
+  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />
 }
 
 function DialogPortal({ ...props }: DialogPrimitive.Portal.Props) {
-  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />;
+  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />
 }
 
 function DialogClose({ ...props }: DialogPrimitive.Close.Props) {
-  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />;
+  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />
 }
 
-function DialogOverlay({ className, ...props }: DialogPrimitive.Backdrop.Props) {
+function DialogOverlay({
+  className,
+  ...props
+}: DialogPrimitive.Backdrop.Props) {
   return (
     <DialogPrimitive.Backdrop
       data-slot="dialog-overlay"
       className={cn(
         "fixed inset-0 isolate z-50 bg-black/10 duration-100 supports-backdrop-filter:backdrop-blur-xs data-open:animate-in data-open:fade-in-0 data-closed:animate-out data-closed:fade-out-0",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
 function DialogContent({
@@ -39,7 +43,7 @@ function DialogContent({
   showCloseButton = true,
   ...props
 }: DialogPrimitive.Popup.Props & {
-  showCloseButton?: boolean;
+  showCloseButton?: boolean
 }) {
   return (
     <DialogPortal>
@@ -48,7 +52,7 @@ function DialogContent({
         data-slot="dialog-content"
         className={cn(
           "fixed top-1/2 left-1/2 z-50 grid w-full max-w-[calc(100%-2rem)] -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl bg-popover p-4 text-sm text-popover-foreground ring-1 ring-foreground/10 duration-100 outline-none sm:max-w-sm data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
-          className,
+          className
         )}
         {...props}
       >
@@ -56,21 +60,32 @@ function DialogContent({
         {showCloseButton && (
           <DialogPrimitive.Close
             data-slot="dialog-close"
-            render={<Button variant="ghost" className="absolute top-2 right-2" size="icon-sm" />}
+            render={
+              <Button
+                variant="ghost"
+                className="absolute top-2 right-2"
+                size="icon-sm"
+              />
+            }
           >
-            <XIcon />
+            <XIcon
+            />
             <span className="sr-only">Close</span>
           </DialogPrimitive.Close>
         )}
       </DialogPrimitive.Popup>
     </DialogPortal>
-  );
+  )
 }
 
 function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
   return (
-    <div data-slot="dialog-header" className={cn("flex flex-col gap-2", className)} {...props} />
-  );
+    <div
+      data-slot="dialog-header"
+      className={cn("flex flex-col gap-2", className)}
+      {...props}
+    />
+  )
 }
 
 function DialogFooter({
@@ -79,46 +94,54 @@ function DialogFooter({
   children,
   ...props
 }: React.ComponentProps<"div"> & {
-  showCloseButton?: boolean;
+  showCloseButton?: boolean
 }) {
   return (
     <div
       data-slot="dialog-footer"
       className={cn(
         "-mx-4 -mb-4 flex flex-col-reverse gap-2 rounded-b-xl border-t bg-muted/50 p-4 sm:flex-row sm:justify-end",
-        className,
+        className
       )}
       {...props}
     >
       {children}
       {showCloseButton && (
-        <DialogPrimitive.Close render={<Button variant="outline" />}>Close</DialogPrimitive.Close>
+        <DialogPrimitive.Close render={<Button variant="outline" />}>
+          Close
+        </DialogPrimitive.Close>
       )}
     </div>
-  );
+  )
 }
 
 function DialogTitle({ className, ...props }: DialogPrimitive.Title.Props) {
   return (
     <DialogPrimitive.Title
       data-slot="dialog-title"
-      className={cn("font-heading text-base leading-none font-medium", className)}
+      className={cn(
+        "font-heading text-base leading-none font-medium",
+        className
+      )}
       {...props}
     />
-  );
+  )
 }
 
-function DialogDescription({ className, ...props }: DialogPrimitive.Description.Props) {
+function DialogDescription({
+  className,
+  ...props
+}: DialogPrimitive.Description.Props) {
   return (
     <DialogPrimitive.Description
       data-slot="dialog-description"
       className={cn(
         "text-sm text-muted-foreground *:[a]:underline *:[a]:underline-offset-3 *:[a]:hover:text-foreground",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
 export {
@@ -132,4 +155,4 @@ export {
   DialogPortal,
   DialogTitle,
   DialogTrigger,
-};
+}

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

@@ -1,7 +1,7 @@
-import { Input as InputPrimitive } from "@base-ui/react/input";
-import type * as React from "react";
+import * as React from "react"
+import { Input as InputPrimitive } from "@base-ui/react/input"
 
-import { cn } from "@/lib/utils";
+import { cn } from "@/lib/utils"
 
 function Input({ className, type, ...props }: React.ComponentProps<"input">) {
   return (
@@ -10,11 +10,11 @@ function Input({ className, type, ...props }: React.ComponentProps<"input">) {
       data-slot="input"
       className={cn(
         "h-8 w-full min-w-0 rounded-lg border border-input bg-transparent px-2.5 py-1 text-base transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
-export { Input };
+export { Input }

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

@@ -1,19 +1,18 @@
-import type * as React from "react";
+import * as React from "react"
 
-import { cn } from "@/lib/utils";
+import { cn } from "@/lib/utils"
 
 function Label({ className, ...props }: React.ComponentProps<"label">) {
   return (
-    // biome-ignore lint/a11y/noLabelWithoutControl: generic Label component; control association handled by consumer
     <label
       data-slot="label"
       className={cn(
         "flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
-export { Label };
+export { Label }

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

@@ -1,21 +1,25 @@
-"use client";
+"use client"
 
-import { Separator as SeparatorPrimitive } from "@base-ui/react/separator";
+import { Separator as SeparatorPrimitive } from "@base-ui/react/separator"
 
-import { cn } from "@/lib/utils";
+import { cn } from "@/lib/utils"
 
-function Separator({ className, orientation = "horizontal", ...props }: SeparatorPrimitive.Props) {
+function Separator({
+  className,
+  orientation = "horizontal",
+  ...props
+}: SeparatorPrimitive.Props) {
   return (
     <SeparatorPrimitive
       data-slot="separator"
       orientation={orientation}
       className={cn(
         "shrink-0 bg-border data-horizontal:h-px data-horizontal:w-full data-vertical:w-px data-vertical:self-stretch",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
-export { Separator };
+export { Separator }

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

@@ -1,6 +1,6 @@
-import type * as React from "react";
+import * as React from "react"
 
-import { cn } from "@/lib/utils";
+import { cn } from "@/lib/utils"
 
 function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
   return (
@@ -8,11 +8,11 @@ function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
       data-slot="textarea"
       className={cn(
         "flex field-sizing-content min-h-16 w-full rounded-lg border border-input bg-transparent px-2.5 py-2 text-base transition-colors outline-none placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
-        className,
+        className
       )}
       {...props}
     />
-  );
+  )
 }
 
-export { Textarea };
+export { Textarea }

packages/workflow-dashboard/src/editor/context.tsx

@@ -1,12 +1,12 @@
-import { type ReactFlowInstance, useReactFlow } from "@xyflow/react";
-import type { FC, PropsWithChildren } from "react";
-import { createContext, useContext, useLayoutEffect, useMemo, useSyncExternalStore } from "react";
-import type { AnyWorkNode } from "./type";
+import { createContext, useMemo, useSyncExternalStore, useContext, useLayoutEffect } from 'react';
+import type { FC, PropsWithChildren } from 'react';
+import { useReactFlow, ReactFlowInstance } from '@xyflow/react';
+import type { AnyWorkNode } from './type';
 
 type Reduce<T> = (data: T) => T;
 type Setter<T> = (ch: Reduce<T> | T) => void;
 
-interface State<T, A> {
+interface State<T, A>  {
   readonly get: () => T;
   readonly set: Setter<T>;
   readonly use: () => T;
@@ -15,7 +15,6 @@ interface State<T, A> {
   readonly onlyView: boolean;
 }
 type Use = <T, A>(sub: SubModel<T, A>) => [T, A];
-// biome-ignore lint/suspicious/noExplicitAny: UseV intentionally erases the action type
 type UseV = <T>(sub: SubModel<T, any>) => T;
 type Create<T, A> = (set: Setter<T>, get: () => T, model: Model) => A;
 
@@ -25,12 +24,10 @@ export function generate<T>(val: T) {
   const listener = new Set<VoidFunction>();
   const get = () => val;
   function set(ch: T | ((prev: T) => T)) {
-    const next = typeof ch === "function" ? (ch as (prev: T) => T)(val) : ch;
+    const next = (typeof ch === 'function') ? (ch as (prev: T) => T)(val) : ch;
     if (Object.is(val, next)) return;
     val = next;
-    for (const call of listener) {
-      call();
-    }
+    listener.forEach(call => call());
   }
   const listen = (call: VoidFunction) => {
     listener.add(call);
@@ -41,26 +38,21 @@ export function generate<T>(val: T) {
 }
 
 class SubModel<T, A> {
-  public readonly name: string;
-  private readonly make: () => T;
-  private readonly create: Create<T, A>;
-  private readonly onlyView: boolean;
-
-  constructor(name: string, _make: () => T, _create: Create<T, A>, _onlyView = false) {
-    this.name = name;
-    this.make = _make;
-    this.create = _create;
-    this.onlyView = _onlyView;
-  }
+  constructor(
+    public readonly name: string,
+    private make: () => T,
+    private create: Create<T, A>,
+    private onlyView = false,
+  ) {}
 
   public gen(model: Model): State<T, A> {
-    const { get, set, use, listen } = generate(this.make());
-    const actions = this.create(set, get, model);
-    return { get, set, use, listen, actions, onlyView: this.onlyView };
+    const { make, create, onlyView } = this;
+    const { get, set, use, listen } = generate(make());
+    const actions = create(set, get, model);
+    return { get, set, use, listen, actions, onlyView };
   }
 
   use(): [T, A] {
-    // biome-ignore lint/correctness/useHookAtTopLevel: use() is called as a hook by consumers
     const { query } = useContext(Context);
     const { use, actions } = query(this);
     return [use(), actions];
@@ -75,27 +67,20 @@ class SubModel<T, A> {
   }
 }
 
-// biome-ignore lint/suspicious/noExplicitAny: snapshot data is heterogeneous
 type Snapshot = [name: string, data: any];
 class Model {
   private ustack: Snapshot[][] = [];
   private rstack: Snapshot[][] = [];
   private transaction = 0;
-  // biome-ignore lint/suspicious/noExplicitAny: backup stores heterogeneous state values
   private backup = new Map<string, any>();
   public flow = {} as ReactFlowInstance<AnyWorkNode>;
   private stackListeners = new Set<() => void>();
   public readonly stackState: readonly [boolean, boolean] = [false, false];
 
-  // biome-ignore lint/suspicious/noExplicitAny: store holds heterogeneous state types
-  private readonly store: Map<string, State<any, any>>;
-  public readonly use: Use;
-
-  // biome-ignore lint/suspicious/noExplicitAny: store holds heterogeneous state types
-  constructor(store: Map<string, State<any, any>>, use: Use) {
-    this.store = store;
-    this.use = use;
-  }
+  constructor(
+    private readonly store: Map<string, State<any, any>>,
+    public readonly use: Use,
+  ) {}
 
   public reset() {
     this.ustack = [];
@@ -108,14 +93,12 @@ class Model {
   public readonly listenStackState = (cb: () => void) => {
     this.stackListeners.add(cb);
     return () => this.stackListeners.delete(cb);
-  };
+  }
 
   private triggerStackState() {
     // @ts-expect-error
     this.stackState = [this.canUndo(), this.canRedo()];
-    for (const call of this.stackListeners) {
-      call();
-    }
+    this.stackListeners.forEach(call => call());
   }
 
   private getStackState = () => this.stackState;
@@ -125,11 +108,13 @@ class Model {
   }
 
   public log() {
-    // biome-ignore lint/suspicious/noExplicitAny: debug log accumulates heterogeneous values
+    console.log('undo stack:', this.ustack);
+    console.log('redo stack:', this.rstack);
     const snapshots: Record<string, any> = {};
-    for (const [name, state] of this.store) {
+    this.store.forEach((state, name) => {
       snapshots[name] = state.get();
-    }
+    });
+    console.log('current state:', snapshots);
   }
 
   public undo() {
@@ -137,13 +122,11 @@ class Model {
     const item = ustack.pop();
     if (!item) return;
     const step: Snapshot[] = [];
-    for (const [name, data] of item) {
-      const entry = store.get(name);
-      if (!entry) continue;
-      const { get, set } = entry;
+    item.forEach(([name, data]) => {
+      const { get, set } = store.get(name)!;
       step.push([name, get()]);
       set(data);
-    }
+    });
     rstack.push(step);
     this.triggerStackState();
   }
@@ -153,13 +136,11 @@ class Model {
     const item = rstack.pop();
     if (!item) return;
     const step: Snapshot[] = [];
-    for (const [name, data] of item) {
-      const entry = store.get(name);
-      if (!entry) continue;
-      const { get, set } = entry;
+    item.forEach(([name, data]) => {
+      const { get, set } = store.get(name)!;
       step.push([name, get()]);
       set(data);
-    }
+    });
     ustack.push(step);
     this.triggerStackState();
   }
@@ -175,10 +156,10 @@ class Model {
   public startTransaction() {
     if (this.transaction === 0) {
       this.backup.clear();
-      for (const [name, state] of this.store) {
-        if (state.onlyView) continue;
+      this.store.forEach((state, name) => {
+        if (state.onlyView) return;
         this.backup.set(name, state.get());
-      }
+      });
     }
     this.transaction += 1;
     return this.endTransaction;
@@ -189,26 +170,24 @@ class Model {
     this.transaction -= 1;
     if (this.transaction === 0) {
       const changes: Snapshot[] = [];
-      for (const [name, state] of this.store) {
-        if (state.onlyView) continue;
+      this.store.forEach((state, name) => {
+        if (state.onlyView) return;
         const before = this.backup.get(name);
-        if (Object.is(before, state.get())) continue;
+        if (Object.is(before, state.get())) return;
         changes.push([name, before]);
-      }
+      });
       this.backup.clear();
       if (changes.length === 0) return;
       this.ustack.push(changes);
       this.rstack.length = 0;
       this.triggerStackState();
     }
-  };
+  }
 }
 
 function build() {
-  // biome-ignore lint/suspicious/noExplicitAny: store holds heterogeneous state types
   const store = new Map<string, State<any, any>>();
 
-  // biome-ignore lint/suspicious/noExplicitAny: memo cache stores heterogeneous values
   const mem: Record<string, any> = {};
   function use<T, A>(m: SubModel<T, A>): [T, A] {
     const state = query(m);
@@ -216,8 +195,8 @@ function build() {
   }
 
   const model = new Model(store, use);
-  if (process.env.NODE_ENV === "development") {
-    // @ts-expect-error
+  if (process.env.NODE_ENV === 'development') {
+    // @ts-ignore
     window.__md__ = model;
   }
 
@@ -227,9 +206,9 @@ function build() {
     const created = m.gen(model);
     store.set(m.name, created);
     return created;
-  }
+  };
 
-  return { query, model, mem, use };
+  return { query, model, mem, use }
 }
 
 const Context = createContext(build());
@@ -243,28 +222,24 @@ export function RegisterFlowToContext() {
   const instance = useReactFlow<AnyWorkNode>();
   useLayoutEffect(() => {
     model.flow = instance;
-  }, [instance, model]);
+  }, [instance]);
   return null;
 }
 
 export const ModelProvider: FC<PropsWithChildren> = (p) => (
-  <Context.Provider value={useMemo(build, [])}>{p.children}</Context.Provider>
+  <Context.Provider value={useMemo(build, [])}>
+    {p.children}
+  </Context.Provider>
 );
 
 function defineModel<T, A>(name: string, make: () => T, create: Create<T, A>) {
   return new SubModel<T, A>(name, make, create);
 }
 
-// biome-ignore lint/suspicious/noExplicitAny: default create returns setter directly
 const defaultCreate: Create<any, Setter<any>> = (set) => set;
-function defineView<T, A>(name: string, make: () => T, create: Create<T, A>): SubModel<T, A>;
-function defineView<T>(name: string, make: () => T): SubModel<T, Setter<T>>;
-function defineView<T>(
-  name: string,
-  make: () => T,
-  create?: Create<T, unknown>,
-): SubModel<T, unknown> {
-  // biome-ignore lint/suspicious/noExplicitAny: wraps into SubModel with erased action type
+function defineView<T, A>(name: string, make: () => T, create: Create<T, A>): SubModel<T, A>
+function defineView<T>(name: string, make: () => T): SubModel<T, Setter<T>>
+function defineView<T>(name: string, make: () => T, create?: any): any {
   return new SubModel<T, any>(name, make, create ?? defaultCreate, true);
 }
 
@@ -272,12 +247,9 @@ function memoize<T>(init: (use: Use, model: Model) => T) {
   const id = uuid();
   return {
     use(): T {
-      // biome-ignore lint/correctness/useHookAtTopLevel: use() is called as a hook by consumers
       const { mem, model, use } = useContext(Context);
-      if (!mem[id]) {
-        mem[id] = init(use, model);
-      }
-      return mem[id] as T;
+      const fn = mem[id] || (mem[id] = init(use, model));
+      return fn as T;
     },
   };
 }
@@ -286,29 +258,21 @@ function compute<T>(calc: (use: UseV) => T) {
   const id = uuid();
   return {
     use(): T {
-      // biome-ignore lint/correctness/useHookAtTopLevel: use() is called as a hook by consumers
       const { mem, query } = useContext(Context);
       let state: ReturnType<typeof generate<T>> = mem[id];
       if (state) return state.use();
 
-      // biome-ignore lint/suspicious/noExplicitAny: deps collect heterogeneous SubModels
       const deps = new Set<SubModel<any, any>>();
-      // biome-ignore lint/suspicious/noExplicitAny: useV erases action type
-      let usev = (m: SubModel<any, any>) => {
-        deps.add(m);
-        return query(m).get();
-      };
+      let usev = (m: SubModel<any, any>) => (deps.add(m), query(m).get());
       mem[id] = state = generate<T>(calc(usev));
       if (deps.size) {
-        usev = (m) => query(m).get();
+        usev = m => query(m).get();
         const update = () => state.set(calc(usev));
-        for (const m of deps) {
-          query(m).listen(update);
-        }
+        deps.forEach(m => query(m).listen(update));
       }
       return state.use();
     },
-  };
+  }
 }
 
 export const define = {

packages/workflow-dashboard/src/editor/edges/conditional.tsx

@@ -1,15 +1,15 @@
 import {
-  type Edge,
-  EdgeLabelRenderer,
-  type EdgeProps,
   getSmoothStepPath,
+  EdgeLabelRenderer,
   useReactFlow,
+  type EdgeProps,
+  type Edge,
 } from "@xyflow/react";
+import { useState, useRef, useEffect, useMemo, type ReactNode } from "react";
 import { Check } from "lucide-react";
-import { type ReactNode, useEffect, useMemo, useRef, useState } from "react";
-import { cn } from "../../lib/utils.ts";
-import { useModel } from "../context.tsx";
 import type { ConditionalEdge as ConditionalEdgeType } from "../type.ts";
+import { useModel } from "../context.tsx";
+import { cn } from "../../lib/utils.ts";
 
 const SOURCE_COLOR = "#10b981";
 const TARGET_COLOR = "#3b82f6";
@@ -38,7 +38,7 @@ function GradientPath({
   const gradientId = `gradient-${id}`;
   const showLack = hasCondition === false;
   const strokeStyle = selected
-    ? { stroke: "#f59e0b", strokeWidth: 2 }
+    ? { stroke: '#f59e0b', strokeWidth: 2 }
     : { stroke: `url(#${gradientId})`, strokeWidth: 1.5 };
 
   return (
@@ -63,7 +63,13 @@ function GradientPath({
         strokeWidth={20}
         className="react-flow__edge-interaction"
       />
-      <path id={id} d={path} fill="none" className="react-flow__edge-path" style={strokeStyle} />
+      <path
+        id={id}
+        d={path}
+        fill="none"
+        className="react-flow__edge-path"
+        style={strokeStyle}
+      />
     </>
   );
 }
@@ -137,12 +143,13 @@ function ConditionLabel({ condition, labelX, labelY, onSave }: ConditionLabelPro
       }}
       onPointerDown={(e) => e.stopPropagation()}
     >
-      {/* biome-ignore lint/a11y/noStaticElementInteractions: click handler on badge label */}
       <div onClick={handleBadgeClick} onKeyDown={undefined} className="cursor-pointer">
         <span
           className={cn(
             "inline-block px-1 bg-white rounded text-[10px]",
-            condition ? "border border-gray-300 text-black" : "border border-dashed text-red-500",
+            condition
+              ? "border border-gray-300 text-black"
+              : "border border-dashed text-red-500",
           )}
           style={condition ? undefined : { borderColor: LACK_COLOR }}
         >
@@ -159,6 +166,7 @@ function ConditionLabel({ condition, labelX, labelY, onSave }: ConditionLabelPro
               value={inputValue}
               onChange={(e) => setInputValue(e.target.value)}
               onKeyDown={handleKeyDown}
+              autoFocus
             />
             <button
               type="button"
@@ -175,7 +183,7 @@ function ConditionLabel({ condition, labelX, labelY, onSave }: ConditionLabelPro
 }
 
 export function isElseEdge(edgeId: string, source: string, allEdges: Edge[]): boolean {
-  const siblings = allEdges.filter((e) => e.source === source && e.type === "conditional");
+  const siblings = allEdges.filter(e => e.source === source && e.type === 'conditional');
   return siblings.length >= 2 && siblings[0].id === edgeId;
 }
 
@@ -192,13 +200,7 @@ export function ConditionalEdge({
   data,
 }: EdgeProps<ConditionalEdgeType>): ReactNode {
   const [edgePath, labelX, labelY] = getSmoothStepPath({
-    sourceX,
-    sourceY,
-    targetX,
-    targetY,
-    sourcePosition,
-    targetPosition,
-    borderRadius: RADIUS,
+    sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, borderRadius: RADIUS,
   });
   const flow = useReactFlow();
   const model = useModel();
@@ -222,20 +224,14 @@ export function ConditionalEdge({
         sourceY={sourceY}
         targetX={targetX}
         targetY={targetY}
-        hasCondition={isElse ? null : !!condition}
+        hasCondition={isElse ? null : (condition ? true : false)}
         selected={!!selected}
       />
       <EdgeLabelRenderer>
-        {isElse ? (
-          <ElseBadge labelX={labelX} labelY={labelY} />
-        ) : (
-          <ConditionLabel
-            condition={condition}
-            labelX={labelX}
-            labelY={labelY}
-            onSave={handleSave}
-          />
-        )}
+        {isElse
+          ? <ElseBadge labelX={labelX} labelY={labelY} />
+          : <ConditionLabel condition={condition} labelX={labelX} labelY={labelY} onSave={handleSave} />
+        }
       </EdgeLabelRenderer>
     </>
   );
@@ -252,13 +248,7 @@ export function GradientEdge({
   selected,
 }: EdgeProps<Edge>): ReactNode {
   const [edgePath] = getSmoothStepPath({
-    sourceX,
-    sourceY,
-    targetX,
-    targetY,
-    sourcePosition,
-    targetPosition,
-    borderRadius: RADIUS,
+    sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, borderRadius: RADIUS,
   });
 
   return (

packages/workflow-dashboard/src/editor/edges/index.tsx

@@ -1,4 +1,4 @@
-import { ConditionalEdge, GradientEdge } from "./conditional";
+import { ConditionalEdge, GradientEdge } from './conditional';
 
 export const edgeTypes = {
   conditional: ConditionalEdge,

packages/workflow-dashboard/src/editor/flow.tsx

@@ -1,16 +1,16 @@
-import { Background, Controls, type Edge, ReactFlow, ReactFlowProvider } from "@xyflow/react";
-import { createContext, createElement, memo, useContext, useEffect, useLayoutEffect } from "react";
-// @ts-expect-error
-import "@xyflow/react/dist/style.css";
-import { ModelProvider, RegisterFlowToContext } from "./context";
-import { edgeTypes } from "./edges";
-import { FlowModel, InternalField } from "./injection";
-import { edgesModel, handlers, injection, nodesModel } from "./model";
-import { nodeTypes } from "./nodes";
-import { Dialogs, TopCenterPanel } from "./panel";
-import type { AnyWorkNode } from "./type";
+import { memo, createElement, useLayoutEffect, useEffect, createContext, useContext } from 'react';
+import { ReactFlow, ReactFlowProvider, Controls, Background, type Edge } from '@xyflow/react';
+// @ts-ignore
+import '@xyflow/react/dist/style.css';
+import { nodesModel, edgesModel, handlers, injection }  from './model';
+import { ModelProvider, RegisterFlowToContext } from './context';
+import { nodeTypes } from './nodes';
+import { edgeTypes } from './edges';
+import { Dialogs, TopCenterPanel } from './panel';
+import type { AnyWorkNode } from './type';
+import { FlowModel, InternalField } from './injection';
 
-export * from "./trans/type";
+export * from './trans/type';
 
 const proOptions = { hideAttribution: true };
 
@@ -20,13 +20,11 @@ export const useReadonly = () => useContext(ReadonlyContext);
 function Flow() {
   const [nodes, { onNodesChange }] = nodesModel.use();
   const [edges, { onEdgesChange, onConnect }] = edgesModel.use();
-  const { onNodeDragStart, onNodeDragStop, onConnectEnd, onBeforeDelete, onDelete, handleKeyDown } =
-    handlers.use();
+  const { onNodeDragStart, onNodeDragStop, onConnectEnd, onBeforeDelete, onDelete, handleKeyDown } = handlers.use();
   const readonly = useReadonly();
 
   return (
-    // biome-ignore lint/a11y/noStaticElementInteractions: keyboard handler for flow shortcuts
-    <div style={{ height: "100%" }} onKeyDown={readonly ? undefined : handleKeyDown}>
+    <div style={{ height: '100%' }} tabIndex={0} onKeyDown={readonly ? undefined : handleKeyDown}>
       <ReactFlowProvider>
         <ReactFlow<AnyWorkNode, Edge>
           nodes={nodes}
@@ -72,11 +70,11 @@ function Connect({ model }: { model: FlowModel }) {
 
   useLayoutEffect(() => {
     return inject(instance);
-  }, [instance, inject]);
+  }, [instance]);
 
   useEffect(() => {
-    return instance.on("load", loadSteps);
-  }, [instance, loadSteps]);
+    return instance.on('load', loadSteps);
+  }, [instance]);
 
   return <MemoFlow />;
 }
@@ -85,6 +83,8 @@ export { FlowModel };
 // biome-ignore lint/style/noDefaultExport: FlowEditor is the main public component
 export default ({ model, readonly = false }: Props) => (
   <ReadonlyContext.Provider value={readonly}>
-    <ModelProvider>{createElement(Connect, { model })}</ModelProvider>
+    <ModelProvider>
+      {createElement(Connect, { model })}
+    </ModelProvider>
   </ReadonlyContext.Provider>
 );

packages/workflow-dashboard/src/editor/injection.ts

@@ -1,5 +1,5 @@
-import type { WorkFlowSteps } from "./trans";
-import { Eventer } from "./utils/eventer";
+import { WorkFlowSteps } from "./trans";
+import { Eventer } from './utils/eventer';
 
 interface PublicEvents {
   save: WorkFlowSteps;
@@ -9,21 +9,19 @@ interface PrivateEvents {
   load: WorkFlowSteps;
 }
 
-export const InternalField = Symbol("InternalField");
+export const InternalField = Symbol('InternalField');
 
 export class Injection extends Eventer<PrivateEvents> {
-  public readonly emitPublic: Eventer<PublicEvents>["emit"];
-  private inital_steps: WorkFlowSteps | undefined;
-
-  constructor(emitPublic: Eventer<PublicEvents>["emit"], inital_steps?: WorkFlowSteps) {
+  constructor(
+    public readonly emitPublic: Eventer<PublicEvents>['emit'],
+    private inital_steps?: WorkFlowSteps,
+  ) {
     super();
-    this.emitPublic = emitPublic;
-    this.inital_steps = inital_steps;
   }
 
-  public on: Eventer<PrivateEvents>["on"] = (type, lisenter) => {
-    const off = super.on(type, lisenter);
-    if (type === "load" && this.inital_steps) {
+  public on: Eventer<PrivateEvents>['on'] = (type, lisenter) => {
+    const off =  super.on(type, lisenter);
+    if (type === 'load' && this.inital_steps) {
       lisenter(this.inital_steps);
       this.inital_steps = undefined;
     }
@@ -39,10 +37,13 @@ export class FlowModel {
   public readonly [InternalField]: Injection;
 
   constructor(inital_steps?: WorkFlowSteps) {
-    this[InternalField] = new Injection(this.eventer.emit.bind(this.eventer), inital_steps);
+    this[InternalField] = new Injection(
+      this.eventer.emit.bind(this.eventer),
+      inital_steps,
+    );
   }
 
   public load(steps: WorkFlowSteps) {
-    this[InternalField].emit("load", steps);
+    this[InternalField].emit('load', steps);
   }
 }

packages/workflow-dashboard/src/editor/layout/index.ts

@@ -1,4 +1,4 @@
-import type { Edge, Node } from "@xyflow/react";
+import { Node, Edge } from '@xyflow/react';
 
 const DEFAULT_NODE_WIDTH = 120;
 const DEFAULT_NODE_HEIGHT = 50;
@@ -34,8 +34,8 @@ function buildGraph(nodes: Node[], edges: Edge[]) {
   // 构建图
   for (const edge of edges) {
     if (nodeIds.has(edge.source) && nodeIds.has(edge.target)) {
-      outgoing.get(edge.source)?.push(edge.target);
-      incoming.get(edge.target)?.push(edge.source);
+      outgoing.get(edge.source)!.push(edge.target);
+      incoming.get(edge.target)!.push(edge.source);
       inDegree.set(edge.target, (inDegree.get(edge.target) ?? 0) + 1);
     }
   }
@@ -55,17 +55,17 @@ function assignLayers(nodes: Node[], edges: Edge[]): Map<string, number> {
   const queue: string[] = [];
 
   // 1. start 节点固定在第 0 层
-  layers.set("start", 0);
-  queue.push("start");
+  layers.set('start', 0);
+  queue.push('start');
 
   // 2. BFS 分层（排除 end 节点，稍后单独处理）
   while (queue.length > 0) {
-    const current = queue.shift() ?? "";
-    const currentLayer = layers.get(current) ?? 0;
+    const current = queue.shift()!;
+    const currentLayer = layers.get(current)!;
 
     for (const target of outgoing.get(current) ?? []) {
       // 跳过 end 节点，稍后处理
-      if (target === "end") continue;
+      if (target === 'end') continue;
 
       const newLayer = currentLayer + 1;
       const existingLayer = layers.get(target);
@@ -93,7 +93,7 @@ function assignLayers(nodes: Node[], edges: Edge[]): Map<string, number> {
   // 把它们放在中间层
   const middleLayer = Math.max(1, Math.floor((maxLayer + 1) / 2));
   for (const node of nodes) {
-    if (node.id !== "start" && node.id !== "end" && !layers.has(node.id)) {
+    if (node.id !== 'start' && node.id !== 'end' && !layers.has(node.id)) {
       layers.set(node.id, middleLayer);
     }
   }
@@ -101,13 +101,13 @@ function assignLayers(nodes: Node[], edges: Edge[]): Map<string, number> {
   // 5. 重新计算最大层级（可能因为孤立节点而变化）
   maxLayer = 0;
   for (const [id, layer] of layers) {
-    if (id !== "end") {
+    if (id !== 'end') {
       maxLayer = Math.max(maxLayer, layer);
     }
   }
 
   // 6. end 节点固定在最后一层
-  layers.set("end", maxLayer + 1);
+  layers.set('end', maxLayer + 1);
 
   return layers;
 }
@@ -123,7 +123,7 @@ function groupByLayer<N extends Node>(nodes: N[], layers: Map<string, number>):
     if (!groups.has(layer)) {
       groups.set(layer, []);
     }
-    groups.get(layer)?.push(node);
+    groups.get(layer)!.push(node);
   }
 
   return groups;
@@ -152,7 +152,7 @@ function calculateLayerWidths(layerGroups: Map<number, Node[]>): Map<number, num
  */
 function calculateLayerXPositions(
   layerWidths: Map<number, number>,
-  maxLayer: number,
+  maxLayer: number
 ): Map<number, number> {
   const xPositions = new Map<number, number>();
   let currentX = 0;

packages/workflow-dashboard/src/editor/model/add-node-view.ts

@@ -1,13 +1,13 @@
-import type { Edge } from "@xyflow/react";
-import { define } from "../context";
-import type { AnyWorkNode, RoleNodeData } from "../type";
-import { edgesModel } from "./edges";
-import { nodesModel } from "./nodes";
+import type { Edge } from '@xyflow/react';
+import { define } from '../context';
+import { nodesModel } from './nodes';
+import { edgesModel } from './edges';
+import type { RoleNodeData, AnyWorkNode } from '../type';
 
 type ConnectHandle = {
   id?: string | null;
   nodeId: string;
-  type: "source" | "target";
+  type: 'source' | 'target';
 };
 
 export type AddNodeState = {
@@ -21,10 +21,10 @@ type CommitParams = {
 };
 
 function addNodeView() {
-  return null as AddNodeState | null;
+  return null as (AddNodeState | null);
 }
 
-export const addNodeViewModel = define.view("addNodeView", addNodeView, (set, get, model) => {
+export const addNodeViewModel = define.view('addNodeView', addNodeView, (set, get, model) => {
   function start(state: AddNodeState) {
     set(state);
   }
@@ -42,19 +42,12 @@ export const addNodeViewModel = define.view("addNodeView", addNodeView, (set, ge
     const { data } = params;
 
     const id = `n${Date.now()}`;
-    const node = {
-      id,
-      data,
-      position,
-      type: "role" as const,
-      origin: [0.0, 0.5] as [number, number],
-    };
+    const node = { id, data, position, type: 'role' as const, origin: [0.0, 0.5] as [number, number] };
 
     const [fnid, fhid] = [fromNode.id, fromHandle.id];
-    const newEdge: Edge =
-      fromHandle.type === "source"
-        ? { id: `e${fnid}-${id}`, source: fnid, target: id, sourceHandle: fhid, animated: true }
-        : { id: `e${id}-${fnid}`, source: id, target: fnid, targetHandle: fhid, animated: true };
+    const newEdge: Edge = fromHandle.type === 'source'
+      ? { id: `e${fnid}-${id}`, source: fnid, target: id, sourceHandle: fhid, animated: true }
+      : { id: `e${id}-${fnid}`, source: id, target: fnid, targetHandle: fhid, animated: true };
 
     model.startTransaction();
     model.use(nodesModel)[1].set((nds) => nds.concat(node));

packages/workflow-dashboard/src/editor/model/edges.ts

@@ -1,16 +1,21 @@
-import { applyEdgeChanges, type Connection, type Edge, type EdgeChange } from "@xyflow/react";
-import { define } from "../context";
+import {
+  applyEdgeChanges,
+  type Edge,
+  type EdgeChange,
+  type Connection,
+} from '@xyflow/react';
+import { define } from '../context';
 
 function makeEdges(): Edge[] {
   return [];
 }
 
 function isInputHandle(handle: string | null | undefined): boolean {
-  return handle === "input" || handle === "input-top" || handle === "input-bottom";
+  return handle === 'input' || handle === 'input-top' || handle === 'input-bottom';
 }
 
 function isOutputHandle(handle: string | null | undefined): boolean {
-  return handle === "output" || handle === "output-top" || handle === "output-bottom";
+  return handle === 'output' || handle === 'output-top' || handle === 'output-bottom';
 }
 
 function normalizeConnection(params: Edge | Connection): Edge | Connection {
@@ -28,10 +33,10 @@ function normalizeConnection(params: Edge | Connection): Edge | Connection {
 
 let edgeCounter = 0;
 
-export const edgesModel = define.model("edges", makeEdges, (set, get, model) => {
+export const edgesModel = define.model('edges', makeEdges, (set, get, model) => {
   function onEdgesChange(changes: EdgeChange[]) {
-    const whites = new Set(["add", "replace"]);
-    if (changes.some((c) => whites.has(c.type))) {
+    const whites = new Set(['add', 'replace']);
+    if (changes.some(c => whites.has(c.type))) {
       model.startTransaction();
       set((eds) => applyEdgeChanges(changes, eds));
       requestAnimationFrame(model.endTransaction);
@@ -49,7 +54,7 @@ export const edgesModel = define.model("edges", makeEdges, (set, get, model) =>
 
     const currentEdges = get();
     const duplicate = currentEdges.some(
-      (e) => e.source === normalized.source && e.target === normalized.target,
+      e => e.source === normalized.source && e.target === normalized.target,
     );
     if (duplicate) return;
 
@@ -62,15 +67,15 @@ export const edgesModel = define.model("edges", makeEdges, (set, get, model) =>
       animated: true,
     } as Edge;
 
-    const existingFromSource = currentEdges.filter((e) => e.source === normalized.source);
+    const existingFromSource = currentEdges.filter(e => e.source === normalized.source);
 
     if (existingFromSource.length > 0) {
-      edge.type = "conditional";
-      edge.data = { condition: "" };
+      edge.type = 'conditional';
+      edge.data = { condition: '' };
 
-      const promoted = currentEdges.map((e) => {
-        if (e.source === normalized.source && e.type !== "conditional") {
-          return { ...e, type: "conditional" as const, data: { condition: "" } };
+      const promoted = currentEdges.map(e => {
+        if (e.source === normalized.source && e.type !== 'conditional') {
+          return { ...e, type: 'conditional' as const, data: { condition: '' } };
         }
         return e;
       });

packages/workflow-dashboard/src/editor/model/edit-node-view.ts

@@ -1,21 +1,21 @@
-import { define } from "../context";
-import type { RoleNodeData, WorkNode } from "../type";
-import { nodesModel } from "./nodes";
+import { define } from '../context';
+import { nodesModel } from './nodes';
+import type { RoleNodeData, WorkNode } from '../type';
 
 export type EditNodeState = {
-  node: WorkNode<"role">;
+  node: WorkNode<'role'>;
 };
 
 function editNodeView() {
-  return null as EditNodeState | null;
+  return null as (EditNodeState | null);
 }
 
-export const editNodeViewModel = define.view("editNodeView", editNodeView, (set, get, model) => {
+export const editNodeViewModel = define.view('editNodeView', editNodeView, (set, get, model) => {
   function start(nodeId: string) {
     const [nodes] = model.use(nodesModel);
-    const node = nodes.find((n) => n.id === nodeId);
-    if (!node || node.type !== "role") return;
-    set({ node: node as WorkNode<"role"> });
+    const node = nodes.find(n => n.id === nodeId);
+    if (!node || node.type !== 'role') return;
+    set({ node: node as WorkNode<'role'> });
   }
 
   function cancel() {
@@ -31,7 +31,6 @@ export const editNodeViewModel = define.view("editNodeView", editNodeView, (set,
 
     model.startTransaction();
     editNode(state.node.id, (node) => {
-      // biome-ignore lint/suspicious/noExplicitAny: node data type varies by node kind
       node.data = data as any;
     });
     requestAnimationFrame(model.endTransaction);

packages/workflow-dashboard/src/editor/model/handlers.ts

@@ -1,14 +1,14 @@
-import type { OnBeforeDelete, OnConnectEnd, OnDelete, OnNodeDrag } from "@xyflow/react";
-import { define } from "../context";
-import { LayoutLR } from "../layout";
-import type { WorkFlowSteps } from "../trans";
-import { transIn, transOut, validate } from "../trans";
-import type { AnyWorkNode } from "../type";
-import { addNodeViewModel } from "./add-node-view";
-import { edgesModel } from "./edges";
-import { editNodeViewModel } from "./edit-node-view";
-import { injection } from "./inject";
-import { nodesModel } from "./nodes";
+import type { OnNodeDrag, OnConnectEnd, OnBeforeDelete, OnDelete } from '@xyflow/react';
+import { define } from '../context';
+import { addNodeViewModel } from './add-node-view';
+import type { AnyWorkNode } from '../type';
+import { LayoutLR } from '../layout';
+import { nodesModel } from './nodes';
+import { edgesModel } from './edges';
+import { injection } from './inject';
+import { transIn, transOut, validate } from '../trans';
+import type { WorkFlowSteps } from '../trans';
+import { editNodeViewModel } from './edit-node-view';
 
 export const handlers = define.memoize((use, model) => {
   const onNodeDragStart: OnNodeDrag<AnyWorkNode> = () => {
@@ -23,7 +23,6 @@ export const handlers = define.memoize((use, model) => {
     if (!to || !fromHandle || !fromNode) return;
     const { clientX, clientY } = event as MouseEvent;
     use(addNodeViewModel)[1].start({
-      // biome-ignore lint/suspicious/noExplicitAny: ReactFlow node type mismatch
       fromNode: fromNode as any as AnyWorkNode,
       fromHandle: fromHandle,
       position: model.flow.screenToFlowPosition({ x: clientX, y: clientY }),
@@ -32,17 +31,15 @@ export const handlers = define.memoize((use, model) => {
 
   const onBeforeDelete: OnBeforeDelete<AnyWorkNode> = async ({ nodes, edges }) => {
     for (const node of nodes) {
-      if (node.type === "start" || node.type === "end") {
+      if (node.type === 'start' || node.type === 'end') {
         return false;
       }
     }
     if (edges.length > 0) {
       const allEdges = use(edgesModel)[0];
       for (const edge of edges) {
-        if (edge.type !== "conditional") continue;
-        const siblings = allEdges.filter(
-          (e) => e.source === edge.source && e.type === "conditional",
-        );
+        if (edge.type !== 'conditional') continue;
+        const siblings = allEdges.filter(e => e.source === edge.source && e.type === 'conditional');
         if (siblings.length >= 2 && siblings[0].id === edge.id) {
           return false;
         }
@@ -55,20 +52,20 @@ export const handlers = define.memoize((use, model) => {
     if (deletedEdges.length > 0) {
       const currentEdges = use(edgesModel)[0];
       const sourcesToCheck = new Set(
-        deletedEdges.filter((e) => e.type === "conditional").map((e) => e.source),
+        deletedEdges
+          .filter(e => e.type === 'conditional')
+          .map(e => e.source),
       );
 
       if (sourcesToCheck.size > 0) {
         let needsDowngrade = false;
-        const updatedEdges = currentEdges.map((e) => {
-          if (!sourcesToCheck.has(e.source) || e.type !== "conditional") return e;
-          const siblings = currentEdges.filter(
-            (s) => s.source === e.source && s.type === "conditional",
-          );
+        const updatedEdges = currentEdges.map(e => {
+          if (!sourcesToCheck.has(e.source) || e.type !== 'conditional') return e;
+          const siblings = currentEdges.filter(s => s.source === e.source && s.type === 'conditional');
           if (siblings.length === 1) {
             needsDowngrade = true;
             const { data: _, ...rest } = e;
-            return { ...rest, type: "default" as const };
+            return { ...rest, type: 'default' as const };
           }
           return e;
         });
@@ -97,7 +94,7 @@ export const handlers = define.memoize((use, model) => {
   }
 
   function handleKeyDown(event: React.KeyboardEvent<HTMLDivElement>) {
-    if (event.code === "Escape") {
+    if (event.code === 'Escape') {
       const [addView, addViewActions] = use(addNodeViewModel);
       const [editView, editViewActions] = use(editNodeViewModel);
       if (addView) addViewActions.cancel();
@@ -105,12 +102,12 @@ export const handlers = define.memoize((use, model) => {
       return;
     }
 
-    if (event.code === "KeyZ") {
+    if (event.code === 'KeyZ') {
       if (event.ctrlKey || event.metaKey) {
         if (event.shiftKey) model.redo();
         else model.undo();
       }
-    } else if (event.code === "KeyY") {
+    } else if (event.code === 'KeyY') {
       if (event.ctrlKey || event.metaKey) {
         model.redo();
       }
@@ -133,7 +130,7 @@ export const handlers = define.memoize((use, model) => {
     if (result.valid) {
       const steps = transOut(nodes, edges);
       const instance = use(injection)[0];
-      instance.emitPublic("save", steps);
+      instance.emitPublic('save', steps);
     }
     return result;
   }

packages/workflow-dashboard/src/editor/model/index.ts

@@ -1,6 +1,6 @@
-export { type AddNodeState, addNodeViewModel } from "./add-node-view";
-export { edgesModel } from "./edges";
-export { type EditNodeState, editNodeViewModel } from "./edit-node-view";
-export { handlers } from "./handlers";
-export { injection } from "./inject";
-export { nodesModel } from "./nodes";
+export { nodesModel } from './nodes';
+export { edgesModel } from './edges';
+export { addNodeViewModel, type AddNodeState } from './add-node-view';
+export { editNodeViewModel, type EditNodeState } from './edit-node-view';
+export { handlers } from './handlers';
+export { injection } from './inject';

packages/workflow-dashboard/src/editor/model/inject.ts

@@ -3,7 +3,8 @@
  */
 
 import { define } from "../context.tsx";
-import { Injection } from "../injection.ts";
+import { Injection } from '../injection.ts';
+
 
 const NOOP = () => {};
 const placeholder = new Injection(NOOP);
@@ -12,7 +13,7 @@ function make(): Injection {
   return placeholder;
 }
 
-export const injection = define.view("injection", make, (set) => {
+export const injection = define.view('injection', make, (set) => {
   function reset() {
     set(make());
   }

packages/workflow-dashboard/src/editor/model/nodes.ts

@@ -1,49 +1,48 @@
-import { applyNodeChanges, type NodeChange } from "@xyflow/react";
-import { type Draft, produce } from "immer";
-import { define } from "../context";
-import type { AnyWorkNode } from "../type";
+import { produce, type Draft } from 'immer';
+import { applyNodeChanges, NodeChange } from '@xyflow/react';
+import { define } from '../context';
+import type { AnyWorkNode } from '../type';
+
 
 function makeNodes(): AnyWorkNode[] {
   return [
     {
-      id: "start",
-      type: "start",
-      data: { label: "Start" },
+      id: 'start',
+      type: 'start',
+      data: { label: 'Start' },
       position: { x: 0, y: 0 },
     },
     {
-      id: "end",
-      data: { label: "End" },
+      id: 'end',
+      data: { label: 'End' },
       position: { x: 1000, y: 0 },
-      type: "end",
+      type: 'end',
     },
   ];
 }
 
-export const nodesModel = define.model("nodes", makeNodes, (set, _get, model) => {
-  const whites = new Set<NodeChange["type"]>(["add", "replace"]);
+export const nodesModel = define.model('nodes', makeNodes, (set, _get, model) => {
+  const whites = new Set<NodeChange['type']>(['add', 'replace']);
   function onNodesChange(changes: NodeChange<AnyWorkNode>[]) {
-    if (changes.some((c) => whites.has(c.type))) {
+    if (changes.some(c => whites.has(c.type))) {
       model.startTransaction();
       set((nds) => applyNodeChanges(changes, nds));
       requestAnimationFrame(model.endTransaction);
       return;
     }
     set((nds) => applyNodeChanges(changes, nds));
-  }
+  };
 
   function editNode(id: string, updater: (node: Draft<AnyWorkNode>) => void) {
-    set(
-      produce((draft) => {
-        const node = draft.find((n) => n.id === id);
-        if (node) updater(node);
-      }),
-    );
+    set(produce((draft) => {
+      const node = draft.find(n => n.id === id);
+      if (node) updater(node);
+    }));
   }
 
   function deleteNode(id: string) {
     model.startTransaction();
-    set((nds) => nds.filter((n) => n.id !== id));
+    set((nds) => nds.filter(n => n.id !== id));
     requestAnimationFrame(model.endTransaction);
   }
 

packages/workflow-dashboard/src/editor/nodes/end.tsx

@@ -1,19 +1,23 @@
-import { Handle, type Node, type NodeProps, Position } from "@xyflow/react";
-import { EndNode } from "./nodes.style";
+import { Handle, Position, Node, NodeProps } from '@xyflow/react';
+import { EndNode } from './nodes.style';
 
 interface NodeData {
   label: string;
   [key: string]: unknown;
 }
 
-type NodeType = Node<NodeData, "end">;
+type NodeType = Node<NodeData, 'end'>;
 type Props = NodeProps<NodeType>;
 
 export function NodeEnd({ data }: Props) {
   return (
     <EndNode>
-      <Handle type="target" position={Position.Left} id="input" />
-      {data?.label || "End"}
+      <Handle
+        type="target"
+        position={Position.Left}
+        id="input"
+      />
+      {data?.label || 'End'}
     </EndNode>
   );
 }

packages/workflow-dashboard/src/editor/nodes/index.tsx

@@ -1,6 +1,6 @@
-import { NodeEnd } from "./end";
-import { NodeRole } from "./role";
-import { NodeStart } from "./start";
+import { NodeStart } from './start';
+import { NodeEnd } from './end';
+import { NodeRole } from './role';
 
 export const nodeTypes = {
   start: NodeStart,

packages/workflow-dashboard/src/editor/nodes/node-toolbar.tsx

@@ -1,5 +1,5 @@
-import { Pencil, Trash2 } from "lucide-react";
 import type { ReactNode } from "react";
+import { Pencil, Trash2 } from "lucide-react";
 import { Button } from "../../components/ui/button.tsx";
 
 type Props = {
@@ -13,13 +13,7 @@ export function NodeToolbarActions({ onEdit, onDelete }: Props): ReactNode {
       <Button variant="ghost" size="icon-xs" onClick={onEdit} title="编辑">
         <Pencil />
       </Button>
-      <Button
-        variant="ghost"
-        size="icon-xs"
-        className="hover:bg-destructive/10 hover:text-destructive"
-        onClick={onDelete}
-        title="删除"
-      >
+      <Button variant="ghost" size="icon-xs" className="hover:bg-destructive/10 hover:text-destructive" onClick={onDelete} title="删除">
         <Trash2 />
       </Button>
     </div>

packages/workflow-dashboard/src/editor/nodes/nodes.style.tsx

@@ -45,7 +45,12 @@ export function NodeContent({ children }: { children: ReactNode }): ReactNode {
 
 export function NodeIcon({ className, children }: Props): ReactNode {
   return (
-    <div className={cn("flex items-center justify-center w-8 h-8 rounded-lg shrink-0", className)}>
+    <div
+      className={cn(
+        "flex items-center justify-center w-8 h-8 rounded-lg shrink-0",
+        className,
+      )}
+    >
       {children}
     </div>
   );
@@ -57,14 +62,23 @@ export function NodeBody({ children }: { children: ReactNode }): ReactNode {
 
 export function NodeKindLabel({ className, children }: Props): ReactNode {
   return (
-    <div className={cn("text-[10px] font-semibold uppercase tracking-wide mb-1", className)}>
+    <div
+      className={cn(
+        "text-[10px] font-semibold uppercase tracking-wide mb-1",
+        className,
+      )}
+    >
       {children}
     </div>
   );
 }
 
 export function NodeHint({ children }: { children: ReactNode }): ReactNode {
-  return <div className="text-[13px] text-gray-800 leading-snug break-words">{children}</div>;
+  return (
+    <div className="text-[13px] text-gray-800 leading-snug break-words">
+      {children}
+    </div>
+  );
 }
 
 export function NodeSubHint({ children }: { children: ReactNode }): ReactNode {
@@ -79,6 +93,8 @@ export function RoleIcon({ children }: { children: ReactNode }): ReactNode {
   );
 }
 
-export function RoleKindLabel({ children }: { children: ReactNode }): ReactNode {
+export function RoleKindLabel({
+  children,
+}: { children: ReactNode }): ReactNode {
   return <NodeKindLabel className="text-teal-700">{children}</NodeKindLabel>;
 }

packages/workflow-dashboard/src/editor/nodes/role.tsx

@@ -1,20 +1,24 @@
-import { Handle, type NodeProps, NodeToolbar, Position, useNodeConnections } from "@xyflow/react";
-import { Users } from "lucide-react";
-import { useMemo } from "react";
-import { useReadonly } from "../flow";
-import { nodesModel } from "../model";
-import { editNodeViewModel } from "../model/edit-node-view";
-import type { WorkNode } from "../type";
-import { NodeToolbarActions } from "./node-toolbar";
-import { NodeBody, NodeContent, NodeHint, RoleIcon, RoleKindLabel } from "./nodes.style";
+import { Handle, Position, NodeToolbar, useNodeConnections, type NodeProps } from '@xyflow/react';
+import { Users } from 'lucide-react';
+import {
+  NodeContent,
+  NodeBody,
+  RoleIcon,
+  RoleKindLabel,
+  NodeHint,
+} from './nodes.style';
+import { NodeToolbarActions } from './node-toolbar';
+import { editNodeViewModel } from '../model/edit-node-view';
+import { nodesModel } from '../model';
+import type { WorkNode } from '../type';
+import { useMemo, type ReactNode } from 'react';
+import { useReadonly } from '../flow';
 
-type Props = NodeProps<WorkNode<"role">>;
+type Props = NodeProps<WorkNode<'role'>>;
 
-const containerClass =
-  "bg-white border border-gray-200 rounded-[10px] shadow-sm transition-all duration-200 hover:shadow-md hover:border-gray-400 [&_.react-flow\\_\\_handle]:w-3 [&_.react-flow\\_\\_handle]:h-3 [&_.react-flow\\_\\_handle]:border-2 [&_.react-flow\\_\\_handle]:transition-all [&_.react-flow\\_\\_handle]:duration-150";
+const containerClass = "bg-white border border-gray-200 rounded-[10px] shadow-sm transition-all duration-200 hover:shadow-md hover:border-gray-400 [&_.react-flow\\_\\_handle]:w-3 [&_.react-flow\\_\\_handle]:h-3 [&_.react-flow\\_\\_handle]:border-2 [&_.react-flow\\_\\_handle]:transition-all [&_.react-flow\\_\\_handle]:duration-150";
 const targetClass = "!bg-blue-100 !border-blue-500 hover:!bg-blue-500 hover:!border-blue-600";
-const sourceClass =
-  "!bg-emerald-100 !border-emerald-500 hover:!bg-emerald-500 hover:!border-emerald-600";
+const sourceClass = "!bg-emerald-100 !border-emerald-500 hover:!bg-emerald-500 hover:!border-emerald-600";
 
 export function NodeRole({ data, id, selected }: Props) {
   const startEdit = editNodeViewModel.useCreation().start;
@@ -31,14 +35,8 @@ export function NodeRole({ data, id, selected }: Props) {
     return set;
   }, [connections, id]);
 
-  const hasInputConnection =
-    connectedHandles.has("input") ||
-    connectedHandles.has("input-top") ||
-    connectedHandles.has("input-bottom");
-  const hasOutputConnection =
-    connectedHandles.has("output") ||
-    connectedHandles.has("output-top") ||
-    connectedHandles.has("output-bottom");
+  const hasInputConnection = connectedHandles.has('input') || connectedHandles.has('input-top') || connectedHandles.has('input-bottom');
+  const hasOutputConnection = connectedHandles.has('output') || connectedHandles.has('output-top') || connectedHandles.has('output-bottom');
 
   const showHandle = (handleId: string, alwaysShow: boolean) => {
     if (readonly) return connectedHandles.has(handleId);
@@ -47,35 +45,9 @@ export function NodeRole({ data, id, selected }: Props) {
 
   return (
     <div className={containerClass}>
-      {showHandle("input", true) && (
-        <Handle
-          type="target"
-          position={Position.Left}
-          id="input"
-          className={targetClass}
-          isConnectableStart
-        />
-      )}
-      {showHandle("input-top", hasInputConnection) && (
-        <Handle
-          type="target"
-          position={Position.Top}
-          id="input-top"
-          style={{ left: "30%" }}
-          className={targetClass}
-          isConnectableStart
-        />
-      )}
-      {showHandle("input-bottom", hasInputConnection) && (
-        <Handle
-          type="target"
-          position={Position.Bottom}
-          id="input-bottom"
-          style={{ left: "30%" }}
-          className={targetClass}
-          isConnectableStart
-        />
-      )}
+      {showHandle('input', true) && <Handle type="target" position={Position.Left} id="input" className={targetClass} isConnectableStart />}
+      {showHandle('input-top', hasInputConnection) && <Handle type="target" position={Position.Top} id="input-top" style={{ left: '30%' }} className={targetClass} isConnectableStart />}
+      {showHandle('input-bottom', hasInputConnection) && <Handle type="target" position={Position.Bottom} id="input-bottom" style={{ left: '30%' }} className={targetClass} isConnectableStart />}
       <NodeContent>
         <RoleIcon>
           <Users size={16} />
@@ -86,37 +58,14 @@ export function NodeRole({ data, id, selected }: Props) {
         </NodeBody>
       </NodeContent>
       <NodeToolbar isVisible={selected && !readonly} position={Position.Bottom}>
-        <NodeToolbarActions onEdit={() => startEdit(id)} onDelete={() => deleteNode(id)} />
+        <NodeToolbarActions
+          onEdit={() => startEdit(id)}
+          onDelete={() => deleteNode(id)}
+        />
       </NodeToolbar>
-      {showHandle("output", true) && (
-        <Handle
-          type="source"
-          position={Position.Right}
-          id="output"
-          className={sourceClass}
-          isConnectableEnd
-        />
-      )}
-      {showHandle("output-top", hasOutputConnection) && (
-        <Handle
-          type="source"
-          position={Position.Top}
-          id="output-top"
-          style={{ left: "70%" }}
-          className={sourceClass}
-          isConnectableEnd
-        />
-      )}
-      {showHandle("output-bottom", hasOutputConnection) && (
-        <Handle
-          type="source"
-          position={Position.Bottom}
-          id="output-bottom"
-          style={{ left: "70%" }}
-          className={sourceClass}
-          isConnectableEnd
-        />
-      )}
+      {showHandle('output', true) && <Handle type="source" position={Position.Right} id="output" className={sourceClass} isConnectableEnd />}
+      {showHandle('output-top', hasOutputConnection) && <Handle type="source" position={Position.Top} id="output-top" style={{ left: '70%' }} className={sourceClass} isConnectableEnd />}
+      {showHandle('output-bottom', hasOutputConnection) && <Handle type="source" position={Position.Bottom} id="output-bottom" style={{ left: '70%' }} className={sourceClass} isConnectableEnd />}
     </div>
   );
 }

packages/workflow-dashboard/src/editor/nodes/start.tsx

@@ -1,13 +1,13 @@
-import { Handle, type Node, type NodeProps, Position, useNodeConnections } from "@xyflow/react";
-import { useMemo } from "react";
-import { StartNode } from "./nodes.style";
+import { Handle, Position, Node, NodeProps, useNodeConnections } from '@xyflow/react';
+import { StartNode } from './nodes.style';
+import { useMemo } from 'react';
 
 interface NodeData {
   label: string;
   [key: string]: unknown;
 }
 
-type NodeType = Node<NodeData, "start">;
+type NodeType = Node<NodeData, 'start'>;
 type Props = NodeProps<NodeType>;
 
 export function NodeStart({ data, id }: Props) {
@@ -19,7 +19,7 @@ export function NodeStart({ data, id }: Props) {
 
   return (
     <StartNode>
-      {data?.label || "Start"}
+      {data?.label || 'Start'}
       <Handle
         type="source"
         position={Position.Right}

packages/workflow-dashboard/src/editor/panel/add-node.tsx

@@ -1,16 +1,16 @@
-import { type ReactNode, useEffect, useState } from "react";
-import { Button } from "../../components/ui/button.tsx";
+import { useState, useEffect, type ReactNode } from "react";
+import { addNodeViewModel, type AddNodeState } from "../model/index.ts";
 import {
   Dialog,
   DialogContent,
-  DialogFooter,
   DialogHeader,
   DialogTitle,
+  DialogFooter,
 } from "../../components/ui/dialog.tsx";
 import { Input } from "../../components/ui/input.tsx";
-import { Label } from "../../components/ui/label.tsx";
 import { Textarea } from "../../components/ui/textarea.tsx";
-import { type AddNodeState, addNodeViewModel } from "../model/index.ts";
+import { Button } from "../../components/ui/button.tsx";
+import { Label } from "../../components/ui/label.tsx";
 import type { RoleNodeData } from "../type.ts";
 
 type FormProps = {
@@ -34,7 +34,7 @@ function Form({ state, onSubmit, onCancel }: FormProps): ReactNode {
     setPrepare("");
     setExecute("");
     setReport("");
-  }, []);
+  }, [state]);
 
   function handleConfirm() {
     if (!name.trim()) return;
@@ -59,7 +59,11 @@ function Form({ state, onSubmit, onCancel }: FormProps): ReactNode {
       <div className="flex flex-col gap-3 max-h-[400px] overflow-y-auto p-1">
         <div className="flex flex-col gap-1.5">
           <Label className="text-xs text-muted-foreground">名称 *</Label>
-          <Input value={name} onChange={(e) => setName(e.target.value)} placeholder="角色名称" />
+          <Input
+            value={name}
+            onChange={(e) => setName(e.target.value)}
+            placeholder="角色名称"
+          />
         </div>
         <div className="flex flex-col gap-1.5">
           <Label className="text-xs text-muted-foreground">描述</Label>
@@ -132,9 +136,7 @@ export function AddNodeDialog(): ReactNode {
   return (
     <Dialog
       open={state !== null}
-      onOpenChange={(open) => {
-        if (!open) cancel();
-      }}
+      onOpenChange={(open) => { if (!open) cancel(); }}
     >
       <DialogContent showCloseButton={false} className="sm:max-w-md">
         {state && <Form state={state} onSubmit={commit} onCancel={cancel} />}

packages/workflow-dashboard/src/editor/panel/edit-node.tsx

@@ -1,16 +1,19 @@
-import { type ReactNode, useEffect, useState } from "react";
-import { Button } from "../../components/ui/button.tsx";
+import { useState, useEffect, type ReactNode } from "react";
+import {
+  editNodeViewModel,
+  type EditNodeState,
+} from "../model/edit-node-view.ts";
 import {
   Dialog,
   DialogContent,
-  DialogFooter,
   DialogHeader,
   DialogTitle,
+  DialogFooter,
 } from "../../components/ui/dialog.tsx";
 import { Input } from "../../components/ui/input.tsx";
-import { Label } from "../../components/ui/label.tsx";
 import { Textarea } from "../../components/ui/textarea.tsx";
-import { type EditNodeState, editNodeViewModel } from "../model/edit-node-view.ts";
+import { Button } from "../../components/ui/button.tsx";
+import { Label } from "../../components/ui/label.tsx";
 import type { RoleNodeData } from "../type.ts";
 
 type FormProps = {
@@ -58,7 +61,11 @@ function Form({ state, onSubmit, onCancel }: FormProps): ReactNode {
       <div className="flex flex-col gap-3 max-h-[400px] overflow-y-auto p-1">
         <div className="flex flex-col gap-1.5">
           <Label className="text-xs text-muted-foreground">名称 *</Label>
-          <Input value={name} onChange={(e) => setName(e.target.value)} placeholder="角色名称" />
+          <Input
+            value={name}
+            onChange={(e) => setName(e.target.value)}
+            placeholder="角色名称"
+          />
         </div>
         <div className="flex flex-col gap-1.5">
           <Label className="text-xs text-muted-foreground">描述</Label>
@@ -131,9 +138,7 @@ export function EditNodeDialog(): ReactNode {
   return (
     <Dialog
       open={state !== null}
-      onOpenChange={(open) => {
-        if (!open) cancel();
-      }}
+      onOpenChange={(open) => { if (!open) cancel(); }}
     >
       <DialogContent showCloseButton={false} className="sm:max-w-md">
         {state && <Form state={state} onSubmit={commit} onCancel={cancel} />}

packages/workflow-dashboard/src/editor/panel/index.tsx

@@ -1,7 +1,8 @@
-import { Panel } from "@xyflow/react";
-import { AddNodeDialog } from "./add-node";
-import { EditNodeDialog } from "./edit-node";
-import { Toolbar } from "./toolbar";
+import { Panel } from '@xyflow/react';
+import { AddNodeDialog } from './add-node';
+import { EditNodeDialog } from './edit-node';
+import { Toolbar } from './toolbar';
+
 
 export function Dialogs() {
   return (
@@ -12,6 +13,7 @@ export function Dialogs() {
   );
 }
 
+
 export function TopCenterPanel() {
   return (
     <Panel position="top-center">

packages/workflow-dashboard/src/editor/panel/toolbar.tsx

@@ -1,21 +1,28 @@
+import { type ReactNode } from "react";
+import {
+  Undo2,
+  Redo2,
+  Users,
+  LayoutList,
+  Save,
+} from "lucide-react";
 import { useReactFlow, useStoreApi } from "@xyflow/react";
-import { LayoutList, Redo2, Save, Undo2, Users } from "lucide-react";
-import { type ReactNode, useState } from "react";
-import { Button } from "../../components/ui/button.tsx";
-import { Separator } from "../../components/ui/separator.tsx";
-import { cn } from "../../lib/utils.ts";
 import { useModel } from "../context.tsx";
 import { handlers, nodesModel } from "../model/index.ts";
+import { Separator } from "../../components/ui/separator.tsx";
+import { Button } from "../../components/ui/button.tsx";
 import type { RoleNodeData, WorkNode } from "../type.ts";
 import { uuid } from "../utils/index.ts";
+import { useState } from "react";
+import { cn } from "../../lib/utils.ts";
 
 const DEFAULT_ROLE_DATA: RoleNodeData = {
-  name: "新角色",
-  description: "",
-  identity: "",
-  prepare: "",
-  execute: "",
-  report: "",
+  name: '新角色',
+  description: '',
+  identity: '',
+  prepare: '',
+  execute: '',
+  report: '',
 };
 
 export function Toolbar(): ReactNode {
@@ -41,9 +48,9 @@ export function Toolbar(): ReactNode {
     const centerY = (height / 2 - y) / zoom;
 
     const id = `n${uuid()}`;
-    const node: WorkNode<"role"> = {
+    const node: WorkNode<'role'> = {
       id,
-      type: "role",
+      type: 'role',
       position: { x: centerX - 80, y: centerY - 40 },
       data: { ...DEFAULT_ROLE_DATA },
     };
@@ -56,22 +63,10 @@ export function Toolbar(): ReactNode {
   return (
     <div className="flex items-center gap-2 px-3 py-1.5 bg-white rounded-[10px] shadow-md">
       <div className="flex items-center gap-0.5">
-        <Button
-          variant="ghost"
-          size="icon-sm"
-          title="撤销 (Undo)"
-          onClick={handleUndo}
-          disabled={!canUndo}
-        >
+        <Button variant="ghost" size="icon-sm" title="撤销 (Undo)" onClick={handleUndo} disabled={!canUndo}>
           <Undo2 />
         </Button>
-        <Button
-          variant="ghost"
-          size="icon-sm"
-          title="重做 (Redo)"
-          onClick={handleRedo}
-          disabled={!canRedo}
-        >
+        <Button variant="ghost" size="icon-sm" title="重做 (Redo)" onClick={handleRedo} disabled={!canRedo}>
           <Redo2 />
         </Button>
       </div>
@@ -106,12 +101,14 @@ function SaveButton(): ReactNode {
     if (valid) {
       setToast({ open: true, severity: "success", message: "流程保存成功" });
     } else {
-      const errorMessages = errors.map(({ message, nodeId }) => (
-        <div key={nodeId ?? message}>
-          {nodeId ? `节点 ${nodeId}：` : ""}
-          {message}
-        </div>
-      ));
+      const errorMessages = errors.map(
+        ({ message, nodeId }) => (
+          <div key={nodeId ?? message}>
+            {nodeId ? `节点 ${nodeId}：` : ""}
+            {message}
+          </div>
+        ),
+      );
       setToast({
         open: true,
         severity: "error",

packages/workflow-dashboard/src/editor/trans/index.ts

@@ -1,4 +1,4 @@
-export * from "./trans-in";
-export * from "./trans-out";
-export * from "./type";
-export * from "./validate";
+export * from './type';
+export * from './trans-in';
+export * from './trans-out';
+export * from './validate';

packages/workflow-dashboard/src/editor/trans/trans-in.ts

@@ -1,20 +1,20 @@
-import type { AnyWorkEdge, AnyWorkNode, ConditionalEdge } from "../type";
-import { uuid } from "../utils";
-import type { WorkFlowStep } from "./type";
+import type { AnyWorkNode, AnyWorkEdge, ConditionalEdge } from '../type';
+import type { WorkFlowStep } from './type';
+import { uuid } from '../utils';
 
 type Result = {
   nodes: AnyWorkNode[];
   edges: AnyWorkEdge[];
 };
 
-const _OUT_HANDLES = ["output-top", "output", "output-bottom"] as const;
-const IN_HANDLES = ["input-top", "input", "input-bottom"] as const;
+const OUT_HANDLES = ['output-top', 'output', 'output-bottom'] as const;
+const IN_HANDLES = ['input-top', 'input', 'input-bottom'] as const;
 
 function assignHandles(
   indices: number[],
   edges: AnyWorkEdge[],
   handles: readonly string[],
-  key: "sourceHandle" | "targetHandle",
+  key: 'sourceHandle' | 'targetHandle',
 ): void {
   if (indices.length === 1) {
     edges[indices[0]] = { ...edges[indices[0]], [key]: handles[1] };
@@ -29,18 +29,8 @@ function assignHandles(
 }
 
 export function transIn(steps: WorkFlowStep[]): Result {
-  const startNode: AnyWorkNode = {
-    id: "start",
-    type: "start",
-    data: { label: "Start" },
-    position: { x: 0, y: 0 },
-  };
-  const endNode: AnyWorkNode = {
-    id: "end",
-    type: "end",
-    data: { label: "End" },
-    position: { x: 250, y: 0 },
-  };
+  const startNode: AnyWorkNode = { id: 'start', type: 'start', data: { label: 'Start' }, position: { x: 0, y: 0 } };
+  const endNode: AnyWorkNode = { id: 'end', type: 'end', data: { label: 'End' }, position: { x: 250, y: 0 } };
 
   if (steps.length === 0) {
     return { nodes: [startNode, endNode], edges: [] };
@@ -50,9 +40,9 @@ export function transIn(steps: WorkFlowStep[]): Result {
   const edges: AnyWorkEdge[] = [];
   const nameToId = new Map<string, string>();
   const idToOrder = new Map<string, number>();
-  nameToId.set("END", "end");
-  idToOrder.set("start", -1);
-  idToOrder.set("end", steps.length);
+  nameToId.set('END', 'end');
+  idToOrder.set('start', -1);
+  idToOrder.set('end', steps.length);
 
   for (let si = 0; si < steps.length; si++) {
     const step = steps[si];
@@ -61,25 +51,25 @@ export function transIn(steps: WorkFlowStep[]): Result {
     idToOrder.set(nodeId, si);
     nodes.push({
       id: nodeId,
-      type: "role",
+      type: 'role',
       data: { ...step.role },
       position: { x: 0, y: 0 },
     });
   }
 
-  const firstStepId = nameToId.get(steps[0].role.name) ?? "";
+  const firstStepId = nameToId.get(steps[0].role.name)!;
   edges.push({
     id: `e-start-${firstStepId}`,
-    source: "start",
-    sourceHandle: "output",
+    source: 'start',
+    sourceHandle: 'output',
     target: firstStepId,
-    targetHandle: "input",
+    targetHandle: 'input',
     animated: true,
   });
 
   for (const step of steps) {
-    const sourceId = nameToId.get(step.role.name) ?? "";
-    const _sourceOrder = idToOrder.get(sourceId) ?? 0;
+    const sourceId = nameToId.get(step.role.name)!;
+    const sourceOrder = idToOrder.get(sourceId)!;
     const hasMultipleTransitions = step.transitions.length > 1;
 
     const sorted = hasMultipleTransitions
@@ -105,10 +95,10 @@ export function transIn(steps: WorkFlowStep[]): Result {
           id: edgeId,
           source: sourceId,
           target: targetId,
-          sourceHandle: "output",
-          targetHandle: "input",
-          type: "conditional",
-          data: { condition: t.condition ?? "" },
+          sourceHandle: 'output',
+          targetHandle: 'input',
+          type: 'conditional',
+          data: { condition: t.condition ?? '' },
           animated: true,
         };
         if (hasMultipleTransitions && i === 0) {
@@ -121,8 +111,8 @@ export function transIn(steps: WorkFlowStep[]): Result {
           id: edgeId,
           source: sourceId,
           target: targetId,
-          sourceHandle: "output",
-          targetHandle: "input",
+          sourceHandle: 'output',
+          targetHandle: 'input',
           animated: true,
         });
       }
@@ -130,7 +120,7 @@ export function transIn(steps: WorkFlowStep[]): Result {
 
     // out: else → output (right); if → sort by target order desc (rightmost first), then top/bottom
     for (const e of elseEdges) {
-      edges.push({ ...e, sourceHandle: "output" });
+      edges.push({ ...e, sourceHandle: 'output' });
     }
     if (ifEdges.length > 0) {
       const sortedIf = [...ifEdges].sort((a, b) => {
@@ -138,7 +128,7 @@ export function transIn(steps: WorkFlowStep[]): Result {
         const ob = idToOrder.get(b.target) ?? 0;
         return ob - oa;
       });
-      const ifHandles = ["output-top", "output-bottom"] as const;
+      const ifHandles = ['output-top', 'output-bottom'] as const;
       for (let i = 0; i < sortedIf.length; i++) {
         edges.push({ ...sortedIf[i], sourceHandle: ifHandles[i % ifHandles.length] });
       }
@@ -150,7 +140,7 @@ export function transIn(steps: WorkFlowStep[]): Result {
   for (let i = 0; i < edges.length; i++) {
     const target = edges[i].target;
     if (!incomingByTarget.has(target)) incomingByTarget.set(target, []);
-    incomingByTarget.get(target)?.push(i);
+    incomingByTarget.get(target)!.push(i);
   }
 
   for (const indices of incomingByTarget.values()) {
@@ -159,7 +149,7 @@ export function transIn(steps: WorkFlowStep[]): Result {
       const ob = idToOrder.get(edges[b].source) ?? 0;
       return oa - ob;
     });
-    assignHandles(indices, edges, IN_HANDLES, "targetHandle");
+    assignHandles(indices, edges, IN_HANDLES, 'targetHandle');
   }
 
   return { nodes, edges };

packages/workflow-dashboard/src/editor/trans/trans-out.ts

@@ -1,5 +1,5 @@
-import type { AnyWorkEdge, AnyWorkNode, ConditionalEdge, WorkNode } from "../type";
-import type { WorkFlowStep, WorkFlowTransition } from "./type";
+import type { AnyWorkNode, AnyWorkEdge, WorkNode, ConditionalEdge } from '../type';
+import type { WorkFlowStep, WorkFlowTransition } from './type';
 
 export function transOut(nodes: AnyWorkNode[], edges: AnyWorkEdge[]): WorkFlowStep[] {
   const nodeMap = new Map<string, AnyWorkNode>();
@@ -12,10 +12,10 @@ export function transOut(nodes: AnyWorkNode[], edges: AnyWorkEdge[]): WorkFlowSt
     if (!outgoingEdges.has(edge.source)) {
       outgoingEdges.set(edge.source, []);
     }
-    outgoingEdges.get(edge.source)?.push(edge);
+    outgoingEdges.get(edge.source)!.push(edge);
   }
 
-  const startOutEdges = outgoingEdges.get("start") ?? [];
+  const startOutEdges = outgoingEdges.get('start') ?? [];
   if (startOutEdges.length === 0) return [];
 
   const firstNodeId = startOutEdges[0].target;
@@ -34,26 +34,23 @@ function traverse(
   visited: Set<string>,
   steps: WorkFlowStep[],
 ): void {
-  if (visited.has(nodeId) || nodeId === "start" || nodeId === "end") return;
+  if (visited.has(nodeId) || nodeId === 'start' || nodeId === 'end') return;
   visited.add(nodeId);
 
   const node = nodeMap.get(nodeId);
-  if (!node || node.type !== "role") return;
+  if (!node || node.type !== 'role') return;
 
-  const roleNode = node as WorkNode<"role">;
+  const roleNode = node as WorkNode<'role'>;
   const outEdges = outgoingEdges.get(nodeId) ?? [];
 
   const transitions: WorkFlowTransition[] = outEdges.map((edge, index) => {
     const targetNode = nodeMap.get(edge.target);
-    const target =
-      edge.target === "end"
-        ? "END"
-        : targetNode?.type === "role"
-          ? (targetNode as WorkNode<"role">).data.name
-          : edge.target;
+    const target = edge.target === 'end'
+      ? 'END'
+      : (targetNode?.type === 'role' ? (targetNode as WorkNode<'role'>).data.name : edge.target);
 
     let condition: string | null = null;
-    if (edge.type === "conditional") {
+    if (edge.type === 'conditional') {
       const isElse = outEdges.length >= 2 && index === 0;
       condition = isElse ? null : ((edge as ConditionalEdge).data?.condition ?? null);
     }

packages/workflow-dashboard/src/editor/trans/type.ts

@@ -1,6 +1,6 @@
 export type {
   WorkFlowRole,
+  WorkFlowTransition,
   WorkFlowStep,
   WorkFlowSteps,
-  WorkFlowTransition,
 } from "../../../shared/types.ts";

packages/workflow-dashboard/src/editor/trans/validate.ts

@@ -1,4 +1,4 @@
-import type { AnyWorkEdge, AnyWorkNode, ConditionalEdge } from "../type";
+import type { AnyWorkNode, AnyWorkEdge, ConditionalEdge } from '../type';
 
 export type ValidationError = {
   nodeId: string | null;
@@ -13,12 +13,12 @@ export type ValidationResult = {
 export function validate(nodes: AnyWorkNode[], edges: AnyWorkEdge[]): ValidationResult {
   const errors: ValidationError[] = [];
 
-  const outgoing = buildEdgeMap(edges, "source");
-  const incoming = buildEdgeMap(edges, "target");
+  const outgoing = buildEdgeMap(edges, 'source');
+  const incoming = buildEdgeMap(edges, 'target');
 
-  const startNodes = nodes.filter((n) => n.type === "start");
-  const endNodes = nodes.filter((n) => n.type === "end");
-  const roleNodes = nodes.filter((n) => n.type === "role");
+  const startNodes = nodes.filter(n => n.type === 'start');
+  const endNodes = nodes.filter(n => n.type === 'end');
+  const roleNodes = nodes.filter(n => n.type === 'role');
 
   validateStartNode(startNodes, outgoing, errors);
   validateEndNode(endNodes, incoming, outgoing, errors);
@@ -29,14 +29,17 @@ export function validate(nodes: AnyWorkNode[], edges: AnyWorkEdge[]): Validation
   return { valid: errors.length === 0, errors };
 }
 
-function buildEdgeMap(edges: AnyWorkEdge[], key: "source" | "target"): Map<string, AnyWorkEdge[]> {
+function buildEdgeMap(
+  edges: AnyWorkEdge[],
+  key: 'source' | 'target',
+): Map<string, AnyWorkEdge[]> {
   const map = new Map<string, AnyWorkEdge[]>();
   for (const edge of edges) {
     const id = edge[key];
     if (!map.has(id)) {
       map.set(id, []);
     }
-    map.get(id)?.push(edge);
+    map.get(id)!.push(edge);
   }
   return map;
 }
@@ -47,20 +50,20 @@ function validateStartNode(
   errors: ValidationError[],
 ): void {
   if (startNodes.length === 0) {
-    errors.push({ nodeId: null, message: "缺少 Start 节点" });
+    errors.push({ nodeId: null, message: '缺少 Start 节点' });
     return;
   }
   if (startNodes.length > 1) {
-    errors.push({ nodeId: null, message: "Start 节点只能有一个" });
+    errors.push({ nodeId: null, message: 'Start 节点只能有一个' });
     return;
   }
 
   const startId = startNodes[0].id;
   const outEdges = outgoing.get(startId) ?? [];
   if (outEdges.length === 0) {
-    errors.push({ nodeId: startId, message: "Start 节点必须有一个输出连接" });
+    errors.push({ nodeId: startId, message: 'Start 节点必须有一个输出连接' });
   } else if (outEdges.length > 1) {
-    errors.push({ nodeId: startId, message: "Start 节点只能有一个输出连接" });
+    errors.push({ nodeId: startId, message: 'Start 节点只能有一个输出连接' });
   }
 }
 
@@ -71,23 +74,23 @@ function validateEndNode(
   errors: ValidationError[],
 ): void {
   if (endNodes.length === 0) {
-    errors.push({ nodeId: null, message: "缺少 End 节点" });
+    errors.push({ nodeId: null, message: '缺少 End 节点' });
     return;
   }
   if (endNodes.length > 1) {
-    errors.push({ nodeId: null, message: "End 节点只能有一个" });
+    errors.push({ nodeId: null, message: 'End 节点只能有一个' });
     return;
   }
 
   const endId = endNodes[0].id;
   const inEdges = incoming.get(endId) ?? [];
   if (inEdges.length === 0) {
-    errors.push({ nodeId: endId, message: "End 节点必须有至少一个输入连接" });
+    errors.push({ nodeId: endId, message: 'End 节点必须有至少一个输入连接' });
   }
 
   const outEdges = outgoing.get(endId) ?? [];
   if (outEdges.length > 0) {
-    errors.push({ nodeId: endId, message: "End 节点不能有输出连接" });
+    errors.push({ nodeId: endId, message: 'End 节点不能有输出连接' });
   }
 }
 
@@ -102,22 +105,22 @@ function validateRoleNodes(
     const outEdges = outgoing.get(node.id) ?? [];
 
     if (inEdges.length === 0) {
-      errors.push({ nodeId: node.id, message: "角色节点缺少输入连接" });
+      errors.push({ nodeId: node.id, message: '角色节点缺少输入连接' });
     }
     if (outEdges.length === 0) {
-      errors.push({ nodeId: node.id, message: "角色节点缺少输出连接" });
+      errors.push({ nodeId: node.id, message: '角色节点缺少输出连接' });
     }
 
     if (outEdges.length > 1) {
-      const conditionalEdges = outEdges.filter((e) => e.type === "conditional");
+      const conditionalEdges = outEdges.filter(e => e.type === 'conditional');
       if (conditionalEdges.length !== outEdges.length) {
-        errors.push({ nodeId: node.id, message: "多输出节点的所有出边必须附带条件" });
+        errors.push({ nodeId: node.id, message: '多输出节点的所有出边必须附带条件' });
       } else {
         const ifEdges = conditionalEdges.slice(1);
         for (const edge of ifEdges) {
           const condEdge = edge as ConditionalEdge;
           if (!condEdge.data?.condition?.trim()) {
-            errors.push({ nodeId: node.id, message: "条件边的条件表达式不能为空" });
+            errors.push({ nodeId: node.id, message: '条件边的条件表达式不能为空' });
             break;
           }
         }
@@ -126,9 +129,12 @@ function validateRoleNodes(
   }
 }
 
-function validateRoleCount(roleNodes: AnyWorkNode[], errors: ValidationError[]): void {
+function validateRoleCount(
+  roleNodes: AnyWorkNode[],
+  errors: ValidationError[],
+): void {
   if (roleNodes.length < 2) {
-    errors.push({ nodeId: null, message: "工作流至少需要 2 个角色节点" });
+    errors.push({ nodeId: null, message: '工作流至少需要 2 个角色节点' });
   }
 }
 
@@ -145,21 +151,21 @@ function validateReachability(
   const backwardAdj = new Map<string, string[]>();
   for (const edge of edges) {
     if (!forwardAdj.has(edge.source)) forwardAdj.set(edge.source, []);
-    forwardAdj.get(edge.source)?.push(edge.target);
+    forwardAdj.get(edge.source)!.push(edge.target);
     if (!backwardAdj.has(edge.target)) backwardAdj.set(edge.target, []);
-    backwardAdj.get(edge.target)?.push(edge.source);
+    backwardAdj.get(edge.target)!.push(edge.source);
   }
 
   const reachableFromStart = bfs(startNodes[0].id, forwardAdj);
   const reachableFromEnd = bfs(endNodes[0].id, backwardAdj);
 
   for (const node of nodes) {
-    if (node.type === "start" || node.type === "end") continue;
+    if (node.type === 'start' || node.type === 'end') continue;
     if (!reachableFromStart.has(node.id)) {
-      errors.push({ nodeId: node.id, message: "节点不可从 Start 到达（孤立节点）" });
+      errors.push({ nodeId: node.id, message: '节点不可从 Start 到达（孤立节点）' });
     }
     if (!reachableFromEnd.has(node.id)) {
-      errors.push({ nodeId: node.id, message: "节点无法到达 End（死端节点）" });
+      errors.push({ nodeId: node.id, message: '节点无法到达 End（死端节点）' });
     }
   }
 }
@@ -169,7 +175,7 @@ function bfs(startId: string, adj: Map<string, string[]>): Set<string> {
   const queue = [startId];
   visited.add(startId);
   while (queue.length > 0) {
-    const current = queue.shift() ?? "";
+    const current = queue.shift()!;
     for (const next of adj.get(current) ?? []) {
       if (!visited.has(next)) {
         visited.add(next);

packages/workflow-dashboard/src/editor/type.ts

@@ -1,4 +1,4 @@
-import type { Edge, Node } from "@xyflow/react";
+import type { Node, Edge } from '@xyflow/react';
 
 type AnyKeyBase = { [key: string]: unknown | undefined };
 
@@ -19,11 +19,11 @@ export type NodeMap = {
 
 export type WorkNodeType = keyof NodeMap;
 export type WorkNode<T extends WorkNodeType> = Node<NodeMap[T], T>;
-export type AnyWorkNode = WorkNode<"start"> | WorkNode<"end"> | WorkNode<"role">;
+export type AnyWorkNode = WorkNode<'start'> | WorkNode<'end'> | WorkNode<'role'>;
 
 export type ConditionalEdgeData = AnyKeyBase & {
   condition: string;
 };
 
-export type ConditionalEdge = Edge<ConditionalEdgeData, "conditional">;
+export type ConditionalEdge = Edge<ConditionalEdgeData, 'conditional'>;
 export type AnyWorkEdge = ConditionalEdge | Edge;

packages/workflow-dashboard/src/editor/utils/eventer.ts

@@ -1,16 +1,12 @@
-type Maper<T> = {
-  [key: string]: T;
-};
+interface Maper<T> { [key: string]: T }
 type Listen<T> = (data: T) => void;
 
-// biome-ignore lint/suspicious/noExplicitAny: generic event map requires any
 export class Eventer<M extends Maper<any>> {
-  // biome-ignore lint/complexity/noBannedTypes: Set<Function> needed for heterogeneous listener types
   private lisenters = {} as { [K in keyof M]: Set<Function> };
 
   public on<K extends keyof M>(key: K, lisenter: Listen<M[K]>) {
     let set = this.lisenters[key];
-    if (set === undefined) {
+    if (set == undefined) {
       set = new Set();
       this.lisenters[key] = set;
     }
@@ -30,8 +26,6 @@ export class Eventer<M extends Maper<any>> {
     const set = this.lisenters[key];
     if (set === undefined) return;
     // Todo: maybe implement stoping bubble
-    for (const call of set) {
-      call(data);
-    }
+    set.forEach(call => call(data));
   }
 }

packages/workflow-dashboard/src/editor/utils/index.ts

@@ -1,3 +1,5 @@
+
+
 export function uuid() {
   const now = Date.now();
   const randon = 1 + Math.random();

packages/workflow-dashboard/src/editor/utils/use-click-out.tsx

@@ -1,4 +1,5 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useRef } from 'react';
+
 
 function judge(container: HTMLElement, target: HTMLElement): boolean {
   if (container === target) {
@@ -7,11 +8,14 @@ function judge(container: HTMLElement, target: HTMLElement): boolean {
   if (target === document.body) {
     return false;
   }
-  const parent = target.parentElement;
+  let parent = target.parentElement;
   return parent ? judge(container, parent) : false;
 }
 
-export function useClickOutRef<T extends HTMLElement>(callback: () => void, delay = 0) {
+export function useClickOutRef<T extends HTMLElement>(
+  callback: () => void,
+  delay = 0,
+) {
   const ref = useRef<T>(null);
   const flag = useRef<boolean>(delay === 0);
 
@@ -33,8 +37,8 @@ export function useClickOutRef<T extends HTMLElement>(callback: () => void, dela
         callback();
       }
     }
-    document.addEventListener("click", handle);
-    return () => document.removeEventListener("click", handle);
+    document.addEventListener('click', handle);
+    return () => document.removeEventListener('click', handle);
   }, [callback]);
 
   return ref;

packages/workflow-dashboard/src/index.css

@@ -33,7 +33,7 @@
   --color-sidebar: var(--sidebar);
   --color-sidebar-foreground: var(--sidebar-foreground);
   --font-heading: var(--font-sans);
-  --font-sans: "Geist Variable", sans-serif;
+  --font-sans: 'Geist Variable', sans-serif;
   --color-sidebar-ring: var(--sidebar-ring);
   --color-sidebar-border: var(--sidebar-border);
   --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
@@ -147,4 +147,4 @@ body {
   html {
     @apply font-sans;
   }
-}
+}

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

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

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

@@ -1,8 +1,8 @@
-import { ArrowLeft, Eye, Pencil } from "lucide-react";
-import { type ReactNode, useEffect, useRef, useState } from "react";
-import { useLocation, useNavigate, useParams } from "react-router";
-import { Button } from "@/components/ui/button";
+import { useState, useEffect, useRef, type ReactNode } from "react";
+import { useParams, useNavigate, useLocation } from "react-router";
 import FlowEditor, { FlowModel, type WorkFlowSteps } from "../editor/flow.tsx";
+import { Button } from "@/components/ui/button";
+import { ArrowLeft, Pencil, Eye } from "lucide-react";
 
 export function DetailPage(): ReactNode {
   const { name } = useParams<{ name: string }>();
@@ -44,18 +44,18 @@ export function DetailPage(): ReactNode {
         if (!cancelled) navigate("/");
       });
 
-    return () => {
-      cancelled = true;
-    };
+    return () => { cancelled = true; };
   }, [name, navigate]);
 
   if (loading) {
     return (
-      <div className="flex h-full items-center justify-center text-muted-foreground">加载中...</div>
+      <div className="flex h-full items-center justify-center text-muted-foreground">
+        加载中...
+      </div>
     );
   }
 
-  const basePath = `/workflow/${encodeURIComponent(name ?? "")}`;
+  const basePath = `/workflow/${encodeURIComponent(name!)}`;
 
   return (
     <div className="flex h-full flex-col">
@@ -66,19 +66,29 @@ export function DetailPage(): ReactNode {
         <h1 className="text-base font-medium">{name}</h1>
         <div className="flex-1" />
         {editing ? (
-          <Button variant="outline" size="sm" onClick={() => navigate(basePath)}>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => navigate(basePath)}
+          >
             <Eye className="size-3.5" data-icon="inline-start" />
             预览
           </Button>
         ) : (
-          <Button variant="outline" size="sm" onClick={() => navigate(`${basePath}/edit`)}>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => navigate(`${basePath}/edit`)}
+          >
             <Pencil className="size-3.5" data-icon="inline-start" />
             编辑
           </Button>
         )}
         {saving && <span className="text-xs text-muted-foreground">保存中...</span>}
       </div>
-      <div className="flex-1">{model && <FlowEditor model={model} readonly={!editing} />}</div>
+      <div className="flex-1">
+        {model && <FlowEditor model={model} readonly={!editing} />}
+      </div>
     </div>
   );
 }

packages/workflow-dashboard/src/pages/editor.tsx

@@ -1,4 +1,4 @@
-import { type ReactNode, useState } from "react";
+import { useState, useEffect, type ReactNode } from "react";
 import FlowEditor, { FlowModel, type WorkFlowSteps } from "../editor/flow.tsx";
 
 const DEFAULT_STEPS: WorkFlowSteps = [

packages/workflow-dashboard/src/pages/home.tsx

@@ -1,19 +1,19 @@
-import { Plus, Trash2, Workflow } from "lucide-react";
-import { type FormEvent, type ReactNode, useCallback, useEffect, useState } from "react";
+import { useState, useEffect, useCallback, type ReactNode, type FormEvent } from "react";
 import { useNavigate } from "react-router";
 import { Button } from "@/components/ui/button";
-import { Card, CardAction, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { Card, CardHeader, CardTitle, CardDescription, CardAction } from "@/components/ui/card";
 import {
   Dialog,
   DialogContent,
-  DialogDescription,
-  DialogFooter,
   DialogHeader,
   DialogTitle,
+  DialogDescription,
+  DialogFooter,
   DialogTrigger,
 } from "@/components/ui/dialog";
 import { Input } from "@/components/ui/input";
 import { Textarea } from "@/components/ui/textarea";
+import { Plus, Trash2, Workflow } from "lucide-react";
 import type { WorkflowSummary } from "../../shared/types.ts";
 
 export function HomePage(): ReactNode {

packages/workflow-dashboard/src/router.tsx

@@ -1,7 +1,7 @@
 import { createBrowserRouter } from "react-router";
 import { Layout } from "./app.tsx";
-import { DetailPage } from "./pages/detail.tsx";
 import { HomePage } from "./pages/home.tsx";
+import { DetailPage } from "./pages/detail.tsx";
 
 export const router = createBrowserRouter([
   {

packages/workflow-dashboard/vite-dev.ts

@@ -1,5 +1,5 @@
-import type { IncomingMessage } from "node:http";
 import type { Plugin } from "vite";
+import type { IncomingMessage } from "node:http";
 import { createApi } from "./server/api.ts";
 
 function buildRequest(req: IncomingMessage, body: string | null): Request {

packages/workflow-protocol/src/schemas.ts

@@ -85,7 +85,6 @@ export const STEP_NODE_SCHEMA: JSONSchema = {
     output: { type: "string", format: "cas_ref" },
     detail: { type: "string", format: "cas_ref" },
     agent: { type: "string" },
-    edgePrompt: { type: "string" },
   },
   additionalProperties: false,
 };

packages/workflow-protocol/src/types.ts

@@ -12,8 +12,6 @@ export type StepRecord = {
   output: CasRef;
   detail: CasRef;
   agent: string;
-  /** Moderator edge prompt that led to this step. Missing in legacy nodes → "". */
-  edgePrompt: string;
 };
 
 // ── 4.2 Workflow 定义 ───────────────────────────────────────────────

packages/workflow-util/__tests__/process-logger.test.ts

@@ -1,7 +1,7 @@
-import { afterEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
 
 import { createProcessLogger } from "../src/process-logger/index.js";
 

packages/workflow-util/src/index.ts

@@ -13,13 +13,13 @@ export {
   validateFrontmatter,
 } from "./frontmatter-markdown/index.js";
 export { createLogger } from "./logger.js";
+export { createProcessLogger } from "./process-logger/index.js";
 export type {
   CreateProcessLoggerOptions,
   ProcessLogFn,
   ProcessLogger,
   ProcessLoggerContext,
 } from "./process-logger/index.js";
-export { createProcessLogger } from "./process-logger/index.js";
 export { normalizeRefsField } from "./refs-field.js";
 export { err, ok } from "./result.js";
 export { getDefaultWorkflowStorageRoot, getGlobalCasDir } from "./storage-root.js";