Merge pull request 'chore(workflow): post-extraction cleanup' (#326) from chore/325-workflow-cleanup into main

- IPC parse functions: replace whole-object 'as' casts with per-field narrowing
- WorkflowConfig: remove duplicate from core, re-export from @uncaged/workflow
- drainTimeoutMs: change from optional param to T | null convention
- Remove duplicate WorkflowWorkerOutboundMessage, keep WorkflowChildToParentMessage

Fixes #325

.cursor/rules/no-dynamic-import.mdc

@@ -20,7 +20,7 @@ Always use static top-level `import` statements.
 ## Exceptions (must include a comment explaining why)
 
 1. **`sense-runtime.ts`** — loads user-authored sense modules whose paths are only known at runtime
-2. **`workflow-worker.ts`** — loads user-authored workflow modules whose paths are only known at runtime
+2. **`packages/workflow/src/worker.ts`** — loads user-authored workflow modules whose paths are only known at runtime
 
 When suppressing, add a comment directly above:
 

.knowledge/sense.md

@@ -17,17 +17,16 @@ export async function compute(): Promise<ComputeResult<T>> { ... }  // pure, no
 - No database access within compute — runtime provides isolated execution context 
 - Must be pure function (no side effects, no external API calls)
 
-**Return Value Contract:**
-- `ComputeResult<T>` = `null | { signal: T; workflow: WorkflowTrigger | null }`
-  - `null` → silent, no storage, no signal  
-  - `{ signal: data, workflow: null }` → persist + emit signal
-  - `{ signal, workflow: WorkflowTrigger }` → persist + emit signal + trigger workflow
-  - Any other value → treated as `{ signal: value, workflow: null }`
+**Return Value Contract (current engine):**
+- `compute(state)` returns `Promise<{ state: S; trigger: SenseTrigger | null }>` where `SenseTrigger = { command: string }`.
+  - `trigger: null` → persist state only; no shell command
+  - `trigger: { command }` → persist state; worker runs the command with `shell: true` after a successful compute
+- Workflows are **not** started from `trigger`; use CLI / daemon IPC (`nerve workflow trigger`, etc.).
 
 **Error Handling & Serialization:**
-- Exceptions caught by worker, logged as errors (no signal emitted)
-- Signal payload must be JSON-serializable (passed via IPC)
-- Invalid workflow triggers silently dropped (signal still emitted)
+- Exceptions caught by worker, logged as errors (state unchanged)
+- State must be JSON-serializable (persisted to `data/senses/<name>.json`)
+- Invalid `trigger` shapes fail IPC validation when the worker sends `compute-result`
 
 **Timeout & Scheduling Semantics:**
 - Timeout priority: explicit config → AbortSignal → DEFAULT_TIMEOUT_MS (30s)

.knowledge/signal-routing.md

@@ -1,30 +1,31 @@
-# Sense compute → workflow (RFC #308)
+# Sense compute → shell + scheduler (issue #318)
 
-Stateful senses no longer emit signals or pass outputs through `routeSenseComputeOutput`. The worker runs `compute(state)` and returns `{ state, workflow }`.
+Stateful senses run `compute(state)` and return `{ state, trigger }`. The worker persists state JSON and sends `compute-result` to the kernel. Optional side effects are **shell commands only**, executed in the sense worker. Workflows are not started from sense return values.
 
 ## Flow
 
 ```
-Sense worker: compute(state) → { state, workflow }
+Sense worker: compute(state) → { state, trigger }
                     ↓
           persist state JSON (data/senses/<name>.json)
                     ↓
-          IPC compute-result → kernel
+     trigger !== null → spawn shell command (cwd = nerve root)
                     ↓
-     workflow !== null → parseWorkflowTrigger (validation) → workflowManager.startWorkflow
-     scheduler.onSenseCompleted(senseName) → dependents with `on: [senseName]`
+          IPC compute-result → kernel (audit: shell-launch log)
+                    ↓
+          scheduler.onSenseCompleted(senseName) → dependents with `on: [senseName]`
 ```
 
-## Workflow trigger shape
+Workflow runs: **`workflowManager.startWorkflow`** from CLI / daemon IPC only (`nerve workflow trigger`, HTTP when enabled).
 
-When `workflow` is non-null it must be a plain object validated by `parseWorkflowTrigger()` in `packages/core/src/sense.ts`:
+## Sense trigger shape
 
-- `name`: non-empty string  
-- `maxRounds`: integer ≥ 1  
-- `prompt`: string  
-- `dryRun`: boolean  
+When `trigger` is non-null it must be a plain object validated by `parseSenseTrigger()` in `packages/core/src/sense.ts`:
 
-Invalid triggers are rejected by the daemon when handling the worker message (workflow is not started).
+- Exactly one property: `command` (non-empty string after trim)
+- No `kind` field; no workflow fields
+
+Invalid triggers are rejected when parsing the worker message.
 
 ## Scheduling
 

CLAUDE.md

@@ -28,6 +28,19 @@ External World → Sense(state) → { newState, workflow? } → Workflow → Log
 
 
 
+### Sense State Persistence
+
+Each sense's state is persisted as a JSON file at `data/senses/<name>.json` (relative to the nerve root, typically `~/.uncaged-nerve/`).
+
+| Event | Behavior |
+|-------|----------|
+| **Worker start** | Read `state.json`; if missing or corrupt, use `initialState` from the sense module |
+| **Compute success** | Write new state atomically (write-temp + rename), then update in-memory state |
+| **Compute failure** | State unchanged (both disk and memory) |
+| **Daemon restart** | State restored from last successful write |
+
+State files are written atomically (temp file + rename) to prevent corruption on crash.
+
 ## Language & Paradigm
 
 ### Functional-first
@@ -91,10 +104,12 @@ type SenseConfig = {
 For mutually exclusive fields, use discriminated unions:
 
 ```typescript
-// ✅ Good — sense modules return explicit next state + optional workflow trigger
+import type { SenseTrigger } from "@uncaged/nerve-core";
+
+// ✅ Good — sense modules return explicit next state + optional shell trigger only
 type SenseComputeReturn<S> = {
   state: S;
-  workflow: WorkflowTrigger | null;
+  trigger: SenseTrigger | null;
 };
 ```
 

README.md

@@ -7,19 +7,21 @@ Nerve is a lightweight daemon that continuously observes external state through
 ## Core Concepts
 
 ```
-External World → Sense(state) → { newState, workflow? } → Workflow → Log
+External World → Sense(state) → { state, trigger? } → (shell in worker) / Log
+                                      │
+                              Workflow → Log   (CLI / daemon IPC only)
                   ↑
           scheduling: interval / on (per sense in nerve.yaml)
 ```
 
 | Concept | Metaphor | Role |
 |---------|----------|------|
-| **Sense** | 👁️ Perception | Stateful `compute(state)` returning `{ state, workflow }`. State lives in `data/senses/<name>.json`. |
+| **Sense** | 👁️ Perception | Stateful `compute(state)` returning `{ state, trigger }`. State lives in `data/senses/<name>.json`. |
 | **Schedule** | ⏱️ When | Each sense entry sets optional `interval` (periodic) and `on: [other senses]` (run after those senses complete a compute). |
-| **Workflow** | 🔧 Action | Stateful multi-step execution with Roles and a Moderator. Started when `workflow` is non-null in the compute result, or via CLI/daemon IPC. |
+| **Workflow** | 🔧 Action | Stateful multi-step execution with Roles and a Moderator. Started via CLI / daemon IPC (`nerve workflow trigger`, transport). Not started from sense `compute()` results. |
 | **Log** | 📝 Record | Immutable audit trail. **Cannot** schedule senses or workflows (prevents feedback loops). |
 
-**Sense → Workflow:** when `workflow` is a structured object `{ name, maxRounds, prompt, dryRun }`, the kernel validates it (`@uncaged/nerve-core` `parseWorkflowTrigger`) and starts that workflow. Use `workflow: null` when no run should start.
+**Sense → shell:** when `trigger` is non-null it must be `{ command: string }`. The sense worker runs it with `shell: true` (cwd = nerve root). Use `trigger: null` when no command should run. To start a workflow, invoke it from that shell command (for example calling the CLI) or trigger workflows separately via IPC.
 
 Two extension points for **what to observe (+ when)** vs **multi-step action** — scheduling is declarative config on each sense, not a separate YAML section.
 
@@ -27,7 +29,7 @@ Two extension points for **what to observe (+ when)** vs **multi-step action**
 
 | Package | Description |
 |---------|-------------|
-| [`@uncaged/nerve-core`](./packages/core) | Shared types, config parser, workflow trigger validation, daemon IPC protocol |
+| [`@uncaged/nerve-core`](./packages/core) | Shared types, config parser, sense trigger validation (`parseSenseTrigger`), daemon IPC protocol |
 | [`@uncaged/nerve-store`](./packages/store) | Append-only log SQLite, JSONL archive, CAS blob store, workflow run rows |
 | [`@uncaged/nerve-daemon`](./packages/daemon) | Kernel, sense workers, sense scheduler, workflow manager, file watcher, IPC |
 | [`@uncaged/nerve-cli`](./packages/cli) | CLI (`nerve`) — init, validate, daemon, dev, logs, sense, store, workflow |

docs/dead-code-analysis.md

@@ -117,7 +117,7 @@
 
 | 项目 | 位置 | 说明 | 置信度 | 建议 |
 |------|------|------|--------|------|
-| ~~已更名 API 仍出现在 README~~ | `packages/core/README.md` | （已修正）文档与 stateful sense、`parseWorkflowTrigger` 对齐；`routeSenseComputeOutput` 已移除 | — | 关闭 |
+| ~~已更名 API 仍出现在 README~~ | `packages/core/README.md` | （已修正）文档与 stateful sense、`parseSenseTrigger`（shell-only）对齐 | — | 关闭 |
 | Hermes 选项合并注释 | `packages/workflow-utils/src/shared/hermes-agent.ts` | 注释称 absorbed from `hermes-options.ts`，该文件已不存在 | **中** | **清理注释**，避免误导。 |
 | `KNOWN_AGENT_ADAPTER_IDS` 含 `codex` | `packages/core/src/agent.ts` | 仓内无 `codex` 适配器包；与常量未被引用叠加 | **中** | **对齐产品**：实现适配器或从列表移除。 |
 

docs/plans/2026-05-05-extract-workflow-package.md

@@ -0,0 +1,496 @@
+# Extract Workflow Engine into `@uncaged/workflow` — Implementation Plan
+
+> **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
+
+**Goal:** Extract the workflow engine (types, runtime, IPC, manager) from nerve-core and nerve-daemon into a standalone `@uncaged/workflow` package.
+
+**Architecture:** Create `packages/workflow/` as a new pnpm workspace package. Move workflow types from core and workflow runtime from daemon into it. The daemon becomes a consumer of `@uncaged/workflow`. No backward-compat re-exports — breaking change, update all consumers in one shot.
+
+**Tech Stack:** TypeScript, pnpm workspace, rslib (bundler, same as other packages), Biome
+
+**Ref:** Fixes #320
+
+---
+
+## Phase 1: Scaffold `packages/workflow/`
+
+### Task 1: Create package skeleton
+
+**Objective:** Create the `@uncaged/workflow` package with package.json, tsconfig, rslib config.
+
+**Files:**
+- Create: `packages/workflow/package.json`
+- Create: `packages/workflow/tsconfig.json`
+- Create: `packages/workflow/rslib.config.ts`
+- Create: `packages/workflow/src/index.ts` (empty barrel)
+
+**Steps:**
+
+1. Copy `packages/workflow-utils/package.json` as template, change name to `@uncaged/workflow`, remove all dependencies except dev deps (typescript, rslib, etc.). No runtime deps initially.
+
+2. Copy `packages/workflow-utils/tsconfig.json` and `rslib.config.ts` as-is (same monorepo conventions).
+
+3. Create empty `packages/workflow/src/index.ts`:
+```typescript
+// @uncaged/workflow — standalone workflow orchestration engine
+```
+
+4. Verify:
+```bash
+cd packages/workflow && pnpm install && pnpm run build
+```
+
+5. Commit:
+```bash
+git add packages/workflow/
+git commit -m "chore(workflow): scaffold @uncaged/workflow package
+
+Refs #320"
+```
+
+---
+
+## Phase 2: Move Types from Core
+
+### Task 2: Move `workflow.ts` types to `@uncaged/workflow`
+
+**Objective:** Move all workflow types and constants from `packages/core/src/workflow.ts` → `packages/workflow/src/types.ts`.
+
+**Files:**
+- Create: `packages/workflow/src/types.ts`
+- Modify: `packages/workflow/src/index.ts`
+
+**Steps:**
+
+1. Copy `packages/core/src/workflow.ts` → `packages/workflow/src/types.ts` verbatim (all 83 lines — `START`, `END`, `DEFAULT_ENGINE_MAX_ROUNDS`, all types).
+
+2. Export everything from `packages/workflow/src/index.ts`:
+```typescript
+export {
+  START,
+  END,
+  DEFAULT_ENGINE_MAX_ROUNDS,
+} from "./types.js";
+export type {
+  WorkflowMessage,
+  RoleResult,
+  Role,
+  RoleMeta,
+  StartStep,
+  ThreadContext,
+  WorkflowContext,
+  AgentFn,
+  RoleStep,
+  ModeratorContext,
+  Moderator,
+  WorkflowDefinition,
+} from "./types.js";
+```
+
+3. Build to verify types compile:
+```bash
+cd packages/workflow && pnpm run build
+```
+
+4. Commit:
+```bash
+git commit -am "refactor(workflow): move workflow types from core to @uncaged/workflow
+
+Refs #320"
+```
+
+### Task 3: Move `WorkflowConfig` to `@uncaged/workflow`
+
+**Objective:** Move the `WorkflowConfig` type (and its constituent types `DropOverflowConfig`, `QueueOverflowConfig`) from core/config.ts to the workflow package.
+
+**Files:**
+- Create: `packages/workflow/src/config.ts`
+- Modify: `packages/workflow/src/index.ts`
+- Modify: `packages/core/src/config.ts` — remove `WorkflowConfig`, `DropOverflowConfig`, `QueueOverflowConfig`; import from `@uncaged/workflow` instead
+
+**Steps:**
+
+1. Create `packages/workflow/src/config.ts` with the three types:
+```typescript
+export type DropOverflowConfig = {
+  concurrency: number;
+  overflow: "drop";
+};
+
+export type QueueOverflowConfig = {
+  concurrency: number;
+  overflow: "queue";
+  maxQueue: number;
+};
+
+export type WorkflowConfig = DropOverflowConfig | QueueOverflowConfig;
+```
+
+2. Re-export from `packages/workflow/src/index.ts`.
+
+3. In `packages/core/package.json`, add dependency: `"@uncaged/workflow": "workspace:*"`.
+
+4. In `packages/core/src/config.ts`:
+   - Remove the three type definitions
+   - Add `import type { WorkflowConfig, DropOverflowConfig, QueueOverflowConfig } from "@uncaged/workflow";`
+   - Keep the re-export from `packages/core/src/index.ts` pointing to config.ts (which now re-exports from workflow)
+
+5. Build entire workspace:
+```bash
+pnpm run build
+```
+
+6. Commit:
+```bash
+git commit -am "refactor(workflow): move WorkflowConfig types to @uncaged/workflow
+
+Refs #320"
+```
+
+### Task 4: Remove workflow types from core, update core exports
+
+**Objective:** Delete `packages/core/src/workflow.ts` entirely. Core re-exports workflow types from `@uncaged/workflow`.
+
+**Files:**
+- Delete: `packages/core/src/workflow.ts`
+- Modify: `packages/core/src/index.ts` — change workflow exports to re-export from `@uncaged/workflow`
+- Modify: `packages/core/src/config.ts` — remove import of `DEFAULT_ENGINE_MAX_ROUNDS` from deleted file
+
+**Steps:**
+
+1. In `packages/core/src/config.ts`, replace:
+   ```typescript
+   import { DEFAULT_ENGINE_MAX_ROUNDS } from "./workflow.js";
+   ```
+   with:
+   ```typescript
+   import { DEFAULT_ENGINE_MAX_ROUNDS } from "@uncaged/workflow";
+   ```
+
+2. In `packages/core/src/index.ts`, replace all workflow.js imports with re-exports from `@uncaged/workflow`:
+   ```typescript
+   // Workflow types — re-exported from @uncaged/workflow
+   export {
+     START, END, DEFAULT_ENGINE_MAX_ROUNDS,
+   } from "@uncaged/workflow";
+   export type {
+     WorkflowMessage, RoleResult, Role, RoleMeta, StartStep,
+     ThreadContext, WorkflowContext, AgentFn, RoleStep,
+     ModeratorContext, Moderator, WorkflowDefinition,
+   } from "@uncaged/workflow";
+   ```
+
+3. Delete `packages/core/src/workflow.ts`.
+
+4. Full build + test:
+```bash
+pnpm run build && pnpm test
+```
+
+5. Commit:
+```bash
+git commit -am "refactor(core): remove workflow.ts, re-export from @uncaged/workflow
+
+Refs #320"
+```
+
+---
+
+## Phase 3: Move Workflow IPC Messages
+
+### Task 5: Extract workflow IPC types to `@uncaged/workflow`
+
+**Objective:** Move workflow-related IPC message types from `packages/daemon/src/ipc.ts` to `packages/workflow/src/ipc.ts`. Sense IPC stays in daemon.
+
+**Files:**
+- Create: `packages/workflow/src/ipc.ts`
+- Modify: `packages/workflow/src/index.ts`
+- Modify: `packages/daemon/src/ipc.ts` — remove workflow IPC types, import from `@uncaged/workflow`
+
+**Steps:**
+
+1. Extract to `packages/workflow/src/ipc.ts`:
+   - `StartThreadMessage`, `ResumeThreadMessage`, `KillThreadMessage`
+   - `ThreadLifecycleEvent`, `ThreadEventMessage`, `WorkflowErrorMessage`, `ThreadWorkflowMessage`
+   - Workflow-related validation logic from `parseParentToWorkerMessage`
+   - Union type for workflow parent→worker messages
+
+2. Keep in daemon `ipc.ts`:
+   - `ComputeMessage`, `ShutdownMessage`, `HealthRequestMessage`
+   - Sense-related worker→parent messages
+   - The combined `ParentToWorkerMessage` union (imports workflow types from `@uncaged/workflow`)
+
+3. Add `@uncaged/workflow` as dependency to `packages/daemon/package.json`.
+
+4. Build + test:
+```bash
+pnpm run build && pnpm test
+```
+
+5. Commit:
+```bash
+git commit -am "refactor(workflow): move workflow IPC types to @uncaged/workflow
+
+Refs #320"
+```
+
+---
+
+## Phase 4: Move Workflow Runtime
+
+### Task 6: Move `workflow-worker.ts` to `@uncaged/workflow`
+
+**Objective:** Move workflow execution runtime (the worker that runs inside a child process) from daemon to the workflow package.
+
+**Files:**
+- Move: `packages/daemon/src/workflow-worker.ts` → `packages/workflow/src/worker.ts`
+- Modify: `packages/workflow/src/index.ts`
+- Modify: `packages/daemon/` — update worker spawn path
+
+**Steps:**
+
+1. Copy `workflow-worker.ts` to `packages/workflow/src/worker.ts`.
+
+2. Update imports: replace `@uncaged/nerve-core` with local imports from `./types.js`, `./ipc.js`.
+
+3. Export the worker entry point or the worker file path from `@uncaged/workflow` so daemon can spawn it.
+
+4. In daemon, update worker spawn to reference `@uncaged/workflow`'s worker.
+
+5. Delete `packages/daemon/src/workflow-worker.ts`.
+
+6. Build + test:
+```bash
+pnpm run build && pnpm test
+```
+
+7. Commit:
+```bash
+git commit -am "refactor(workflow): move workflow-worker runtime to @uncaged/workflow
+
+Refs #320"
+```
+
+### Task 7: Move `workflow-manager.ts` and `workflow-manager-support.ts` to `@uncaged/workflow`
+
+**Objective:** Move workflow process management from daemon to workflow package.
+
+**Files:**
+- Move: `packages/daemon/src/workflow-manager.ts` → `packages/workflow/src/manager.ts`
+- Move: `packages/daemon/src/workflow-manager-support.ts` → `packages/workflow/src/manager-support.ts`
+- Modify: `packages/daemon/src/kernel.ts` — import from `@uncaged/workflow`
+
+**Steps:**
+
+1. Copy both files to `packages/workflow/src/`.
+
+2. Update imports to use local paths within the workflow package.
+
+3. Export manager creation function from `packages/workflow/src/index.ts`.
+
+4. Update `packages/daemon/src/kernel.ts` to import workflow manager from `@uncaged/workflow`.
+
+5. Delete the original files from daemon.
+
+6. Build + test:
+```bash
+pnpm run build && pnpm test
+```
+
+7. Commit:
+```bash
+git commit -am "refactor(workflow): move workflow-manager to @uncaged/workflow
+
+Refs #320"
+```
+
+---
+
+## Phase 5: Update All Consumers
+
+### Task 8: Update `workflow-utils` to depend on `@uncaged/workflow`
+
+**Objective:** Change `@uncaged/nerve-workflow-utils` to import workflow types from `@uncaged/workflow` instead of `@uncaged/nerve-core`.
+
+**Files:**
+- Modify: `packages/workflow-utils/package.json` — replace `@uncaged/nerve-core` dep with `@uncaged/workflow`
+- Modify: all `packages/workflow-utils/src/*.ts` — update import paths
+
+**Steps:**
+
+1. In `package.json`, replace `"@uncaged/nerve-core": "workspace:*"` with `"@uncaged/workflow": "workspace:*"`.
+
+2. Find-and-replace all `from "@uncaged/nerve-core"` → `from "@uncaged/workflow"` in `packages/workflow-utils/src/`.
+
+3. Build + test:
+```bash
+pnpm run build && pnpm test
+```
+
+4. Commit:
+```bash
+git commit -am "refactor(workflow-utils): import from @uncaged/workflow
+
+Refs #320"
+```
+
+### Task 9: Update `workflow-meta` to depend on `@uncaged/workflow`
+
+**Objective:** Same as Task 8 but for `packages/workflow-meta/`.
+
+**Files:**
+- Modify: `packages/workflow-meta/package.json`
+- Modify: all `packages/workflow-meta/src/**/*.ts`
+
+**Steps:** Same pattern as Task 8.
+
+### Task 10: Update adapter packages
+
+**Objective:** Update `adapter-cursor` and `adapter-hermes` to import workflow types from `@uncaged/workflow`.
+
+**Files:**
+- Modify: `packages/adapter-cursor/src/index.ts`
+- Modify: `packages/adapter-cursor/package.json`
+- Modify: `packages/adapter-hermes/src/index.ts`
+- Modify: `packages/adapter-hermes/package.json`
+
+**Steps:** Same pattern — add `@uncaged/workflow` dep, update imports.
+
+### Task 11: Update CLI package
+
+**Objective:** Update CLI to import workflow types from `@uncaged/workflow`.
+
+**Files:**
+- Modify: `packages/cli/package.json`
+- Modify: `packages/cli/src/commands/workflow.ts`
+- Modify: `packages/cli/src/commands/thread.ts`
+- Modify: `packages/cli/src/commands/create.ts`
+- Modify: `packages/cli/src/workflow-agent-validation.ts`
+- Modify: other files that import workflow types from nerve-core
+
+**Steps:**
+
+1. Add `"@uncaged/workflow": "workspace:*"` to `packages/cli/package.json`.
+
+2. In each file, change workflow-related imports from `@uncaged/nerve-core` to `@uncaged/workflow`.
+
+3. Build + test:
+```bash
+pnpm run build && pnpm test
+```
+
+4. Commit:
+```bash
+git commit -am "refactor(cli): import workflow types from @uncaged/workflow
+
+Refs #320"
+```
+
+---
+
+## Phase 6: Clean Up Core Re-exports
+
+### Task 12: Remove workflow re-exports from `@uncaged/nerve-core`
+
+**Objective:** Core no longer re-exports any workflow types. All consumers import directly from `@uncaged/workflow`.
+
+**Files:**
+- Modify: `packages/core/src/index.ts` — remove all workflow re-exports
+- Modify: `packages/core/package.json` — remove `@uncaged/workflow` dependency (core no longer needs it)
+
+**Steps:**
+
+1. Remove all workflow-related `export` lines from `packages/core/src/index.ts`.
+
+2. Remove `@uncaged/workflow` from core's dependencies.
+
+3. Full build + full test:
+```bash
+pnpm run build && pnpm test
+```
+
+4. Run biome check:
+```bash
+pnpm run check
+```
+
+5. Commit:
+```bash
+git commit -am "refactor(core): remove workflow re-exports, clean break
+
+Fixes #320"
+```
+
+---
+
+## Phase 7: Verify & PR
+
+### Task 13: Final verification
+
+**Objective:** Full workspace build, all tests pass, biome clean.
+
+**Steps:**
+
+1. Clean build:
+```bash
+pnpm run build
+```
+
+2. Full tests:
+```bash
+pnpm test
+```
+
+3. Biome:
+```bash
+pnpm run check
+```
+
+4. Verify monorepo structure matches issue spec:
+```
+packages/
+  core/           # @uncaged/nerve-core — sense types, config (no workflow)
+  workflow/       # @uncaged/workflow — standalone orchestration engine
+  workflow-utils/ # helper roles, extract layer
+  workflow-meta/  # meta-workflows
+  daemon/         # @uncaged/nerve-daemon — sense engine + workflow integration
+  cli/            # @uncaged/nerve-cli
+```
+
+5. Create PR:
+```bash
+tea pr create --title "refactor: extract workflow engine into @uncaged/workflow" \
+  --description "## What
+Extract workflow engine into standalone @uncaged/workflow package.
+
+## Why
+Workflow engine is now independent of sense observation — can be used standalone.
+
+## Changes
+- packages/workflow/ — new package with types, IPC, worker, manager
+- packages/core/ — removed workflow types, no longer re-exports them
+- packages/daemon/ — imports workflow runtime from @uncaged/workflow
+- packages/cli/ — imports workflow types from @uncaged/workflow
+- packages/workflow-utils/ — depends on @uncaged/workflow
+- packages/workflow-meta/ — depends on @uncaged/workflow
+- packages/adapter-*/ — depends on @uncaged/workflow
+
+## Ref
+Fixes #320"
+```
+
+---
+
+## Pitfalls & Notes
+
+1. **Worker spawn path**: `workflow-worker.ts` is spawned as a child process via `node`. After moving to `@uncaged/workflow`, the daemon needs to resolve the worker entry point from the package (e.g. `require.resolve("@uncaged/workflow/worker")`). This likely requires a separate export in `package.json` exports map.
+
+2. **Dynamic import exception**: `workflow-worker.ts` uses dynamic `import()` for user workflow modules — this exception carries over to the new package. Add comment per CLAUDE.md conventions.
+
+3. **IPC split**: The `ipc.ts` in daemon has both sense and workflow messages in one file with shared validation. The split needs careful handling of the `ParentToWorkerMessage` union type and `parseParentToWorkerMessage` function.
+
+4. **No backward compat**: Per user preference, no deprecated re-exports — straight breaking change. Phase 6 removes re-exports from core entirely.
+
+5. **`workflow-utils` may still need `nerve-core`**: If workflow-utils imports non-workflow types (like `Schema`, `ExtractFn`, `ExtractError`) from core, it will need both deps. Check carefully.
+
+6. **Test files**: Many test files in daemon import workflow types. They need updating in Phase 5 alongside the source files.

package.json

@@ -4,9 +4,16 @@
   "engines": {
     "node": ">=22.5.0"
   },
+  "pnpm": {
+    "overrides": {
+      "@uncaged/nerve-core": "workspace:*",
+      "@uncaged/nerve-store": "workspace:*",
+      "@uncaged/workflow": "workspace:*"
+    }
+  },
   "scripts": {
     "prepare": "husky",
-    "build": "pnpm -r run build",
+    "build": "pnpm --filter @uncaged/workflow run build:public-types && pnpm --filter @uncaged/nerve-core run build && pnpm --filter @uncaged/nerve-store run build && pnpm --filter @uncaged/workflow run build && pnpm -r --filter '!@uncaged/nerve-core' --filter '!@uncaged/nerve-store' --filter '!@uncaged/workflow' run build",
     "test": "pnpm -r test",
     "check": "biome check .",
     "format": "biome format --write .",

packages/adapter-cursor/package.json

@@ -14,7 +14,8 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@uncaged/nerve-core": "workspace:*"
+    "@uncaged/nerve-core": "workspace:*",
+    "@uncaged/workflow": "workspace:*"
   },
   "devDependencies": {
     "@rslib/core": "^0.21.3",

packages/adapter-cursor/src/index.ts

@@ -1,5 +1,6 @@
-import type { AgentConfig, AgentFn, ThreadContext } from "@uncaged/nerve-core";
+import type { AgentConfig } from "@uncaged/nerve-core";
 import { type Result, type SpawnEnv, type SpawnError, ok, spawnSafe } from "@uncaged/nerve-core";
+import type { AgentFn, ThreadContext } from "@uncaged/workflow";
 
 export type CursorAgentMode = "plan" | "ask" | "default";
 

packages/adapter-hermes/package.json

@@ -14,7 +14,8 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@uncaged/nerve-core": "workspace:*"
+    "@uncaged/nerve-core": "workspace:*",
+    "@uncaged/workflow": "workspace:*"
   },
   "devDependencies": {
     "@rslib/core": "^0.21.3",

packages/adapter-hermes/src/index.ts

@@ -1,5 +1,6 @@
-import type { AgentConfig, AgentFn, ThreadContext } from "@uncaged/nerve-core";
+import type { AgentConfig } from "@uncaged/nerve-core";
 import { type Result, type SpawnEnv, type SpawnError, ok, spawnSafe } from "@uncaged/nerve-core";
+import type { AgentFn, ThreadContext } from "@uncaged/workflow";
 
 /**
  * Spawns a non-interactive `hermes chat` invocation with YOLO enabled, argv-only

packages/cli/package.json

@@ -17,12 +17,13 @@
   "scripts": {
     "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
     "build": "rslib build",
-    "pretest": "pnpm --filter @uncaged/nerve-core run build && pnpm --filter @uncaged/nerve-daemon run build",
+    "pretest": "pnpm --filter @uncaged/workflow run build:public-types && pnpm --filter @uncaged/nerve-core run build && pnpm --filter @uncaged/nerve-store run build && pnpm --filter @uncaged/workflow run build && pnpm --filter @uncaged/nerve-daemon run build",
     "test": "vitest run"
   },
   "dependencies": {
     "@uncaged/nerve-core": "workspace:*",
     "@uncaged/nerve-store": "workspace:*",
+    "@uncaged/workflow": "workspace:*",
     "citty": "^0.1.6",
     "picomatch": "^4.0.2",
     "yaml": "^2.8.3"

packages/cli/skills/claude/CLAUDE.md

@@ -0,0 +1,547 @@
+# Nerve — AI Agent 观测引擎
+
+Nerve 是一个轻量级观测引擎守护进程。它持续观测外部状态，通过声明式规则响应变化，编排多步骤工作流。
+
+## 核心架构
+
+```
+External World → Sense(state) → { newState, workflow? } → Workflow → Log
+```
+
+| 概念 | 说明 |
+|------|------|
+| **Sense** | 有状态的 `compute(state)` 函数。返回新状态和可选的 workflow trigger。状态以 JSON 文件持久化。调度由 nerve.yaml 配置。 |
+| **Workflow** | 有状态的多步骤执行。包含 Role（有副作用的执行者）和 Moderator（纯路由器）。每个实例是一个 Thread，有唯一 runId。 |
+| **Log** | 不可变审计日志。记录执行、状态转换、错误。不能触发 Sense（防止反馈循环）。 |
+| **Engine** | 内核，持有 Process Manager、Workflow Manager、Sense Scheduler。不直接加载用户代码。 |
+| **Daemon** | 引擎运行时，作为后台进程运行。 |
+
+**关键规则：**
+- 因果链单向：External → Sense(state) → Workflow（触发时） + Log
+- 进程隔离：每个 Sense group 一个 worker（长期），每个 Workflow 类型一个 worker（按需）
+- 两个扩展点：Sense（观测什么 + 何时）、Workflow（做什么）
+
+## 工作区结构
+
+由 `nerve init` 生成的工作区根目录（默认 `~/.uncaged-nerve/`）包含 **`AGENT.md`**。实现 sense/workflow 前先阅读该文件。
+
+```
+~/.uncaged-nerve/
+├── AGENT.md               # 人类 / Agent 可读的工作区约定（init 生成）
+├── nerve.yaml             # 核心配置
+├── package.json           # 单一根包（sense/workflow 下不再有独立 package）
+├── scripts/build.mjs      # 根目录 esbuild；通过 npm/pnpm 的 build 脚本调用
+├── senses/
+│   └── <name>/
+│       └── src/index.ts   # exports compute(state) + initialState
+├── workflows/
+│   └── <name>/
+│       ├── index.ts       # default export：WorkflowDefinition
+│       ├── moderator.ts   # 可选：抽出 moderator，由 index 导入
+│       ├── build.ts       # 可选：共享常量 / 纯函数（避免 index 臃肿；非 esbuild 入口）
+│       └── roles/
+│           └── <role>.ts  # 每角色单文件（推荐平铺，而非 roles/<role>/index.ts）
+└── data/
+    ├── senses/            # sense 状态 JSON 文件（自动生成）
+    └── logs.db            # 日志存储（自动生成）
+```
+
+### 命名约定
+
+- **Workflow**：动词开头的 kebab-case（例如 `review-pull-request`、`deploy-staging`）。避免单独名词式命名（如 `notifications`）。
+- **Sense**：描述性名词 kebab-case（例如 `cpu-usage`）。
+
+---
+
+## CLI 完整参考
+
+全局选项：`--host <host:port>`（连接远程 daemon）、`--api-token <secret>`（Bearer 认证）
+
+### 初始化与脚手架
+
+```bash
+nerve init                          # 初始化工作区
+nerve init --from <git-url>         # 从 git 仓库克隆工作区
+nerve init workspace                # 只初始化工作区结构
+
+nerve create sense <name>           # 创建 sense 脚手架
+nerve create sense <name> --force   # 覆盖已有
+nerve create workflow <name>        # 创建 workflow 脚手架
+nerve create workflow <name> --force
+
+nerve validate                      # 验证 nerve.yaml 配置
+```
+
+### Daemon 管理
+
+```bash
+nerve daemon start                  # 启动后台 daemon
+nerve daemon start --port 3000      # 指定 HTTP API 端口
+nerve daemon stop                   # 停止 daemon
+nerve daemon restart                # 重启
+nerve daemon status                 # 查看状态
+nerve daemon logs                   # 查看日志
+nerve daemon logs --follow          # 实时日志
+nerve daemon logs --n 50            # 最近 50 行
+
+nerve dev                           # 前台开发模式（不 fork daemon）
+nerve dev --port 3000               # 指定端口
+```
+
+### Sense 操作
+
+```bash
+nerve sense list                    # 列出所有注册的 sense
+nerve sense trigger <name>          # 手动触发 sense 计算
+```
+
+### Workflow 操作
+
+```bash
+nerve workflow list                 # 列出 nerve.yaml 中定义的 workflow
+nerve workflow status               # 查看运行中的 workflow 状态
+nerve workflow trigger <name>       # 触发 workflow
+nerve workflow trigger <name> --prompt "检查生产环境"
+nerve workflow trigger <name> --maxRounds 50
+nerve workflow trigger <name> --dryRun   # 干跑模式
+```
+
+### Thread（Workflow 执行记录）
+
+```bash
+nerve thread list                   # 列出最近的 workflow 执行
+nerve thread list --all             # 包含已完成/失败的
+nerve thread list --workflow <name> # 按 workflow 过滤
+nerve thread list --limit 50        # 最多 50 条
+
+nerve thread show <runId>           # 查看 role 对话轮次
+nerve thread show <runId> --budget 16000  # 增大输出预算（默认 8000 字符）
+
+nerve thread inspect <runId>        # 查看详情和事件
+
+nerve thread kill <runId>           # 终止运行中/排队中的 thread
+```
+
+### Store（日志归档）
+
+```bash
+nerve store archive                 # 导出旧日志到 JSONL 归档
+nerve store archive --vacuum        # 归档后 VACUUM 数据库
+```
+
+### Knowledge（知识库）
+
+```bash
+nerve knowledge sync                # 从 knowledge.yaml 重建索引
+nerve knowledge query "搜索内容"     # 搜索知识库
+nerve knowledge query "内容" --limit 5
+nerve knowledge query "内容" -g     # 搜索所有注册仓库
+```
+
+### Remote（远程 daemon）
+
+```bash
+nerve remote add <name> <host:port> --token <secret>
+nerve remote list
+nerve remote show <name>
+nerve remote set-url <name> <host>
+nerve remote set-token <name> <token>
+nerve remote remove <name>
+nerve remote default <name>         # 设为默认远程
+```
+
+### Agent（向 AI Agent 注入 nerve skill）
+
+```bash
+nerve agent status                  # CLI 版本与各注入目录中的 skill 版本
+nerve agent inject hermes           # 安装到 ~/.hermes/skills/nerve
+nerve agent inject hermes --profile <name>   # 写入 ~/.hermes/profiles/<name>/skills/nerve
+nerve agent inject cursor           # 注入到当前项目 .cursorrules
+nerve agent inject claude           # 注入到 ~/.claude/CLAUDE.md
+nerve agent update                  # 将所有已注入目录更新到当前 CLI 对应版本
+nerve agent remove hermes           # 移除 Hermes 注入
+nerve agent remove cursor           # 移除 Cursor 注入
+nerve agent remove claude           # 移除 Claude Code 注入
+```
+
+---
+
+## nerve.yaml 配置参考
+
+```yaml
+# 引擎全局配置
+max_rounds: 100              # moderator 最大轮次（默认 100）
+
+# Sense 配置
+senses:
+  cpu-usage:
+    group: system            # 必填，同 group 的 sense 共享 worker
+    interval: 10s            # 轮询间隔（duration: 5s, 10m, 1h）
+    throttle: 5s             # 最小计算间隔
+    timeout: 10s             # compute 超时
+    grace_period: null       # 超时后优雅等待
+
+  system-health:
+    group: derived
+    on: [cpu-usage, disk-usage]  # 响应式：被列出的 sense 完成 compute 时触发
+    throttle: null
+    timeout: null
+
+# Workflow 配置
+workflows:
+  my-workflow:
+    concurrency: 1           # 必填，并发数
+    overflow: drop           # 必填，超并发时处理：drop | queue
+    max_queue: 100           # overflow=queue 时的队列上限（默认 100）
+
+# HTTP API
+api:
+  port: 3000                 # null = 不启用 HTTP
+  host: "127.0.0.1"         # 监听地址
+  token: null                # 非 loopback 时必填
+
+# LLM Extract（可选）
+extract:
+  provider: anthropic
+  model: claude-sonnet-4-20250514
+```
+
+---
+
+## Sense 开发指南
+
+### compute 函数签名
+
+Sense 的 `compute` 接收当前状态，返回新状态和可选的 shell trigger（`{ command: string }`）。状态以 JSON 文件持久化在 `data/senses/<name>.json`。Workflow 只能通过 CLI / daemon IPC 启动，不能从 sense 返回值直接启动。
+
+```typescript
+import type { SenseComputeFn } from "@uncaged/nerve-core";
+
+type MyState = {
+  lastRun: number | null;
+  count: number;
+};
+
+export const initialState: MyState = { lastRun: null, count: 0 };
+
+export async function compute(state: MyState): Promise<{
+  state: MyState;
+  trigger: { command: string } | null;
+}> {
+  return {
+    state: { lastRun: Date.now(), count: state.count + 1 },
+    trigger: null,
+  };
+}
+```
+
+### 状态持久化
+
+| 时机 | 行为 |
+|------|------|
+| Worker 启动 | 读取 `data/senses/<name>.json`；不存在或损坏则使用 `initialState` |
+| Compute 成功 | 原子写入新状态（temp + rename），然后更新内存 |
+| Compute 失败 | 状态不变（磁盘和内存都不变） |
+| Daemon 重启 | 从上次成功写入恢复 |
+
+### 返回值
+
+```typescript
+// trigger: null → 不执行 shell 命令
+// trigger: { command } → sense worker 在成功的 compute 后以 shell 执行该命令（cwd = nerve 根目录）
+// 启动 workflow：在 shell 中调用 `nerve workflow trigger ...`，或使用 daemon IPC / HTTP API
+```
+
+### Sense 模块导出
+
+每个 sense 的 `src/index.ts` 必须导出两个东西：
+
+```typescript
+// senses/<name>/src/index.ts
+
+// 1. 初始状态
+export const initialState: MyState = { ... };
+
+// 2. compute 函数
+export async function compute(state: MyState): Promise<{
+  state: MyState;
+  trigger: { command: string } | null;
+}> {
+  // ...
+}
+```
+
+### 调度方式
+
+1. **interval 轮询**：`interval: 10s` — 每 10 秒执行一次
+2. **响应式触发**：`on: [cpu-usage]` — 当 cpu-usage 完成 compute 后触发
+3. 两者可以组合
+
+### 调试
+
+```bash
+nerve dev                           # 前台运行，看实时输出
+nerve sense trigger <name>          # 手动触发一次
+```
+
+### 完整示例：CPU 监控
+
+```typescript
+// senses/cpu-usage/src/index.ts
+import { loadavg } from "node:os";
+
+type CpuState = {
+  samples: Array<{ ts: number; value: number }>;
+};
+
+export const initialState: CpuState = { samples: [] };
+
+export async function compute(state: CpuState): Promise<{
+  state: CpuState;
+  trigger: null;
+}> {
+  const [oneMin] = loadavg();
+  const value = typeof oneMin === "number" && !Number.isNaN(oneMin) ? oneMin : 0;
+  const newSamples = [...state.samples.slice(-99), { ts: Date.now(), value }];
+  return { state: { samples: newSamples }, trigger: null };
+}
+```
+
+nerve.yaml:
+```yaml
+senses:
+  cpu-usage:
+    group: system
+    interval: 10s
+    throttle: 5s
+    timeout: 10s
+```
+
+---
+
+## Workflow 开发指南
+
+### 核心类型
+
+```typescript
+import type {
+  WorkflowDefinition,
+  RoleResult,
+  ThreadContext,
+  RoleMeta,
+  Moderator,
+} from "@uncaged/nerve-core";
+import { END } from "@uncaged/nerve-core";
+
+// Role<Meta> — (ctx: ThreadContext) => Promise<RoleResult<Meta>>
+// RoleResult<Meta> — { content: string; meta: Meta }
+// ThreadContext<M extends RoleMeta> — threadId, start（__start__ 帧）, steps（各 role 轮次）
+// Moderator<M> — (ctx) => 下一个 role 名 | END
+// WorkflowDefinition<M extends RoleMeta> — name, roles, moderator
+```
+
+### createRole 四元组（接入 LLM 时推荐）
+
+工作区根目录需安装 **`@uncaged/nerve-workflow-utils`**（及所选 agent 适配器包）。默认 `nerve init` 的 `package.json` 不含该依赖时，在 `~/.uncaged-nerve` 下执行 `pnpm add @uncaged/nerve-workflow-utils`（或 npm 等价命令）。
+
+使用 **`createRole`**，按固定顺序传入四件事：
+
+1. **adapter** — `AgentFn`，`(ctx, systemPrompt) => Promise<string>`（原始模型输出文本）。
+2. **prompt** — `string`，或 `async (ctx: ThreadContext) => string`。
+3. **meta** — `z.ZodType<M>`，供 moderator 路由的结构化 meta。
+4. **extract** — `{ provider: LlmProvider; dryRun: boolean | null }`，声明从回复中抽取 meta 时用的 LLM（OpenAI 兼容）及是否 dry-run。
+
+```typescript
+import { createLlmAdapter, createRole } from "@uncaged/nerve-workflow-utils";
+import type { ThreadContext } from "@uncaged/nerve-core";
+import { z } from "zod";
+
+const provider = {
+  baseUrl: "https://api.example.com/v1",
+  apiKey: process.env.EXAMPLE_API_KEY!,
+  model: "gpt-4o-mini",
+};
+
+const planMeta = z.object({ next: z.enum(["execute", "stop"]) });
+
+export const planner = createRole(
+  createLlmAdapter(provider),
+  async (ctx: ThreadContext) => `规划任务：${ctx.start.content}`,
+  planMeta,
+  { provider, dryRun: null },
+);
+```
+
+`createLlmAdapter` 仅位于 **`@uncaged/nerve-workflow-utils`**：用 `LlmProvider` 生成 `AgentFn`，单轮对话里 **system** 来自 `createRole` 解析后的 prompt 字符串，**user** 为线程起点 `ctx.start.content`。
+
+### 基本 Workflow 示例（平铺 `roles/<role>.ts`）
+
+```typescript
+// workflows/example/roles/main.ts
+import type { RoleResult, ThreadContext } from "@uncaged/nerve-core";
+
+export async function main(ctx: ThreadContext): Promise<RoleResult<{ round: number }>> {
+  const prompt = ctx.start.content;
+  return {
+    content: `处理完成: ${prompt}`,
+    meta: { round: ctx.steps.length },
+  };
+}
+```
+
+```typescript
+// workflows/example/index.ts
+import type { ThreadContext, WorkflowDefinition } from "@uncaged/nerve-core";
+import { END } from "@uncaged/nerve-core";
+
+import { main } from "./roles/main.js";
+
+type Meta = Record<"main", { round: number }>;
+
+const workflow: WorkflowDefinition<Meta> = {
+  name: "example",
+  roles: { main },
+  moderator(ctx: ThreadContext<Meta>) {
+    return ctx.steps.length === 0 ? "main" : END;
+  },
+};
+
+export default workflow;
+```
+
+可选：将 `moderator` 挪到 `moderator.ts` 再 `import { route } from "./moderator.js"`，保持 `index.ts` 只负责组装 `WorkflowDefinition`。
+
+### 多 Role Workflow 示例
+
+```typescript
+// workflows/plan-execute-review/roles/planner.ts
+import type { RoleResult, ThreadContext } from "@uncaged/nerve-core";
+
+export async function planner(ctx: ThreadContext): Promise<RoleResult<{ status: string }>> {
+  void ctx;
+  return { content: "计划: ...", meta: { status: "planned" } };
+}
+```
+
+```typescript
+// workflows/plan-execute-review/roles/executor.ts
+import type { RoleResult, ThreadContext } from "@uncaged/nerve-core";
+
+export async function executor(ctx: ThreadContext): Promise<RoleResult<{ status: string }>> {
+  void ctx;
+  return { content: "执行: ...", meta: { status: "executed" } };
+}
+```
+
+```typescript
+// workflows/plan-execute-review/roles/reviewer.ts
+import type { RoleResult, ThreadContext } from "@uncaged/nerve-core";
+
+export async function reviewer(ctx: ThreadContext): Promise<RoleResult<{ status: string }>> {
+  void ctx;
+  return { content: "审核通过", meta: { status: "approved" } };
+}
+```
+
+```typescript
+// workflows/plan-execute-review/index.ts
+import type { WorkflowDefinition, ThreadContext } from "@uncaged/nerve-core";
+import { END } from "@uncaged/nerve-core";
+
+import { executor } from "./roles/executor.js";
+import { planner } from "./roles/planner.js";
+import { reviewer } from "./roles/reviewer.js";
+
+type Roles = Record<"planner" | "executor" | "reviewer", { status: string }>;
+
+const workflow: WorkflowDefinition<Roles> = {
+  name: "plan-execute-review",
+  roles: { planner, executor, reviewer },
+  moderator(ctx: ThreadContext<Roles>) {
+    if (ctx.steps.length === 0) return "planner";
+    const last = ctx.steps[ctx.steps.length - 1];
+    if (last.role === "planner") return "executor";
+    if (last.role === "executor") return "reviewer";
+    return END;
+  },
+};
+
+export default workflow;
+```
+
+### Agent 适配器
+
+Workflow role 可以集成 AI agent。已知适配器 **ID**：`echo`、`cursor`、`hermes`、`codex`。
+
+```typescript
+type AgentFn = (ctx: ThreadContext, systemPrompt: string) => Promise<string>;
+```
+
+没有现成 agent 包时，用 **`createLlmAdapter`（`@uncaged/nerve-workflow-utils`）** 从 OpenAI 兼容的 `LlmProvider` 构造 `AgentFn`，再交给 **`createRole`** 的四元组。
+
+### Workflow 运行状态
+
+`queued` → `started` → `completed` | `failed` | `crashed` | `killed` | `interrupted` | `dropped`
+
+---
+
+## 日常操作 Pattern
+
+### 查看系统整体状态
+
+```bash
+nerve daemon status                 # daemon 是否在运行
+nerve sense list                    # 所有 sense 及其调度配置
+nerve workflow status               # 运行中的 workflow
+nerve thread list                   # 最近的 workflow 执行记录
+```
+
+### 手动触发 workflow
+
+```bash
+nerve workflow trigger my-workflow --prompt "手动检查"
+nerve thread list --workflow my-workflow  # 查看执行状态
+nerve thread show <runId>           # 查看对话详情
+```
+
+### 排查 sense 报错
+
+```bash
+nerve daemon logs --follow          # 查看实时日志
+nerve sense trigger <name>          # 手动触发看报错
+nerve dev                           # 前台模式，更详细的输出
+```
+
+### 开发新 sense
+
+```bash
+nerve create sense my-sensor        # 脚手架
+# 编辑 senses/my-sensor/src/index.ts — 实现 compute(state) + initialState
+nerve validate                      # 验证配置
+nerve dev                           # 前台测试
+nerve sense trigger my-sensor       # 单次触发验证
+```
+
+### 开发新 workflow
+
+```bash
+nerve create workflow my-flow       # 脚手架
+# 推荐对齐 AGENT.md：workflows/my-flow/index.ts + roles/<role>.ts（平铺），moderator 可拆到 moderator.ts
+nerve validate                      # 验证配置
+cd ~/.uncaged-nerve && npm run build   # 工作区根目录构建；勿在单个 workflow 子目录单独跑 build
+nerve workflow trigger my-flow --prompt "测试" --dryRun  # 干跑
+nerve thread show <runId>           # 查看执行轨迹
+```
+
+---
+
+## Pitfalls
+
+- **Sense 状态**：`compute(state)` 必须返回 `{ state, workflow }` 对象。不要返回 null 或 undefined。
+- **initialState**：每个 sense 必须导出 `initialState`，否则加载失败。
+- **状态持久化**：daemon 自动管理状态读写，业务代码不要自行读写 state.json。
+- **no optional properties**：nerve 代码规范禁止 `?:`，用 `T | null` 代替。
+- **函数式风格**：用 `function` + `type`，不用 `class` + `interface`。
+- **workflow 用 default export**：工作区里通常只有 `workflows/<name>/index.ts` 使用 default export（daemon 加载约定）。
+- **concurrency + overflow**：workflow 必须配置并发策略，否则验证失败。
+- **moderator 是同步函数**：不要加 async，moderator 是纯路由逻辑，不能有副作用。

packages/cli/skills/cursor/.cursorrules

@@ -252,22 +252,7 @@ export async function compute(): Promise<ComputeResult<MySignalShape>> {
 
 ### 返回值
 
-```typescript
-// 返回 null = 静默，不发 signal
-// 返回非 null = 发出 signal（并写入业务表），可选触发 workflow
-type ComputeResult<T> =
-  | null
-  | { signal: T; workflow: WorkflowTrigger | null };
-
-type WorkflowTrigger = {
-  name: string;          // workflow 名称（对应 nerve.yaml 中的 key）
-  maxRounds: number;     // moderator 最大轮次
-  prompt: string;        // 初始 prompt
-  dryRun: boolean;       // 干跑模式
-};
-```
-
-若返回值是普通对象且不含 `signal` 字段，内核会按 shorthand 视为 `{ signal: payload, workflow: null }`（见 core 的 `routeSenseComputeOutput`）。
+当前引擎：`compute(state)` 返回 `{ state, trigger }`，`trigger` 为 `null` 或 `{ command: string }`（shell 命令）。Workflow 仅通过 CLI / daemon IPC 启动；类型见 `@uncaged/nerve-core` 的 `SenseComputeFn` / `SenseTrigger`。
 
 ### Sense 模块导出
 

packages/cli/skills/hermes/SKILL.md

@@ -245,22 +245,7 @@ export async function compute(): Promise<ComputeResult<MySignalShape>> {
 
 ### 返回值
 
-```typescript
-// 返回 null = 静默，不发 signal
-// 返回非 null = 发出 signal（并写入业务表），可选触发 workflow
-type ComputeResult<T> =
-  | null
-  | { signal: T; workflow: WorkflowTrigger | null };
-
-type WorkflowTrigger = {
-  name: string;          // workflow 名称（对应 nerve.yaml 中的 key）
-  maxRounds: number;     // moderator 最大轮次
-  prompt: string;        // 初始 prompt
-  dryRun: boolean;       // 干跑模式
-};
-```
-
-若返回值是普通对象且不含 `signal` 字段，内核会按 shorthand 视为 `{ signal: payload, workflow: null }`（见 core 的 `routeSenseComputeOutput`）。
+当前引擎：`compute(state)` 返回 `{ state, trigger }`，其中 `trigger` 为 `null` 或 `{ command: string }`（sense worker 内 `shell: true` 执行）。Workflow 仅通过 CLI / daemon IPC 启动，类型见 `@uncaged/nerve-core` 的 `SenseComputeFn` / `SenseTrigger`。
 
 ### Sense 模块导出
 
@@ -273,7 +258,7 @@ type Row = { ts: number; value: number };
 
 export async function compute(): Promise<ComputeResult<Row>> {
   const row: Row = { ts: Date.now(), value: Math.random() }; // 替换为真实观测逻辑
-  return { signal: row, workflow: null };
+  return { signal: row, trigger: null };
 }
 
 export { table };
@@ -325,7 +310,7 @@ type Row = { ts: number; value: number };
 
 export async function compute(): Promise<ComputeResult<Row>> {
   const oneMin = os.loadavg()[0];
-  return { signal: { ts: Date.now(), value: oneMin }, workflow: null };
+  return { signal: { ts: Date.now(), value: oneMin }, trigger: null };
 }
 
 export { table };

packages/cli/src/__tests__/create-sense.test.ts

@@ -26,7 +26,7 @@ describe("buildSenseIndexTs", () => {
     expect(ts).toContain("type SenseState");
     expect(ts).toContain("export const initialState");
     expect(ts).toContain("export async function compute");
-    expect(ts).toContain("workflow: null");
+    expect(ts).toContain("trigger: null");
     expect(ts).toContain("lastRun");
   });
 });

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

@@ -27,10 +27,10 @@ describe("buildWorkflowScaffold", () => {
     expect(roleMainIndexTs).toContain("my-workflow started");
   });
 
-  it("root index contains WorkflowDefinition import from nerve-core", () => {
+  it("root index contains WorkflowDefinition import from @uncaged/workflow", () => {
     const { indexTs } = buildWorkflowScaffold("test");
     expect(indexTs).toContain("WorkflowDefinition");
-    expect(indexTs).toContain("@uncaged/nerve-core");
+    expect(indexTs).toContain("@uncaged/workflow");
   });
 
   it("root index wires moderator with ThreadContext and END", () => {

packages/cli/src/__tests__/e2e-create.test.ts

@@ -2,9 +2,12 @@
  * E2E-style tests for `nerve create workflow` and `nerve create sense`.
  */
 
+import { execFile } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
 
 import { defineCommand, runCommand } from "citty";
 import { afterEach, describe, expect, it } from "vitest";
@@ -12,6 +15,23 @@ import { afterEach, describe, expect, it } from "vitest";
 import { createCommand } from "../commands/create.js";
 import { initCommand } from "../commands/init.js";
 
+const execFileAsync = promisify(execFile);
+const requireFromHere = createRequire(import.meta.url);
+
+/**
+ * Default init pins `@uncaged/workflow` to npm `latest`, but that package is not published yet.
+ * Install from the monorepo workspace so `pnpm run build` can resolve workflow types.
+ */
+async function installWorkspaceWithLocalWorkflow(nerveRoot: string): Promise<void> {
+  const pkgPath = join(nerveRoot, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { dependencies: Record<string, string> };
+  const wfRoot = dirname(requireFromHere.resolve("@uncaged/workflow/package.json"));
+  pkg.dependencies["@uncaged/workflow"] = `file:${wfRoot}`;
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf8");
+  await execFileAsync("pnpm", ["install", "--no-frozen-lockfile"], { cwd: nerveRoot });
+  await execFileAsync("pnpm", ["run", "build"], { cwd: nerveRoot });
+}
+
 const testRootCommand = defineCommand({
   meta: { name: "nerve", description: "e2e-create" },
   subCommands: {
@@ -128,7 +148,8 @@ describe("e2e create", () => {
       fakeHome = mkdtempSync(join(tmpdir(), "nerve-create-e2e-"));
       const nerveRoot = join(fakeHome, ".uncaged-nerve");
 
-      await runTestCli(fakeHome, ["init", "--force"]);
+      await runTestCli(fakeHome, ["init", "--force", "--skip-install"]);
+      await installWorkspaceWithLocalWorkflow(nerveRoot);
 
       const wf = await runTestCli(fakeHome, ["create", "workflow", "e2e-flow"]);
       expect(wf.exitCode).toBe(0);
@@ -153,7 +174,8 @@ describe("e2e create", () => {
       fakeHome = mkdtempSync(join(tmpdir(), "nerve-create-e2e-"));
       const nerveRoot = join(fakeHome, ".uncaged-nerve");
 
-      await runTestCli(fakeHome, ["init", "--force"]);
+      await runTestCli(fakeHome, ["init", "--force", "--skip-install"]);
+      await installWorkspaceWithLocalWorkflow(nerveRoot);
 
       const sense = await runTestCli(fakeHome, ["create", "sense", "e2e-sense"]);
       expect(sense.exitCode).toBe(0);

packages/cli/src/__tests__/e2e-harness.ts

@@ -51,8 +51,9 @@ import { workflowCommand } from "../commands/workflow.js";
 
 const require = createRequire(import.meta.url);
 const nerveDaemonRoot = dirname(require.resolve("@uncaged/nerve-daemon/package.json"));
+const nerveWorkflowRoot = dirname(require.resolve("@uncaged/workflow/package.json"));
 const senseWorkerScript = join(nerveDaemonRoot, "dist", "sense-worker.js");
-const workflowWorkerScript = join(nerveDaemonRoot, "dist", "workflow-worker.js");
+const workflowWorkerScript = join(nerveWorkflowRoot, "dist", "worker.js");
 
 const nerveYamlTemplate = `senses:
   counter:
@@ -120,29 +121,7 @@ const counterIndexJs = `export const initialState = { count: 0 };
 export async function compute(state) {
   return {
     state: { count: state.count + 1 },
-    workflow: null,
-  };
-}
-`;
-
-/** First trigger launches local noop workflow; later triggers only advance idleTicks. */
-const counterIndexJsWithNoopWorkflow = `export const initialState = { launched: false, idleTicks: 0 };
-
-export async function compute(state) {
-  if (!state.launched) {
-    return {
-      state: { launched: true, idleTicks: state.idleTicks },
-      workflow: {
-        name: "noop",
-        maxRounds: 3,
-        prompt: "e2e-archive",
-        dryRun: false,
-      },
-    };
-  }
-  return {
-    state: { launched: state.launched, idleTicks: state.idleTicks + 1 },
-    workflow: null,
+    trigger: null,
   };
 }
 `;
@@ -204,11 +183,7 @@ function writeWorkspaceLayout(nerveRoot: string, withNoopWorkflow: boolean): voi
     withNoopWorkflow ? nerveYamlWithNoopWorkflow : nerveYamlTemplate,
     "utf8",
   );
-  writeFileSync(
-    join(nerveRoot, "dist", "senses", "counter", "index.js"),
-    withNoopWorkflow ? counterIndexJsWithNoopWorkflow : counterIndexJs,
-    "utf8",
-  );
+  writeFileSync(join(nerveRoot, "dist", "senses", "counter", "index.js"), counterIndexJs, "utf8");
   writeFileSync(
     join(nerveRoot, "dist", "workflows", "echo", "index.js"),
     echoWorkflowIndexJs,
@@ -234,8 +209,8 @@ export type TestDaemonHandle = {
 
 export type StartTestDaemonOpts = {
   /**
-   * When true, counter sense's first compute launches a local `noop` workflow (real
-   * workflow-worker child). Requires built `workflow-worker.js` next to `sense-worker.js`.
+   * When true, bundles a local `noop` workflow under `dist/workflows/noop` for tests that
+   * start runs via `nerve workflow trigger` (real workflow-worker child).
    */
   withNoopWorkflow: boolean;
 } | null;
@@ -300,7 +275,7 @@ export async function startTestDaemon(
   }
   if (!existsSync(workflowWorkerScript)) {
     throw new Error(
-      `Missing "${workflowWorkerScript}". Run \`pnpm --filter @uncaged/nerve-daemon build\`.`,
+      `Missing "${workflowWorkerScript}". Run \`pnpm --filter @uncaged/workflow build\`.`,
     );
   }
 

packages/cli/src/__tests__/e2e-store-archive.test.ts

@@ -46,8 +46,14 @@ describe("e2e store archive", () => {
       daemon = await startTestDaemon({ withNoopWorkflow: true });
       linkWorkspaceDaemonIntoNerveRoot(daemon.nerveRoot);
 
-      const triggerResult = await runCli(daemon, ["sense", "trigger", "counter"]);
-      expect(triggerResult.exitCode).toBe(0);
+      const wfTrigger = await runCli(daemon, [
+        "workflow",
+        "trigger",
+        "noop",
+        "--prompt",
+        "e2e-archive",
+      ]);
+      expect(wfTrigger.exitCode).toBe(0);
 
       const logsDb = join(daemon.nerveRoot, "data", "logs.db");
       await pollUntil(() => {
@@ -101,8 +107,14 @@ describe("e2e store archive", () => {
     daemon = await startTestDaemon({ withNoopWorkflow: true });
     linkWorkspaceDaemonIntoNerveRoot(daemon.nerveRoot);
 
-    const triggerResult = await runCli(daemon, ["sense", "trigger", "counter"]);
-    expect(triggerResult.exitCode).toBe(0);
+    const wfTrigger = await runCli(daemon, [
+      "workflow",
+      "trigger",
+      "noop",
+      "--prompt",
+      "e2e-archive",
+    ]);
+    expect(wfTrigger.exitCode).toBe(0);
 
     const logsDb = join(daemon.nerveRoot, "data", "logs.db");
     await pollUntil(() => {

packages/cli/src/commands/agent.ts

@@ -65,6 +65,10 @@ function writeVersionFile(skillDir: string, version: string): void {
 
 const CURSOR_VERSION_MARKER_RE = /<!--\s*nerve-cli-version:\s*([^>]+?)\s*-->/;
 
+const CLAUDE_BLOCK_START_RE = /<!--\s*nerve-cli:start\s+v([^\s>]+)\s*-->/;
+const CLAUDE_BLOCK_END = "<!-- nerve-cli:end -->";
+const CLAUDE_BLOCK_RE = /<!--\s*nerve-cli:start\s+v[^\s>]+\s*-->[\s\S]*?<!--\s*nerve-cli:end\s*-->/;
+
 function resolveCursorProjectDir(pathArg: string | null): string {
   const raw = pathArg !== null && pathArg !== "" ? pathArg : process.cwd();
   return resolvePath(raw);
@@ -164,6 +168,82 @@ function removeHermes(profile: string | null): void {
   process.stdout.write(`✅ Removed Hermes nerve skill${loc}\n`);
 }
 
+// --- Claude Code ---
+
+function getClaudeGlobalFile(): string {
+  return join(homedir(), ".claude", "CLAUDE.md");
+}
+
+function readClaudeBlockVersion(): string | null {
+  const filePath = getClaudeGlobalFile();
+  if (!existsSync(filePath)) return null;
+  const content = readFileSync(filePath, "utf8");
+  const match = content.match(CLAUDE_BLOCK_START_RE);
+  return match !== null ? match[1].trim() : null;
+}
+
+function injectClaude(): void {
+  const templatePath = join(getSkillSourceDir(), "claude", "CLAUDE.md");
+  if (!existsSync(templatePath)) {
+    throw new Error("Cannot locate claude/CLAUDE.md template. Is the CLI package intact?");
+  }
+  const version = cliVersion();
+  const existingVer = readClaudeBlockVersion();
+
+  if (existingVer === version) {
+    process.stdout.write(`✅ Claude Code nerve skill is already up to date (v${version})\n`);
+    return;
+  }
+
+  const body = readFileSync(templatePath, "utf8");
+  const block = `<!-- nerve-cli:start v${version} -->\n${body.trim()}\n${CLAUDE_BLOCK_END}`;
+
+  const filePath = getClaudeGlobalFile();
+  mkdirSync(dirname(filePath), { recursive: true });
+
+  if (existsSync(filePath)) {
+    const existing = readFileSync(filePath, "utf8");
+    if (CLAUDE_BLOCK_RE.test(existing)) {
+      // Replace existing block
+      const updated = existing.replace(CLAUDE_BLOCK_RE, block);
+      writeFileSync(filePath, updated, "utf8");
+    } else {
+      // Append
+      const sep = existing.endsWith("\n") ? "\n" : "\n\n";
+      writeFileSync(filePath, `${existing}${sep}${block}\n`, "utf8");
+    }
+  } else {
+    writeFileSync(filePath, `${block}\n`, "utf8");
+  }
+
+  const action = existingVer !== null ? "Updated" : "Installed";
+  process.stdout.write(`✅ ${action} Claude Code nerve skill v${version}\n`);
+  process.stdout.write(`   → ${filePath}\n`);
+}
+
+function removeClaude(): void {
+  const filePath = getClaudeGlobalFile();
+  if (!existsSync(filePath)) {
+    process.stdout.write("ℹ️ Claude Code nerve skill is not installed.\n");
+    return;
+  }
+  const content = readFileSync(filePath, "utf8");
+  if (!CLAUDE_BLOCK_RE.test(content)) {
+    process.stdout.write("ℹ️ Claude Code nerve skill is not installed.\n");
+    return;
+  }
+  const cleaned = content
+    .replace(CLAUDE_BLOCK_RE, "")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+  if (cleaned.length === 0) {
+    rmSync(filePath, { force: true });
+  } else {
+    writeFileSync(filePath, `${cleaned}\n`, "utf8");
+  }
+  process.stdout.write("✅ Removed Claude Code nerve skill\n");
+}
+
 function printCursorStatusLine(projectDir: string): void {
   const rulesPath = join(projectDir, ".cursorrules");
   const label = `Cursor (${projectDir})`;
@@ -193,6 +273,11 @@ function printStatus(): void {
   printCursorStatusLine(process.cwd());
   process.stdout.write("\n");
 
+  // Claude Code
+  const claudeVer = readClaudeBlockVersion();
+  printAgentLine("Claude Code", claudeVer);
+  process.stdout.write("\n");
+
   // Default profile
   const defaultDir = getHermesSkillDir(null);
   const defaultVer = readVersionFile(defaultDir);
@@ -237,7 +322,7 @@ const injectCommand = defineCommand({
   args: {
     target: {
       type: "positional",
-      description: "Agent target: hermes | cursor",
+      description: "Agent target: hermes | cursor | claude",
     },
     profile: {
       type: "string",
@@ -267,8 +352,12 @@ const injectCommand = defineCommand({
       injectCursor(resolveCursorProjectDir(pathArg));
       return;
     }
+    if (target === "claude") {
+      injectClaude();
+      return;
+    }
     process.stderr.write(`❌ Unknown agent target: ${target}\n`);
-    process.stderr.write("   Supported targets: hermes, cursor\n");
+    process.stderr.write("   Supported targets: hermes, cursor, claude\n");
     process.exit(1);
   },
 });
@@ -307,6 +396,12 @@ const updateCommand = defineCommand({
     if (updated === 0) {
       process.stdout.write("ℹ️ No injected skills found. Run `nerve agent inject hermes` first.\n");
     }
+
+    // Claude Code (always check, no profiles)
+    const claudeVer = readClaudeBlockVersion();
+    if (claudeVer !== null) {
+      injectClaude();
+    }
   },
 });
 
@@ -348,8 +443,12 @@ const removeCommand = defineCommand({
       removeCursor(resolveCursorProjectDir(pathArg));
       return;
     }
+    if (target === "claude") {
+      removeClaude();
+      return;
+    }
     process.stderr.write(`❌ Unknown agent target: ${target}\n`);
-    process.stderr.write("   Supported targets: hermes, cursor\n");
+    process.stderr.write("   Supported targets: hermes, cursor, claude\n");
     process.exit(1);
   },
 });

packages/cli/src/commands/create.ts

@@ -31,8 +31,8 @@ export function buildWorkflowScaffold(name: string): WorkflowScaffoldFiles {
 }
 
 function buildWorkflowIndexTs(name: string): string {
-  return `import type { ThreadContext, WorkflowDefinition } from "@uncaged/nerve-core";
-import { END } from "@uncaged/nerve-core";
+  return `import type { ThreadContext, WorkflowDefinition } from "@uncaged/workflow";
+import { END } from "@uncaged/workflow";
 
 import { mainRole } from "./roles/main/index.js";
 
@@ -56,7 +56,7 @@ export default workflow;
 }
 
 function buildWorkflowMainRoleIndexTs(name: string): string {
-  return `import type { RoleResult, ThreadContext } from "@uncaged/nerve-core";
+  return `import type { RoleResult, ThreadContext } from "@uncaged/workflow";
 
 /**
  * Main role — implement LLM calls, scripts, HTTP, etc.
@@ -94,12 +94,12 @@ export const initialState: SenseState = { lastRun: null };
 
 export async function compute(state: SenseState): Promise<{
   state: SenseState;
-  workflow: null;
+  trigger: null;
 }> {
   // TODO: implement sense logic
   return {
     state: { lastRun: Date.now() },
-    workflow: null,
+    trigger: null,
   };
 }
 `;

packages/cli/src/commands/init.ts

@@ -54,6 +54,7 @@ const PACKAGE_JSON = `${JSON.stringify(
     dependencies: {
       "@uncaged/nerve-core": "latest",
       "@uncaged/nerve-daemon": "latest",
+      "@uncaged/workflow": "latest",
       zod: "^4.3.6",
     },
     devDependencies: {
@@ -224,12 +225,12 @@ export const initialState: CpuState = { samples: [] };
 
 export async function compute(state: CpuState): Promise<{
   state: CpuState;
-  workflow: null;
+  trigger: null;
 }> {
   const [oneMin] = loadavg();
   const value = typeof oneMin === "number" && !Number.isNaN(oneMin) ? oneMin : 0;
   const newSamples = [...state.samples.slice(-99), { ts: Date.now(), value }];
-  return { state: { samples: newSamples }, workflow: null };
+  return { state: { samples: newSamples }, trigger: null };
 }
 `;
 

packages/cli/src/commands/workflow.ts

@@ -1,7 +1,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { DEFAULT_ENGINE_MAX_ROUNDS, isPlainRecord, parseNerveConfig } from "@uncaged/nerve-core";
+import { isPlainRecord, parseNerveConfig } from "@uncaged/nerve-core";
+import { DEFAULT_ENGINE_MAX_ROUNDS } from "@uncaged/workflow";
 import { defineCommand } from "citty";
 import { stringify } from "yaml";
 

packages/cli/src/daemon-client.ts

@@ -20,12 +20,8 @@ import type {
   SenseInfo,
   WorkflowStatus,
 } from "@uncaged/nerve-core";
-import {
-  DEFAULT_ENGINE_MAX_ROUNDS,
-  isPlainRecord,
-  isSenseInfo,
-  isWorkflowStatus,
-} from "@uncaged/nerve-core";
+import { isPlainRecord, isSenseInfo, isWorkflowStatus } from "@uncaged/nerve-core";
+import { DEFAULT_ENGINE_MAX_ROUNDS } from "@uncaged/workflow";
 
 import { getCliDaemonApiToken, getCliDaemonHost } from "./cli-global.js";
 import { HttpTransport } from "./http-transport.js";

packages/cli/src/http-transport.ts

@@ -6,12 +6,8 @@ import type {
   SenseInfo,
   WorkflowStatus,
 } from "@uncaged/nerve-core";
-import {
-  DEFAULT_ENGINE_MAX_ROUNDS,
-  isPlainRecord,
-  isSenseInfo,
-  isWorkflowStatus,
-} from "@uncaged/nerve-core";
+import { isPlainRecord, isSenseInfo, isWorkflowStatus } from "@uncaged/nerve-core";
+import { DEFAULT_ENGINE_MAX_ROUNDS } from "@uncaged/workflow";
 
 function normalizeBaseUrl(host: string): string {
   const t = host.trim();

packages/core/README.md

@@ -4,9 +4,9 @@ Shared types and configuration parser for the [nerve](../../README.md) observati
 
 ## What's Inside
 
-- **Type definitions** — `SenseConfig`, `SenseInfo`, `SenseComputeFn`, `SenseModule`, `WorkflowConfig`, `NerveConfig`, `WorkflowTrigger`, and related types
+- **Type definitions** — `SenseConfig`, `SenseInfo`, `SenseComputeFn`, `SenseModule`, `SenseTrigger`, `WorkflowConfig`, `NerveConfig`, and related types
 - **Config parser** — `parseNerveConfig(yaml)` validates and parses `nerve.yaml` into `NerveConfig` (top-level `reflexes` is rejected; use `interval` / `on` on each sense)
-- **Workflow triggers** — `parseWorkflowTrigger` validates structured workflow launch objects from Sense compute results or IPC
+- **Sense triggers** — `parseSenseTrigger` validates `{ command: string }` from sense compute results or worker IPC (`trigger` field on `compute-result`)
 - **Daemon IPC protocol** — request/response types (`DaemonIpcRequest`, `DaemonIpcResponse`, …) and `parseDaemonIpcRequest` for newline-delimited JSON on the CLI ↔ daemon socket
 - **Workflow automaton types** — `START` / `END` sentinel constants, `WorkflowMessage`, `StartStep`, `RoleStep`, `ModeratorContext` (`start` + `steps`; empty `steps` on first moderator call), `Moderator` (single `context` argument), `WorkflowDefinition`, `Role`, `RoleResult`, plus `DEFAULT_ENGINE_MAX_ROUNDS`
 - **Result type** — `Result<T>` with `ok()` / `err()` helpers for explicit error handling (no thrown exceptions for parse paths)
@@ -23,23 +23,18 @@ if (result.ok) {
 }
 ```
 
-### Workflow trigger validation
+### Sense trigger validation
 
 ```typescript
-import { parseWorkflowTrigger } from "@uncaged/nerve-core";
+import { parseSenseTrigger } from "@uncaged/nerve-core";
 
-const directive = parseWorkflowTrigger({
-  name: "my-workflow",
-  maxRounds: 8,
-  prompt: "Hello from sense",
-  dryRun: false,
-});
-if (directive.ok) {
-  console.log(directive.value.name, directive.value.maxRounds, directive.value.prompt);
+const parsed = parseSenseTrigger({ command: "echo hello" });
+if (parsed.ok) {
+  console.log(parsed.value.command);
 }
 ```
 
-Sense modules return `{ state, workflow }` from `compute(state)`; when `workflow` is non-null it must satisfy the shape validated by `parseWorkflowTrigger` (the daemon validates before starting a run).
+Sense modules return `{ state, trigger }` from `compute(state)`; when `trigger` is non-null it must be exactly `{ command: string }` (non-empty after trim). The daemon validates worker IPC with `parseSenseTrigger`. Workflows are started only via CLI / daemon IPC, not from this field.
 
 ## Duration Format
 

packages/core/package.json

@@ -20,6 +20,7 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "@uncaged/workflow": "workspace:*",
     "yaml": "^2.8.3"
   },
   "devDependencies": {

packages/core/src/__tests__/sense-trigger.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+
+import { parseSenseTrigger } from "../sense.js";
+
+describe("parseSenseTrigger", () => {
+  it("accepts a valid command trigger", () => {
+    const r = parseSenseTrigger({ command: "echo hi" });
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value).toEqual({ command: "echo hi" });
+  });
+
+  it("trims command", () => {
+    const r = parseSenseTrigger({ command: "  echo hi  " });
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value).toEqual({ command: "echo hi" });
+  });
+
+  it("rejects empty command", () => {
+    const r = parseSenseTrigger({ command: "" });
+    expect(r.ok).toBe(false);
+  });
+
+  it("rejects whitespace-only command", () => {
+    const r = parseSenseTrigger({ command: "   " });
+    expect(r.ok).toBe(false);
+  });
+
+  it("rejects non-string command", () => {
+    const r = parseSenseTrigger({ command: 1 as unknown as string });
+    expect(r.ok).toBe(false);
+  });
+
+  it("rejects non-object", () => {
+    expect(parseSenseTrigger(null).ok).toBe(false);
+    expect(parseSenseTrigger("x").ok).toBe(false);
+    expect(parseSenseTrigger([]).ok).toBe(false);
+  });
+
+  it("rejects extra properties", () => {
+    const r = parseSenseTrigger({ command: "x", kind: "shell" });
+    expect(r.ok).toBe(false);
+  });
+
+  it("rejects empty object", () => {
+    const r = parseSenseTrigger({});
+    expect(r.ok).toBe(false);
+  });
+});

packages/core/src/__tests__/sense-workflow-directive.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { parseWorkflowTrigger } from "../sense.js";
-
-describe("parseWorkflowTrigger", () => {
-  it("accepts a valid trigger object", () => {
-    const r = parseWorkflowTrigger({
-      name: "my-wf",
-      maxRounds: 3,
-      prompt: "go",
-      dryRun: true,
-    });
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.value).toEqual({ name: "my-wf", maxRounds: 3, prompt: "go", dryRun: true });
-  });
-
-  it("trims workflow name", () => {
-    const r = parseWorkflowTrigger({
-      name: "  spaced  ",
-      maxRounds: 1,
-      prompt: "",
-      dryRun: false,
-    });
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.value.name).toBe("spaced");
-  });
-
-  it("rejects empty name", () => {
-    const r = parseWorkflowTrigger({ name: "", maxRounds: 1, prompt: "x", dryRun: false });
-    expect(r.ok).toBe(false);
-  });
-
-  it("rejects non-integer maxRounds", () => {
-    const r = parseWorkflowTrigger({
-      name: "w",
-      maxRounds: 1.5,
-      prompt: "",
-      dryRun: false,
-    });
-    expect(r.ok).toBe(false);
-  });
-
-  it("rejects maxRounds < 1", () => {
-    const r = parseWorkflowTrigger({ name: "w", maxRounds: 0, prompt: "", dryRun: false });
-    expect(r.ok).toBe(false);
-  });
-
-  it("rejects non-boolean dryRun", () => {
-    const r = parseWorkflowTrigger({
-      name: "w",
-      maxRounds: 1,
-      prompt: "",
-      dryRun: "no" as unknown as boolean,
-    });
-    expect(r.ok).toBe(false);
-  });
-});

packages/core/src/config.ts

@@ -1,7 +1,12 @@
 import { parse } from "yaml";
 
+import type { DropOverflowConfig, QueueOverflowConfig, WorkflowConfig } from "@uncaged/workflow";
 import { type Result, err, isPlainRecord, ok, parseDurationStringToMs } from "./util.js";
-import { DEFAULT_ENGINE_MAX_ROUNDS } from "./workflow.js";
+
+export type { DropOverflowConfig, QueueOverflowConfig, WorkflowConfig };
+
+/** Engine-wide fallback when nerve.yaml omits max_rounds (keep in sync with workflow package default). */
+export const DEFAULT_ENGINE_MAX_ROUNDS = 100;
 
 export type SenseConfig = {
   group: string;
@@ -14,19 +19,6 @@ export type SenseConfig = {
   on: string[];
 };
 
-export type DropOverflowConfig = {
-  concurrency: number;
-  overflow: "drop";
-};
-
-export type QueueOverflowConfig = {
-  concurrency: number;
-  overflow: "queue";
-  maxQueue: number;
-};
-
-export type WorkflowConfig = DropOverflowConfig | QueueOverflowConfig;
-
 /** Optional HTTP control plane. When `port` is null, the HTTP server is not started. */
 export type NerveApiConfig = {
   port: number | null;
@@ -52,12 +44,13 @@ export type ExtractConfig = {
   model: string;
 };
 
-/** Parameters for starting a workflow from a Sense compute result (or CLI trigger). */
-export type WorkflowTrigger = {
-  name: string;
-  maxRounds: number;
-  prompt: string;
-  dryRun: boolean;
+/**
+ * Optional shell side effect after a successful sense `compute()`.
+ * Executed in the sense worker (`spawn` with `shell: true`, cwd = nerve root).
+ * Workflows are started only via CLI / daemon IPC, not from sense compute results.
+ */
+export type SenseTrigger = {
+  command: string;
 };
 
 export type NerveConfig = {

packages/core/src/index.ts

@@ -1,32 +1,14 @@
 export type {
   SenseConfig,
-  DropOverflowConfig,
-  QueueOverflowConfig,
-  WorkflowConfig,
   NerveApiConfig,
   AgentConfig,
   ExtractConfig,
   NerveConfig,
-  WorkflowTrigger,
+  SenseTrigger,
 } from "./config.js";
 export type { SenseInfo } from "./sense.js";
 export type { SenseComputeFn, SenseModule } from "./sense.js";
 export { senseTriggerLabels } from "./sense.js";
-export type {
-  WorkflowMessage,
-  RoleResult,
-  Role,
-  RoleMeta,
-  StartStep,
-  ThreadContext,
-  WorkflowContext,
-  AgentFn,
-  RoleStep,
-  ModeratorContext,
-  Moderator,
-  WorkflowDefinition,
-} from "./workflow.js";
-export { START, END, DEFAULT_ENGINE_MAX_ROUNDS } from "./workflow.js";
 export type { Schema, ExtractFn } from "./agent.js";
 export { ExtractError } from "./agent.js";
 export type { Result } from "./util.js";
@@ -44,7 +26,7 @@ export type { KnowledgeConfig } from "./config.js";
 export { parseKnowledgeYaml } from "./config.js";
 export { isPlainRecord } from "./util.js";
 
-export { parseWorkflowTrigger } from "./sense.js";
+export { parseSenseTrigger } from "./sense.js";
 
 export { isSenseInfo, isWorkflowStatus } from "./daemon.js";
 export type {

packages/core/src/sense.ts

@@ -1,4 +1,4 @@
-import type { SenseConfig, WorkflowTrigger } from "./config.js";
+import type { SenseConfig, SenseTrigger } from "./config.js";
 import { type Result, err, isPlainRecord, ok } from "./util.js";
 
 /** Runtime metadata for a sense (e.g. daemon list-senses IPC). */
@@ -8,7 +8,7 @@ export type SenseInfo = {
   throttle: number | null;
   timeout: number | null;
   /** Declarative schedule (`interval` / `on`) for this sense (derived from nerve.yaml). */
-  triggers: string[];
+  triggers: ReadonlyArray<string>;
 };
 
 /**
@@ -16,11 +16,11 @@ export type SenseInfo = {
  * `compute` export.
  *
  * Pure: no DB, no peers.
- * Returns the next sense state and an optional workflow to start (`workflow: null` means no workflow).
+ * Returns the next sense state and an optional trigger (`trigger: null` means no side effect).
  */
 export type SenseComputeFn<S = unknown> = (
   state: S,
-) => Promise<{ state: S; workflow: WorkflowTrigger | null }>;
+) => Promise<{ state: S; trigger: SenseTrigger | null }>;
 
 /**
  * The full shape a sense module (`src/index.ts`) must export.
@@ -69,28 +69,19 @@ export function senseTriggerLabels(
   return [labelSenseTrigger({ interval: sc.interval, on: sc.on })];
 }
 
-/**
- * Validates a structured workflow trigger object from Sense compute or IPC.
- */
-export function parseWorkflowTrigger(value: unknown): Result<WorkflowTrigger> {
+/** Validates `{ command: string }` from Sense compute or IPC (`trigger` field). */
+export function parseSenseTrigger(value: unknown): Result<SenseTrigger> {
   if (!isPlainRecord(value)) {
-    return err(new Error("workflow trigger must be a plain object"));
+    return err(new Error("sense trigger must be a plain object"));
   }
-  const nameRaw = value.name;
-  if (typeof nameRaw !== "string" || nameRaw.trim().length === 0) {
-    return err(new Error('workflow trigger: "name" must be a non-empty string'));
+  for (const key of Object.keys(value)) {
+    if (key !== "command") {
+      return err(new Error(`sense trigger: unexpected property "${key}"`));
+    }
   }
-  const maxRounds = value.maxRounds;
-  if (typeof maxRounds !== "number" || !Number.isInteger(maxRounds) || maxRounds < 1) {
-    return err(new Error('workflow trigger: "maxRounds" must be an integer >= 1'));
+  const command = value.command;
+  if (typeof command !== "string" || command.trim().length === 0) {
+    return err(new Error('sense trigger: "command" must be a non-empty string'));
   }
-  const prompt = value.prompt;
-  if (typeof prompt !== "string") {
-    return err(new Error('workflow trigger: "prompt" must be a string'));
-  }
-  const dryRun = value.dryRun;
-  if (typeof dryRun !== "boolean") {
-    return err(new Error('workflow trigger: "dryRun" must be a boolean'));
-  }
-  return ok({ name: nameRaw.trim(), maxRounds, prompt, dryRun });
+  return ok({ command: command.trim() });
 }

packages/daemon/package.json

@@ -22,10 +22,11 @@
   "scripts": {
     "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
     "build": "rslib build",
-    "pretest": "pnpm --filter @uncaged/nerve-core run build",
+    "pretest": "pnpm --filter @uncaged/workflow run build:public-types && pnpm --filter @uncaged/nerve-core run build && pnpm --filter @uncaged/nerve-store run build && pnpm --filter @uncaged/workflow run build",
     "test": "vitest run"
   },
   "dependencies": {
+    "@uncaged/workflow": "workspace:*",
     "@uncaged/nerve-core": "workspace:*",
     "@uncaged/nerve-store": "workspace:*",
     "yaml": "^2.8.3"

packages/daemon/rslib.config.ts

@@ -11,7 +11,6 @@ export default defineConfig({
     entry: {
       index: "src/index.ts",
       "sense-worker": "src/sense-worker.ts",
-      "workflow-worker": "src/workflow-worker.ts",
       "experimental-warning-suppression": "src/experimental-warning-suppression.ts",
     },
   },

packages/daemon/src/__tests__/crash-recovery.test.ts

@@ -10,7 +10,8 @@
 
 import { EventEmitter } from "node:events";
 
-import type { NerveConfig, WorkflowConfig } from "@uncaged/nerve-core";
+import type { NerveConfig } from "@uncaged/nerve-core";
+import type { WorkflowConfig } from "@uncaged/workflow";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 type MockChild = EventEmitter & {
@@ -62,7 +63,7 @@ vi.mock("node:child_process", () => ({
   }),
 }));
 
-const { createWorkflowManager } = await import("../workflow-manager.js");
+const { createWorkflowManager } = await import("@uncaged/workflow");
 
 function makeConfig(workflows: Record<string, WorkflowConfig> = {}): NerveConfig {
   return {

packages/daemon/src/__tests__/file-watcher.test.ts

@@ -79,7 +79,7 @@ describe("createFileWatcher", () => {
     await new Promise((r) => setTimeout(r, 100));
     writeFileSync(
       join(root, "senses", "cpu-usage", "index.js"),
-      "export const initialState = {}; export async function compute(state) { return { state, workflow: null }; }",
+      "export const initialState = {}; export async function compute(state) { return { state, trigger: null }; }",
     );
 
     await waitFor(() => changes.length > 0, 3000);

packages/daemon/src/__tests__/fixtures/crash-once-worker.mjs

@@ -35,7 +35,7 @@ process.on("message", (msg) => {
       type: "compute-result",
       sense: msg.sense,
       state: 42,
-      workflow: null,
+      trigger: null,
     });
   }
 });

packages/daemon/src/__tests__/fixtures/mock-worker.mjs

@@ -9,7 +9,7 @@
  *
  * Behaviour:
  *   - Sends { type: "ready" } on startup
- *   - On { type: "compute", sense } → sends back compute-result with state + workflow:null
+ *   - On { type: "compute", sense } → sends back compute-result with state + trigger:null
  *   - On { type: "shutdown" } → exits cleanly with code 0
  */
 
@@ -27,7 +27,7 @@ process.on("message", (msg) => {
       type: "compute-result",
       sense: msg.sense,
       state: 42,
-      workflow: null,
+      trigger: null,
     });
   }
 });

packages/daemon/src/__tests__/fixtures/slow-worker.mjs

@@ -22,7 +22,7 @@ process.on("message", (msg) => {
         type: "compute-result",
         sense: msg.sense,
         state: "late",
-        workflow: null,
+        trigger: null,
       });
     }, 10_000);
   }

packages/daemon/src/__tests__/hot-reload.test.ts

@@ -15,7 +15,8 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import type { NerveConfig, WorkflowConfig } from "@uncaged/nerve-core";
+import type { NerveConfig } from "@uncaged/nerve-core";
+import type { WorkflowConfig } from "@uncaged/workflow";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 type MockChild = EventEmitter & {
@@ -67,7 +68,7 @@ vi.mock("node:child_process", () => ({
   }),
 }));
 
-const { createWorkflowManager } = await import("../workflow-manager.js");
+const { createWorkflowManager } = await import("@uncaged/workflow");
 const { createKernel } = await import("../kernel.js");
 
 function makeWfConfig(workflows: Record<string, WorkflowConfig> = {}): NerveConfig {

packages/daemon/src/__tests__/kernel-workflow-integration.test.ts

@@ -1,8 +1,9 @@
 /**
  * Integration tests for Kernel + WorkflowManager integration.
  *
- * Verifies that sense compute-result IPC triggers workflow runs when `workflow`
- * is non-null; that workflow events are logged; that reloadConfig handles workflow changes;
+ * Verifies that workflow runs are started via `workflowManager.startWorkflow` (CLI / IPC path);
+ * that sense compute-result with a shell trigger does not start workflows;
+ * that workflow events are logged; that reloadConfig handles workflow changes;
  * and that graceful shutdown stops workflow workers.
  *
  * Uses mocked child_process.fork to avoid real subprocesses.
@@ -57,7 +58,7 @@ function makeMockChild(pid = 1): MockChild {
           type: "compute-result",
           sense: m.sense,
           state: 42,
-          workflow: null,
+          trigger: null,
         });
       });
     }
@@ -153,20 +154,10 @@ describe("kernel + workflowManager integration", () => {
     rmSync(nerveRoot, { recursive: true, force: true });
   });
 
-  describe("sense compute triggers workflow via return value", () => {
-    it("calls workflowManager.startWorkflow when a sense compute returns a workflow launch", async () => {
+  describe("workflowManager.startWorkflow", () => {
+    it("spawns a workflow worker and sends start-thread", async () => {
       const logStore = makeLogStore();
       const config = makeConfig({
-        senses: {
-          "cpu-usage": {
-            group: "system",
-            throttle: null,
-            timeout: null,
-            gracePeriod: null,
-            interval: null,
-            on: [],
-          },
-        },
         workflows: { "my-workflow": { concurrency: 2, overflow: "drop" } },
       });
 
@@ -177,24 +168,14 @@ describe("kernel + workflowManager integration", () => {
       await flushSenseWorkerForkMicrotasks(kernel);
       await vi.runAllTimersAsync();
 
-      const workerPool = mockChildren[0];
-      if (workerPool) {
-        workerPool.emit("message", {
-          type: "compute-result",
-          sense: "cpu-usage",
-          state: { reason: "test" },
-          workflow: {
-            name: "my-workflow",
-            maxRounds: 10,
-            prompt: "run this workflow",
-            dryRun: false,
-          },
-        });
-      }
+      kernel.workflowManager.startWorkflow("my-workflow", {
+        prompt: "run this workflow",
+        maxRounds: 10,
+        dryRun: false,
+      });
 
       await vi.runAllTimersAsync();
 
-      // A workflow worker should be spawned and a start-thread message sent
       const workflowWorker = mockChildren.find((c) =>
         (c.send as ReturnType<typeof vi.fn>).mock.calls.some(
           (args: unknown[]) =>
@@ -210,19 +191,9 @@ describe("kernel + workflowManager integration", () => {
       await stopPromise;
     });
 
-    it("passes prompt and maxRounds from the workflow field to the workflow", async () => {
+    it("passes prompt and maxRounds on start-thread", async () => {
       const logStore = makeLogStore();
       const config = makeConfig({
-        senses: {
-          "cpu-usage": {
-            group: "system",
-            throttle: null,
-            timeout: null,
-            gracePeriod: null,
-            interval: null,
-            on: [],
-          },
-        },
         workflows: { "alert-workflow": { concurrency: 1, overflow: "drop" } },
       });
 
@@ -233,24 +204,14 @@ describe("kernel + workflowManager integration", () => {
       await flushSenseWorkerForkMicrotasks(kernel);
       await vi.runAllTimersAsync();
 
-      const workerPool = mockChildren[0];
-      if (workerPool) {
-        workerPool.emit("message", {
-          type: "compute-result",
-          sense: "cpu-usage",
-          state: { level: "critical" },
-          workflow: {
-            name: "alert-workflow",
-            maxRounds: 5,
-            prompt: "handle critical alert",
-            dryRun: false,
-          },
-        });
-      }
+      kernel.workflowManager.startWorkflow("alert-workflow", {
+        prompt: "handle critical alert",
+        maxRounds: 5,
+        dryRun: false,
+      });
 
       await vi.runAllTimersAsync();
 
-      // Find the start-thread call and verify triggerPayload
       const startThreadCall = mockChildren
         .flatMap((c) => (c.send as ReturnType<typeof vi.fn>).mock.calls as [unknown][])
         .find(
@@ -273,8 +234,10 @@ describe("kernel + workflowManager integration", () => {
       await vi.runAllTimersAsync();
       await stopPromise;
     });
+  });
 
-    it("logs compute-complete before workflow-launch when workflow is present", async () => {
+  describe("sense compute-result triggers", () => {
+    it("logs compute-complete before shell-launch when shell trigger is present", async () => {
       const logStore = makeLogStore();
       const config = makeConfig({
         workflows: { "order-wf": { concurrency: 1, overflow: "drop" } },
@@ -293,12 +256,7 @@ describe("kernel + workflowManager integration", () => {
           type: "compute-result",
           sense: "cpu-usage",
           state: { seq: 1 },
-          workflow: {
-            name: "order-wf",
-            maxRounds: 2,
-            prompt: "p",
-            dryRun: true,
-          },
+          trigger: { command: "echo order-test" },
         });
       }
 
@@ -309,16 +267,16 @@ describe("kernel + workflowManager integration", () => {
         .filter((e) => e.source === "sense" && e.refId === "cpu-usage");
       const typeOrder = senseEntries.map((e) => e.type);
       const completeAt = typeOrder.indexOf("compute-complete");
-      const launchAt = typeOrder.indexOf("workflow-launch");
+      const shellAt = typeOrder.indexOf("shell-launch");
       expect(completeAt).toBeGreaterThanOrEqual(0);
-      expect(launchAt).toBeGreaterThan(completeAt);
+      expect(shellAt).toBeGreaterThan(completeAt);
 
       const stopPromise = kernel.stop();
       await vi.runAllTimersAsync();
       await stopPromise;
     });
 
-    it("does not trigger workflow when compute-result has workflow null", async () => {
+    it("does not trigger workflow when compute-result has trigger null", async () => {
       const logStore = makeLogStore();
       const config = makeConfig({
         senses: {
@@ -355,11 +313,10 @@ describe("kernel + workflowManager integration", () => {
           type: "compute-result",
           sense: "cpu-usage",
           state: 50,
-          workflow: null,
+          trigger: null,
         });
       }
 
-      // No workflow should have been started
       const workflowWorkerSpawned = mockChildren.some((c) =>
         (c.send as ReturnType<typeof vi.fn>).mock.calls.some(
           (args: unknown[]) =>
@@ -374,25 +331,10 @@ describe("kernel + workflowManager integration", () => {
       await vi.runAllTimersAsync();
       await stopPromise;
     });
-  });
 
-  describe("workflow events are logged", () => {
-    it("logs a 'started' event when workflow thread is triggered via sense compute", async () => {
+    it("logs shell-launch and does not start a workflow for shell triggers", async () => {
       const logStore = makeLogStore();
-      const config = makeConfig({
-        senses: {
-          "cpu-usage": {
-            group: "system",
-            throttle: null,
-            timeout: null,
-            gracePeriod: null,
-            interval: null,
-            on: [],
-          },
-        },
-        workflows: { "log-test-workflow": { concurrency: 2, overflow: "drop" } },
-      });
-
+      const config = makeConfig({ workflows: {} });
       const kernel = createKernel(config, nerveRoot, {
         workerScript: "fake-worker.js",
         logStore,
@@ -405,18 +347,58 @@ describe("kernel + workflowManager integration", () => {
         workerPool.emit("message", {
           type: "compute-result",
           sense: "cpu-usage",
-          state: { note: "log" },
-          workflow: {
-            name: "log-test-workflow",
-            maxRounds: 10,
-            prompt: "test prompt",
-            dryRun: false,
+          state: {},
+          trigger: {
+            command: "echo nerve-shell-test",
           },
         });
       }
 
       await vi.runAllTimersAsync();
 
+      const shellLaunch = logStore.append.mock.calls
+        .map((c) => c[0] as { source: string; type: string })
+        .find((e) => e.type === "shell-launch");
+      expect(shellLaunch).toBeDefined();
+
+      const startThread = mockChildren
+        .flatMap((c) => (c.send as ReturnType<typeof vi.fn>).mock.calls as [unknown][])
+        .some(
+          ([msg]) =>
+            msg !== null &&
+            typeof msg === "object" &&
+            (msg as Record<string, unknown>).type === "start-thread",
+        );
+      expect(startThread).toBe(false);
+
+      const stopPromise = kernel.stop();
+      await vi.runAllTimersAsync();
+      await stopPromise;
+    });
+  });
+
+  describe("workflow events are logged", () => {
+    it("logs a 'started' event when workflow thread is started via workflowManager", async () => {
+      const logStore = makeLogStore();
+      const config = makeConfig({
+        workflows: { "log-test-workflow": { concurrency: 2, overflow: "drop" } },
+      });
+
+      const kernel = createKernel(config, nerveRoot, {
+        workerScript: "fake-worker.js",
+        logStore,
+      });
+      await flushSenseWorkerForkMicrotasks(kernel);
+      await vi.runAllTimersAsync();
+
+      kernel.workflowManager.startWorkflow("log-test-workflow", {
+        prompt: "test prompt",
+        maxRounds: 10,
+        dryRun: false,
+      });
+
+      await vi.runAllTimersAsync();
+
       expect(logStore.upsertWorkflowRun).toHaveBeenCalledWith(
         expect.objectContaining({ source: "workflow", type: "started" }),
         expect.objectContaining({ workflow: "log-test-workflow", status: "started" }),
@@ -432,16 +414,6 @@ describe("kernel + workflowManager integration", () => {
     it("new workflows are available after reloadConfig", async () => {
       const logStore = makeLogStore();
       const initialConfig = makeConfig({
-        senses: {
-          "cpu-usage": {
-            group: "system",
-            throttle: null,
-            timeout: null,
-            gracePeriod: null,
-            interval: null,
-            on: [],
-          },
-        },
         workflows: {},
         maxRounds: 10,
       });
@@ -453,7 +425,6 @@ describe("kernel + workflowManager integration", () => {
       await flushSenseWorkerForkMicrotasks(kernel);
       await vi.runAllTimersAsync();
 
-      // Reload with a workflow added
       const newConfig: NerveConfig = {
         senses: {
           "cpu-usage": {
@@ -472,20 +443,11 @@ describe("kernel + workflowManager integration", () => {
       };
       kernel.reloadConfig(newConfig);
 
-      const workerPool = mockChildren[0];
-      if (workerPool) {
-        workerPool.emit("message", {
-          type: "compute-result",
-          sense: "cpu-usage",
-          state: { phase: "reload" },
-          workflow: {
-            name: "new-workflow",
-            maxRounds: 10,
-            prompt: "reload test",
-            dryRun: false,
-          },
-        });
-      }
+      kernel.workflowManager.startWorkflow("new-workflow", {
+        prompt: "reload test",
+        maxRounds: 10,
+        dryRun: false,
+      });
 
       await vi.runAllTimersAsync();
 
@@ -509,16 +471,6 @@ describe("kernel + workflowManager integration", () => {
     it("old workflows are removed after reloadConfig", async () => {
       const logStore = makeLogStore();
       const initialConfig = makeConfig({
-        senses: {
-          "cpu-usage": {
-            group: "system",
-            throttle: null,
-            timeout: null,
-            gracePeriod: null,
-            interval: null,
-            on: [],
-          },
-        },
         workflows: { "old-workflow": { concurrency: 1, overflow: "drop" } },
       });
 
@@ -529,7 +481,6 @@ describe("kernel + workflowManager integration", () => {
       await flushSenseWorkerForkMicrotasks(kernel);
       await vi.runAllTimersAsync();
 
-      // Reload with the workflow removed
       const newConfig: NerveConfig = {
         senses: {
           "cpu-usage": {
@@ -548,25 +499,15 @@ describe("kernel + workflowManager integration", () => {
       };
       kernel.reloadConfig(newConfig);
 
-      // Clear send history
       for (const c of mockChildren) {
         (c.send as ReturnType<typeof vi.fn>).mockClear();
       }
 
-      const workerPool = mockChildren[0];
-      if (workerPool) {
-        workerPool.emit("message", {
-          type: "compute-result",
-          sense: "cpu-usage",
-          state: { stale: true },
-          workflow: {
-            name: "old-workflow",
-            maxRounds: 10,
-            prompt: "should not work",
-            dryRun: false,
-          },
-        });
-      }
+      kernel.workflowManager.startWorkflow("old-workflow", {
+        prompt: "should not work",
+        maxRounds: 10,
+        dryRun: false,
+      });
 
       await vi.runAllTimersAsync();
 
@@ -591,16 +532,6 @@ describe("kernel + workflowManager integration", () => {
     it("stop() resolves after workflow workers exit", async () => {
       const logStore = makeLogStore();
       const config = makeConfig({
-        senses: {
-          "cpu-usage": {
-            group: "system",
-            throttle: null,
-            timeout: null,
-            gracePeriod: null,
-            interval: null,
-            on: [],
-          },
-        },
         workflows: { "shutdown-test": { concurrency: 1, overflow: "drop" } },
       });
 
@@ -611,20 +542,11 @@ describe("kernel + workflowManager integration", () => {
       await flushSenseWorkerForkMicrotasks(kernel);
       await vi.runAllTimersAsync();
 
-      const workerPool = mockChildren[0];
-      if (workerPool) {
-        workerPool.emit("message", {
-          type: "compute-result",
-          sense: "cpu-usage",
-          state: { shutdownCase: true },
-          workflow: {
-            name: "shutdown-test",
-            maxRounds: 10,
-            prompt: "test",
-            dryRun: false,
-          },
-        });
-      }
+      kernel.workflowManager.startWorkflow("shutdown-test", {
+        prompt: "test",
+        maxRounds: 10,
+        dryRun: false,
+      });
 
       await vi.runAllTimersAsync();
 
@@ -655,16 +577,6 @@ describe("kernel + workflowManager integration", () => {
     it("getHealth includes activeWorkflows count", async () => {
       const logStore = makeLogStore();
       const config = makeConfig({
-        senses: {
-          "cpu-usage": {
-            group: "system",
-            throttle: null,
-            timeout: null,
-            gracePeriod: null,
-            interval: null,
-            on: [],
-          },
-        },
         workflows: { "health-wf": { concurrency: 2, overflow: "drop" } },
       });
 

packages/daemon/src/__tests__/kernel.test.ts

@@ -41,7 +41,7 @@ function makeMockChild(pid = 1): MockChild {
           type: "compute-result",
           sense: m.sense,
           state: 42,
-          workflow: null,
+          trigger: null,
         });
       });
     }
@@ -140,7 +140,7 @@ describe("kernel — message routing", () => {
         type: "compute-result",
         sense: "cpu-usage",
         state: 42,
-        workflow: null,
+        trigger: null,
       });
     }).not.toThrow();
 
@@ -171,7 +171,7 @@ describe("kernel — message routing", () => {
         type: "compute-result",
         sense: "cpu-usage",
         state: 123,
-        workflow: null,
+        trigger: null,
       });
       const rows = logStore.query({
         source: "sense",

packages/daemon/src/__tests__/sense-runtime.test.ts

@@ -63,7 +63,7 @@ describe("executeCompute", () => {
   it("passes state into compute and persists returned state", async () => {
     const path = makeTempStatePath();
     const runtime = makeRuntime(
-      async (s) => ({ state: { n: s.n + 1 }, workflow: null }),
+      async (s) => ({ state: { n: s.n + 1 }, trigger: null }),
       { n: 0 },
       path,
     );
@@ -71,7 +71,7 @@ describe("executeCompute", () => {
     const result = await executeCompute(runtime);
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value).toEqual({ state: { n: 1 }, workflow: null });
+    expect(result.value).toEqual({ state: { n: 1 }, trigger: null });
     expect(runtime.state).toEqual({ n: 1 });
     expect(JSON.parse(readFileSync(path, "utf8"))).toEqual({ n: 1 });
   });
@@ -93,7 +93,7 @@ describe("executeCompute", () => {
   it("returns err when compute exceeds timeoutMs", async () => {
     const runtime = makeRuntime(
       async (s) =>
-        new Promise((resolve) => setTimeout(() => resolve({ state: s, workflow: null }), 5_000)),
+        new Promise((resolve) => setTimeout(() => resolve({ state: s, trigger: null }), 5_000)),
       { n: 0 },
     );
 
@@ -104,7 +104,7 @@ describe("executeCompute", () => {
   });
 
   it("completes within timeout when compute is fast", async () => {
-    const runtime = makeRuntime(async (s) => ({ state: { n: s.n }, workflow: null }), { n: 42 });
+    const runtime = makeRuntime(async (s) => ({ state: { n: s.n }, trigger: null }), { n: 42 });
     const result = await executeCompute(runtime, 5_000);
     expect(result.ok).toBe(true);
     if (!result.ok) return;

packages/daemon/src/__tests__/worker-pool.test.ts

@@ -84,13 +84,13 @@ describe("createSenseWorkerPool", () => {
       type: "compute-result",
       sense: "s",
       state: 1,
-      workflow: null,
+      trigger: null,
     });
     expect(onWorkerMessage).toHaveBeenCalledWith({
       type: "compute-result",
       sense: "s",
       state: 1,
-      workflow: null,
+      trigger: null,
     });
   });
 

packages/daemon/src/__tests__/worker-runtime.test.ts

@@ -1,7 +1,7 @@
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createWorkerRuntime } from "@uncaged/workflow";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { createWorkerRuntime } from "../worker-runtime.js";
 
 const fixturesDir = join(dirname(fileURLToPath(import.meta.url)), "fixtures");
 const echoWorkerPath = join(fixturesDir, "echo-worker.js");

packages/daemon/src/__tests__/workflow-manager.test.ts

@@ -61,7 +61,7 @@ vi.mock("node:child_process", () => ({
 }));
 
 // Import after mock is set up
-const { createWorkflowManager } = await import("../workflow-manager.js");
+const { createWorkflowManager } = await import("@uncaged/workflow");
 
 // ---------------------------------------------------------------------------
 // Helpers

packages/daemon/src/daemon-handlers.ts

@@ -1,6 +1,6 @@
 import type { HealthInfo, SenseInfo, WorkflowStatus } from "@uncaged/nerve-core";
 
-import type { WorkflowManager } from "./workflow-manager.js";
+import type { WorkflowManager } from "@uncaged/workflow";
 
 export type DaemonHandlerBundle = {
   health: () => HealthInfo;

packages/daemon/src/index.ts

@@ -12,7 +12,7 @@ export type {
   ResumeThreadMessage,
   ThreadEventMessage,
   WorkflowErrorMessage,
-  ThreadWorkflowMessageMessage,
+  ThreadWorkflowMessage,
 } from "./ipc.js";
 
 export { loadSenseModule, executeCompute, readState, writeState } from "./sense-runtime.js";
@@ -45,5 +45,5 @@ export type {
   WorkflowRunStatus,
 } from "@uncaged/nerve-store";
 
-export { createWorkflowManager } from "./workflow-manager.js";
-export type { WorkflowManager } from "./workflow-manager.js";
+export { createWorkflowManager } from "@uncaged/workflow";
+export type { WorkflowManager } from "@uncaged/workflow";

packages/daemon/src/ipc.ts

@@ -1,10 +1,30 @@
 /**
  * IPC message types for parent (kernel) ↔ sense worker communication.
  * Protocol per RFC §5.2: hub-and-spoke, all messages through engine.
+ *
+ * Workflow worker IPC types and parsers live in `@uncaged/workflow`.
  */
 
-import type { Result, WorkflowTrigger } from "@uncaged/nerve-core";
-import { err, isPlainRecord, ok, parseWorkflowTrigger } from "@uncaged/nerve-core";
+import type { Result, SenseTrigger } from "@uncaged/nerve-core";
+import { err, isPlainRecord, ok, parseSenseTrigger } from "@uncaged/nerve-core";
+import type {
+  KillThreadMessage,
+  ResumeThreadMessage,
+  StartThreadMessage,
+  ThreadEventMessage,
+  ThreadWorkflowMessage,
+  WorkflowErrorMessage,
+} from "@uncaged/workflow";
+import { parseWorkflowParentMessage, parseWorkflowWorkerToParentMessage } from "@uncaged/workflow";
+
+export type {
+  KillThreadMessage,
+  ResumeThreadMessage,
+  StartThreadMessage,
+  ThreadEventMessage,
+  ThreadWorkflowMessage,
+  WorkflowErrorMessage,
+} from "@uncaged/workflow";
 
 /** Parent → Worker: trigger one compute cycle for a sense */
 export type ComputeMessage = {
@@ -22,40 +42,6 @@ export type HealthRequestMessage = {
   type: "health-request";
 };
 
-// ---------------------------------------------------------------------------
-// Workflow IPC messages (RFC-002 §5.2)
-// ---------------------------------------------------------------------------
-
-/** Parent → Workflow Worker: start a new thread */
-export type StartThreadMessage = {
-  type: "start-thread";
-  runId: string;
-  workflow: string;
-  prompt: string;
-  /** Safety-valve: max moderator rounds for this thread (engine launch parameter). */
-  maxRounds: number;
-  /** When true, roles may skip side effects (thread-level hint on the start frame). */
-  dryRun: boolean;
-};
-
-/** Parent → Workflow Worker: resume an existing thread after crash recovery */
-export type ResumeThreadMessage = {
-  type: "resume-thread";
-  runId: string;
-  /** Serialised WorkflowMessage history to rebuild chain (must begin with `__start__`). */
-  messages: Array<{ role: string; content: string; meta: unknown; timestamp: number }>;
-  /** Safety-valve: max moderator rounds for this thread. */
-  maxRounds: number;
-  /** Thread-level dry-run hint (aligns with persisted `__start__` meta when replaying). */
-  dryRun: boolean;
-};
-
-/** Parent → Workflow Worker: kill a specific running thread */
-export type KillThreadMessage = {
-  type: "kill-thread";
-  runId: string;
-};
-
 /** Union of all messages the parent sends to a worker */
 export type ParentToWorkerMessage =
   | ComputeMessage
@@ -65,19 +51,12 @@ export type ParentToWorkerMessage =
   | ResumeThreadMessage
   | KillThreadMessage;
 
-/** Worker → Parent: sense compute finished (state persisted in worker; workflow optional). */
+/** Worker → Parent: sense compute finished (state persisted in worker; optional shell trigger). */
 export type ComputeResultMessage = {
   type: "compute-result";
   sense: string;
   state: unknown;
-  workflow: WorkflowTrigger | null;
-};
-
-/** Worker → Parent: sense compute result includes a workflow to start */
-export type SenseWorkflowTriggerMessage = {
-  type: "sense-workflow-trigger";
-  sense: string;
-  workflow: WorkflowTrigger;
+  trigger: SenseTrigger | null;
 };
 
 /** Worker → Parent: compute threw or returned an unexpected error */
@@ -99,46 +78,6 @@ export type HealthResponseMessage = {
   inFlightCount: number;
 };
 
-// ---------------------------------------------------------------------------
-// Workflow Worker → Parent messages (RFC-002 §5.2)
-// ---------------------------------------------------------------------------
-
-/** Valid lifecycle event types for a workflow thread. */
-export type ThreadEventType =
-  | "queued"
-  | "started"
-  | "step_complete"
-  | "completed"
-  | "failed"
-  | "killed";
-
-/**
- * Workflow Worker → Parent: a thread lifecycle event.
- */
-export type ThreadEventMessage = {
-  type: "thread-event";
-  runId: string;
-  eventType: ThreadEventType;
-  payload: unknown;
-};
-
-/** Workflow Worker → Parent: a thread encountered an unrecoverable error. */
-export type WorkflowErrorMessage = {
-  type: "workflow-error";
-  runId: string;
-  error: string;
-  /** Exit code conveying the failure reason (1=role error, 2=maxRounds exhausted). */
-  exitCode: number;
-};
-
-/** Workflow Worker → Parent: a WorkflowMessage produced by a role (for crash recovery). */
-export type ThreadWorkflowMessageMessage = {
-  type: "thread-workflow-message";
-  runId: string;
-  /** The WorkflowMessage produced by the role — persisted for crash recovery. */
-  message: { role: string; content: string; meta: unknown; timestamp: number };
-};
-
 /** Union of all messages a worker sends to the parent */
 export type WorkerToParentMessage =
   | ComputeResultMessage
@@ -147,8 +86,7 @@ export type WorkerToParentMessage =
   | HealthResponseMessage
   | ThreadEventMessage
   | WorkflowErrorMessage
-  | ThreadWorkflowMessageMessage
-  | SenseWorkflowTriggerMessage;
+  | ThreadWorkflowMessage;
 
 const PARENT_MSG_TYPES = new Set([
   "compute",
@@ -159,24 +97,6 @@ const PARENT_MSG_TYPES = new Set([
   "kill-thread",
 ]);
 
-function validateStartThreadMsg(obj: Record<string, unknown>): string | null {
-  if (typeof obj.runId !== "string") return "'start-thread' message missing string 'runId'";
-  if (typeof obj.workflow !== "string") return "'start-thread' message missing string 'workflow'";
-  if (typeof obj.prompt !== "string") return "'start-thread' message missing string 'prompt'";
-  if (typeof obj.maxRounds !== "number") return "'start-thread' message missing number 'maxRounds'";
-  if (typeof obj.dryRun !== "boolean") return "'start-thread' message missing boolean 'dryRun'";
-  return null;
-}
-
-function validateResumeThreadMsg(obj: Record<string, unknown>): string | null {
-  if (typeof obj.runId !== "string") return "'resume-thread' message missing string 'runId'";
-  if (!Array.isArray(obj.messages)) return "'resume-thread' message missing 'messages' array";
-  if (typeof obj.maxRounds !== "number")
-    return "'resume-thread' message missing number 'maxRounds'";
-  if (typeof obj.dryRun !== "boolean") return "'resume-thread' message missing boolean 'dryRun'";
-  return null;
-}
-
 function parseParentCompute(obj: Record<string, unknown>): Result<ParentToWorkerMessage> {
   if (typeof obj.sense !== "string") {
     return err(new Error("IPC 'compute' message missing string 'sense' field"));
@@ -184,40 +104,6 @@ function parseParentCompute(obj: Record<string, unknown>): Result<ParentToWorker
   return ok({ type: "compute", sense: obj.sense });
 }
 
-function parseParentStartThread(obj: Record<string, unknown>): Result<ParentToWorkerMessage> {
-  const errMsg = validateStartThreadMsg(obj);
-  if (errMsg !== null) return err(new Error(errMsg));
-  // Field types are validated above; `Record<string, unknown>` values stay `unknown` to TypeScript.
-  return ok({
-    type: "start-thread",
-    runId: obj.runId,
-    workflow: obj.workflow,
-    prompt: obj.prompt,
-    maxRounds: obj.maxRounds,
-    dryRun: obj.dryRun,
-  } as StartThreadMessage);
-}
-
-function parseParentResumeThread(obj: Record<string, unknown>): Result<ParentToWorkerMessage> {
-  const errMsg = validateResumeThreadMsg(obj);
-  if (errMsg !== null) return err(new Error(errMsg));
-  // Elements are validated as plain objects by the kernel; trust the wire shape here.
-  return ok({
-    type: "resume-thread",
-    runId: obj.runId,
-    messages: obj.messages as ResumeThreadMessage["messages"],
-    maxRounds: obj.maxRounds,
-    dryRun: obj.dryRun,
-  } as ResumeThreadMessage);
-}
-
-function parseParentKillThread(obj: Record<string, unknown>): Result<ParentToWorkerMessage> {
-  if (typeof obj.runId !== "string") {
-    return err(new Error("'kill-thread' message missing string 'runId'"));
-  }
-  return ok({ type: "kill-thread", runId: obj.runId } as KillThreadMessage);
-}
-
 /** Validate and parse an unknown IPC message received from the parent process. */
 export function parseParentMessage(raw: unknown): Result<ParentToWorkerMessage> {
   if (!isPlainRecord(raw)) {
@@ -238,11 +124,14 @@ export function parseParentMessage(raw: unknown): Result<ParentToWorkerMessage>
     case "health-request":
       return ok({ type: "health-request" });
     case "start-thread":
-      return parseParentStartThread(obj);
     case "resume-thread":
-      return parseParentResumeThread(obj);
-    case "kill-thread":
-      return parseParentKillThread(obj);
+    case "kill-thread": {
+      const wf = parseWorkflowParentMessage(raw);
+      if (!wf.ok) {
+        return wf;
+      }
+      return ok(wf.value as ParentToWorkerMessage);
+    }
     default:
       return err(new Error(`Unhandled IPC message type: "${obj.type}"`));
   }
@@ -255,26 +144,26 @@ function parseComputeResultMsg(obj: Record<string, unknown>): Result<WorkerToPar
   if (!("state" in obj)) {
     return err(new Error("Worker 'compute-result' message missing 'state' field"));
   }
-  if (!("workflow" in obj)) {
-    return err(new Error("Worker 'compute-result' message missing 'workflow' field"));
+  if (!("trigger" in obj)) {
+    return err(new Error("Worker 'compute-result' message missing 'trigger' field"));
   }
-  const wfRaw = obj.workflow;
-  if (wfRaw !== null && !isPlainRecord(wfRaw)) {
-    return err(new Error("Worker 'compute-result' workflow must be an object or null"));
+  const triggerRaw = obj.trigger;
+  if (triggerRaw !== null && !isPlainRecord(triggerRaw)) {
+    return err(new Error("Worker 'compute-result' trigger must be an object or null"));
   }
-  let workflow: WorkflowTrigger | null;
-  if (wfRaw === null) {
-    workflow = null;
+  let trigger: SenseTrigger | null;
+  if (triggerRaw === null) {
+    trigger = null;
   } else {
-    const parsed = parseWorkflowTrigger(wfRaw);
+    const parsed = parseSenseTrigger(triggerRaw);
     if (!parsed.ok) return err(parsed.error);
-    workflow = parsed.value;
+    trigger = parsed.value;
   }
   return ok({
     type: "compute-result",
     sense: obj.sense,
     state: obj.state,
-    workflow,
+    trigger,
   });
 }
 
@@ -307,55 +196,11 @@ function parseHealthResponseMsg(obj: Record<string, unknown>): Result<WorkerToPa
   });
 }
 
-function isThreadEventType(value: string): value is ThreadEventType {
-  switch (value) {
-    case "queued":
-    case "started":
-    case "step_complete":
-    case "completed":
-    case "failed":
-    case "killed":
-      return true;
-    default:
-      return false;
-  }
-}
-
-function parseThreadEventMsg(obj: Record<string, unknown>): Result<WorkerToParentMessage> {
-  if (typeof obj.runId !== "string") {
-    return err(new Error("Worker 'thread-event' message missing string 'runId' field"));
-  }
-  if (typeof obj.eventType !== "string" || !isThreadEventType(obj.eventType)) {
-    return err(
-      new Error(`Worker 'thread-event' message has invalid 'eventType': "${obj.eventType}"`),
-    );
-  }
-  if (!("payload" in obj)) {
-    return err(new Error("Worker 'thread-event' message missing 'payload' field"));
-  }
-  return ok({
-    type: "thread-event",
-    runId: obj.runId,
-    eventType: obj.eventType,
-    payload: obj.payload,
-  });
-}
-
-function parseWorkflowErrorMsg(obj: Record<string, unknown>): Result<WorkerToParentMessage> {
-  if (typeof obj.runId !== "string") {
-    return err(new Error("Worker 'workflow-error' message missing string 'runId' field"));
-  }
-  if (typeof obj.error !== "string") {
-    return err(new Error("Worker 'workflow-error' message missing string 'error' field"));
-  }
-  const exitCode = typeof obj.exitCode === "number" ? obj.exitCode : 1;
-  return ok({
-    type: "workflow-error",
-    runId: obj.runId,
-    error: obj.error,
-    exitCode,
-  });
-}
+const WORKFLOW_WORKER_MSG_TYPES = new Set([
+  "thread-event",
+  "workflow-error",
+  "thread-workflow-message",
+]);
 
 const WORKER_MSG_TYPES = new Set([
   "compute-result",
@@ -365,74 +210,8 @@ const WORKER_MSG_TYPES = new Set([
   "thread-event",
   "workflow-error",
   "thread-workflow-message",
-  "sense-workflow-trigger",
 ]);
 
-function parseThreadWorkflowMessageMsg(
-  obj: Record<string, unknown>,
-): Result<WorkerToParentMessage> {
-  if (typeof obj.runId !== "string") {
-    return err(new Error("Worker 'thread-workflow-message' missing string 'runId' field"));
-  }
-  if (!isPlainRecord(obj.message)) {
-    return err(new Error("Worker 'thread-workflow-message' missing object 'message' field"));
-  }
-  const msg = obj.message;
-  if (typeof msg.role !== "string") {
-    return err(new Error("Worker 'thread-workflow-message' message missing string 'role' field"));
-  }
-  if (typeof msg.content !== "string") {
-    return err(
-      new Error("Worker 'thread-workflow-message' message missing string 'content' field"),
-    );
-  }
-  if (typeof msg.timestamp !== "number") {
-    return err(
-      new Error("Worker 'thread-workflow-message' message missing number 'timestamp' field"),
-    );
-  }
-  return ok({
-    type: "thread-workflow-message",
-    runId: obj.runId,
-    message: {
-      role: msg.role,
-      content: msg.content,
-      meta: "meta" in msg ? msg.meta : undefined,
-      timestamp: msg.timestamp,
-    },
-  });
-}
-
-function parseSenseWorkflowTriggerMsg(obj: Record<string, unknown>): Result<WorkerToParentMessage> {
-  if (typeof obj.sense !== "string") {
-    return err(new Error("Worker 'sense-workflow-trigger' message missing string 'sense' field"));
-  }
-  if (!isPlainRecord(obj.workflow)) {
-    return err(
-      new Error("Worker 'sense-workflow-trigger' message missing object 'workflow' field"),
-    );
-  }
-  const wf = obj.workflow;
-  if (typeof wf.name !== "string")
-    return err(new Error("Worker 'sense-workflow-trigger' workflow missing string 'name'"));
-  if (typeof wf.maxRounds !== "number")
-    return err(new Error("Worker 'sense-workflow-trigger' workflow missing number 'maxRounds'"));
-  if (typeof wf.prompt !== "string")
-    return err(new Error("Worker 'sense-workflow-trigger' workflow missing string 'prompt'"));
-  if (typeof wf.dryRun !== "boolean")
-    return err(new Error("Worker 'sense-workflow-trigger' workflow missing boolean 'dryRun'"));
-  return ok({
-    type: "sense-workflow-trigger",
-    sense: obj.sense,
-    workflow: {
-      name: wf.name,
-      maxRounds: wf.maxRounds,
-      prompt: wf.prompt,
-      dryRun: wf.dryRun,
-    },
-  });
-}
-
 /** Validate and parse an unknown IPC message received from a worker process. */
 export function parseWorkerMessage(raw: unknown): Result<WorkerToParentMessage> {
   if (!isPlainRecord(raw)) {
@@ -445,12 +224,15 @@ export function parseWorkerMessage(raw: unknown): Result<WorkerToParentMessage>
   if (!WORKER_MSG_TYPES.has(obj.type)) {
     return err(new Error(`Unknown worker IPC message type: "${obj.type}"`));
   }
+  if (WORKFLOW_WORKER_MSG_TYPES.has(obj.type)) {
+    const wf = parseWorkflowWorkerToParentMessage(raw);
+    if (!wf.ok) {
+      return wf;
+    }
+    return ok(wf.value as WorkerToParentMessage);
+  }
   if (obj.type === "compute-result") return parseComputeResultMsg(obj);
   if (obj.type === "error") return parseErrorMsg(obj);
   if (obj.type === "health-response") return parseHealthResponseMsg(obj);
-  if (obj.type === "thread-event") return parseThreadEventMsg(obj);
-  if (obj.type === "workflow-error") return parseWorkflowErrorMsg(obj);
-  if (obj.type === "thread-workflow-message") return parseThreadWorkflowMessageMsg(obj);
-  if (obj.type === "sense-workflow-trigger") return parseSenseWorkflowTriggerMsg(obj);
   return ok({ type: "ready" });
 }

packages/daemon/src/kernel-file-watch.ts

@@ -9,7 +9,7 @@ import type { NerveConfig } from "@uncaged/nerve-core";
 import { parseNerveConfig } from "@uncaged/nerve-core";
 
 import type { LogStore } from "@uncaged/nerve-store";
-import type { WorkflowManager } from "./workflow-manager.js";
+import type { WorkflowManager } from "@uncaged/workflow";
 
 export type KernelFileWatchDeps = {
   nerveRoot: string;

packages/daemon/src/kernel.ts

@@ -12,12 +12,14 @@ import {
   type HealthInfo,
   type NerveConfig,
   type SenseInfo,
-  type WorkflowTrigger,
+  type SenseTrigger,
   senseTriggerLabels,
 } from "@uncaged/nerve-core";
 
 import { createLogStore } from "@uncaged/nerve-store";
 import type { LogStore } from "@uncaged/nerve-store";
+import { createWorkflowManager } from "@uncaged/workflow";
+import type { WorkflowManager } from "@uncaged/workflow";
 import { createDaemonHandlers } from "./daemon-handlers.js";
 import { createDaemonIpcServer } from "./daemon-ipc.js";
 import type { DaemonIpcServer } from "./daemon-ipc.js";
@@ -36,8 +38,6 @@ import {
 import { createSenseScheduler } from "./sense-scheduler.js";
 import type { SenseScheduler } from "./sense-scheduler.js";
 import { createSenseWorkerPool, resolveWorkerScript } from "./worker-pool.js";
-import { createWorkflowManager } from "./workflow-manager.js";
-import type { WorkflowManager } from "./workflow-manager.js";
 
 export type KernelHealth = {
   uptime: number;
@@ -145,7 +145,7 @@ export function createKernel(
     }
   }
 
-  function handleComputeResult(senseName: string, workflow: WorkflowTrigger | null): void {
+  function handleComputeResult(senseName: string, trigger: SenseTrigger | null): void {
     logStore.append({
       source: "sense",
       type: "compute-complete",
@@ -154,17 +154,12 @@ export function createKernel(
       timestamp: Date.now(),
     });
 
-    if (workflow !== null) {
-      workflowManager.startWorkflow(workflow.name, {
-        prompt: workflow.prompt,
-        maxRounds: workflow.maxRounds,
-        dryRun: workflow.dryRun,
-      });
+    if (trigger !== null) {
       logStore.append({
         source: "sense",
-        type: "workflow-launch",
+        type: "shell-launch",
         refId: senseName,
-        payload: JSON.stringify(workflow),
+        payload: JSON.stringify(trigger),
         timestamp: Date.now(),
       });
     }
@@ -202,7 +197,7 @@ export function createKernel(
     }
 
     if (msg.type === "compute-result") {
-      handleComputeResult(msg.sense, msg.workflow);
+      handleComputeResult(msg.sense, msg.trigger);
     }
   }
 

packages/daemon/src/sense-runtime.ts

@@ -1,7 +1,7 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 
-import type { Result, SenseComputeFn, WorkflowTrigger } from "@uncaged/nerve-core";
+import type { Result, SenseComputeFn, SenseTrigger } from "@uncaged/nerve-core";
 import { err, isPlainRecord, ok } from "@uncaged/nerve-core";
 
 /** All state held for one sense inside a worker */
@@ -14,16 +14,24 @@ export type SenseRuntime = {
 
 export function readState(statePath: string, initialState: unknown): unknown {
   try {
+    if (!existsSync(statePath)) return initialState;
     const raw = readFileSync(statePath, "utf8");
     return JSON.parse(raw);
-  } catch {
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(
+      `[sense-runtime] warning: failed to read state from "${statePath}": ${msg} — using initialState\n`,
+    );
     return initialState;
   }
 }
 
 export function writeState(statePath: string, state: unknown): void {
-  mkdirSync(dirname(statePath), { recursive: true });
-  writeFileSync(statePath, JSON.stringify(state, null, 2));
+  const dir = dirname(statePath);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.${Date.now()}.tmp`);
+  writeFileSync(tmp, JSON.stringify(state, null, 2));
+  renameSync(tmp, statePath);
 }
 
 /**
@@ -66,7 +74,7 @@ export async function loadSenseModule(
 export async function executeCompute(
   runtime: SenseRuntime,
   timeoutMs?: number,
-): Promise<Result<{ state: unknown; workflow: WorkflowTrigger | null }>> {
+): Promise<Result<{ state: unknown; trigger: SenseTrigger | null }>> {
   const controller = new AbortController();
 
   let timer: ReturnType<typeof setTimeout> | undefined;
@@ -86,8 +94,8 @@ export async function executeCompute(
       ? await Promise.race([computePromise, timeoutPromise])
       : await computePromise;
 
-    runtime.state = result.state;
     writeState(runtime.statePath, result.state);
+    runtime.state = result.state;
 
     return ok(result);
   } catch (e) {

packages/daemon/src/sense-worker.ts

@@ -14,11 +14,12 @@
 
 import "./experimental-warning-suppression.js";
 
+import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 
 import { parseNerveConfig } from "@uncaged/nerve-core";
-import type { NerveConfig, WorkflowTrigger } from "@uncaged/nerve-core";
+import type { NerveConfig, SenseTrigger } from "@uncaged/nerve-core";
 
 import type { WorkerToParentMessage } from "./ipc.js";
 import { parseParentMessage } from "./ipc.js";
@@ -42,9 +43,36 @@ function sendReady(): void {
 
 function sendComputeResult(
   sense: string,
-  value: { state: unknown; workflow: WorkflowTrigger | null },
+  value: { state: unknown; trigger: SenseTrigger | null },
 ): void {
-  send({ type: "compute-result", sense, state: value.state, workflow: value.workflow });
+  send({ type: "compute-result", sense, state: value.state, trigger: value.trigger });
+}
+
+function executeShellTriggerIfNeeded(nerveRoot: string, trigger: SenseTrigger | null): void {
+  if (trigger === null) return;
+  const child = spawn(trigger.command, {
+    shell: true,
+    cwd: nerveRoot,
+    detached: true,
+    stdio: ["ignore", "ignore", "pipe"],
+  });
+  child.on("error", (err) => {
+    process.stderr.write(`[sense-worker] shell trigger failed: ${err.message}\n`);
+  });
+  if (child.stderr) {
+    let stderrBuf = "";
+    child.stderr.on("data", (chunk: Buffer) => {
+      stderrBuf += chunk.toString();
+    });
+    child.on("close", (code) => {
+      if (code !== null && code !== 0 && stderrBuf.length > 0) {
+        process.stderr.write(
+          `[sense-worker] shell trigger exited with code ${code}: ${stderrBuf.trimEnd()}\n`,
+        );
+      }
+    });
+  }
+  child.unref();
 }
 
 function sendError(sense: string, error: string): void {
@@ -132,6 +160,7 @@ async function runCompute(
   runtime: SenseRuntime,
   timeoutMs: number,
   gracePeriodMs: number | null,
+  nerveRoot: string,
 ): Promise<void> {
   try {
     const result = await executeCompute(runtime, timeoutMs);
@@ -143,6 +172,7 @@ async function runCompute(
       return;
     }
     clearGracePeriodTimer(senseName);
+    executeShellTriggerIfNeeded(nerveRoot, result.value.trigger);
     sendComputeResult(senseName, result.value);
   } catch (e: unknown) {
     const errMsg = e instanceof Error ? e.message : String(e);
@@ -160,6 +190,7 @@ function handleMessage(
   group: string,
   senseConfigs: Map<string, { timeout: number | null; gracePeriod: number | null }>,
   inFlight: Map<string, Promise<void>>,
+  nerveRoot: string,
 ): void {
   const parseResult = parseParentMessage(raw);
   if (!parseResult.ok) {
@@ -196,7 +227,7 @@ function handleMessage(
 
   const previous = inFlight.get(msg.sense) ?? Promise.resolve();
   const next = previous
-    .then(() => runCompute(msg.sense, runtime, timeoutMs, gracePeriodMs))
+    .then(() => runCompute(msg.sense, runtime, timeoutMs, gracePeriodMs, nerveRoot))
     .catch((e: unknown) => {
       const errMsg = e instanceof Error ? e.message : String(e);
       sendError(msg.sense, errMsg);
@@ -257,7 +288,7 @@ async function bootstrap(nerveRoot: string, group: string): Promise<void> {
   sendReady();
 
   process.on("message", (raw: unknown) => {
-    handleMessage(raw, runtimes, group, senseConfigs, inFlight);
+    handleMessage(raw, runtimes, group, senseConfigs, inFlight, nerveRoot);
   });
 }
 

packages/daemon/src/worker-pool.ts

@@ -5,12 +5,12 @@
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import type { ComputeMessage } from "./ipc.js";
 import {
   createWorkerRuntime,
   formatCapturedStderrTail,
   formatChildExitSummary,
-} from "./worker-runtime.js";
+} from "@uncaged/workflow";
+import type { ComputeMessage } from "./ipc.js";
 
 export function resolveWorkerScript(): string {
   const __filename = fileURLToPath(import.meta.url);

packages/role-committer/package.json

@@ -15,6 +15,7 @@
   },
   "dependencies": {
     "@uncaged/nerve-core": "workspace:*",
+    "@uncaged/workflow": "workspace:*",
     "@uncaged/nerve-workflow-utils": "workspace:*",
     "zod": "^4.3.6"
   },

packages/role-committer/src/index.ts

@@ -1,6 +1,6 @@
-import type { AgentFn, Role, ThreadContext } from "@uncaged/nerve-core";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
 import { createRole, decorateRole, onFail, withDryRun } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, Role, ThreadContext } from "@uncaged/workflow";
 import { z } from "zod";
 
 export const committerMetaSchema = z.object({

packages/role-reviewer/package.json

@@ -15,6 +15,7 @@
   },
   "dependencies": {
     "@uncaged/nerve-core": "workspace:*",
+    "@uncaged/workflow": "workspace:*",
     "@uncaged/nerve-workflow-utils": "workspace:*",
     "zod": "^4.3.6"
   },

packages/role-reviewer/src/reviewer.ts

@@ -1,6 +1,6 @@
-import type { AgentFn, Role, ThreadContext } from "@uncaged/nerve-core";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
 import { createRole } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, Role, ThreadContext } from "@uncaged/workflow";
 import { z } from "zod";
 
 export const reviewerMetaSchema = z.object({

packages/skills/nerve-dev/SKILL.md

@@ -150,46 +150,30 @@ export async function compute(
 }
 ```
 
-**Signal + Workflow 联动**：Signal 和 Workflow 是蕴含关系 — 有 signal 才可能触发 workflow，两者不互斥：
+**Shell trigger vs Workflow**：Sense `compute` 只能请求 `{ command: string }`，由 worker 执行 shell。要跑 workflow，请在命令里调用 CLI（例如 `nerve workflow trigger <name> ...`）或由外部通过 daemon IPC 触发。
 
 ```typescript
-export async function compute(db) {
+// 示例：异常时在 shell 里触发 workflow（需 PATH 中能调用 nerve）
+export async function compute(state) {
   const anomaly = detectAnomaly();
-  if (!anomaly) return null;
+  if (!anomaly) return { state, trigger: null };
 
   return {
-    signal: { level: "critical", cpu: anomaly.cpu },
-    workflow: {
-      name: "alert",
-      maxRounds: 5,
-      prompt: "CPU 持续高负载，需要分析",
-      dryRun: false,
+    state: { ...state, lastAlert: Date.now() },
+    trigger: {
+      command:
+        'nerve workflow trigger alert --prompt "CPU 持续高负载" --max-rounds 5',
     },
   };
-  // → 先发 Signal，再启动 alert workflow
 }
 ```
 
-**`WorkflowTrigger` 类型**（定义在 `@uncaged/nerve-core`）：
+**`SenseTrigger` 类型**（`@uncaged/nerve-core`）：`{ command: string }`。由 `parseSenseTrigger` 校验（仅允许 `command` 键）。
 
-```typescript
-type WorkflowTrigger = {
-  name: string;        // workflow 名称
-  maxRounds: number;   // 最大轮数（>= 1）
-  prompt: string;      // 传递给 workflow 的 prompt
-  dryRun: boolean;     // 是否 dry-run
-};
-```
-
-**compute 返回值路由规则**（由 `routeSenseComputeOutput()` 决定）：
-
-| 返回值 | 行为 |
+| `trigger` | 行为 |
 |--------|------|
-| `null` | 静默，不发 Signal |
-| `{ signal: T, workflow: null }` | 发出 **Signal**，不触发 Workflow |
-| `{ signal: T, workflow: WorkflowTrigger }` | 先发 **Signal**，再启动 **Workflow** |
-| `{ signal: T, workflow: 非法对象 }` | 降级为 signal-only（workflow 被忽略） |
-| 裸值（无 `signal` 键） | 兼容模式：整个值作为 signal payload，不触发 workflow |
+| `null` | 只持久化 state |
+| `{ command }` | 持久化 state + worker 执行 shell 命令 |
 
 ### Drizzle Schema 与迁移
 

packages/workflow-meta/package.json

@@ -15,6 +15,7 @@
   },
   "dependencies": {
     "@uncaged/nerve-core": "workspace:*",
+    "@uncaged/workflow": "workspace:*",
     "@uncaged/nerve-role-committer": "workspace:*",
     "@uncaged/nerve-role-reviewer": "workspace:*",
     "@uncaged/nerve-workflow-utils": "workspace:*",

packages/workflow-meta/src/develop-sense/build.ts

@@ -1,7 +1,7 @@
-import type { AgentFn, WorkflowDefinition } from "@uncaged/nerve-core";
 import { createCommitterRole } from "@uncaged/nerve-role-committer";
 import { createReviewerRole } from "@uncaged/nerve-role-reviewer";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, WorkflowDefinition } from "@uncaged/workflow";
 
 import { moderator } from "./moderator.js";
 import type { SenseMeta } from "./moderator.js";

packages/workflow-meta/src/develop-sense/moderator.ts

@@ -1,7 +1,7 @@
-import { END } from "@uncaged/nerve-core";
-import type { Moderator } from "@uncaged/nerve-core";
 import type { CommitterMeta } from "@uncaged/nerve-role-committer";
 import type { ReviewerMeta } from "@uncaged/nerve-role-reviewer";
+import { END } from "@uncaged/workflow";
+import type { Moderator } from "@uncaged/workflow";
 import type { CoderMeta } from "./roles/coder.js";
 import type { PlannerMeta } from "./roles/planner.js";
 import type { TesterMeta } from "./roles/tester.js";

packages/workflow-meta/src/develop-sense/roles/coder.ts

@@ -1,6 +1,6 @@
-import type { AgentFn, Role, ThreadContext } from "@uncaged/nerve-core";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
 import { createRole } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, Role, ThreadContext } from "@uncaged/workflow";
 import { z } from "zod";
 
 export const coderMetaSchema = z.object({

packages/workflow-meta/src/develop-sense/roles/planner.ts

@@ -1,6 +1,6 @@
-import type { AgentFn, Role, ThreadContext } from "@uncaged/nerve-core";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
 import { createRole } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, Role, ThreadContext } from "@uncaged/workflow";
 import { z } from "zod";
 
 export const plannerMetaSchema = z.object({

packages/workflow-meta/src/develop-sense/roles/tester.ts

@@ -1,6 +1,6 @@
-import type { AgentFn, Role, ThreadContext } from "@uncaged/nerve-core";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
 import { createRole } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, Role, ThreadContext } from "@uncaged/workflow";
 import { z } from "zod";
 
 export const testerMetaSchema = z.object({

packages/workflow-meta/src/develop-workflow/build.ts

@@ -1,7 +1,7 @@
-import type { AgentFn, WorkflowDefinition } from "@uncaged/nerve-core";
 import { createCommitterRole } from "@uncaged/nerve-role-committer";
 import { createReviewerRole } from "@uncaged/nerve-role-reviewer";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, WorkflowDefinition } from "@uncaged/workflow";
 
 import { moderator } from "./moderator.js";
 import type { WorkflowMeta } from "./moderator.js";

packages/workflow-meta/src/develop-workflow/moderator.ts

@@ -1,7 +1,7 @@
-import { END } from "@uncaged/nerve-core";
-import type { Moderator } from "@uncaged/nerve-core";
 import type { CommitterMeta } from "@uncaged/nerve-role-committer";
 import type { ReviewerMeta } from "@uncaged/nerve-role-reviewer";
+import { END } from "@uncaged/workflow";
+import type { Moderator } from "@uncaged/workflow";
 import type { CoderMeta } from "./roles/coder.js";
 import type { PlannerMeta } from "./roles/planner.js";
 import type { TesterMeta } from "./roles/tester.js";

packages/workflow-meta/src/develop-workflow/roles/coder.ts

@@ -1,6 +1,6 @@
-import type { AgentFn, Role, ThreadContext } from "@uncaged/nerve-core";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
 import { createRole } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, Role, ThreadContext } from "@uncaged/workflow";
 import { z } from "zod";
 
 export const coderMetaSchema = z.object({

packages/workflow-meta/src/develop-workflow/roles/planner.ts

@@ -1,6 +1,6 @@
-import type { AgentFn, Role, ThreadContext } from "@uncaged/nerve-core";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
 import { createRole } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, Role, ThreadContext } from "@uncaged/workflow";
 import { z } from "zod";
 
 export const plannerMetaSchema = z.object({

packages/workflow-meta/src/develop-workflow/roles/tester.ts

@@ -1,6 +1,6 @@
-import type { AgentFn, Role, ThreadContext } from "@uncaged/nerve-core";
 import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
 import { createRole } from "@uncaged/nerve-workflow-utils";
+import type { AgentFn, Role, ThreadContext } from "@uncaged/workflow";
 import { z } from "zod";
 
 export const testerMetaSchema = z.object({

packages/workflow-utils/package.json

@@ -24,6 +24,7 @@
     "@uncaged/nerve-adapter-cursor": "workspace:*",
     "@uncaged/nerve-adapter-hermes": "workspace:*",
     "@uncaged/nerve-core": "workspace:*",
+    "@uncaged/workflow": "workspace:*",
     "zod": "^4.3.6"
   },
   "devDependencies": {

packages/workflow-utils/src/__tests__/create-llm-adapter.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 
-import { START, type ThreadContext } from "@uncaged/nerve-core";
+import { START, type ThreadContext } from "@uncaged/workflow";
 
 import { createLlmAdapter } from "../create-llm-adapter.js";
 

packages/workflow-utils/src/__tests__/create-role.test.ts

@@ -4,8 +4,8 @@ import type {
   RoleMeta,
   ThreadContext,
   WorkflowDefinition,
-} from "@uncaged/nerve-core";
-import { END, START } from "@uncaged/nerve-core";
+} from "@uncaged/workflow";
+import { END, START } from "@uncaged/workflow";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { z } from "zod";
 

packages/workflow-utils/src/__tests__/role-decorators.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest";
 
-import type { Role, ThreadContext } from "@uncaged/nerve-core";
+import type { Role, ThreadContext } from "@uncaged/workflow";
 
-import { START } from "@uncaged/nerve-core";
+import { START } from "@uncaged/workflow";
 import { decorateRole, onFail, withDryRun } from "../role-decorators.js";
 
 type TestMeta = Record<string, unknown> & { ok: boolean };

packages/workflow-utils/src/__tests__/role-factories.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { z } from "zod";
 
-import { START, type ThreadContext } from "@uncaged/nerve-core";
+import { START, type ThreadContext } from "@uncaged/workflow";
 
 import { createCursorRole } from "../role-cursor.js";
 import { createHermesRole } from "../role-hermes.js";

packages/workflow-utils/src/create-llm-adapter.ts

@@ -1,4 +1,4 @@
-import type { AgentFn, ThreadContext } from "@uncaged/nerve-core";
+import type { AgentFn, ThreadContext } from "@uncaged/workflow";
 
 import { formatLlmError } from "./shared/format-error.js";
 import { chatCompletionText } from "./shared/llm-chat.js";

packages/workflow-utils/src/create-role.ts

@@ -1,4 +1,4 @@
-import type { AgentFn, Role, ThreadContext } from "@uncaged/nerve-core";
+import type { AgentFn, Role, ThreadContext } from "@uncaged/workflow";
 import type { z } from "zod";
 
 import { extractMetaOrThrow } from "./shared/extract-fn.js";

packages/workflow-utils/src/role-cursor.ts

@@ -1,5 +1,6 @@
 import { type CursorAgentMode, cursorAgent } from "@uncaged/nerve-adapter-cursor";
-import type { Role, SpawnEnv } from "@uncaged/nerve-core";
+import type { SpawnEnv } from "@uncaged/nerve-core";
+import type { Role } from "@uncaged/workflow";
 
 import type { CursorRoleDefaults, CursorRoleRequired } from "./role-types.js";
 import { formatLlmError } from "./shared/format-error.js";

packages/workflow-utils/src/role-decorators.ts

@@ -1,4 +1,4 @@
-import type { Role, ThreadContext } from "@uncaged/nerve-core";
+import type { Role, ThreadContext } from "@uncaged/workflow";
 
 // ---------------------------------------------------------------------------
 // Decorator types

packages/workflow-utils/src/role-hermes.ts

@@ -1,4 +1,4 @@
-import type { Role } from "@uncaged/nerve-core";
+import type { Role } from "@uncaged/workflow";
 
 import type { HermesRoleDefaults, HermesRoleRequired } from "./role-types.js";
 import { formatLlmError } from "./shared/format-error.js";

packages/workflow-utils/src/role-llm.ts

@@ -1,4 +1,4 @@
-import type { Role } from "@uncaged/nerve-core";
+import type { Role } from "@uncaged/workflow";
 
 import type { LlmMessage, LlmRoleDefaults, LlmRoleRequired } from "./role-types.js";
 import { formatLlmError } from "./shared/format-error.js";

packages/workflow-utils/src/role-react.ts

@@ -1,4 +1,4 @@
-import type { Role } from "@uncaged/nerve-core";
+import type { Role } from "@uncaged/workflow";
 
 import type { LlmMessage, ReActRoleDefaults, ReActRoleRequired } from "./role-types.js";
 import { formatLlmError } from "./shared/format-error.js";

packages/workflow-utils/src/role-types.ts

@@ -1,4 +1,5 @@
-import type { SpawnEnv, ThreadContext } from "@uncaged/nerve-core";
+import type { SpawnEnv } from "@uncaged/nerve-core";
+import type { ThreadContext } from "@uncaged/workflow";
 import type { z } from "zod";
 
 import type { LlmProvider } from "./shared/llm-extract.js";

packages/workflow/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@uncaged/workflow",
+  "version": "0.5.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./public-types": {
+      "types": "./dist/public-types.d.ts",
+      "default": "./dist/public-types.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
+    "build": "rslib build && pnpm run build:public-types",
+    "build:public-types": "tsc -p tsconfig.public-types.json"
+  },
+  "dependencies": {
+    "@uncaged/nerve-core": "^0.5.0",
+    "@uncaged/nerve-store": "^0.5.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.21.3",
+    "@types/node": "^22.0.0"
+  }
+}

packages/workflow/rslib.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from "@rslib/core";
+
+export default defineConfig({
+  lib: [
+    {
+      format: "esm",
+      dts: true,
+    },
+  ],
+  source: {
+    entry: {
+      index: "src/index.ts",
+      worker: "src/worker.ts",
+    },
+  },
+  output: {
+    target: "node",
+    cleanDistPath: true,
+  },
+});

packages/workflow/src/config.ts

@@ -0,0 +1,12 @@
+export type DropOverflowConfig = {
+  concurrency: number;
+  overflow: "drop";
+};
+
+export type QueueOverflowConfig = {
+  concurrency: number;
+  overflow: "queue";
+  maxQueue: number;
+};
+
+export type WorkflowConfig = DropOverflowConfig | QueueOverflowConfig;

packages/workflow/src/experimental-warning-suppression.ts

@@ -0,0 +1,23 @@
+/**
+ * Patches `process.emit` so `ExperimentalWarning` (e.g. from `node:sqlite`) is not
+ * forwarded to the default handler. Other warning types are unchanged.
+ *
+ * Import this module before any code that loads `node:sqlite`.
+ */
+
+const WARNING_EVENT = "warning";
+const EXPERIMENTAL_WARNING_NAME = "ExperimentalWarning";
+
+type EmitFn = typeof process.emit;
+
+const originalEmit = process.emit.bind(process) as EmitFn;
+
+process.emit = ((event: string | symbol, ...args: unknown[]): boolean => {
+  if (event === WARNING_EVENT) {
+    const w = args[0];
+    if (w instanceof Error && w.name === EXPERIMENTAL_WARNING_NAME) {
+      return false;
+    }
+  }
+  return Reflect.apply(originalEmit, process, [event, ...args]) as boolean;
+}) as EmitFn;

packages/workflow/src/index.ts

@@ -0,0 +1,52 @@
+// @uncaged/workflow — standalone workflow orchestration engine
+
+export { START, END, DEFAULT_ENGINE_MAX_ROUNDS } from "./types.js";
+export type {
+  WorkflowMessage,
+  RoleResult,
+  Role,
+  RoleMeta,
+  StartStep,
+  ThreadContext,
+  WorkflowContext,
+  AgentFn,
+  RoleStep,
+  ModeratorContext,
+  Moderator,
+  WorkflowDefinition,
+} from "./types.js";
+
+export type { DropOverflowConfig, QueueOverflowConfig, WorkflowConfig } from "./config.js";
+
+export type {
+  KillThreadMessage,
+  ResumeThreadMessage,
+  StartThreadMessage,
+  WorkflowParentToWorkerMessage,
+  WorkflowWorkerShutdownMessage,
+  ThreadEventType,
+  ThreadLifecycleEvent,
+  ThreadEventMessage,
+  WorkflowErrorMessage,
+  ThreadWorkflowMessage,
+  WorkflowWorkerToParentMessage,
+  WorkflowWorkerReadyMessage,
+  WorkflowChildToParentMessage,
+} from "./ipc.js";
+export {
+  parseWorkflowParentMessage,
+  parseWorkflowWorkerToParentMessage,
+  parseWorkflowChildMessage,
+} from "./ipc.js";
+
+export { WORKFLOW_WORKER_PATH } from "./paths.js";
+
+export {
+  createWorkerRuntime,
+  formatCapturedStderrTail,
+  formatChildExitSummary,
+} from "./worker-runtime.js";
+export type { WorkerDrainOpts, WorkerRuntime, WorkerRuntimeConfig } from "./worker-runtime.js";
+
+export { createWorkflowManager } from "./manager.js";
+export type { WorkflowLaunchParams, WorkflowManager } from "./manager.js";

packages/workflow/src/ipc.ts

@@ -0,0 +1,309 @@
+/**
+ * IPC message types for parent (kernel) ↔ workflow worker communication.
+ * Protocol per RFC-002 §5.2.
+ */
+
+import type { Result } from "@uncaged/nerve-core";
+import { err, isPlainRecord, ok } from "@uncaged/nerve-core";
+
+/** Parent → Workflow Worker: start a new thread */
+export type StartThreadMessage = {
+  type: "start-thread";
+  runId: string;
+  workflow: string;
+  prompt: string;
+  /** Safety-valve: max moderator rounds for this thread (engine launch parameter). */
+  maxRounds: number;
+  /** When true, roles may skip side effects (thread-level hint on the start frame). */
+  dryRun: boolean;
+};
+
+/** Parent → Workflow Worker: resume an existing thread after crash recovery */
+export type ResumeThreadMessage = {
+  type: "resume-thread";
+  runId: string;
+  /** Serialised WorkflowMessage history to rebuild chain (must begin with `__start__`). */
+  messages: Array<{ role: string; content: string; meta: unknown; timestamp: number }>;
+  /** Safety-valve: max moderator rounds for this thread. */
+  maxRounds: number;
+  /** Thread-level dry-run hint (aligns with persisted `__start__` meta when replaying). */
+  dryRun: boolean;
+};
+
+/** Parent → Workflow Worker: kill a specific running thread */
+export type KillThreadMessage = {
+  type: "kill-thread";
+  runId: string;
+};
+
+/** Parent → Workflow Worker: graceful shutdown (same wire shape as sense worker). */
+export type WorkflowWorkerShutdownMessage = {
+  type: "shutdown";
+};
+
+/** Messages the parent sends to a workflow worker process */
+export type WorkflowParentToWorkerMessage =
+  | StartThreadMessage
+  | ResumeThreadMessage
+  | KillThreadMessage
+  | WorkflowWorkerShutdownMessage;
+
+/** Valid lifecycle event types for a workflow thread. */
+export type ThreadEventType =
+  | "queued"
+  | "started"
+  | "step_complete"
+  | "completed"
+  | "failed"
+  | "killed";
+
+/** Alias — lifecycle channel uses `ThreadEventType` values. */
+export type ThreadLifecycleEvent = ThreadEventType;
+
+/**
+ * Workflow Worker → Parent: a thread lifecycle event.
+ */
+export type ThreadEventMessage = {
+  type: "thread-event";
+  runId: string;
+  eventType: ThreadEventType;
+  payload: unknown;
+};
+
+/** Workflow Worker → Parent: a thread encountered an unrecoverable error. */
+export type WorkflowErrorMessage = {
+  type: "workflow-error";
+  runId: string;
+  error: string;
+  /** Exit code conveying the failure reason (1=role error, 2=maxRounds exhausted). */
+  exitCode: number;
+};
+
+/** Workflow Worker → Parent: a WorkflowMessage produced by a role (for crash recovery). */
+export type ThreadWorkflowMessage = {
+  type: "thread-workflow-message";
+  runId: string;
+  /** The WorkflowMessage produced by the role — persisted for crash recovery. */
+  message: { role: string; content: string; meta: unknown; timestamp: number };
+};
+
+/** Messages a workflow worker sends to the parent (subset of full worker IPC). */
+export type WorkflowWorkerToParentMessage =
+  | ThreadEventMessage
+  | WorkflowErrorMessage
+  | ThreadWorkflowMessage;
+
+export type WorkflowWorkerReadyMessage = { type: "ready" };
+
+/** Messages a workflow child may emit on IPC (including bootstrap ready). */
+export type WorkflowChildToParentMessage =
+  | WorkflowWorkerReadyMessage
+  | WorkflowWorkerToParentMessage;
+
+const WORKFLOW_PARENT_MSG_TYPES = new Set([
+  "start-thread",
+  "resume-thread",
+  "kill-thread",
+  "shutdown",
+]);
+
+function validateStartThreadMsg(obj: Record<string, unknown>): string | null {
+  if (typeof obj.runId !== "string") return "'start-thread' message missing string 'runId'";
+  if (typeof obj.workflow !== "string") return "'start-thread' message missing string 'workflow'";
+  if (typeof obj.prompt !== "string") return "'start-thread' message missing string 'prompt'";
+  if (typeof obj.maxRounds !== "number") return "'start-thread' message missing number 'maxRounds'";
+  if (typeof obj.dryRun !== "boolean") return "'start-thread' message missing boolean 'dryRun'";
+  return null;
+}
+
+function validateResumeThreadMsg(obj: Record<string, unknown>): string | null {
+  if (typeof obj.runId !== "string") return "'resume-thread' message missing string 'runId'";
+  if (!Array.isArray(obj.messages)) return "'resume-thread' message missing 'messages' array";
+  if (typeof obj.maxRounds !== "number")
+    return "'resume-thread' message missing number 'maxRounds'";
+  if (typeof obj.dryRun !== "boolean") return "'resume-thread' message missing boolean 'dryRun'";
+  return null;
+}
+
+function parseParentStartThread(obj: Record<string, unknown>): Result<StartThreadMessage> {
+  const errMsg = validateStartThreadMsg(obj);
+  if (errMsg !== null) return err(new Error(errMsg));
+  return ok({
+    type: "start-thread",
+    runId: obj.runId as string,
+    workflow: obj.workflow as string,
+    prompt: obj.prompt as string,
+    maxRounds: obj.maxRounds as number,
+    dryRun: obj.dryRun as boolean,
+  });
+}
+
+function parseParentResumeThread(obj: Record<string, unknown>): Result<ResumeThreadMessage> {
+  const errMsg = validateResumeThreadMsg(obj);
+  if (errMsg !== null) return err(new Error(errMsg));
+  return ok({
+    type: "resume-thread",
+    runId: obj.runId as string,
+    messages: obj.messages as ResumeThreadMessage["messages"],
+    maxRounds: obj.maxRounds as number,
+    dryRun: obj.dryRun as boolean,
+  });
+}
+
+function parseParentKillThread(obj: Record<string, unknown>): Result<KillThreadMessage> {
+  if (typeof obj.runId !== "string") {
+    return err(new Error("'kill-thread' message missing string 'runId'"));
+  }
+  return ok({ type: "kill-thread", runId: obj.runId as string });
+}
+
+/** Validate and parse an unknown IPC message for a workflow worker process. */
+export function parseWorkflowParentMessage(raw: unknown): Result<WorkflowParentToWorkerMessage> {
+  if (!isPlainRecord(raw)) {
+    return err(new Error("IPC message is not an object"));
+  }
+  const obj = raw;
+  if (typeof obj.type !== "string") {
+    return err(new Error("IPC message missing string 'type' field"));
+  }
+  if (!WORKFLOW_PARENT_MSG_TYPES.has(obj.type)) {
+    return err(new Error(`Unknown workflow IPC message type: "${obj.type}"`));
+  }
+  switch (obj.type) {
+    case "shutdown":
+      return ok({ type: "shutdown" });
+    case "start-thread":
+      return parseParentStartThread(obj);
+    case "resume-thread":
+      return parseParentResumeThread(obj);
+    case "kill-thread":
+      return parseParentKillThread(obj);
+    default:
+      return err(new Error(`Unhandled workflow IPC message type: "${obj.type}"`));
+  }
+}
+
+function isThreadEventType(value: string): value is ThreadEventType {
+  switch (value) {
+    case "queued":
+    case "started":
+    case "step_complete":
+    case "completed":
+    case "failed":
+    case "killed":
+      return true;
+    default:
+      return false;
+  }
+}
+
+function parseThreadEventMsg(obj: Record<string, unknown>): Result<ThreadEventMessage> {
+  if (typeof obj.runId !== "string") {
+    return err(new Error("Worker 'thread-event' message missing string 'runId' field"));
+  }
+  if (typeof obj.eventType !== "string" || !isThreadEventType(obj.eventType)) {
+    return err(
+      new Error(`Worker 'thread-event' message has invalid 'eventType': "${obj.eventType}"`),
+    );
+  }
+  if (!("payload" in obj)) {
+    return err(new Error("Worker 'thread-event' message missing 'payload' field"));
+  }
+  return ok({
+    type: "thread-event",
+    runId: obj.runId,
+    eventType: obj.eventType,
+    payload: obj.payload,
+  });
+}
+
+function parseWorkflowErrorMsg(obj: Record<string, unknown>): Result<WorkflowErrorMessage> {
+  if (typeof obj.runId !== "string") {
+    return err(new Error("Worker 'workflow-error' message missing string 'runId' field"));
+  }
+  if (typeof obj.error !== "string") {
+    return err(new Error("Worker 'workflow-error' message missing string 'error' field"));
+  }
+  const exitCode = typeof obj.exitCode === "number" ? obj.exitCode : 1;
+  return ok({
+    type: "workflow-error",
+    runId: obj.runId,
+    error: obj.error,
+    exitCode,
+  });
+}
+
+function parseThreadWorkflowMessageMsg(
+  obj: Record<string, unknown>,
+): Result<ThreadWorkflowMessage> {
+  if (typeof obj.runId !== "string") {
+    return err(new Error("Worker 'thread-workflow-message' missing string 'runId' field"));
+  }
+  if (!isPlainRecord(obj.message)) {
+    return err(new Error("Worker 'thread-workflow-message' missing object 'message' field"));
+  }
+  const msg = obj.message;
+  if (typeof msg.role !== "string") {
+    return err(new Error("Worker 'thread-workflow-message' message missing string 'role' field"));
+  }
+  if (typeof msg.content !== "string") {
+    return err(
+      new Error("Worker 'thread-workflow-message' message missing string 'content' field"),
+    );
+  }
+  if (typeof msg.timestamp !== "number") {
+    return err(
+      new Error("Worker 'thread-workflow-message' message missing number 'timestamp' field"),
+    );
+  }
+  return ok({
+    type: "thread-workflow-message",
+    runId: obj.runId,
+    message: {
+      role: msg.role,
+      content: msg.content,
+      meta: "meta" in msg ? msg.meta : null,
+      timestamp: msg.timestamp,
+    },
+  });
+}
+
+const WORKFLOW_WORKER_MSG_TYPES = new Set([
+  "thread-event",
+  "workflow-error",
+  "thread-workflow-message",
+]);
+
+/** Validate and parse workflow worker → parent IPC messages. */
+export function parseWorkflowWorkerToParentMessage(
+  raw: unknown,
+): Result<WorkflowWorkerToParentMessage> {
+  if (!isPlainRecord(raw)) {
+    return err(new Error("Worker IPC message is not an object"));
+  }
+  const obj = raw;
+  if (typeof obj.type !== "string") {
+    return err(new Error("Worker IPC message missing string 'type' field"));
+  }
+  if (!WORKFLOW_WORKER_MSG_TYPES.has(obj.type)) {
+    return err(new Error(`Unknown workflow worker IPC message type: "${obj.type}"`));
+  }
+  if (obj.type === "thread-event") return parseThreadEventMsg(obj);
+  if (obj.type === "workflow-error") return parseWorkflowErrorMsg(obj);
+  return parseThreadWorkflowMessageMsg(obj);
+}
+
+/** Parse messages from a workflow worker child (thread IPC + optional `ready`). */
+export function parseWorkflowChildMessage(raw: unknown): Result<WorkflowChildToParentMessage> {
+  if (!isPlainRecord(raw)) {
+    return err(new Error("Worker IPC message is not an object"));
+  }
+  const obj = raw;
+  if (typeof obj.type !== "string") {
+    return err(new Error("Worker IPC message missing string 'type' field"));
+  }
+  if (obj.type === "ready") {
+    return ok({ type: "ready" });
+  }
+  return parseWorkflowWorkerToParentMessage(raw);
+}

packages/workflow/src/manager-support.ts

@@ -2,15 +2,13 @@
  * Pure helpers and IPC branching for workflow-manager (keeps workflow-manager.ts lean).
  */
 
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import type { WorkflowMessage } from "@uncaged/nerve-core";
-import { START, isPlainRecord } from "@uncaged/nerve-core";
+import { isPlainRecord } from "@uncaged/nerve-core";
 
 import type { LogStore, WorkflowRunStatus } from "@uncaged/nerve-store";
 import type { ResumeThreadMessage, ThreadEventMessage } from "./ipc.js";
-import type { WorkerToParentMessage } from "./ipc.js";
+import type { WorkflowChildToParentMessage } from "./ipc.js";
+import type { WorkflowMessage } from "./types.js";
+import { START } from "./types.js";
 
 export type PendingThread = {
   runId: string;
@@ -33,7 +31,7 @@ export const WORKFLOW_WORKER_RESPAWN = {
 } as const;
 
 /**
- * Worker shutdown timeout — must stay in sync with SHUTDOWN_TIMEOUT_MS in workflow-worker.ts.
+ * Worker shutdown timeout — must stay in sync with shutdown handling in `worker.ts`.
  * The drain timeout passed to drainAndRespawn must be >= this value so the worker has
  * enough time to finish in-flight threads before the parent force-kills it.
  */
@@ -79,12 +77,6 @@ export function ensureThreadMessagesWithStart(
   return [start, ...mapped];
 }
 
-export function resolveWorkflowWorkerScript(): string {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dir = dirname(__filename);
-  return join(__dir, "workflow-worker.js");
-}
-
 export function mapWorkflowRunStatus(eventType: string): WorkflowRunStatus | null {
   const map: Record<string, WorkflowRunStatus> = {
     started: "started",
@@ -223,9 +215,13 @@ export type WorkflowManagerMessageDeps = {
 
 export function dispatchWorkflowWorkerMessage(
   workflowName: string,
-  msg: WorkerToParentMessage,
+  msg: WorkflowChildToParentMessage,
   deps: WorkflowManagerMessageDeps,
 ): void {
+  if (msg.type === "ready") {
+    return;
+  }
+
   if (msg.type === "thread-event") {
     deps.handleThreadEvent(workflowName, msg);
     return;
@@ -247,10 +243,5 @@ export function dispatchWorkflowWorkerMessage(
       `[workflow-manager] workflow-error for runId "${msg.runId}" in "${workflowName}": ${msg.error}\n`,
     );
     deps.onWorkflowRoleError(workflowName, msg.runId, msg.error, msg.exitCode);
-    return;
-  }
-
-  if (msg.type === "error") {
-    process.stderr.write(`[workflow-manager] error from "${workflowName}" worker: ${msg.error}\n`);
   }
 }

packages/workflow/src/manager.ts

@@ -6,16 +6,13 @@
  * Concurrency and overflow (drop/queue) are enforced here in the parent process.
  */
 
-import type { NerveConfig, WorkflowConfig, WorkflowStatus } from "@uncaged/nerve-core";
+import type { NerveConfig, WorkflowStatus } from "@uncaged/nerve-core";
+
+import type { WorkflowConfig } from "./config.js";
 
 import type { LogStore } from "@uncaged/nerve-store";
 import type { KillThreadMessage, StartThreadMessage, ThreadEventMessage } from "./ipc.js";
-import { parseWorkerMessage } from "./ipc.js";
-import {
-  createWorkerRuntime,
-  formatCapturedStderrTail,
-  formatChildExitSummary,
-} from "./worker-runtime.js";
+import { parseWorkflowChildMessage } from "./ipc.js";
 import {
   DEFAULT_MAX_QUEUE,
   WORKER_SHUTDOWN_TIMEOUT_MS,
@@ -25,8 +22,13 @@ import {
   dispatchWorkflowWorkerMessage,
   extractExitCodeFromPayload,
   recoverThreadsFromStore,
-  resolveWorkflowWorkerScript,
-} from "./workflow-manager-support.js";
+} from "./manager-support.js";
+import { WORKFLOW_WORKER_PATH } from "./paths.js";
+import {
+  createWorkerRuntime,
+  formatCapturedStderrTail,
+  formatChildExitSummary,
+} from "./worker-runtime.js";
 
 export type WorkflowLaunchParams = {
   prompt: string;
@@ -35,7 +37,7 @@ export type WorkflowLaunchParams = {
 };
 
 export type WorkflowManager = {
-  /** Trigger a new workflow thread (Sense-driven launch or CLI / IPC). */
+  /** Trigger a new workflow thread (CLI / daemon IPC). */
   startWorkflow: (workflowName: string, launch: WorkflowLaunchParams) => void;
   /**
    * Kill a running or queued workflow thread by runId.
@@ -56,8 +58,9 @@ export type WorkflowManager = {
    * Drain active threads for a workflow, then respawn its worker process.
    * Used for hot reload when bundled workflow output under dist/workflows/<name>/ changes.
    * Waits up to `drainTimeoutMs` for threads to complete before force-killing.
+   * Pass `null` to use the manager default timeout.
    */
-  drainAndRespawn: (workflowName: string, drainTimeoutMs?: number) => Promise<void>;
+  drainAndRespawn: (workflowName: string, drainTimeoutMs?: number | null) => Promise<void>;
   /**
    * Schedule a drain+respawn that waits for in-flight runs to finish first.
    * If no runs are active, drains immediately. Otherwise marks a pending reload
@@ -73,7 +76,7 @@ export function createWorkflowManager(
   initialConfig: NerveConfig,
   logStore: LogStore,
 ): WorkflowManager {
-  const workerScript = resolveWorkflowWorkerScript();
+  const workerScript = WORKFLOW_WORKER_PATH;
 
   /**
    * Default drain timeout must be at least WORKER_SHUTDOWN_TIMEOUT_MS so the worker
@@ -309,7 +312,7 @@ export function createWorkflowManager(
   }
 
   function handleWorkerMessage(workflowName: string, raw: unknown): void {
-    const result = parseWorkerMessage(raw);
+    const result = parseWorkflowChildMessage(raw);
     if (!result.ok) {
       process.stderr.write(
         `[workflow-manager] invalid message from "${workflowName}" worker: ${result.error.message}\n`,
@@ -448,13 +451,16 @@ export function createWorkflowManager(
 
   async function drainAndRespawn(
     workflowName: string,
-    drainTimeoutMs: number = DEFAULT_DRAIN_TIMEOUT_MS,
+    drainTimeoutMs: number | null = null,
   ): Promise<void> {
     if (!trackedWorkflows.has(workflowName)) {
       return;
     }
 
-    const shutdownMs = Math.max(drainTimeoutMs, WORKER_SHUTDOWN_TIMEOUT_MS);
+    const shutdownMs = Math.max(
+      drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS,
+      WORKER_SHUTDOWN_TIMEOUT_MS,
+    );
     hotReloadEvicting.add(workflowName);
     try {
       await runtime.evict(workflowName, { shutdownTimeoutMs: shutdownMs });

packages/workflow/src/paths.ts

@@ -0,0 +1,5 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** Resolved path to the workflow child-process entry (`worker.js` adjacent to this module in dist). */
+export const WORKFLOW_WORKER_PATH = join(dirname(fileURLToPath(import.meta.url)), "worker.js");

packages/workflow/src/public-types.ts

@@ -0,0 +1,22 @@
+/**
+ * Narrow surface for `@uncaged/nerve-core` — workflow automaton types + config only.
+ * Keeps core's declaration graph free of IPC / manager / store.
+ */
+
+export { START, END, DEFAULT_ENGINE_MAX_ROUNDS } from "./types.js";
+export type {
+  WorkflowMessage,
+  RoleResult,
+  Role,
+  RoleMeta,
+  StartStep,
+  ThreadContext,
+  WorkflowContext,
+  AgentFn,
+  RoleStep,
+  ModeratorContext,
+  Moderator,
+  WorkflowDefinition,
+} from "./types.js";
+
+export type { DropOverflowConfig, QueueOverflowConfig, WorkflowConfig } from "./config.js";

packages/workflow/src/worker-signals.ts

@@ -0,0 +1,17 @@
+/**
+ * Worker-process signal handling (fork IPC children only).
+ * Worker entrypoints import this module — not worker-runtime.ts (parent/kernel code).
+ */
+
+/**
+ * Forked workers inherit the parent's process group. In foreground `nerve dev`,
+ * terminal-driven SIGINT/SIGTERM is delivered to the whole group, so workers can exit
+ * on the default handler before the kernel sends `{ type: "shutdown" }` over IPC.
+ * Swallow these in worker processes so the parent coordinates shutdown (issue #55).
+ * Only call when `process.send` is defined (fork IPC); standalone `node …-worker.js` keeps default Ctrl+C behaviour.
+ */
+export function ignoreSessionBroadcastSignals(): void {
+  const swallow = (): void => {};
+  process.on("SIGINT", swallow);
+  process.on("SIGTERM", swallow);
+}

packages/workflow/src/worker.ts

@@ -14,6 +14,14 @@ import "./experimental-warning-suppression.js";
 import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 
+import { isPlainRecord } from "@uncaged/nerve-core";
+
+import type {
+  ThreadEventType,
+  ThreadWorkflowMessage,
+  WorkflowChildToParentMessage,
+} from "./ipc.js";
+import { parseWorkflowParentMessage } from "./ipc.js";
 import type {
   RoleMeta,
   RoleStep,
@@ -21,22 +29,15 @@ import type {
   ThreadContext,
   WorkflowDefinition,
   WorkflowMessage,
-} from "@uncaged/nerve-core";
-import { END, START, isPlainRecord } from "@uncaged/nerve-core";
-
-import type {
-  ThreadEventType,
-  ThreadWorkflowMessageMessage,
-  WorkerToParentMessage,
-} from "./ipc.js";
-import { parseParentMessage } from "./ipc.js";
+} from "./types.js";
+import { END, START } from "./types.js";
 import { ignoreSessionBroadcastSignals } from "./worker-signals.js";
 
 // ---------------------------------------------------------------------------
 // IPC helpers
 // ---------------------------------------------------------------------------
 
-function send(msg: WorkerToParentMessage): void {
+function send(msg: WorkflowChildToParentMessage): void {
   if (process.send) {
     process.send(msg);
   }
@@ -55,7 +56,7 @@ function sendWorkflowError(runId: string, error: string, exitCode = 1): void {
 }
 
 function sendWorkflowMessage(runId: string, message: WorkflowMessage): void {
-  const msg: ThreadWorkflowMessageMessage = {
+  const msg: ThreadWorkflowMessage = {
     type: "thread-workflow-message",
     runId,
     message: {
@@ -334,7 +335,7 @@ function handleMessage(
   killFlags: Map<string, KillFlag>,
   shuttingDown: { value: boolean },
 ): void {
-  const parseResult = parseParentMessage(raw);
+  const parseResult = parseWorkflowParentMessage(raw);
   if (!parseResult.ok) {
     process.stderr.write(`[workflow-worker] Invalid IPC message: ${parseResult.error.message}\n`);
     return;

packages/workflow/tsconfig.json

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