fix: PR #81 review follow-ups (closes #83 )

- Filter __start__ messages in getThreadRoundCount SQL to fix round offset - Remove duplicate parseWorkflowField, use parseSenseWorkflowDirective - Remove unnecessary double casts in workflow CLI - Add runtime validation for Role meta in workflow-worker - Export DEFAULT_ENGINE_MAX_ROUNDS from types.ts 小橘 🍊（NEKO Team）
Merge pull request 'refactor(core): restore type-safe workflow automaton from Pulse design' (#81 ) from refactor/workflow-type-safety into main
2026-04-24 11:09:31 +00:00 · 2026-04-24 11:02:23 +00:00 · 2026-04-24 10:58:48 +00:00 · 2026-04-24 09:50:28 +00:00 · 2026-04-24 06:08:11 +00:00 · 2026-04-24 06:04:32 +00:00
55 changed files with 2442 additions and 924 deletions
@@ -0,0 +1,189 @@
+---
+description: Nerve project coding conventions — style, patterns, and toolchain
+globs: packages/*/src/**/*.ts
+alwaysApply: true
+---
+
+# Nerve Coding Conventions
+
+## Core Concepts
+
+```
+External World → Sense → Signal → Reflex → Workflow → Log
+                  ↑                                     ↑
+              "what to observe"                  "what to do"
+```
+
+**Nerve** is a lightweight observation engine daemon for autonomous agents. It continuously observes external state, reacts to changes via declarative rules, and orchestrates multi-step workflows.
+
+### Key Terms
+
+| Concept | What it is |
+|---------|-----------|
+| **Sense** | A `compute()` function that samples or derives data. Returns `T \| null` — non-null emits a Signal, null is silent. Each Sense has its own SQLite database. |
+| **Signal** | A notification emitted when a Sense returns non-null. Pure fact, no intent. Distributed via an in-memory Signal Bus. Not persisted. |
+| **Reflex** | A declarative trigger (YAML) connecting Senses to actions. Trigger types: `interval` (periodic), `on` (react to Signals). Action types: trigger a Sense, or start a Workflow. |
+| **Workflow** | A stateful multi-step execution. Contains **Roles** (actors with side effects) and a **Moderator** (pure router). Each instance is a **Thread** with a unique `runId`. |
+| **Log** | Immutable audit trail. Records executions, state transitions, errors. **Cannot trigger Reflexes** — prevents feedback loops. |
+| **Engine** | The kernel orchestrating everything. Holds Signal Bus, Reflex Scheduler, Process Manager, Workflow Manager. Never loads user code directly — all user code runs in isolated Workers. |
+| **Daemon** | The `nerve-daemon` package — engine runtime. Runs as a background process. |
+
+### Architecture Rules
+
+- **Three orthogonal extension points**: Sense (what to compute), Reflex (when to compute), Workflow (what to do)
+- **Process isolation**: One worker per Sense group (long-lived), one per Workflow type (on-demand). Workers never talk to each other.
+- **Causality is one-directional**: External world → Sense → Signal → Reflex → Action + Log. Logs are the end of the chain.
+
+
+
+## Language & Paradigm
+
+### Functional-first
+
+Use `function` + `type`, not `class` + `interface`.
+
+```typescript
+// ✅ Good
+type Signal = {
+  senseId: string;
+  value: unknown;
+  ts: number;
+};
+
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() };
+}
+
+// ❌ Bad — no class, no interface
+class Signal implements ISignal { ... }
+```
+
+### Rules
+
+| Rule | Description |
+|------|-------------|
+| `type` over `interface` | All type definitions use `type` |
+| `function` over `class` | Pure functions + closures, no class |
+| No `this` | Functions must not depend on `this` context |
+| No inheritance | No `extends`, `implements`, `abstract` |
+| Composition over inheritance | Use function composition |
+| Immutability first | Use `Readonly<T>`, `as const`, avoid mutation |
+| No optional properties | Use `T \| null` instead of `?:` — see below |
+
+### Exceptions
+
+Classes are allowed when:
+- Required by a third-party library (e.g. Drizzle's `sqliteTable`)
+- Error subclasses (`class NerveError extends Error`)
+
+### No Optional Properties
+
+Never use `?:`. All nullable fields must be explicit `T | null`.
+
+```typescript
+// ✅ Good
+type SenseConfig = {
+  group: string;
+  throttle: string | null;
+  timeout: string | null;
+};
+
+// ❌ Bad
+type SenseConfig = {
+  group: string;
+  throttle?: string;
+  timeout?: string;
+};
+```
+
+For mutually exclusive fields, use discriminated unions:
+
+```typescript
+// ✅ Good
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null };
+```
+
+## Modules & Exports
+
+- Always named exports, never default exports
+- One module = one responsibility, filename = purpose
+
+```typescript
+// ✅ Named exports only
+export function startEngine(config: EngineConfig): Engine { ... }
+export type EngineConfig = { ... };
+
+// ❌ No default exports
+export default function startEngine() { ... }
+```
+
+## Naming
+
+| Type | Style | Example |
+|------|-------|---------|
+| Files | kebab-case | `signal-bus.ts` |
+| Types | PascalCase | `SignalBus` |
+| Functions/variables | camelCase | `createSignalBus` |
+| Constants | UPPER_SNAKE | `MAX_RETRY_COUNT` |
+| Generics | Single letter or descriptive | `T`, `TValue` |
+
+## Error Handling
+
+- Use `Result` type for expected failures
+- `throw` only for unrecoverable bugs (programmer errors)
+- No try-catch for flow control
+
+```typescript
+type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+
+function parseSenseConfig(raw: unknown): Result<SenseConfig> { ... }
+```
+
+## Async
+
+- Always `async/await`, never `.then()` chains
+
+## Toolchain
+
+| Tool | Purpose |
+|------|---------|
+| **pnpm** | Package manager |
+| **TypeScript** | Type checking (strict mode) |
+| **Biome** | Lint + format (replaces ESLint + Prettier) |
+| **tsup** | Bundling |
+
+### Commands
+
+```bash
+pnpm run check      # biome check (lint + format)
+pnpm run format     # biome format --write
+pnpm run build      # full build
+pnpm test           # run tests
+```
+
+## Monorepo Structure
+
+```
+nerve/
+  packages/
+    core/           # @nerve/core — shared types and utils
+    cli/            # @nerve/cli — CLI entry point
+    daemon/         # @nerve/daemon — engine runtime
+  docs/             # RFCs, conventions
+  biome.json        # root Biome config
+  tsconfig.json     # root TypeScript config (composite project references)
+```
+
+- `core` is the shared layer; `cli` and `daemon` both depend on it
+- `cli` and `daemon` must NOT depend on each other
+
+## Commit Convention
+
+```
+<type>(<scope>): <description>
+
+type: feat | fix | refactor | docs | chore | test
+scope: core | cli | daemon | rfc-001 | ...
+```
@@ -0,0 +1,180 @@
+# Nerve Coding Conventions
+
+## Core Concepts
+
+```
+External World → Sense → Signal → Reflex → Workflow → Log
+                  ↑                                     ↑
+              "what to observe"                  "what to do"
+```
+
+**Nerve** is a lightweight observation engine daemon for autonomous agents. It continuously observes external state, reacts to changes via declarative rules, and orchestrates multi-step workflows.
+
+### Key Terms
+
+| Concept | What it is |
+|---------|-----------|
+| **Sense** | A `compute()` function that samples or derives data. Returns `T \| null` — non-null emits a Signal, null is silent. Each Sense has its own SQLite database. |
+| **Signal** | A notification emitted when a Sense returns non-null. Pure fact, no intent. Distributed via an in-memory Signal Bus. Not persisted. |
+| **Reflex** | A declarative trigger (YAML) connecting Senses to actions. Trigger types: `interval` (periodic), `on` (react to Signals). Action types: trigger a Sense, or start a Workflow. |
+| **Workflow** | A stateful multi-step execution. Contains **Roles** (actors with side effects) and a **Moderator** (pure router). Each instance is a **Thread** with a unique `runId`. |
+| **Log** | Immutable audit trail. Records executions, state transitions, errors. **Cannot trigger Reflexes** — prevents feedback loops. |
+| **Engine** | The kernel orchestrating everything. Holds Signal Bus, Reflex Scheduler, Process Manager, Workflow Manager. Never loads user code directly — all user code runs in isolated Workers. |
+| **Daemon** | The `nerve-daemon` package — engine runtime. Runs as a background process. |
+
+### Architecture Rules
+
+- **Three orthogonal extension points**: Sense (what to compute), Reflex (when to compute), Workflow (what to do)
+- **Process isolation**: One worker per Sense group (long-lived), one per Workflow type (on-demand). Workers never talk to each other.
+- **Causality is one-directional**: External world → Sense → Signal → Reflex → Action + Log. Logs are the end of the chain.
+
+
+
+## Language & Paradigm
+
+### Functional-first
+
+Use `function` + `type`, not `class` + `interface`.
+
+```typescript
+// ✅ Good
+type Signal = {
+  senseId: string;
+  value: unknown;
+  ts: number;
+};
+
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() };
+}
+
+// ❌ Bad — no class, no interface
+class Signal implements ISignal { ... }
+```
+
+### Rules
+
+| Rule | Description |
+|------|-------------|
+| `type` over `interface` | All type definitions use `type` |
+| `function` over `class` | Pure functions + closures, no class |
+| No `this` | Functions must not depend on `this` context |
+| No inheritance | No `extends`, `implements`, `abstract` |
+| Composition over inheritance | Use function composition |
+| Immutability first | Use `Readonly<T>`, `as const`, avoid mutation |
+| No optional properties | Use `T \| null` instead of `?:` — see below |
+
+### Exceptions
+
+Classes are allowed when:
+- Required by a third-party library (e.g. Drizzle's `sqliteTable`)
+- Error subclasses (`class NerveError extends Error`)
+
+### No Optional Properties
+
+Never use `?:`. All nullable fields must be explicit `T | null`.
+
+```typescript
+// ✅ Good
+type SenseConfig = {
+  group: string;
+  throttle: string | null;
+  timeout: string | null;
+};
+
+// ❌ Bad
+type SenseConfig = {
+  group: string;
+  throttle?: string;
+  timeout?: string;
+};
+```
+
+For mutually exclusive fields, use discriminated unions:
+
+```typescript
+// ✅ Good
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null };
+```
+
+## Modules & Exports
+
+- Always named exports, never default exports
+- One module = one responsibility, filename = purpose
+
+## Naming
+
+| Type | Style | Example |
+|------|-------|---------|
+| Files | kebab-case | `signal-bus.ts` |
+| Types | PascalCase | `SignalBus` |
+| Functions/variables | camelCase | `createSignalBus` |
+| Constants | UPPER_SNAKE | `MAX_RETRY_COUNT` |
+| Generics | Single letter or descriptive | `T`, `TValue` |
+
+## Error Handling
+
+- Use `Result` type for expected failures
+- `throw` only for unrecoverable bugs (programmer errors)
+- No try-catch for flow control
+
+```typescript
+type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+```
+
+## Async
+
+- Always `async/await`, never `.then()` chains
+
+## No Dynamic Import
+
+Do NOT use `await import()` in production code. Always use static top-level `import`.
+
+Exceptions (must include a comment):
+1. `sense-runtime.ts` — user module paths known only at runtime
+2. `workflow-worker.ts` — user module paths known only at runtime
+
+Test files (`__tests__/**`) are exempt.
+
+## Toolchain
+
+| Tool | Purpose |
+|------|---------|
+| **pnpm** | Package manager |
+| **TypeScript** | Type checking (strict mode) |
+| **Biome** | Lint + format (replaces ESLint + Prettier) |
+| **tsup** | Bundling |
+
+### Commands
+
+```bash
+pnpm run check      # biome check (lint + format)
+pnpm run format     # biome format --write
+pnpm run build      # full build
+pnpm test           # run tests
+```
+
+## Monorepo Structure
+
+```
+nerve/
+  packages/
+    core/           # @nerve/core — shared types and utils
+    cli/            # @nerve/cli — CLI entry point
+    daemon/         # @nerve/daemon — engine runtime
+  docs/             # RFCs, conventions
+```
+
+- `core` is the shared layer; `cli` and `daemon` both depend on it
+- `cli` and `daemon` must NOT depend on each other
+
+## Commit Convention
+
+```
+<type>(<scope>): <description>
+
+type: feat | fix | refactor | docs | chore | test
+scope: core | cli | daemon | rfc-001 | ...
+```
@@ -2,3 +2,4 @@ node_modules
 dist
 .turbo
 *.tsbuildinfo
+*.tgz
@@ -0,0 +1,180 @@
+# Nerve Coding Conventions
+
+## Core Concepts
+
+```
+External World → Sense → Signal → Reflex → Workflow → Log
+                  ↑                                     ↑
+              "what to observe"                  "what to do"
+```
+
+**Nerve** is a lightweight observation engine daemon for autonomous agents. It continuously observes external state, reacts to changes via declarative rules, and orchestrates multi-step workflows.
+
+### Key Terms
+
+| Concept | What it is |
+|---------|-----------|
+| **Sense** | A `compute()` function that samples or derives data. Returns `T \| null` — non-null emits a Signal, null is silent. Each Sense has its own SQLite database. |
+| **Signal** | A notification emitted when a Sense returns non-null. Pure fact, no intent. Distributed via an in-memory Signal Bus. Not persisted. |
+| **Reflex** | A declarative trigger (YAML) connecting Senses to actions. Trigger types: `interval` (periodic), `on` (react to Signals). Action types: trigger a Sense, or start a Workflow. |
+| **Workflow** | A stateful multi-step execution. Contains **Roles** (actors with side effects) and a **Moderator** (pure router). Each instance is a **Thread** with a unique `runId`. |
+| **Log** | Immutable audit trail. Records executions, state transitions, errors. **Cannot trigger Reflexes** — prevents feedback loops. |
+| **Engine** | The kernel orchestrating everything. Holds Signal Bus, Reflex Scheduler, Process Manager, Workflow Manager. Never loads user code directly — all user code runs in isolated Workers. |
+| **Daemon** | The `nerve-daemon` package — engine runtime. Runs as a background process. |
+
+### Architecture Rules
+
+- **Three orthogonal extension points**: Sense (what to compute), Reflex (when to compute), Workflow (what to do)
+- **Process isolation**: One worker per Sense group (long-lived), one per Workflow type (on-demand). Workers never talk to each other.
+- **Causality is one-directional**: External world → Sense → Signal → Reflex → Action + Log. Logs are the end of the chain.
+
+
+
+## Language & Paradigm
+
+### Functional-first
+
+Use `function` + `type`, not `class` + `interface`.
+
+```typescript
+// ✅ Good
+type Signal = {
+  senseId: string;
+  value: unknown;
+  ts: number;
+};
+
+function createSignal(senseId: string, value: unknown): Signal {
+  return { senseId, value, ts: Date.now() };
+}
+
+// ❌ Bad — no class, no interface
+class Signal implements ISignal { ... }
+```
+
+### Rules
+
+| Rule | Description |
+|------|-------------|
+| `type` over `interface` | All type definitions use `type` |
+| `function` over `class` | Pure functions + closures, no class |
+| No `this` | Functions must not depend on `this` context |
+| No inheritance | No `extends`, `implements`, `abstract` |
+| Composition over inheritance | Use function composition |
+| Immutability first | Use `Readonly<T>`, `as const`, avoid mutation |
+| No optional properties | Use `T \| null` instead of `?:` — see below |
+
+### Exceptions
+
+Classes are allowed when:
+- Required by a third-party library (e.g. Drizzle's `sqliteTable`)
+- Error subclasses (`class NerveError extends Error`)
+
+### No Optional Properties
+
+Never use `?:`. All nullable fields must be explicit `T | null`.
+
+```typescript
+// ✅ Good
+type SenseConfig = {
+  group: string;
+  throttle: string | null;
+  timeout: string | null;
+};
+
+// ❌ Bad
+type SenseConfig = {
+  group: string;
+  throttle?: string;
+  timeout?: string;
+};
+```
+
+For mutually exclusive fields, use discriminated unions:
+
+```typescript
+// ✅ Good
+type ReflexConfig =
+  | { kind: "sense"; sense: string; interval: string | null; on: string[] | null }
+  | { kind: "workflow"; workflow: string; on: string[] | null };
+```
+
+## Modules & Exports
+
+- Always named exports, never default exports
+- One module = one responsibility, filename = purpose
+
+## Naming
+
+| Type | Style | Example |
+|------|-------|---------|
+| Files | kebab-case | `signal-bus.ts` |
+| Types | PascalCase | `SignalBus` |
+| Functions/variables | camelCase | `createSignalBus` |
+| Constants | UPPER_SNAKE | `MAX_RETRY_COUNT` |
+| Generics | Single letter or descriptive | `T`, `TValue` |
+
+## Error Handling
+
+- Use `Result` type for expected failures
+- `throw` only for unrecoverable bugs (programmer errors)
+- No try-catch for flow control
+
+```typescript
+type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+```
+
+## Async
+
+- Always `async/await`, never `.then()` chains
+
+## No Dynamic Import
+
+Do NOT use `await import()` in production code. Always use static top-level `import`.
+
+Exceptions (must include a comment):
+1. `sense-runtime.ts` — user module paths known only at runtime
+2. `workflow-worker.ts` — user module paths known only at runtime
+
+Test files (`__tests__/**`) are exempt.
+
+## Toolchain
+
+| Tool | Purpose |
+|------|---------|
+| **pnpm** | Package manager |
+| **TypeScript** | Type checking (strict mode) |
+| **Biome** | Lint + format (replaces ESLint + Prettier) |
+| **tsup** | Bundling |
+
+### Commands
+
+```bash
+pnpm run check      # biome check (lint + format)
+pnpm run format     # biome format --write
+pnpm run build      # full build
+pnpm test           # run tests
+```
+
+## Monorepo Structure
+
+```
+nerve/
+  packages/
+    core/           # @nerve/core — shared types and utils
+    cli/            # @nerve/cli — CLI entry point
+    daemon/         # @nerve/daemon — engine runtime
+  docs/             # RFCs, conventions
+```
+
+- `core` is the shared layer; `cli` and `daemon` both depend on it
+- `cli` and `daemon` must NOT depend on each other
+
+## Commit Convention
+
+```
+<type>(<scope>): <description>
+
+type: feat | fix | refactor | docs | chore | test
+scope: core | cli | daemon | rfc-001 | ...
+```
@@ -1,3 +1,165 @@
 # nerve

-Observation engine — Sense, Reflex, Workflow
+**Observation engine for autonomous agents** — sense the world, react to changes, run workflows.
+
+Nerve is a lightweight daemon that continuously observes external state through **Senses**, reacts via declarative **Reflexes**, and orchestrates multi-step **Workflows**. Built for the [Uncaged](https://github.com/uncaged) agent framework.
+
+## Core Concepts
+
+```
+External World → Sense → Signal → Reflex → Workflow → Log
+                  ↑                                     ↑
+              "what to observe"                  "what to do"
+```
+
+| Concept | Metaphor | Role |
+|---------|----------|------|
+| **Sense** | 👁️ Perception | A `compute()` function that samples or derives data. Each sense has its own SQLite database. |
+| **Reflex** | ⚡ Reaction | Declarative trigger — interval-based, event-driven, or both. Connects senses to actions. |
+| **Signal** | 📡 Notification | Emitted when a sense returns non-null. Other reflexes can listen for signals. |
+| **Workflow** | 🔧 Action | Stateful multi-step execution with Roles (actors) and a Moderator (coordinator). |
+| **Log** | 📝 Record | Immutable audit trail. Queryable by senses, but **cannot** trigger reflexes (prevents feedback loops). |
+
+Three extension points, fully orthogonal — a Sense doesn't know when it runs, a Reflex doesn't know what it computes, a Workflow doesn't know why it was triggered.
+
+## Packages
+
+| Package | Description |
+|---------|-------------|
+| [`@uncaged/nerve-core`](./packages/core) | Shared types and config parser |
+| [`@uncaged/nerve-daemon`](./packages/daemon) | The observation engine — kernel, sense runtime, reflex scheduler, workflow manager |
+| [`@uncaged/nerve-cli`](./packages/cli) | CLI tool (`nerve`) — init, start, stop, logs, query |
+
+## Quick Start
+
+```bash
+# Requirements: Node.js ≥ 22.5, pnpm
+pnpm add -g @uncaged/nerve-cli
+
+# Initialize a workspace
+mkdir my-agent && cd my-agent
+nerve init
+
+# Write a sense
+cat > senses/cpu-usage/compute.ts << 'EOF'
+export async function compute() {
+  const [load] = (await import("node:os")).loadavg();
+  return load > 2.0 ? { load } : null;  // signal only when load is high
+}
+EOF
+
+# Configure reflexes in nerve.yaml
+cat > nerve.yaml << 'EOF'
+senses:
+  cpu-usage:
+    group: system
+    throttle: 10s
+
+reflexes:
+  - kind: sense
+    sense: cpu-usage
+    interval: 30s
+EOF
+
+# Run
+nerve dev          # foreground (development)
+nerve daemon start # background (production)
+nerve status       # check health
+nerve logs         # view logs
+```
+
+## Configuration
+
+`nerve.yaml` declares senses, reflexes, and workflows:
+
+```yaml
+senses:
+  cpu-usage:
+    group: system          # senses in the same group share a worker process
+    throttle: 10s          # min interval between computes
+    timeout: 30s           # max compute duration
+    gracePeriod: 5s        # wait before first compute after startup
+
+reflexes:
+  - kind: sense
+    sense: cpu-usage
+    interval: 30s          # periodic trigger
+    on: [disk-pressure]    # also trigger on signals from other senses
+
+  - kind: workflow
+    workflow: cleanup
+    on: [disk-pressure]    # start a workflow when signal fires
+
+workflows:
+  cleanup:
+    concurrency: 1
+    overflow: drop         # discard if already running
+  code-review:
+    concurrency: 3
+    overflow: queue
+    maxQueue: 20
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Kernel                                                 │
+│                                                         │
+│  ┌──────────┐   ┌──────────┐   ┌──────────┐           │
+│  │ Worker   │   │ Worker   │   │ Worker   │  (1 per   │
+│  │ (group A)│   │ (group B)│   │ (group C)│   group)  │
+│  │ sense-1  │   │ sense-3  │   │ sense-5  │           │
+│  │ sense-2  │   │ sense-4  │   │          │           │
+│  └────┬─────┘   └────┬─────┘   └────┬─────┘           │
+│       │              │              │                   │
+│       └──────────────┼──────────────┘                   │
+│                      ▼                                  │
+│              ┌──────────────┐                           │
+│              │  Signal Bus  │                           │
+│              └──────┬───────┘                           │
+│                     ▼                                   │
+│           ┌──────────────────┐                          │
+│           │ Reflex Scheduler │                          │
+│           └────────┬─────────┘                          │
+│                    ▼                                    │
+│          ┌───────────────────┐                          │
+│          │ Workflow Manager  │──→ Log Store (SQLite)    │
+│          └───────────────────┘                          │
+└─────────────────────────────────────────────────────────┘
+```
+
+- **Worker processes** — one per sense group, forked by the kernel. Isolated compute execution.
+- **Signal Bus** — in-memory pub/sub for signal distribution.
+- **Reflex Scheduler** — interval timers + signal subscriptions, with throttle/coalesce.
+- **Workflow Manager** — concurrency control (drop/queue), thread lifecycle tracking.
+- **Log Store** — WAL-mode SQLite via `node:sqlite`, with archival and retention policies.
+
+## Tech Stack
+
+- **Zero native addons** — uses Node.js built-in `node:sqlite` (DatabaseSync)
+- **Drizzle ORM** v1.0 for sense databases
+- **rslib** (rspack) for building
+- **Biome** for formatting/linting
+- **Vitest** for testing
+- **pnpm** workspaces for monorepo management
+
+## Development
+
+```bash
+git clone https://git.shazhou.work/uncaged/nerve.git
+cd nerve
+pnpm install
+pnpm build
+pnpm -r test     # run all tests
+```
+
+## Design Documents
+
+- [RFC-001: Observation Engine](./docs/rfc-001-observation-engine.md) — Sense, Signal, Reflex model
+- [RFC-002: Workflow Engine](./docs/rfc-002-workflow-engine.md) — Stateful workflow execution
+- [Coding Conventions](./docs/coding-conventions.md)
+
+## License
+
+MIT
@@ -11,7 +11,7 @@
  },
  "devDependencies": {
    "@biomejs/biome": "^1.9.0",
-    "tsup": "^8.0.0",
+    "@rslib/core": "^0.21.3",
    "typescript": "^5.5.0"
  }
 }
@@ -0,0 +1,69 @@
+# @uncaged/nerve-cli
+
+Command-line interface for the [nerve](../../README.md) observation engine.
+
+## Install
+
+```bash
+pnpm add -g @uncaged/nerve-cli
+# or
+npx @uncaged/nerve-cli
+```
+
+Requires Node.js ≥ 22.5.
+
+## Commands
+
+### Workspace
+
+```bash
+nerve init                  # Initialize a nerve workspace (installs deps, scaffolds config)
+nerve validate              # Validate nerve.yaml configuration
+```
+
+### Daemon Management
+
+```bash
+nerve daemon start          # Start the daemon (background)
+nerve daemon stop           # Stop the daemon
+nerve daemon status         # Check daemon health
+nerve daemon restart        # Restart the daemon
+nerve daemon logs           # Tail daemon logs
+```
+
+### Development
+
+```bash
+nerve dev                   # Run in foreground mode (no daemon, Ctrl+C to stop)
+```
+
+### Querying
+
+```bash
+nerve logs                  # View structured logs
+nerve sense query <name>    # Query a sense's SQLite database
+nerve sense schema <name>   # Show a sense's database schema
+nerve status                # Daemon health summary
+```
+
+### Workflows
+
+```bash
+nerve workflow list         # List workflow runs
+nerve workflow show <runId> # Show workflow run details
+```
+
+### Top-level Aliases
+
+For convenience, these aliases are available:
+
+```bash
+nerve start    → nerve daemon start
+nerve stop     → nerve daemon stop
+nerve status   → nerve daemon status
+nerve logs     → nerve daemon logs
+```
+
+## License
+
+MIT
@@ -3,29 +3,29 @@
  "engines": {
    "node": ">=22.5.0"
  },
-  "version": "0.1.8",
+  "version": "0.3.0",
  "type": "module",
  "bin": {
    "nerve": "dist/cli.js"
  },
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
  "publishConfig": {
    "access": "public"
  },
  "scripts": {
    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
-    "build": "tsup",
+    "build": "rslib build",
    "test": "vitest run"
  },
  "dependencies": {
    "@uncaged/nerve-core": "workspace:*",
-    "citty": "^0.1.6"
+    "citty": "^0.1.6",
+    "yaml": "^2.8.3"
  },
  "devDependencies": {
+    "@rslib/core": "^0.21.3",
    "@types/node": "^22.0.0",
    "@uncaged/nerve-daemon": "workspace:*",
    "vitest": "^4.1.5"
@@ -0,0 +1,25 @@
+import { defineConfig } from "@rslib/core";
+
+export default defineConfig({
+  lib: [
+    {
+      format: "esm",
+      dts: true,
+      banner: {
+        js: "#!/usr/bin/env node",
+      },
+    },
+  ],
+  source: {
+    entry: {
+      index: "src/index.ts",
+      cli: "src/cli.ts",
+      "daemon-bootstrap": "src/daemon-bootstrap.ts",
+    },
+  },
+  output: {
+    target: "node",
+    cleanDistPath: true,
+    externals: ["@uncaged/nerve-daemon"],
+  },
+});
@@ -234,7 +234,11 @@ describe("logsCommand negative offset", () => {

  it("exits with code 1 and writes to stderr when offset is negative", async () => {
    await expect(
-      logsCommand.run!({ args: { n: "50", offset: "-5", follow: false }, rawArgs: [], cmd: logsCommand as never }),
+      logsCommand.run!({
+        args: { n: "50", offset: "-5", follow: false },
+        rawArgs: [],
+        cmd: logsCommand as never,
+      }),
    ).rejects.toThrow("process.exit(1)");
    expect(exitCode).toBe(1);
    expect(stderrOutput).toContain("--offset must be a non-negative integer");
@@ -243,7 +247,11 @@ describe("logsCommand negative offset", () => {

  it("exits with code 1 for offset=-1", async () => {
    await expect(
-      logsCommand.run!({ args: { n: "10", offset: "-1", follow: false }, rawArgs: [], cmd: logsCommand as never }),
+      logsCommand.run!({
+        args: { n: "10", offset: "-1", follow: false },
+        rawArgs: [],
+        cmd: logsCommand as never,
+      }),
    ).rejects.toThrow("process.exit(1)");
    expect(exitCode).toBe(1);
  });
@@ -16,15 +16,19 @@ import { createLogStore } from "@uncaged/nerve-daemon";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";

 import {
+  DEFAULT_THREAD_BUDGET_CHARS,
  buildInspectOutput,
  buildListOutput,
+  buildThreadCommandOutput,
+  formatThreadRoundBlock,
  formatTs,
  getAllWorkflowRuns,
  parseIntArg,
+  partitionWorkflowMessage,
  statusIcon,
 } from "../commands/workflow.js";
 import { triggerWorkflowViaDaemon } from "../daemon-client.js";
-import type { LogStore, WorkflowRun } from "../daemon-types.js";
+import type { LogStore, ThreadRoundRow, WorkflowRun } from "../daemon-types.js";

 // ---------------------------------------------------------------------------
 // Test helpers
@@ -322,6 +326,93 @@ describe("workflow list — integration with real store", () => {
  });
 });

+// ---------------------------------------------------------------------------
+// nerve workflow thread — formatting helpers
+// ---------------------------------------------------------------------------
+
+describe("partitionWorkflowMessage", () => {
+  it("extracts role, content, and meta", () => {
+    const p = partitionWorkflowMessage({
+      role: "scanner",
+      content: "ok",
+      meta: { items: [1, 2] },
+    });
+    expect(p.roleStr).toBe("scanner");
+    expect(p.contentBody).toBe("ok");
+    expect(p.meta).toEqual({ items: [1, 2] });
+  });
+
+  it("uses fallback role and stringifies non-string content", () => {
+    const p = partitionWorkflowMessage({ content: { n: 1 } });
+    expect(p.roleStr).toBe("?");
+    expect(p.contentBody).toBe('{"n":1}');
+  });
+});
+
+describe("formatThreadRoundBlock", () => {
+  const row: ThreadRoundRow = {
+    round: 2,
+    logId: 99,
+    ts: new Date("2026-01-02T03:04:05.006Z").getTime(),
+    message: { role: "bot", content: "hi", meta: { score: 0.5 }, timestamp: 1735783445006 },
+  };
+
+  it("includes header, YAML frontmatter for meta, and body", () => {
+    const text = formatThreadRoundBlock(row);
+    expect(text).toContain("[#2 bot]");
+    expect(text).toContain("---\n");
+    expect(text).toContain("score: 0.5");
+    expect(text).toContain("hi");
+  });
+});
+
+describe("buildThreadCommandOutput", () => {
+  function row(n: number, content: string): ThreadRoundRow {
+    return {
+      round: n,
+      logId: 10 + n,
+      ts: 1000 + n,
+      message: { role: "r", content, meta: { extra: n }, timestamp: 1000 + n },
+    };
+  }
+
+  it("orders rounds chronologically (oldest first in output)", () => {
+    const desc = [row(3, "ccc"), row(2, "bbb"), row(1, "aaa")];
+    const prefix = ["HEADER\n"];
+    const { lines, paginationHint } = buildThreadCommandOutput(prefix, desc, 50_000, "run-x");
+    const text = lines.join("");
+    const idxA = text.indexOf("\naaa\n");
+    const idxB = text.indexOf("\nbbb\n");
+    const idxC = text.indexOf("\nccc\n");
+    expect(idxA).toBeGreaterThan(-1);
+    expect(idxB).toBeGreaterThan(idxA);
+    expect(idxC).toBeGreaterThan(idxB);
+    expect(paginationHint).toBeNull();
+  });
+
+  it("emits pagination hint with --before when oldest shown round is still > 1", () => {
+    const desc = [row(4, "d"), row(3, "c")];
+    const { paginationHint } = buildThreadCommandOutput([], desc, 50_000, "run-y");
+    expect(paginationHint).toContain("--before 3");
+    expect(paginationHint).toContain("run-y");
+  });
+
+  it("respects budget and hints with non-default --budget in command", () => {
+    const big = "y".repeat(500);
+    const desc = [row(2, big), row(1, "a")];
+    const { lines, paginationHint } = buildThreadCommandOutput([], desc, 400, "run-z");
+    const text = lines.join("");
+    expect(text).toContain("[#2");
+    expect(text).not.toContain("[#1");
+    expect(paginationHint).toContain("--before 2");
+    expect(paginationHint).toContain("--budget 400");
+  });
+
+  it("default budget constant matches workflow command default", () => {
+    expect(DEFAULT_THREAD_BUDGET_CHARS).toBe(8000);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // parseIntArg
 // ---------------------------------------------------------------------------
@@ -12,6 +12,26 @@ import { storeCommand } from "./commands/store.js";
 import { validateCommand } from "./commands/validate.js";
 import { workflowCommand } from "./commands/workflow.js";

+/**
+ * Citty picks the first non-flag token as a subcommand name. Rewrite
+ * `nerve init --from <url>` so the URL is not mistaken for `workflow`/`workspace`.
+ */
+function normalizeNerveArgv(argv: string[]): string[] {
+  const initIdx = argv.indexOf("init");
+  if (initIdx === -1) return argv;
+  const tail = argv.slice(initIdx + 1);
+  const fromAt = tail.indexOf("--from");
+  if (fromAt === -1) return argv;
+  const beforeFrom = tail.slice(0, fromAt);
+  if (beforeFrom.some((a) => !a.startsWith("-"))) return argv;
+  const next = tail[fromAt + 1];
+  if (next === undefined || next.startsWith("-")) return argv;
+  const reserved = new Set(["workflow", "workspace"]);
+  if (reserved.has(next)) return argv;
+  const mergedTail = [...tail.slice(0, fromAt), `--from=${next}`, ...tail.slice(fromAt + 2)];
+  return [...argv.slice(0, initIdx + 1), ...mergedTail];
+}
+
 const main = defineCommand({
  meta: {
    name: "nerve",
@@ -32,4 +52,4 @@ const main = defineCommand({
  },
 });

-runMain(main);
+runMain(main, { rawArgs: normalizeNerveArgv(process.argv.slice(2)) });
@@ -1,5 +1,5 @@
 import { execFile, spawn } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";

@@ -236,6 +236,76 @@ async function verifyNodeSqlite(): Promise<boolean> {
  }
 }

+function isNerveRootNonEmpty(nerveRoot: string): boolean {
+  if (!existsSync(nerveRoot)) return false;
+  return readdirSync(nerveRoot).length > 0;
+}
+
+async function runInitFromGit(url: string): Promise<void> {
+  const trimmed = url.trim();
+  if (trimmed.length === 0) {
+    process.stderr.write("❌ --from requires a non-empty git URL.\n");
+    process.exit(1);
+  }
+
+  const nerveRoot = getNerveRoot();
+  if (isNerveRootNonEmpty(nerveRoot)) {
+    process.stderr.write(
+      `❌ ${nerveRoot} already exists and is not empty. Remove it (or empty it) before using --from.\n`,
+    );
+    process.exit(1);
+  }
+
+  try {
+    await execFileAsync("git", ["--version"]);
+  } catch {
+    process.stderr.write("❌ git is not available. Install git and retry.\n");
+    process.exit(1);
+  }
+
+  try {
+    await execFileAsync("pnpm", ["--version"]);
+  } catch {
+    process.stderr.write("❌ pnpm is not available. Install pnpm and retry.\n");
+    process.exit(1);
+  }
+
+  process.stdout.write(`Cloning ${trimmed} → ${nerveRoot} …\n`);
+  try {
+    await runCommand("git", ["clone", trimmed, nerveRoot], process.cwd());
+  } catch {
+    process.stderr.write("❌ git clone failed.\n");
+    process.exit(1);
+  }
+
+  if (!existsSync(join(nerveRoot, "nerve.yaml"))) {
+    process.stdout.write(`⚠️ ${join(nerveRoot, "nerve.yaml")} not found after clone.\n`);
+  }
+  if (!existsSync(join(nerveRoot, "package.json"))) {
+    process.stdout.write(`⚠️ ${join(nerveRoot, "package.json")} not found after clone.\n`);
+  }
+
+  process.stdout.write("Installing dependencies with pnpm …\n");
+  try {
+    await runCommand("pnpm", ["install", "--no-cache"], nerveRoot);
+  } catch {
+    process.stdout.write(
+      `⚠️ pnpm install failed. Try manually:\n   cd ${nerveRoot} && pnpm install --no-cache\n`,
+    );
+  }
+
+  if (!(await verifyNodeSqlite())) {
+    process.stdout.write(
+      "⚠️ Built-in SQLite (node:sqlite) is not available in this Node.js build. " +
+        "The daemon requires Node.js 22.5 or newer with SQLite enabled.\n",
+    );
+  }
+
+  process.stdout.write(
+    `✅ Workspace cloned to ${nerveRoot}\n\n💡 Next steps:\n   1. Review nerve.yaml and install any missing tooling.\n   2. Run \`nerve start\` to launch the daemon.\n`,
+  );
+}
+
 async function runInitWorkspace(force: boolean): Promise<void> {
  const nerveRoot = getNerveRoot();

@@ -294,7 +364,7 @@ export const initCommand = defineCommand({
  meta: {
    name: "init",
    description:
-      "Initialize workspace (nerve init) or scaffold templates (nerve init workflow <name>)",
+      "Initialize workspace (nerve init), clone from git (nerve init --from <url>), or scaffold templates (nerve init workflow <name>)",
  },
  args: {
    force: {
@@ -302,12 +372,21 @@ export const initCommand = defineCommand({
      description: "Reinitialize even if workspace already exists (preserves data/)",
      default: false,
    },
+    from: {
+      type: "string",
+      description: "Clone an existing git repo into ~/.uncaged-nerve instead of scaffolding",
+      required: false,
+    },
  },
  subCommands: {
    workflow: initWorkflowCommand,
    workspace: initWorkspaceCommand,
  },
  async run({ args }) {
+    if (args.from !== undefined) {
+      await runInitFromGit(String(args.from));
+      return;
+    }
    await runInitWorkspace(args.force);
  },
 });
@@ -76,7 +76,7 @@ async function runDaemon(nerveRoot: string): Promise<void> {

  const child = spawn(process.execPath, [bootstrapPath], {
    detached: true,
-    stdio: ["ignore", logStream.fd, logStream.fd],
+    stdio: ["ignore", (logStream as any).fd, (logStream as any).fd],
    env: { ...process.env, NERVE_ROOT: nerveRoot },
    cwd: nerveRoot,
  });
@@ -2,14 +2,21 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";

 import { defineCommand } from "citty";
+import { stringify } from "yaml";

 import { triggerWorkflowViaDaemon } from "../daemon-client.js";
-import type { LogStore, WorkflowRun } from "../daemon-types.js";
+import type { LogStore, ThreadRoundRow, WorkflowRun } from "../daemon-types.js";
 import { loadDaemonModule } from "../workspace-daemon.js";
 import { getNerveRoot, getSocketPath, isRunning } from "../workspace.js";

 export const DEFAULT_PAGE_SIZE = 20;

+/** Default max characters for `nerve workflow thread` output (including run header). */
+export const DEFAULT_THREAD_BUDGET_CHARS = 8000;
+
+/** Max role-round rows read from SQLite per invocation (DESC by round). */
+export const THREAD_ROUNDS_FETCH_LIMIT = 8192;
+
 export function parseIntArg(raw: string, fallback: number): number {
  const v = Number.parseInt(raw, 10);
  return Number.isNaN(v) ? fallback : v;
@@ -172,6 +179,116 @@ export function buildInspectOutput(
  return { header, eventLines, paginationHint };
 }

+// ---------------------------------------------------------------------------
+// nerve workflow thread <runId> — agent-oriented role rounds
+// ---------------------------------------------------------------------------
+
+export type PartitionedMessage = {
+  roleStr: string;
+  contentBody: string;
+  meta: Record<string, unknown>;
+};
+
+/**
+ * Extract display fields from a WorkflowMessage-shaped object.
+ * `role` and `content` are used for header/body; `meta` is serialized as YAML frontmatter.
+ */
+export function partitionWorkflowMessage(msg: {
+  role: string;
+  content: string;
+  meta: unknown;
+  timestamp: number;
+}): PartitionedMessage {
+  const roleStr = msg.role;
+  const contentBody = msg.content;
+  const meta: Record<string, unknown> =
+    msg.meta !== null && msg.meta !== undefined && typeof msg.meta === "object"
+      ? (msg.meta as Record<string, unknown>)
+      : {};
+  return { roleStr, contentBody, meta };
+}
+
+/**
+ * One role round as plain text: header line, YAML frontmatter (meta only), body (content).
+ */
+export function formatThreadRoundBlock(row: ThreadRoundRow): string {
+  const { roleStr, contentBody, meta } = partitionWorkflowMessage(row.message);
+  const yamlBlock =
+    Object.keys(meta).length === 0 ? "{}\n" : `${stringify(meta, { lineWidth: 100 })}\n`;
+  return (
+    `[#${row.round} ${roleStr}] ${formatTs(row.ts)}\n` +
+    `---\n` +
+    yamlBlock +
+    `---\n` +
+    `${contentBody}\n\n`
+  );
+}
+
+export type ThreadCommandOutput = {
+  lines: string[];
+  paginationHint: string | null;
+};
+
+/**
+ * Build stdout lines for `nerve workflow thread`: newest-first selection from
+ * `descRows` until `budgetChars` (including `prefixLines`), then chronological order.
+ */
+export function buildThreadCommandOutput(
+  prefixLines: string[],
+  descRows: ThreadRoundRow[],
+  budgetChars: number,
+  runId: string,
+): ThreadCommandOutput {
+  const prefixText = prefixLines.join("");
+  let remaining = Math.max(0, budgetChars - prefixText.length);
+  const picked: ThreadRoundRow[] = [];
+
+  const budgetFlag =
+    budgetChars === DEFAULT_THREAD_BUDGET_CHARS ? "" : ` --budget ${String(budgetChars)}`;
+
+  for (const row of descRows) {
+    const block = formatThreadRoundBlock(row);
+    if (block.length <= remaining) {
+      picked.push(row);
+      remaining -= block.length;
+      continue;
+    }
+    if (picked.length === 0) {
+      const { roleStr, contentBody, meta } = partitionWorkflowMessage(row.message);
+      const yamlBlock =
+        Object.keys(meta).length === 0 ? "{}\n" : `${stringify(meta, { lineWidth: 100 })}\n`;
+      const header =
+        `[#${row.round} ${roleStr}] ${formatTs(row.ts)}\n` + `---\n` + yamlBlock + `---\n`;
+      const maxBody = Math.max(0, remaining - header.length - `[truncated]\n`.length);
+      const truncated =
+        maxBody > 0 && contentBody.length > maxBody
+          ? `${contentBody.slice(0, maxBody)}\n[truncated]\n`
+          : `${contentBody}\n[truncated]\n`;
+      const single = header + truncated + "\n";
+      const hintRound = row.round;
+      return {
+        lines: [...prefixLines, single],
+        paginationHint:
+          hintRound > 1
+            ? `\n⏩ Older rounds exist. Fetch with:\n   nerve workflow thread ${runId} --before ${String(hintRound)}${budgetFlag}\n`
+            : null,
+      };
+    }
+    break;
+  }
+
+  const blocksAsc = picked.map(formatThreadRoundBlock).reverse();
+  const shownMinRound = picked.length === 0 ? null : Math.min(...picked.map((r) => r.round));
+  let paginationHint: string | null = null;
+  if (shownMinRound !== null && shownMinRound > 1) {
+    paginationHint =
+      `\n⏩ Older rounds not shown. Fetch with:\n` +
+      `   nerve workflow thread ${runId} --before ${String(shownMinRound)}${budgetFlag}\n`;
+  }
+
+  return { lines: [...prefixLines, ...blocksAsc], paginationHint };
+}
+
 // ---------------------------------------------------------------------------
 // nerve workflow list
 // ---------------------------------------------------------------------------
@@ -293,6 +410,92 @@ const workflowInspectCommand = defineCommand({
  },
 });

+// ---------------------------------------------------------------------------
+// nerve workflow thread <runId>
+// ---------------------------------------------------------------------------
+
+const workflowThreadCommand = defineCommand({
+  meta: {
+    name: "thread",
+    description: "Print role rounds for a workflow run (agent-oriented, budget-limited)",
+  },
+  args: {
+    runId: {
+      type: "positional",
+      description: "The run ID to dump role rounds for",
+    },
+    before: {
+      type: "string",
+      description:
+        "Exclusive upper bound on 1-based round index (use with hint from prior output to load older rounds)",
+      default: "0",
+    },
+    budget: {
+      type: "string",
+      description: `Max output characters including header (default: ${String(DEFAULT_THREAD_BUDGET_CHARS)})`,
+      default: String(DEFAULT_THREAD_BUDGET_CHARS),
+    },
+  },
+  async run({ args }) {
+    const store = await openStore();
+
+    try {
+      const before = Math.max(0, parseIntArg(args.before, 0));
+      const budgetChars = Math.max(1, parseIntArg(args.budget, DEFAULT_THREAD_BUDGET_CHARS));
+
+      const run = store.getWorkflowRun(args.runId);
+      if (run === null) {
+        process.stderr.write(`❌ No workflow run found with runId: ${args.runId}\n`);
+        process.exit(1);
+      }
+
+      const totalRoleRounds = store.getThreadRoundCount(args.runId);
+      if (totalRoleRounds === 0) {
+        process.stdout.write(
+          `🧵 Workflow thread: ${run.runId}\n` +
+            `   workflow: ${run.workflow}\n` +
+            `   status:   ${run.status}\n\n` +
+            `📭 No role rounds recorded for this run.\n`,
+        );
+        return;
+      }
+
+      const descRows = store.getThreadRounds(args.runId, {
+        before,
+        limit: THREAD_ROUNDS_FETCH_LIMIT,
+      });
+
+      const prefixLines = [
+        `🧵 Role rounds (workflow thread)\n`,
+        `   runId:    ${run.runId}\n`,
+        `   workflow: ${run.workflow}\n`,
+        `   status:   ${run.status}\n`,
+        `   rounds:   ${String(totalRoleRounds)} role event(s) total\n\n`,
+      ];
+
+      const { lines, paginationHint } = buildThreadCommandOutput(
+        prefixLines,
+        descRows,
+        budgetChars,
+        args.runId,
+      );
+
+      for (const line of lines) {
+        process.stdout.write(line);
+      }
+      if (paginationHint !== null) {
+        process.stdout.write(paginationHint);
+      }
+
+      if (descRows.length === 0 && before > 0) {
+        process.stdout.write(`\n📭 No rounds with index < ${String(before)}.\n`);
+      }
+    } finally {
+      store.close();
+    }
+  },
+});
+
 // ---------------------------------------------------------------------------
 // nerve workflow trigger <name>
 // ---------------------------------------------------------------------------
@@ -359,6 +562,7 @@ export const workflowCommand = defineCommand({
  subCommands: {
    list: workflowListCommand,
    inspect: workflowInspectCommand,
+    thread: workflowThreadCommand,
    trigger: workflowTriggerCommand,
  },
 });
@@ -58,6 +58,20 @@ export type ArchiveLogsResult = {
  vacuumed: boolean;
 };

+/** One role round row — keep in sync with daemon `log-store` `ThreadRoundRow`. */
+export type ThreadRoundRow = {
+  round: number;
+  logId: number;
+  ts: number;
+  message: { role: string; content: string; meta: unknown; timestamp: number };
+};
+
+/** Keep in sync with daemon `log-store` `GetThreadRoundsParams`. */
+export type GetThreadRoundsParams = {
+  before: number;
+  limit: number;
+};
+
 /** Subset of daemon LogStore used by the CLI workflow commands. */
 export type LogStore = {
  query: (filter?: LogQuery) => LogEntry[];
@@ -65,6 +79,8 @@ export type LogStore = {
  getActiveWorkflowRuns: (workflowName?: string) => WorkflowRun[];
  getAllWorkflowRuns: (workflowName: string | null) => WorkflowRun[];
  upsertWorkflowRun: (entry: Omit<LogEntry, "id">, run: WorkflowRun) => LogEntry;
+  getThreadRoundCount: (runId: string) => number;
+  getThreadRounds: (runId: string, params: GetThreadRoundsParams) => ThreadRoundRow[];
  archiveLogs: (options?: ArchiveLogsOptions) => ArchiveLogsResult;
  close: () => void;
 };
@@ -6,5 +6,6 @@
    "composite": false,
    "types": ["node"]
  },
-  "include": ["src"]
+  "include": ["src"],
+  "exclude": ["src/__tests__"]
 }
@@ -1,13 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts", "src/cli.ts", "src/daemon-bootstrap.ts"],
-  format: ["esm"],
-  dts: true,
-  clean: true,
-  banner: {
-    js: "#!/usr/bin/env node",
-  },
-  /** Daemon is loaded from workspace node_modules at runtime — never bundle it. */
-  external: ["@uncaged/nerve-daemon"],
-});
@@ -0,0 +1,39 @@
+# @uncaged/nerve-core
+
+Shared types and configuration parser for the [nerve](../../README.md) observation engine.
+
+## What's Inside
+
+- **Type definitions** — `Signal`, `SenseConfig`, `ReflexConfig`, `WorkflowConfig`, `NerveConfig`, and all related types
+- **Config parser** — `parseNerveConfig(yaml)` validates and parses `nerve.yaml` into a typed `NerveConfig`
+- **Result type** — `Result<T>` with `ok()` / `err()` helpers for explicit error handling (no thrown exceptions)
+
+## Usage
+
+```typescript
+import { parseNerveConfig, ok, err } from "@uncaged/nerve-core";
+import type { NerveConfig, Signal, Result } from "@uncaged/nerve-core";
+
+const result: Result<NerveConfig> = parseNerveConfig(yamlString);
+if (result.ok) {
+  console.log(result.value.senses);
+}
+```
+
+## Duration Format
+
+Config fields like `throttle`, `timeout`, and `interval` accept human-readable durations:
+
+- `5s` — 5 seconds
+- `10m` — 10 minutes
+- `1h` — 1 hour
+
+## Install
+
+```bash
+pnpm add @uncaged/nerve-core
+```
+
+## License
+
+MIT
@@ -1,6 +1,6 @@
 {
  "name": "@uncaged/nerve-core",
-  "version": "0.1.4",
+  "version": "0.3.0",
  "type": "module",
  "main": "dist/index.js",
  "files": ["dist"],
@@ -10,13 +10,14 @@
  "types": "dist/index.d.ts",
  "scripts": {
    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
-    "build": "tsup",
+    "build": "rslib build",
    "test": "vitest run"
  },
  "dependencies": {
    "yaml": "^2.8.3"
  },
  "devDependencies": {
+    "@rslib/core": "^0.21.3",
    "vitest": "^4.1.5"
  }
 }
@@ -0,0 +1,19 @@
+import { defineConfig } from "@rslib/core";
+
+export default defineConfig({
+  lib: [
+    {
+      format: "esm",
+      dts: true,
+    },
+  ],
+  source: {
+    entry: {
+      index: "src/index.ts",
+    },
+  },
+  output: {
+    target: "node",
+    cleanDistPath: true,
+  },
+});
@@ -18,9 +18,6 @@ reflexes:
  - sense: memory
    on:
      - high_usage
-  - workflow: alert
-    on:
-      - cpu

 workflows:
  alert:
@@ -48,7 +45,7 @@ describe("parseNerveConfig", () => {
        timeout: 10_000,
        gracePeriod: 3000,
      });
-      expect(result.value.reflexes).toHaveLength(3);
+      expect(result.value.reflexes).toHaveLength(2);
      expect(result.value.reflexes[0]).toEqual({
        kind: "sense",
        sense: "cpu",
@@ -61,11 +58,6 @@ describe("parseNerveConfig", () => {
        interval: null,
        on: ["high_usage"],
      });
-      expect(result.value.reflexes[2]).toEqual({
-        kind: "workflow",
-        workflow: "alert",
-        on: ["cpu"],
-      });
      expect(result.value.workflows?.alert).toEqual({
        concurrency: 2,
        overflow: "queue",
@@ -3,6 +3,7 @@ import { parse } from "yaml";
 import type { Result } from "./result.js";
 import { err, ok } from "./result.js";
 import type { NerveConfig, ReflexConfig, SenseConfig, WorkflowConfig } from "./types.js";
+import { DEFAULT_ENGINE_MAX_ROUNDS } from "./types.js";

 const DURATION_RE = /^(\d+)([smh])$/;

@@ -112,26 +113,6 @@ function parseSenseReflex(
  });
 }

-function parseWorkflowReflex(
-  index: number,
-  obj: Record<string, unknown>,
-  on: string[] | null,
-): Result<ReflexConfig> {
-  if (typeof obj.workflow !== "string") {
-    return err(new Error(`reflexes[${index}].workflow: must be a string`));
-  }
-  if (obj.interval !== undefined) {
-    return err(
-      new Error(`reflexes[${index}]: workflow reflex does not support "interval" (use "on")`),
-    );
-  }
-  return ok({
-    kind: "workflow" as const,
-    workflow: obj.workflow,
-    on,
-  });
-}
-
 function validateReflexConfig(
  index: number,
  raw: unknown,
@@ -143,22 +124,37 @@ function validateReflexConfig(

  const obj = raw as Record<string, unknown>;
  const hasSense = obj.sense !== undefined;
-  const hasWorkflow = obj.workflow !== undefined;
+  const hasWorkflowKey = Object.hasOwn(obj, "workflow");

-  if (hasSense && hasWorkflow) {
-    return err(new Error(`reflexes[${index}]: cannot have both "sense" and "workflow"`));
+  if (hasWorkflowKey) {
+    return err(
+      new Error(
+        `reflexes[${index}]: YAML "workflow" entries are not supported — start workflows from a Sense compute return value using a "workflow" string field (format: name|maxRounds|prompt)`,
+      ),
+    );
  }
-  if (!hasSense && !hasWorkflow) {
-    return err(new Error(`reflexes[${index}]: must have either "sense" or "workflow"`));
+  if (!hasSense) {
+    return err(new Error(`reflexes[${index}]: must include "sense"`));
  }

  const onResult = parseOnField(index, obj);
  if (!onResult.ok) return onResult;

-  if (hasSense) {
-    return parseSenseReflex(index, obj, senseNames, onResult.value);
+  return parseSenseReflex(index, obj, senseNames, onResult.value);
+}
+
+function parseEngineMaxRounds(obj: Record<string, unknown>): Result<number> {
+  if (obj.max_rounds === undefined || obj.max_rounds === null) {
+    return ok(DEFAULT_ENGINE_MAX_ROUNDS);
  }
-  return parseWorkflowReflex(index, obj, onResult.value);
+  if (
+    typeof obj.max_rounds !== "number" ||
+    !Number.isInteger(obj.max_rounds) ||
+    obj.max_rounds < 1
+  ) {
+    return err(new Error("max_rounds: must be a positive integer"));
+  }
+  return ok(obj.max_rounds);
 }

 function validateWorkflowConfig(name: string, raw: unknown): Result<WorkflowConfig> {
@@ -295,16 +291,11 @@ export function parseNerveConfig(raw: string): Result<NerveConfig> {
  const workflowsResult = parseWorkflows(obj);
  if (!workflowsResult.ok) return workflowsResult;

-  // Cross-validate: workflow reflexes must reference defined workflows
-  const workflowNames = new Set(workflowsResult.value ? Object.keys(workflowsResult.value) : []);
-  for (let i = 0; i < reflexesResult.value.length; i++) {
-    const reflex = reflexesResult.value[i];
-    if (reflex.kind === "workflow" && !workflowNames.has(reflex.workflow)) {
-      return err(new Error(`reflexes[${i}].workflow: "${reflex.workflow}" not found in workflows`));
-    }
-  }
+  const maxRoundsResult = parseEngineMaxRounds(obj);
+  if (!maxRoundsResult.ok) return maxRoundsResult;

  return ok({
+    maxRounds: maxRoundsResult.value,
    senses,
    reflexes: reflexesResult.value,
    workflows: workflowsResult.value,
@@ -3,21 +3,25 @@ export type {
  SenseConfig,
  SenseInfo,
  SenseReflexConfig,
-  WorkflowReflexConfig,
  ReflexConfig,
  DropOverflowConfig,
  QueueOverflowConfig,
  WorkflowConfig,
  NerveConfig,
-  CommandEvent,
-  ThreadState,
-  ModerateResult,
-  WorkflowContext,
-  RoleExecuteFn,
+  WorkflowMessage,
+  RoleResult,
  Role,
-  ModerateFn,
+  RoleMeta,
+  StartSignal,
+  RoleSignal,
+  Moderator,
  WorkflowDefinition,
+  SenseResult,
 } from "./types.js";
+export { START, END, DEFAULT_ENGINE_MAX_ROUNDS } from "./types.js";
 export type { Result } from "./result.js";
 export { ok, err } from "./result.js";
 export { parseNerveConfig } from "./config.js";
+
+export type { ParsedSenseWorkflowDirective, SenseComputeRoute } from "./sense-workflow-directive.js";
+export { parseSenseWorkflowDirective, routeSenseComputeOutput } from "./sense-workflow-directive.js";
@@ -0,0 +1,76 @@
+import type { Result } from "./result.js";
+import { err, ok } from "./result.js";
+
+/** Parsed `workflow-name|maxRounds|prompt` from a Sense compute return value. */
+export type ParsedSenseWorkflowDirective = {
+  workflowName: string;
+  maxRounds: number;
+  prompt: string;
+};
+
+/**
+ * Parses the pipe-separated `workflow` field from a Sense compute result.
+ * `prompt` may contain `|` — only the first two pipes delimit name and rounds.
+ */
+export function parseSenseWorkflowDirective(field: string): Result<ParsedSenseWorkflowDirective> {
+  const trimmed = field.trim();
+  if (trimmed.length === 0) {
+    return err(new Error("workflow directive is empty"));
+  }
+  const parts = trimmed.split("|");
+  if (parts.length < 3) {
+    return err(
+      new Error(
+        `workflow directive must be "name|maxRounds|prompt" (got ${String(parts.length)} segment(s))`,
+      ),
+    );
+  }
+  const workflowName = (parts[0] ?? "").trim();
+  if (workflowName.length === 0) {
+    return err(new Error("workflow directive: empty workflow name"));
+  }
+  const roundsRaw = (parts[1] ?? "").trim();
+  const maxRounds = Number.parseInt(roundsRaw, 10);
+  if (!Number.isInteger(maxRounds) || maxRounds < 1) {
+    return err(new Error(`workflow directive: invalid maxRounds "${roundsRaw}"`));
+  }
+  const prompt = parts.slice(2).join("|");
+  return ok({ workflowName, maxRounds, prompt });
+}
+
+export type SenseComputeRoute =
+  | { kind: "launch"; launch: ParsedSenseWorkflowDirective }
+  | { kind: "signal"; payload: unknown };
+
+function stripWorkflowKey(payload: Record<string, unknown>): Record<string, unknown> {
+  const { workflow: _drop, ...rest } = payload;
+  return rest;
+}
+
+/**
+ * Interprets a Sense compute non-null return value for the engine:
+ * - `workflow` missing → normal signal with full payload
+ * - `workflow: null` or `""` → normal signal; `workflow` key stripped from emitted payload
+ * - `workflow: "name|n|prompt"` → launch workflow; no Signal is emitted to the bus
+ */
+export function routeSenseComputeOutput(payload: unknown): SenseComputeRoute {
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+    return { kind: "signal", payload };
+  }
+  const obj = payload as Record<string, unknown>;
+  if (!Object.hasOwn(obj, "workflow")) {
+    return { kind: "signal", payload };
+  }
+  const w = obj.workflow;
+  if (w === null || w === "") {
+    return { kind: "signal", payload: stripWorkflowKey(obj) };
+  }
+  if (typeof w !== "string") {
+    return { kind: "signal", payload };
+  }
+  const parsed = parseSenseWorkflowDirective(w);
+  if (!parsed.ok) {
+    return { kind: "signal", payload: stripWorkflowKey(obj) };
+  }
+  return { kind: "launch", launch: parsed.value };
+}
@@ -28,13 +28,8 @@ export type SenseReflexConfig = {
  on: string[] | null;
 };

-export type WorkflowReflexConfig = {
-  kind: "workflow";
-  workflow: string;
-  on: string[] | null;
-};
-
-export type ReflexConfig = SenseReflexConfig | WorkflowReflexConfig;
+/** Reflexes only schedule Senses; workflow launches come from Sense return values. */
+export type ReflexConfig = SenseReflexConfig;

 export type DropOverflowConfig = {
  concurrency: number;
@@ -50,62 +45,78 @@ export type QueueOverflowConfig = {
 export type WorkflowConfig = DropOverflowConfig | QueueOverflowConfig;

 export type NerveConfig = {
+  /** Engine-wide default max moderator rounds (e.g. CLI workflow trigger when omitted). */
+  maxRounds: number;
  senses: Record<string, SenseConfig>;
  reflexes: ReflexConfig[];
  workflows: Record<string, WorkflowConfig> | null;
 };

 // ---------------------------------------------------------------------------
-// Workflow Engine types (RFC-002)
+// Workflow Automaton types (issue #80)
 // ---------------------------------------------------------------------------

-/** A single event in the command event stream that drives a workflow thread. */
-export type CommandEvent = {
-  type: string;
-  [key: string]: unknown;
-};
+export const START = "__start__" as const;
+export const END = "__end__" as const;
+export type START = typeof START;
+export type END = typeof END;

-/** Accumulated state of a running thread — the event history for moderate(). */
-export type ThreadState = {
-  runId: string;
-  /** All events so far, including the initial thread_start event. */
-  events: CommandEvent[];
-};
+/** Engine-wide fallback for max moderator rounds when not specified in config. */
+export const DEFAULT_ENGINE_MAX_ROUNDS = 100;

-/** The result of moderate() — which role to hand to next, and what prompt to pass. */
-export type ModerateResult = {
+/** A single message in the workflow conversation chain (runtime, type-erased). */
+export type WorkflowMessage = {
  role: string;
-  prompt: unknown;
+  content: string;
+  meta: unknown;
+  timestamp: number;
 };

-/** Context injected into every role execute() call. */
-export type WorkflowContext = {
-  runId: string;
-  workflowName: string;
-  /** Emit a log message back to the parent process. */
-  log: (message: string) => void;
-};
+/** The typed output of a Role execution. */
+export type RoleResult<Meta> = { content: string; meta: Meta };

 /**
- * A role's execute function. Has side effects (API calls, file I/O, etc.).
- * Returns a CommandEvent that is fed back into moderate().
+ * A Role is a pure async function: receives the full message chain,
+ * returns typed content + meta. Implementation can be an agent, LLM call,
+ * script, HTTP request, etc.
 */
-export type RoleExecuteFn = (prompt: unknown, ctx: WorkflowContext) => Promise<CommandEvent>;
+export type Role<Meta> = (messages: WorkflowMessage[]) => Promise<RoleResult<Meta>>;

-/** A role in a workflow — a named unit of execution with side effects. */
-export type Role = {
-  execute: RoleExecuteFn;
+/** Maps role names to their meta types — the single generic that drives all inference. */
+export type RoleMeta = Record<string, Record<string, unknown>>;
+
+/** First message in the thread chain (`messages[0]`) — passed to the moderator on start. */
+export type StartSignal = {
+  role: START;
+  content: string;
+  meta: { maxRounds: number };
+  timestamp: number;
 };

+/** A discriminated union of signals from each role, derived from the meta map. */
+export type RoleSignal<M extends RoleMeta> = {
+  [K in keyof M & string]: { role: K; meta: M[K] };
+}[keyof M & string];
+
 /**
- * The moderator function — pure, no side effects.
- * Decides which role to pass control to next.
- * Returns null to signal thread completion.
+ * The moderator — a pure routing function. Receives the last signal,
+ * current round, and maxRounds. Returns the next role name or END.
 */
-export type ModerateFn = (thread: ThreadState, event: CommandEvent) => ModerateResult | null;
+export type Moderator<M extends RoleMeta> = (
+  signal: StartSignal | RoleSignal<M>,
+  round: number,
+  maxRounds: number,
+) => (keyof M & string) | END;

 /** The complete definition of a workflow, as authored by users. */
-export type WorkflowDefinition = {
-  roles: Record<string, Role>;
-  moderate: ModerateFn;
+export type WorkflowDefinition<M extends RoleMeta> = {
+  name: string;
+  roles: { [K in keyof M & string]: Role<M[K]> };
+  moderator: Moderator<M>;
+};
+
+/** The result of a Sense compute — payload plus optional workflow directive. */
+export type SenseResult = {
+  payload: unknown;
+  workflow: string | null;
 };
@@ -1,8 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts"],
-  format: ["esm"],
-  dts: true,
-  clean: true,
-});
@@ -0,0 +1,57 @@
+# @uncaged/nerve-daemon
+
+The observation engine runtime for [nerve](../../README.md) — runs senses, routes signals, schedules reflexes, and manages workflows.
+
+## Architecture
+
+| Module | Responsibility |
+|--------|---------------|
+| **Kernel** | Top-level orchestrator — spawns workers, wires up signal bus, scheduler, and workflow manager. Supports hot reload and graceful shutdown. |
+| **Sense Runtime** | Per-sense SQLite database (via `node:sqlite` + Drizzle ORM), migration runner, peer DB read access. |
+| **Sense Worker** | Forked child process — one per sense group. Runs compute functions in isolation. |
+| **Signal Bus** | In-memory pub/sub. Sense computes emit signals; reflexes and workflows subscribe. |
+| **Reflex Scheduler** | Drives compute triggers — interval timers, signal-based events, throttle/coalesce logic. |
+| **Workflow Manager** | Concurrency control (drop/queue), thread lifecycle, worker process management (RFC-002). |
+| **Log Store** | Structured log storage in WAL-mode SQLite. Supports retention policies, archival to JSONL, and workflow run tracking. |
+| **Blob Store** | Binary artifact storage for workflow outputs. |
+| **File Watcher** | Watches `nerve.yaml` and sense files for hot reload. |
+| **Daemon IPC** | Unix socket server for CLI ↔ daemon communication. |
+
+## Key Design Decisions
+
+- **One worker process per sense group** — isolation between groups, shared compute within a group
+- **`node:sqlite` (DatabaseSync)** — zero native addons, WAL mode, built into Node.js ≥ 22.5
+- **Throttle + coalesce** — if compute is in-flight, at most one pending trigger is queued (no unbounded accumulation)
+- **Log ≠ Signal** — logs are queryable data assets but cannot trigger reflexes (prevents feedback loops)
+
+## Usage
+
+The daemon is typically started via the CLI (`nerve daemon start`), but can be used programmatically:
+
+```typescript
+import { createKernel } from "@uncaged/nerve-daemon";
+
+const kernel = await createKernel(nerveRoot);
+await kernel.ready;
+
+// Trigger a sense manually
+kernel.triggerSense("cpu-usage");
+
+// Check health
+const health = kernel.getHealth();
+
+// Graceful shutdown
+await kernel.stop();
+```
+
+## Install
+
+```bash
+pnpm add @uncaged/nerve-daemon
+```
+
+Requires Node.js ≥ 22.5 (for `node:sqlite`).
+
+## License
+
+MIT
@@ -1,18 +1,16 @@
 {
  "name": "@uncaged/nerve-daemon",
-  "version": "0.1.5",
+  "version": "0.3.0",
  "type": "module",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
  "publishConfig": {
    "access": "public"
  },
  "scripts": {
    "prepublishOnly": "bash ../../scripts/prepublish-check.sh",
-    "build": "tsup",
+    "build": "rslib build",
    "test": "vitest run"
  },
  "dependencies": {
@@ -21,6 +19,7 @@
    "yaml": "^2.8.3"
  },
  "devDependencies": {
+    "@rslib/core": "^0.21.3",
    "@types/node": "^22.0.0",
    "vitest": "^4.1.5"
  }
@@ -0,0 +1,21 @@
+import { defineConfig } from "@rslib/core";
+
+export default defineConfig({
+  lib: [
+    {
+      format: "esm",
+      dts: true,
+    },
+  ],
+  source: {
+    entry: {
+      index: "src/index.ts",
+      "sense-worker": "src/sense-worker.ts",
+      "workflow-worker": "src/workflow-worker.ts",
+    },
+  },
+  output: {
+    target: "node",
+    cleanDistPath: true,
+  },
+});
@@ -64,6 +64,7 @@ function makeConfig(workflows: Record<string, WorkflowConfig> = {}): NerveConfig
    senses: {},
    reflexes: [],
    workflows,
+    maxRounds: 10,
  };
 }

@@ -90,7 +91,16 @@ function makeLogStore(
      return activeRuns;
    }),
    getTriggerPayload: vi.fn((): unknown => ({ value: 42 })),
-    getThreadEvents: vi.fn((): Array<{ type: string; [key: string]: unknown }> => [{ type: "thread_start", triggerPayload: {} }]),
+    getThreadEvents: vi.fn(
+      (): Array<{ type: string; [key: string]: unknown }> => [
+        { type: "thread_start", triggerPayload: {} },
+      ],
+    ),
+    getThreadMessages: vi.fn(
+      (): Array<{ role: string; content: string; meta: unknown; timestamp: number }> => [],
+    ),
+    getThreadRoundCount: vi.fn(() => 0),
+    getThreadRounds: vi.fn(() => []),
    archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
    close: vi.fn(),
    getAllWorkflowRuns: vi.fn(() => []),
@@ -117,8 +127,8 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("my-wf", { n: 1 });
-      mgr.startWorkflow("my-wf", { n: 2 });
+      mgr.startWorkflow("my-wf", { prompt: "test 1", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test 2", maxRounds: 10 });
      expect(mgr.activeCount("my-wf")).toBe(2);

      // Simulate unexpected exit (not shutdown)
@@ -144,8 +154,8 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("my-wf", {});
-      mgr.startWorkflow("my-wf", {});
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
      expect(mgr.activeCount("my-wf")).toBe(2);

      const child = mockChildren[0];
@@ -169,7 +179,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("my-wf", {});
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
      expect(mockChildren).toHaveLength(1);

      const child = mockChildren[0];
@@ -192,9 +202,8 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
        { runId: "run-started-1", workflow: "my-wf", status: "started" as const, ts: 1000 },
      ];
      const logStore = makeLogStore(activeRuns);
-      logStore.getThreadEvents.mockReturnValue([
-        { type: "thread_start", triggerPayload: {} },
-        { type: "scan_complete", items: ["a"] },
+      logStore.getThreadMessages.mockReturnValue([
+        { role: "scanner", content: "done", meta: { items: ["a"] }, timestamp: 1000 },
      ]);
      logStore.getTriggerPayload.mockReturnValue({ trigger: "initial" });

@@ -203,7 +212,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("my-wf", {});
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
      const firstChild = mockChildren[0];
      firstChild.exitCode = 1;
      firstChild.connected = false;
@@ -228,7 +237,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
        runId: "run-started-1",
        triggerPayload: { trigger: "initial" },
      });
-      expect(Array.isArray((resumeCalls[0][0] as Record<string, unknown>).events)).toBe(true);
+      expect(Array.isArray((resumeCalls[0][0] as Record<string, unknown>).messages)).toBe(true);

      const stopPromise = mgr.stop();
      await vi.runAllTimersAsync();
@@ -248,7 +257,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

      // Start one thread to fill the concurrency slot (so queued run stays queued on respawn)
-      mgr.startWorkflow("my-wf", {});
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
      const firstChild = mockChildren[0];
      firstChild.exitCode = 1;
      firstChild.connected = false;
@@ -265,34 +274,33 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
    });
  });

-  describe("command events are persisted (for crash recovery replay)", () => {
-    it("persists thread_command_event when worker sends thread-command-event IPC", async () => {
+  describe("workflow messages are persisted (for crash recovery replay)", () => {
+    it("persists thread_workflow_message when worker sends thread-workflow-message IPC", async () => {
      const logStore = makeLogStore();
      const config = makeConfig({
        "my-wf": { concurrency: 1, overflow: "drop" },
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("my-wf", { x: 1 });
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });

      const child = mockChildren[0];
      const startCall = (child.send as ReturnType<typeof vi.fn>).mock.calls[0];
      const runId = (startCall[0] as Record<string, unknown>).runId as string;

-      // Simulate worker sending a command event back
      child.emit("message", {
-        type: "thread-command-event",
+        type: "thread-workflow-message",
        runId,
-        event: { type: "scan_complete", items: ["a", "b"] },
+        message: { role: "scanner", content: "done", meta: { items: ["a", "b"] }, timestamp: 1000 },
      });

      const appendCalls = logStore.append.mock.calls.filter(
-        (args: any[]) => (args[0] as { type: string }).type === "thread_command_event",
+        (args: any[]) => (args[0] as { type: string }).type === "thread_workflow_message",
      );
      expect(appendCalls).toHaveLength(1);
      expect(appendCalls[0][0]).toMatchObject({
        source: "workflow",
-        type: "thread_command_event",
+        type: "thread_workflow_message",
        refId: runId,
      });

@@ -310,7 +318,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      const payload = { task: "build-docker", repo: "myrepo" };
+      const payload = { prompt: "build-docker for myrepo", maxRounds: 10 };
      mgr.startWorkflow("my-wf", payload);

      const startedCall = logStore.upsertWorkflowRun.mock.calls.find(
@@ -342,7 +350,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

      // Start one thread to fill the concurrency slot
-      mgr.startWorkflow("my-wf", {});
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
      const firstChild = mockChildren[0];

      // Crash once → respawn → crash again → second respawn
@@ -370,7 +378,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
        { runId: "run-started-dup", workflow: "my-wf", status: "started" as const, ts: 1000 },
      ];
      const logStore = makeLogStore(activeRuns);
-      logStore.getThreadEvents.mockReturnValue([{ type: "thread_start", triggerPayload: {} }]);
+      logStore.getThreadMessages.mockReturnValue([]);
      logStore.getTriggerPayload.mockReturnValue({ s: 1 });

      const config = makeConfig({
@@ -378,7 +386,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("my-wf", {});
+      mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
      const firstChild = mockChildren[0];
      firstChild.exitCode = 1;
      firstChild.connected = false;
@@ -408,7 +416,7 @@ describe("WorkflowManager — crash recovery (Phase 3)", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("crash-wf", {});
+      mgr.startWorkflow("crash-wf", { prompt: "test", maxRounds: 10 });

      // Crash the worker 6 times in rapid succession (within CRASH_WINDOW_MS = 60s)
      for (let i = 0; i < 6; i++) {
@@ -63,7 +63,10 @@ function sendRaw(path: string, message: object): Promise<object> {
 }

 beforeEach(() => {
-  sockPath = join(tmpdir(), `nerve-ipc-test-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`);
+  sockPath = join(
+    tmpdir(),
+    `nerve-ipc-test-${Date.now()}-${Math.random().toString(36).slice(2)}.sock`,
+  );
 });

 afterEach(async () => {
@@ -62,7 +62,7 @@ const { createWorkflowManager } = await import("../workflow-manager.js");
 const { createKernel } = await import("../kernel.js");

 function makeWfConfig(workflows: Record<string, WorkflowConfig> = {}): NerveConfig {
-  return { senses: {}, reflexes: [], workflows };
+  return { senses: {}, reflexes: [], workflows, maxRounds: 10 };
 }

 function makeLogStore() {
@@ -77,6 +77,9 @@ function makeLogStore() {
    getActiveWorkflowRuns: vi.fn(() => []),
    getTriggerPayload: vi.fn(() => null),
    getThreadEvents: vi.fn(() => []),
+    getThreadMessages: vi.fn(() => []),
+    getThreadRoundCount: vi.fn(() => 0),
+    getThreadRounds: vi.fn(() => []),
    archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
    close: vi.fn(),
    getAllWorkflowRuns: vi.fn(() => []),
@@ -99,7 +102,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
    const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
    const mgr = createWorkflowManager("/nerve-root", config, logStore);

-    mgr.startWorkflow("my-wf", {});
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
    expect(mockChildren).toHaveLength(1);

    // Remove workflow from config before drain completes
@@ -118,8 +121,8 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
    const config = makeWfConfig({ "my-wf": { concurrency: 2, overflow: "drop" } });
    const mgr = createWorkflowManager("/nerve-root", config, logStore);

-    mgr.startWorkflow("my-wf", { n: 1 });
-    mgr.startWorkflow("my-wf", { n: 2 });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
    expect(mgr.activeCount("my-wf")).toBe(2);

    const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -150,7 +153,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
    const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
    const mgr = createWorkflowManager("/nerve-root", config, logStore);

-    mgr.startWorkflow("my-wf", {});
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
    expect(mockChildren).toHaveLength(1);

    const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -166,7 +169,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
    const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
    const mgr = createWorkflowManager("/nerve-root", config, logStore);

-    mgr.startWorkflow("my-wf", {});
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
    expect(mockChildren).toHaveLength(1);

    const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
@@ -183,7 +186,7 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
    const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
    const mgr = createWorkflowManager("/nerve-root", config, logStore);

-    mgr.startWorkflow("my-wf", {});
+    mgr.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });

    const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
    await vi.runAllTimersAsync();
@@ -208,14 +211,14 @@ describe("WorkflowManager — drainAndRespawn (Phase 3 hot reload)", () => {
    const config = makeWfConfig({ "my-wf": { concurrency: 1, overflow: "drop" } });
    const mgr = createWorkflowManager("/nerve-root", config, logStore);

-    mgr.startWorkflow("my-wf", { first: true });
+    mgr.startWorkflow("my-wf", { prompt: "first", maxRounds: 10 });

    const drainPromise = mgr.drainAndRespawn("my-wf", 5000);
    await vi.runAllTimersAsync();
    await drainPromise;

    // Start a new thread on the fresh worker
-    mgr.startWorkflow("my-wf", { second: true });
+    mgr.startWorkflow("my-wf", { prompt: "second", maxRounds: 10 });

    const newChild = mockChildren[1];
    const startCalls = (newChild.send as ReturnType<typeof vi.fn>).mock.calls.filter(
@@ -247,8 +250,9 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
    const logStore = makeLogStore();
    const config: NerveConfig = {
      senses: {},
-      reflexes: [{ kind: "workflow", workflow: "my-wf", on: null }],
+      reflexes: [{ kind: "workflow", workflow: "my-wf", on: null } as any],
      workflows: { "my-wf": { concurrency: 1, overflow: "drop" } },
+      maxRounds: 10,
    };

    const kernel = createKernel(config, "/tmp/nerve-hot-reload-test", {
@@ -257,7 +261,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
    });

    // Trigger a workflow thread so a worker is spawned
-    kernel.workflowManager.startWorkflow("my-wf", {});
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });

    // Manually call drainAndRespawn (simulating what kernel does on workflow file change)
    const drainPromise = kernel.workflowManager.drainAndRespawn("my-wf", 1000);
@@ -267,7 +271,9 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
    // Kernel's handleWorkflowFileChange should log a workflow_reload event
    // We test this via the kernel itself
    const appendCalls = logStore.append.mock.calls;
-    const startCall = appendCalls.find((args: any[]) => (args[0] as { type: string }).type === "start");
+    const startCall = appendCalls.find(
+      (args: any[]) => (args[0] as { type: string }).type === "start",
+    );
    expect(startCall).toBeDefined();

    const stopPromise = kernel.stop();
@@ -279,8 +285,9 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
    const logStore = makeLogStore();
    const initialConfig: NerveConfig = {
      senses: {},
-      reflexes: [{ kind: "workflow", workflow: "old-wf", on: null }],
+      reflexes: [{ kind: "workflow", workflow: "old-wf", on: null } as any],
      workflows: { "old-wf": { concurrency: 1, overflow: "drop" } },
+      maxRounds: 10,
    };

    const kernel = createKernel(initialConfig, "/tmp/nerve-hot-reload-test", {
@@ -289,7 +296,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
    });

    // Spawn a worker for old-wf
-    kernel.workflowManager.startWorkflow("old-wf", {});
+    kernel.workflowManager.startWorkflow("old-wf", { prompt: "test", maxRounds: 10 });
    expect(mockChildren).toHaveLength(1);

    // Reload config without old-wf
@@ -297,6 +304,7 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
      senses: {},
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    };
    kernel.reloadConfig(newConfig);

@@ -316,8 +324,9 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
    const logStore = makeLogStore();
    const initialConfig: NerveConfig = {
      senses: {},
-      reflexes: [{ kind: "workflow", workflow: "my-wf", on: null }],
+      reflexes: [{ kind: "workflow", workflow: "my-wf", on: null } as any],
      workflows: { "my-wf": { concurrency: 1, overflow: "drop" } },
+      maxRounds: 10,
    };

    const kernel = createKernel(initialConfig, "/tmp/nerve-hot-reload-test", {
@@ -325,14 +334,15 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
      logStore,
    });

-    kernel.workflowManager.startWorkflow("my-wf", {});
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
    const workersBefore = mockChildren.length;

    // Reload with updated concurrency — should NOT spawn a new workflow worker
    const newConfig: NerveConfig = {
      senses: {},
-      reflexes: [{ kind: "workflow", workflow: "my-wf", on: null }],
+      reflexes: [{ kind: "workflow", workflow: "my-wf", on: null } as any],
      workflows: { "my-wf": { concurrency: 5, overflow: "queue", maxQueue: 50 } },
+      maxRounds: 10,
    };
    kernel.reloadConfig(newConfig);

@@ -344,8 +354,8 @@ describe("Kernel — workflow hot reload via file-watcher (Phase 3)", () => {
    expect(kernel.workflowManager.activeCount("my-wf")).toBe(1);

    // Can now start up to 5 concurrent threads (previously only 1)
-    kernel.workflowManager.startWorkflow("my-wf", { n: 2 });
-    kernel.workflowManager.startWorkflow("my-wf", { n: 3 });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
+    kernel.workflowManager.startWorkflow("my-wf", { prompt: "test", maxRounds: 10 });
    expect(kernel.workflowManager.activeCount("my-wf")).toBe(3);

    const stopPromise = kernel.stop();
@@ -27,6 +27,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
    },
    reflexes: [],
    workflows: null,
+    maxRounds: 10,
    ...overrides,
  };
 }
@@ -74,6 +74,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
    },
    reflexes: [],
    workflows: null,
+    maxRounds: 10,
    ...overrides,
  };
 }
@@ -180,6 +181,7 @@ describe("kernel — reloadConfig", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    });

    expect(kernel.groups.has("network")).toBe(true);
@@ -196,6 +198,7 @@ describe("kernel — reloadConfig", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    };
    const kernel = createKernel(config, "/tmp/nerve-test");

@@ -210,6 +213,7 @@ describe("kernel — reloadConfig", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    });

    expect(kernel.groups.has("network")).toBe(false);
@@ -232,6 +236,7 @@ describe("kernel — reloadConfig", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    });

    expect(kernel.getHealth().activeSenses).toBe(2);
@@ -74,6 +74,9 @@ function makeMockLogStore() {
    getAllWorkflowRuns: vi.fn(() => []),
    getTriggerPayload: vi.fn(() => null),
    getThreadEvents: vi.fn(() => []),
+    getThreadMessages: vi.fn(() => []),
+    getThreadRoundCount: vi.fn(() => 0),
+    getThreadRounds: vi.fn(() => []),
    archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
    close: vi.fn(),
  };
@@ -90,6 +93,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
    },
    reflexes: [],
    workflows: null,
+    maxRounds: 10,
    ...overrides,
  };
 }
@@ -191,9 +195,7 @@ describe("kernel.triggerSense()", () => {

    // Should not throw even when the worker is disconnected
    expect(() => kernel.triggerSense("cpu-usage")).not.toThrow();
-    expect(worker.send).not.toHaveBeenCalledWith(
-      expect.objectContaining({ type: "compute" }),
-    );
+    expect(worker.send).not.toHaveBeenCalledWith(expect.objectContaining({ type: "compute" }));

    await kernel.stop();
  }, 10_000);
@@ -81,6 +81,9 @@ function makeLogStore() {
    getAllWorkflowRuns: vi.fn(() => []),
    getTriggerPayload: vi.fn(() => null),
    getThreadEvents: vi.fn(() => []),
+    getThreadMessages: vi.fn(() => []),
+    getThreadRoundCount: vi.fn(() => 0),
+    getThreadRounds: vi.fn(() => []),
    archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
    close: vi.fn(),
  };
@@ -93,6 +96,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
    },
    reflexes: [],
    workflows: null,
+    maxRounds: 10,
    ...overrides,
  };
 }
@@ -119,7 +123,7 @@ describe("kernel + workflowManager integration", () => {
        senses: {
          "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
        },
-        reflexes: [{ kind: "workflow", workflow: "my-workflow", on: ["cpu-usage"] }],
+        reflexes: [{ kind: "workflow", workflow: "my-workflow", on: ["cpu-usage"] } as any],
        workflows: { "my-workflow": { concurrency: 2, overflow: "drop" } },
      });

@@ -157,7 +161,7 @@ describe("kernel + workflowManager integration", () => {
        senses: {
          "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
        },
-        reflexes: [{ kind: "workflow", workflow: "alert-workflow", on: ["cpu-usage"] }],
+        reflexes: [{ kind: "workflow", workflow: "alert-workflow", on: ["cpu-usage"] } as any],
        workflows: { "alert-workflow": { concurrency: 1, overflow: "drop" } },
      });

@@ -198,7 +202,7 @@ describe("kernel + workflowManager integration", () => {
          "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
          "disk-io": { group: "system", throttle: null, timeout: null, gracePeriod: null },
        },
-        reflexes: [{ kind: "workflow", workflow: "my-workflow", on: ["disk-io"] }],
+        reflexes: [{ kind: "workflow", workflow: "my-workflow", on: ["disk-io"] } as any],
        workflows: { "my-workflow": { concurrency: 1, overflow: "drop" } },
      });

@@ -234,7 +238,7 @@ describe("kernel + workflowManager integration", () => {
        senses: {
          "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
        },
-        reflexes: [{ kind: "workflow", workflow: "log-test-workflow", on: ["cpu-usage"] }],
+        reflexes: [{ kind: "workflow", workflow: "log-test-workflow", on: ["cpu-usage"] } as any],
        workflows: { "log-test-workflow": { concurrency: 2, overflow: "drop" } },
      });

@@ -265,6 +269,7 @@ describe("kernel + workflowManager integration", () => {
        },
        reflexes: [],
        workflows: null,
+    maxRounds: 10,
      });

      const kernel = createKernel(initialConfig, "/tmp/nerve-test", {
@@ -277,8 +282,9 @@ describe("kernel + workflowManager integration", () => {
        senses: {
          "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
        },
-        reflexes: [{ kind: "workflow", workflow: "new-workflow", on: ["cpu-usage"] }],
+        reflexes: [{ kind: "workflow", workflow: "new-workflow", on: ["cpu-usage"] } as any],
        workflows: { "new-workflow": { concurrency: 1, overflow: "drop" } },
+        maxRounds: 10,
      };
      kernel.reloadConfig(newConfig);

@@ -308,7 +314,7 @@ describe("kernel + workflowManager integration", () => {
        senses: {
          "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
        },
-        reflexes: [{ kind: "workflow", workflow: "old-workflow", on: ["cpu-usage"] }],
+        reflexes: [{ kind: "workflow", workflow: "old-workflow", on: ["cpu-usage"] } as any],
        workflows: { "old-workflow": { concurrency: 1, overflow: "drop" } },
      });

@@ -324,6 +330,7 @@ describe("kernel + workflowManager integration", () => {
        },
        reflexes: [],
        workflows: null,
+    maxRounds: 10,
      };
      kernel.reloadConfig(newConfig);

@@ -359,7 +366,7 @@ describe("kernel + workflowManager integration", () => {
        senses: {
          "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
        },
-        reflexes: [{ kind: "workflow", workflow: "shutdown-test", on: ["cpu-usage"] }],
+        reflexes: [{ kind: "workflow", workflow: "shutdown-test", on: ["cpu-usage"] } as any],
        workflows: { "shutdown-test": { concurrency: 1, overflow: "drop" } },
      });

@@ -401,7 +408,7 @@ describe("kernel + workflowManager integration", () => {
        senses: {
          "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
        },
-        reflexes: [{ kind: "workflow", workflow: "health-wf", on: ["cpu-usage"] }],
+        reflexes: [{ kind: "workflow", workflow: "health-wf", on: ["cpu-usage"] } as any],
        workflows: { "health-wf": { concurrency: 2, overflow: "drop" } },
      });

@@ -60,6 +60,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
    },
    reflexes: [],
    workflows: null,
+    maxRounds: 10,
    ...overrides,
  };
 }
@@ -200,6 +201,7 @@ describe("kernel — groupForSense mapping", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    };
    const kernel = createKernel(config, "/tmp/nerve-test");

@@ -195,4 +195,65 @@ describe("LogStore — crash recovery helpers (Phase 3)", () => {
      expect(result8[0].type).toBe("event_for_8");
    });
  });
+
+  describe("getThreadRoundCount / getThreadRounds", () => {
+    it("excludes thread_start from rounds and assigns ROW_NUMBER in chronological order", () => {
+      store.append({
+        source: "workflow",
+        type: "thread_command_event",
+        refId: "run-tr",
+        payload: JSON.stringify({ type: "thread_start", triggerPayload: { x: 1 } }),
+        ts: 100,
+      });
+      store.append({
+        source: "workflow",
+        type: "thread_command_event",
+        refId: "run-tr",
+        payload: JSON.stringify({
+          type: "step_a",
+          role: "alpha",
+          content: "hello",
+          meta: 1,
+        }),
+        ts: 101,
+      });
+      store.append({
+        source: "workflow",
+        type: "thread_command_event",
+        refId: "run-tr",
+        payload: JSON.stringify({ type: "step_b", role: "beta", content: "world" }),
+        ts: 102,
+      });
+
+      expect(store.getThreadRoundCount("run-tr")).toBe(2);
+
+      const all = store.getThreadRounds("run-tr", { before: 0, limit: 50 });
+      expect(all).toHaveLength(2);
+      expect(all.map((r) => r.round)).toEqual([2, 1]);
+      expect(all[0].message.role).toBe("beta");
+      expect(all[1].message.role).toBe("alpha");
+    });
+
+    it("getThreadRounds respects exclusive before bound", () => {
+      for (let i = 0; i < 3; i++) {
+        store.append({
+          source: "workflow",
+          type: "thread_command_event",
+          refId: "run-b4",
+          payload: JSON.stringify({ type: `ev_${i}`, role: "r", content: String(i) }),
+          ts: 200 + i,
+        });
+      }
+
+      expect(store.getThreadRoundCount("run-b4")).toBe(3);
+
+      const page = store.getThreadRounds("run-b4", { before: 3, limit: 50 });
+      expect(page.map((r) => r.round)).toEqual([2, 1]);
+    });
+
+    it("returns empty when no role rounds for runId", () => {
+      expect(store.getThreadRoundCount("missing")).toBe(0);
+      expect(store.getThreadRounds("missing", { before: 0, limit: 10 })).toHaveLength(0);
+    });
+  });
 });
@@ -30,6 +30,7 @@ describe("LogStore + ReflexScheduler integration", () => {
      },
      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: null, on: ["cpu-usage"] }],
      workflows: null,
+    maxRounds: 10,
    };
    const bus = createSignalBus();
    const triggered: string[] = [];
@@ -57,6 +58,7 @@ describe("LogStore + ReflexScheduler integration", () => {
      },
      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: 1000, on: null }],
      workflows: null,
+    maxRounds: 10,
    };
    const bus = createSignalBus();
    const ref: { scheduler: ReturnType<typeof createReflexScheduler> | null } = { scheduler: null };
@@ -87,6 +89,7 @@ describe("LogStore + ReflexScheduler integration", () => {
      },
      reflexes: [{ kind: "sense", sense: "cpu-usage", interval: null, on: ["cpu-usage"] }],
      workflows: null,
+    maxRounds: 10,
    };
    const bus = createSignalBus();
    const triggered: string[] = [];
@@ -24,6 +24,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
    },
    reflexes: [],
    workflows: null,
+    maxRounds: 10,
    ...overrides,
  };
 }
@@ -136,6 +137,7 @@ describe("phase6 — reloadConfig", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    };

    kernel.reloadConfig(newConfig);
@@ -155,6 +157,7 @@ describe("phase6 — reloadConfig", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    };
    kernel = createKernel(config, "/tmp/nerve-phase6-test", {
      workerScript: MOCK_WORKER,
@@ -169,6 +172,7 @@ describe("phase6 — reloadConfig", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    };

    kernel.reloadConfig(newConfig);
@@ -199,6 +203,7 @@ describe("phase6 — error isolation", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    };

    kernel = createKernel(config, "/tmp/nerve-phase6-test", {
@@ -302,6 +307,7 @@ describe("phase6 — getHealth", () => {
      },
      reflexes: [],
      workflows: null,
+    maxRounds: 10,
    };
    kernel.reloadConfig(newConfig);

@@ -11,6 +11,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
    },
    reflexes: [],
    workflows: null,
+    maxRounds: 10,
    ...overrides,
  };
 }
@@ -17,6 +17,7 @@ function makeConfig(overrides: Partial<NerveConfig> = {}): NerveConfig {
    },
    reflexes: [],
    workflows: null,
+    maxRounds: 10,
    ...overrides,
  };
 }
@@ -290,10 +291,11 @@ describe("ReflexScheduler — workflow reflexes ignored", () => {
  it("does not set up any scheduling for workflow kind reflexes", () => {
    const triggered: string[] = [];
    const config: NerveConfig = {
+      maxRounds: 10,
      senses: {
        "cpu-usage": { group: "system", throttle: null, timeout: null, gracePeriod: null },
      },
-      reflexes: [{ kind: "workflow", workflow: "my-workflow", on: ["cpu-usage"] }],
+      reflexes: [{ kind: "workflow", workflow: "my-workflow", on: ["cpu-usage"] } as any],
      workflows: {
        "my-workflow": { concurrency: 1, overflow: "drop" },
      },
@@ -74,6 +74,9 @@ function makeLogStore() {
    getActiveWorkflowRuns: vi.fn(() => []),
    getTriggerPayload: vi.fn(() => null),
    getThreadEvents: vi.fn(() => []),
+    getThreadMessages: vi.fn(() => []),
+    getThreadRoundCount: vi.fn(() => 0),
+    getThreadRounds: vi.fn(() => []),
    archiveLogs: vi.fn(() => ({ days: [], vacuumed: false })),
    close: vi.fn(),
    getAllWorkflowRuns: vi.fn(() => []),
@@ -82,6 +85,7 @@ function makeLogStore() {

 function makeConfig(overrides: Partial<NerveConfig["workflows"]> = {}): NerveConfig {
  return {
+    maxRounds: 10,
    senses: {},
    reflexes: [],
    workflows: overrides as NerveConfig["workflows"],
@@ -111,7 +115,7 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("my-workflow", { event: "test" });
+      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10 });

      expect(mockChildren).toHaveLength(1);
      expect(mockChildren[0].send).toHaveBeenCalledWith(
@@ -127,8 +131,8 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("my-workflow", { n: 1 });
-      mgr.startWorkflow("my-workflow", { n: 2 });
+      mgr.startWorkflow("my-workflow", { prompt: "test 1", maxRounds: 10 });
+      mgr.startWorkflow("my-workflow", { prompt: "test 2", maxRounds: 10 });

      // Only one forked child — worker is reused
      expect(mockChildren).toHaveLength(1);
@@ -143,7 +147,7 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("my-workflow", { x: 1 });
+      mgr.startWorkflow("my-workflow", { prompt: "test", maxRounds: 10 });

      expect(logStore.upsertWorkflowRun).toHaveBeenCalledWith(
        expect.objectContaining({ source: "workflow", type: "started" }),
@@ -160,9 +164,9 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("drop-wf", { first: true });
+      mgr.startWorkflow("drop-wf", { prompt: "first", maxRounds: 10 });
      // now at limit — second call should be dropped
-      mgr.startWorkflow("drop-wf", { second: true });
+      mgr.startWorkflow("drop-wf", { prompt: "second", maxRounds: 10 });

      expect(mgr.activeCount("drop-wf")).toBe(1);
      expect(mgr.queueLength("drop-wf")).toBe(0);
@@ -177,8 +181,8 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("drop-wf", {});
-      mgr.startWorkflow("drop-wf", {});
+      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("drop-wf", { prompt: "test", maxRounds: 10 });

      const droppedCall = logStore.upsertWorkflowRun.mock.calls.find(
        ([entry]) => entry.type === "dropped",
@@ -195,8 +199,8 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("queue-wf", { first: true });
-      mgr.startWorkflow("queue-wf", { second: true });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });

      expect(mgr.activeCount("queue-wf")).toBe(1);
      expect(mgr.queueLength("queue-wf")).toBe(1);
@@ -209,8 +213,8 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("queue-wf", {});
-      mgr.startWorkflow("queue-wf", {});
+      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "test", maxRounds: 10 });

      const queuedCall = logStore.upsertWorkflowRun.mock.calls.find(
        ([entry]) => entry.type === "queued",
@@ -229,12 +233,12 @@ describe("WorkflowManager", () => {
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

      // Fill the concurrency slot
-      mgr.startWorkflow("queue-wf", { n: 0 });
+      mgr.startWorkflow("queue-wf", { prompt: "test 0", maxRounds: 10 });
      // Fill the queue to maxQueue
-      mgr.startWorkflow("queue-wf", { n: 1 });
-      mgr.startWorkflow("queue-wf", { n: 2 });
-      // This one should push out { n: 1 }
-      mgr.startWorkflow("queue-wf", { n: 3 });
+      mgr.startWorkflow("queue-wf", { prompt: "test 1", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "test 2", maxRounds: 10 });
+      // This one should push out the oldest
+      mgr.startWorkflow("queue-wf", { prompt: "test 3", maxRounds: 10 });

      // Queue should still be at maxQueue (2)
      expect(mgr.queueLength("queue-wf")).toBe(2);
@@ -255,8 +259,8 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("queue-wf", { first: true });
-      mgr.startWorkflow("queue-wf", { second: true });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });

      expect(mgr.activeCount("queue-wf")).toBe(1);
      expect(mgr.queueLength("queue-wf")).toBe(1);
@@ -290,8 +294,8 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("queue-wf", { first: true });
-      mgr.startWorkflow("queue-wf", { second: true });
+      mgr.startWorkflow("queue-wf", { prompt: "first", maxRounds: 10 });
+      mgr.startWorkflow("queue-wf", { prompt: "second", maxRounds: 10 });

      const child = mockChildren[0];
      const firstRunId = (child.send as ReturnType<typeof vi.fn>).mock.calls[0][0].runId as string;
@@ -317,8 +321,8 @@ describe("WorkflowManager", () => {
      });
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("wf-a", {});
-      mgr.startWorkflow("wf-b", {});
+      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10 });
+      mgr.startWorkflow("wf-b", { prompt: "test", maxRounds: 10 });

      // Two distinct workers should have been forked
      expect(mockChildren).toHaveLength(2);
@@ -344,7 +348,7 @@ describe("WorkflowManager", () => {
      await vi.runAllTimersAsync();
      await stopPromise;

-      mgr.startWorkflow("wf-a", {});
+      mgr.startWorkflow("wf-a", { prompt: "test", maxRounds: 10 });

      // No worker should have been spawned
      expect(mockChildren).toHaveLength(0);
@@ -357,7 +361,7 @@ describe("WorkflowManager", () => {
      const config = makeConfig({});
      const mgr = createWorkflowManager("/nerve-root", config, logStore);

-      mgr.startWorkflow("no-such-workflow", {});
+      mgr.startWorkflow("no-such-workflow", { prompt: "test", maxRounds: 10 });

      expect(mockChildren).toHaveLength(0);
      expect(logStore.upsertWorkflowRun).not.toHaveBeenCalled();
@@ -23,7 +23,8 @@ export type { SenseInfo };
 export type TriggerWorkflowRequest = {
  type: "trigger-workflow";
  workflow: string;
-  payload: unknown;
+  prompt: string;
+  maxRounds: number;
 };

 /** JSON message sent by the CLI to trigger a sense compute on-demand. */
@@ -55,7 +56,9 @@ function parseRequest(line: string): DaemonRequest | null {
    const req = obj as Record<string, unknown>;
    if (req.type === "trigger-workflow") {
      if (typeof req.workflow !== "string" || req.workflow.length === 0) return null;
-      return { type: "trigger-workflow", workflow: req.workflow, payload: req.payload ?? {} };
+      if (typeof req.prompt !== "string") return null;
+      if (typeof req.maxRounds !== "number") return null;
+      return { type: "trigger-workflow", workflow: req.workflow, prompt: req.prompt, maxRounds: req.maxRounds as number };
    }
    if (req.type === "trigger-sense") {
      if (typeof req.sense !== "string" || req.sense.length === 0) return null;
@@ -102,7 +105,7 @@ export function createDaemonIpcServer(

    try {
      if (req.type === "trigger-workflow") {
-        workflowManager.startWorkflow(req.workflow, req.payload);
+        workflowManager.startWorkflow(req.workflow, { prompt: req.prompt, maxRounds: req.maxRounds });
        const resp: DaemonResponse = { ok: true };
        socket.write(`${JSON.stringify(resp)}\n`);
      } else if (req.type === "trigger-sense") {
@@ -12,6 +12,7 @@ export type {
  ResumeThreadMessage,
  ThreadEventMessage,
  WorkflowErrorMessage,
+  ThreadWorkflowMessageMessage,
 } from "./ipc.js";

 export type { SignalBus, SignalHandler, Unsubscribe } from "./signal-bus.js";
@@ -47,6 +48,8 @@ export type {
  ArchiveLogsDayResult,
  ArchiveLogsOptions,
  ArchiveLogsResult,
+  ThreadRoundRow,
+  GetThreadRoundsParams,
 } from "./log-store.js";

 export { createWorkflowManager } from "./workflow-manager.js";
@@ -31,18 +31,19 @@ export type StartThreadMessage = {
  type: "start-thread";
  runId: string;
  workflow: string;
-  /** The trigger payload from the Reflex that initiated this thread. */
-  triggerPayload: unknown;
+  prompt: string;
+  /** Safety-valve: max moderator rounds for this thread (engine launch parameter). */
+  maxRounds: number;
 };

 /** Parent → Workflow Worker: resume an existing thread after crash recovery */
 export type ResumeThreadMessage = {
  type: "resume-thread";
  runId: string;
-  /** Serialised CommandEvent history to rebuild ThreadState. */
-  events: Array<{ type: string; [key: string]: unknown }>;
-  /** Serialised trigger payload (the same value as in the original start-thread). */
-  triggerPayload: unknown;
+  /** 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;
 };

 /** Union of all messages the parent sends to a worker */
@@ -103,12 +104,12 @@ export type WorkflowErrorMessage = {
  error: string;
 };

-/** Workflow Worker → Parent: a thread CommandEvent produced by a role (for crash recovery). */
-export type ThreadCommandEventMessage = {
-  type: "thread-command-event";
+/** Workflow Worker → Parent: a WorkflowMessage produced by a role (for crash recovery). */
+export type ThreadWorkflowMessageMessage = {
+  type: "thread-workflow-message";
  runId: string;
-  /** The CommandEvent returned by role.execute() — will be persisted for crash recovery. */
-  event: { type: string; [key: string]: unknown };
+  /** 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 */
@@ -119,7 +120,7 @@ export type WorkerToParentMessage =
  | HealthResponseMessage
  | ThreadEventMessage
  | WorkflowErrorMessage
-  | ThreadCommandEventMessage;
+  | ThreadWorkflowMessageMessage;

 const PARENT_MSG_TYPES = new Set([
  "compute",
@@ -132,14 +133,16 @@ const PARENT_MSG_TYPES = new Set([
 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 (!("triggerPayload" in obj)) return "'start-thread' message missing 'triggerPayload'";
+  if (typeof obj.prompt !== "string") return "'start-thread' message missing string 'prompt'";
+  if (typeof obj.maxRounds !== "number") return "'start-thread' message missing number 'maxRounds'";
  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.events)) return "'resume-thread' message missing 'events' array";
-  if (!("triggerPayload" in obj)) return "'resume-thread' message missing 'triggerPayload'";
+  if (!Array.isArray(obj.messages)) return "'resume-thread' message missing 'messages' array";
+  if (typeof obj.maxRounds !== "number")
+    return "'resume-thread' message missing number 'maxRounds'";
  return null;
 }

@@ -245,24 +248,34 @@ const WORKER_MSG_TYPES = new Set([
  "health-response",
  "thread-event",
  "workflow-error",
-  "thread-command-event",
+  "thread-workflow-message",
 ]);

-function parseThreadCommandEventMsg(
+function parseThreadWorkflowMessageMsg(
  obj: Record<string, unknown>,
  raw: unknown,
 ): Result<WorkerToParentMessage> {
  if (typeof obj.runId !== "string") {
-    return err(new Error("Worker 'thread-command-event' message missing string 'runId' field"));
+    return err(new Error("Worker 'thread-workflow-message' missing string 'runId' field"));
  }
-  if (obj.event === null || typeof obj.event !== "object") {
-    return err(new Error("Worker 'thread-command-event' message missing object 'event' field"));
+  if (obj.message === null || typeof obj.message !== "object") {
+    return err(new Error("Worker 'thread-workflow-message' missing object 'message' field"));
  }
-  const event = obj.event as Record<string, unknown>;
-  if (typeof event.type !== "string") {
-    return err(new Error("Worker 'thread-command-event' event missing string 'type' field"));
+  const msg = obj.message as Record<string, unknown>;
+  if (typeof msg.role !== "string") {
+    return err(new Error("Worker 'thread-workflow-message' message missing string 'role' field"));
  }
-  return ok(raw as ThreadCommandEventMessage);
+  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(raw as ThreadWorkflowMessageMessage);
 }

 /** Validate and parse an unknown IPC message received from a worker process. */
@@ -282,6 +295,6 @@ export function parseWorkerMessage(raw: unknown): Result<WorkerToParentMessage>
  if (obj.type === "health-response") return parseHealthResponseMsg(obj, raw);
  if (obj.type === "thread-event") return parseThreadEventMsg(obj, raw);
  if (obj.type === "workflow-error") return parseWorkflowErrorMsg(obj, raw);
-  if (obj.type === "thread-command-event") return parseThreadCommandEventMsg(obj, raw);
+  if (obj.type === "thread-workflow-message") return parseThreadWorkflowMessageMsg(obj, raw);
  return ok({ type: "ready" });
 }
@@ -19,7 +19,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";

 import type { NerveConfig, SenseInfo, Signal } from "@uncaged/nerve-core";
-import { parseNerveConfig } from "@uncaged/nerve-core";
+import { parseNerveConfig, routeSenseComputeOutput } from "@uncaged/nerve-core";

 import { createDaemonIpcServer } from "./daemon-ipc.js";
 import type { DaemonIpcServer } from "./daemon-ipc.js";
@@ -230,20 +230,33 @@ export function createKernel(
    }

    if (msg.type === "signal") {
-      const signal: Signal = {
-        id: nextSignalId(),
-        senseId: msg.sense,
-        payload: msg.payload,
-        ts: Date.now(),
-      };
-      logStore.append({
-        source: "sense",
-        type: "signal",
-        refId: msg.sense,
-        payload: JSON.stringify(msg.payload),
-        ts: signal.ts,
-      });
-      bus.emit(signal);
+      const route = routeSenseComputeOutput(msg.payload);
+      if (route.kind === "launch") {
+        const { workflowName, maxRounds, prompt } = route.launch;
+        workflowManager.startWorkflow(workflowName, { prompt, maxRounds });
+        logStore.append({
+          source: "sense",
+          type: "workflow-launch",
+          refId: msg.sense,
+          payload: JSON.stringify(route.launch),
+          ts: Date.now(),
+        });
+      } else {
+        const signal: Signal = {
+          id: nextSignalId(),
+          senseId: msg.sense,
+          payload: route.payload,
+          ts: Date.now(),
+        };
+        logStore.append({
+          source: "sense",
+          type: "signal",
+          refId: msg.sense,
+          payload: JSON.stringify(route.payload),
+          ts: signal.ts,
+        });
+        bus.emit(signal);
+      }
      scheduler.onComputeComplete(msg.sense);
    }

@@ -319,9 +332,6 @@ export function createKernel(

  scheduler = createReflexScheduler(config, bus, triggerFn, {
    logStore,
-    workflowTriggerFn: (workflowName, payload) => {
-      workflowManager.startWorkflow(workflowName, payload);
-    },
  });

  if (groups.size === 0) {
@@ -408,9 +418,6 @@ export function createKernel(
    scheduler.stop();
    scheduler = createReflexScheduler(config, bus, triggerFn, {
      logStore,
-      workflowTriggerFn: (workflowName, payload) => {
-        workflowManager.startWorkflow(workflowName, payload);
-      },
    });
    // Update workflow concurrency/overflow config incrementally — no restart needed
    workflowManager.updateConfig(newConfig);
@@ -83,6 +83,25 @@ export type WorkflowRun = {
  ts: number;
 };

+/** One role-produced workflow-message row with 1-based round index (ROW_NUMBER over role messages only). */
+export type ThreadRoundRow = {
+  round: number;
+  logId: number;
+  ts: number;
+  message: { role: string; content: string; meta: unknown; timestamp: number };
+};
+
+/** Parameters for {@link LogStore.getThreadRounds}. */
+export type GetThreadRoundsParams = {
+  /**
+   * Exclusive upper bound on round index (1-based among role events).
+   * Use `0` to include all rounds (subject to `limit`).
+   */
+  before: number;
+  /** Maximum rows returned from the DB (DESC by round). */
+  limit: number;
+};
+
 export type LogStore = {
  append: (entry: Omit<LogEntry, "id">) => LogEntry;
  query: (filter?: LogQuery) => LogEntry[];
@@ -117,9 +136,27 @@ export type LogStore = {
  getTriggerPayload: (runId: string) => unknown;
  /**
   * Get all workflow CommandEvents for a specific run, ordered by id ASC.
-   * Used for crash recovery to rebuild ThreadState.
+   * @deprecated Use getThreadMessages for the new WorkflowMessage format.
   */
  getThreadEvents: (runId: string) => Array<{ type: string; [key: string]: unknown }>;
+  /**
+   * Get all WorkflowMessages for a specific run, ordered by id ASC.
+   * Used for crash recovery to rebuild the message chain.
+   */
+  getThreadMessages: (
+    runId: string,
+  ) => Array<{ role: string; content: string; meta: unknown; timestamp: number }>;
+  /**
+   * Count role command events for a run (excludes `thread_start`/`__start__` messages and invalid payloads).
+   * Round indices for {@link getThreadRounds} are 1..count in chronological order.
+   */
+  getThreadRoundCount: (runId: string) => number;
+  /**
+   * Role rounds for agent-oriented retrieval: each row is one `thread_command_event` or
+   * `thread_workflow_message` whose JSON `type` is not `thread_start` and `role` is not `__start__`,
+   * with `round` from ROW_NUMBER() OVER (ORDER BY id ASC). No schema migration — numbering is computed in SQL.
+   */
+  getThreadRounds: (runId: string, params: GetThreadRoundsParams) => ThreadRoundRow[];
  /**
   * Export logs older than the retention window to `data/archive/logs/YYYY-MM-DD.jsonl`,
   * then delete those rows and advance `meta.archived_up_to` in one transaction per day
@@ -279,6 +316,34 @@ export function createLogStore(dbPath: string): LogStore {
    "SELECT payload FROM logs WHERE source = 'workflow' AND type = 'thread_command_event' AND ref_id = ? ORDER BY id ASC",
  );

+  const getThreadMessagesStmt = sqlite.prepare(
+    "SELECT payload FROM logs WHERE source = 'workflow' AND type = 'thread_workflow_message' AND ref_id = ? ORDER BY id ASC",
+  );
+
+  const getThreadRoundCountStmt = sqlite.prepare(
+    `SELECT COUNT(*) AS c FROM logs
+     WHERE source = 'workflow' AND type IN ('thread_command_event', 'thread_workflow_message') AND ref_id = ?
+       AND payload IS NOT NULL AND json_valid(payload) = 1
+       AND COALESCE(json_extract(payload, '$.type'), '') != 'thread_start'
+       AND COALESCE(json_extract(payload, '$.role'), '') != '__start__'`,
+  );
+
+  const getThreadRoundsStmt = sqlite.prepare(
+    `WITH numbered AS (
+       SELECT id, ts, payload,
+         ROW_NUMBER() OVER (ORDER BY id ASC) AS rn
+       FROM logs
+       WHERE source = 'workflow' AND type IN ('thread_command_event', 'thread_workflow_message') AND ref_id = @runId
+         AND payload IS NOT NULL AND json_valid(payload) = 1
+         AND COALESCE(json_extract(payload, '$.type'), '') != 'thread_start'
+         AND COALESCE(json_extract(payload, '$.role'), '') != '__start__'
+     )
+     SELECT id, ts, payload, rn FROM numbered
+     WHERE (@before = 0 OR rn < @before)
+     ORDER BY rn DESC
+     LIMIT @lim`,
+  );
+
  const getActiveWorkflowRunsStmt = sqlite.prepare(
    "SELECT run_id, workflow, status, ts FROM workflow_runs WHERE status IN ('queued', 'started') ORDER BY ts ASC",
  );
@@ -335,7 +400,7 @@ export function createLogStore(dbPath: string): LogStore {

  function query(filter: LogQuery = {}): LogEntry[] {
    const conditions: string[] = [];
-    const params: Record<string, unknown> = {};
+    const params: Record<string, string | number> = {};

    if (filter.source !== undefined) {
      conditions.push("source = @source");
@@ -475,6 +540,95 @@ export function createLogStore(dbPath: string): LogStore {
    return result;
  }

+  function tryParseWorkflowMessage(
+    payload: string,
+  ): { role: string; content: string; meta: unknown; timestamp: number } | null {
+    try {
+      const parsed = JSON.parse(payload) as unknown;
+      if (parsed === null || typeof parsed !== "object") return null;
+      const obj = parsed as Record<string, unknown>;
+      if (typeof obj.role !== "string" || typeof obj.content !== "string") return null;
+      return {
+        role: obj.role,
+        content: obj.content,
+        meta: obj.meta,
+        timestamp: typeof obj.timestamp === "number" ? obj.timestamp : 0,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  function getThreadMessages(
+    runId: string,
+  ): Array<{ role: string; content: string; meta: unknown; timestamp: number }> {
+    const rows = getThreadMessagesStmt.all(runId) as Array<{ payload: string | null }>;
+    const result: Array<{ role: string; content: string; meta: unknown; timestamp: number }> = [];
+    for (const row of rows) {
+      if (row.payload === null) continue;
+      const msg = tryParseWorkflowMessage(row.payload);
+      if (msg !== null) result.push(msg);
+    }
+    return result;
+  }
+
+  function getThreadRoundCount(runId: string): number {
+    const row = getThreadRoundCountStmt.get(runId) as { c: number } | undefined;
+    const c = row?.c;
+    if (c === null || c === undefined) return 0;
+    return Number(c);
+  }
+
+  function parseRoundPayload(
+    payload: string,
+    fallbackTs: number,
+  ): { role: string; content: string; meta: unknown; timestamp: number } | null {
+    try {
+      const parsed = JSON.parse(payload) as unknown;
+      if (parsed === null || typeof parsed !== "object") return null;
+      const obj = parsed as Record<string, unknown>;
+      if (typeof obj.role === "string" && typeof obj.content === "string") {
+        return {
+          role: obj.role,
+          content: obj.content,
+          meta: obj.meta,
+          timestamp: typeof obj.timestamp === "number" ? obj.timestamp : 0,
+        };
+      }
+      if (typeof obj.type === "string") {
+        return {
+          role: typeof obj.role === "string" ? obj.role : obj.type,
+          content: typeof obj.content === "string" ? obj.content : JSON.stringify(obj),
+          meta: obj,
+          timestamp: fallbackTs,
+        };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  function getThreadRounds(runId: string, params: GetThreadRoundsParams): ThreadRoundRow[] {
+    if (params.limit < 1) return [];
+
+    const rows = getThreadRoundsStmt.all({
+      runId,
+      before: params.before,
+      lim: params.limit,
+    }) as Array<{ id: number; ts: number; payload: string | null; rn: number }>;
+
+    const out: ThreadRoundRow[] = [];
+    for (const row of rows) {
+      if (row.payload === null) continue;
+      const message = parseRoundPayload(row.payload, row.ts);
+      if (message !== null) {
+        out.push({ round: row.rn, logId: row.id, ts: row.ts, message });
+      }
+    }
+    return out;
+  }
+
  function archiveDayTx(day: string, start: number, endExclusive: number): void {
    runInTransaction(sqlite, () => {
      deleteLogsForDayStmt.run({ start, endExclusive });
@@ -539,6 +693,9 @@ export function createLogStore(dbPath: string): LogStore {
    getAllWorkflowRuns,
    getTriggerPayload,
    getThreadEvents,
+    getThreadMessages,
+    getThreadRoundCount,
+    getThreadRounds,
    archiveLogs,
    close,
  };
@@ -16,9 +16,6 @@ import type { SignalBus, Unsubscribe } from "./signal-bus.js";
 /** Sends a compute message to the worker responsible for the given sense. */
 export type TriggerFn = (senseName: string) => void;

-/** Triggers a workflow run in response to a signal. */
-export type WorkflowTriggerFn = (workflowName: string, payload: unknown) => void;
-
 /** Per-sense mutable state tracked by the scheduler. */
 type SenseState = {
  lastComputeAt: number;
@@ -40,7 +37,6 @@ function makeSenseState(): SenseState {

 export type ReflexSchedulerOptions = {
  logStore?: LogStore;
-  workflowTriggerFn?: WorkflowTriggerFn;
 };

 /**
@@ -157,21 +153,6 @@ export function createReflexScheduler(
  }

  for (const reflex of config.reflexes) {
-    if (reflex.kind === "workflow") {
-      if (opts?.workflowTriggerFn !== undefined && reflex.on !== null && reflex.on.length > 0) {
-        const workflowTriggerFn = opts.workflowTriggerFn;
-        const workflowName = reflex.workflow;
-        const watchedSenses = new Set(reflex.on);
-        const unsub = bus.subscribe((signal) => {
-          if (watchedSenses.has(signal.senseId)) {
-            workflowTriggerFn(workflowName, signal.payload);
-          }
-        });
-        unsubscribers.push(unsub);
-      }
-      continue;
-    }
-
    if (reflex.kind !== "sense") continue;
    const senseReflex = reflex;
    const senseName = senseReflex.sense;
@@ -26,10 +26,7 @@ export function teeCapturedStderr(child: ChildProcess, tail: { value: string }):
  });
 }

-export function formatChildExitSummary(
-  code: number | null,
-  signal: NodeJS.Signals | null,
-): string {
+export function formatChildExitSummary(code: number | null, signal: NodeJS.Signals | null): string {
  const codeStr = code === null || code === undefined ? "null" : String(code);
  if (signal) {
    return `code=${codeStr} signal=${signal}`;
@@ -11,7 +11,8 @@ import type { ChildProcess } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";

-import type { NerveConfig, WorkflowConfig } from "@uncaged/nerve-core";
+import type { NerveConfig, WorkflowConfig, WorkflowMessage } from "@uncaged/nerve-core";
+import { START } from "@uncaged/nerve-core";

 import type {
  ResumeThreadMessage,
@@ -28,9 +29,14 @@ import {
  teeCapturedStderr,
 } from "./worker-fork-support.js";

+export type WorkflowLaunchParams = {
+  prompt: string;
+  maxRounds: number;
+};
+
 export type WorkflowManager = {
-  /** Trigger a new workflow thread (called by Reflex scheduler). */
-  startWorkflow: (workflowName: string, payload: unknown) => void;
+  /** Trigger a new workflow thread (Sense-driven launch or CLI / IPC). */
+  startWorkflow: (workflowName: string, launch: WorkflowLaunchParams) => void;
  /** Number of currently active (running) threads for a workflow. */
  activeCount: (workflowName: string) => number;
  /** Number of pending queued threads waiting to run for a workflow. */
@@ -51,7 +57,8 @@ export type WorkflowManager = {

 type PendingThread = {
  runId: string;
-  payload: unknown;
+  prompt: string;
+  maxRounds: number;
 };

 type WorkflowState = {
@@ -81,6 +88,42 @@ const WORKER_SHUTDOWN_TIMEOUT_MS = 10_000;

 const DEFAULT_MAX_QUEUE = 100;

+function readLaunchFromTriggerPayload(
+  raw: unknown,
+  engineDefaultMaxRounds: number,
+): { prompt: string; maxRounds: number } {
+  if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
+    const o = raw as Record<string, unknown>;
+    if (typeof o.prompt === "string" && typeof o.maxRounds === "number") {
+      return { prompt: o.prompt, maxRounds: o.maxRounds };
+    }
+  }
+  return { prompt: "", maxRounds: engineDefaultMaxRounds };
+}
+
+function ensureThreadMessagesWithStart(
+  messages: Array<{ role: string; content: string; meta: unknown; timestamp: number }>,
+  fallbackPrompt: string,
+  fallbackMaxRounds: number,
+): WorkflowMessage[] {
+  const mapped: WorkflowMessage[] = messages.map((m) => ({
+    role: m.role,
+    content: m.content,
+    meta: m.meta,
+    timestamp: m.timestamp,
+  }));
+  if (mapped.length > 0 && mapped[0].role === START) {
+    return mapped;
+  }
+  const start: WorkflowMessage = {
+    role: START,
+    content: fallbackPrompt,
+    meta: { maxRounds: fallbackMaxRounds },
+    timestamp: Date.now(),
+  };
+  return [start, ...mapped];
+}
+
 function resolveWorkerScript(): string {
  const __filename = fileURLToPath(import.meta.url);
  const __dir = dirname(__filename);
@@ -213,7 +256,12 @@ export function createWorkflowManager(
    }
  }

-  function dispatchThread(workflowName: string, runId: string, payload: unknown): void {
+  function dispatchThread(
+    workflowName: string,
+    runId: string,
+    prompt: string,
+    maxRounds: number,
+  ): void {
    const state = getOrCreateState(workflowName);
    state.active.add(runId);

@@ -222,11 +270,11 @@ export function createWorkflowManager(
      type: "start-thread",
      runId,
      workflow: workflowName,
-      triggerPayload: payload,
+      prompt,
+      maxRounds,
    };
    sendStartThread(worker.process, msg);
-    // Store triggerPayload in the log so it can be recovered after a crash
-    logWorkflowEvent(workflowName, runId, "started", { triggerPayload: payload });
+    logWorkflowEvent(workflowName, runId, "started", { prompt, maxRounds });
  }

  function dequeueNext(workflowName: string): void {
@@ -239,7 +287,7 @@ export function createWorkflowManager(
    if (state.active.size < concurrency) {
      const next = state.queue.shift();
      if (next !== undefined) {
-        dispatchThread(workflowName, next.runId, next.payload);
+        dispatchThread(workflowName, next.runId, next.prompt, next.maxRounds);
      }
    }
  }
@@ -260,8 +308,8 @@ export function createWorkflowManager(

  function recoverQueuedRun(workflowName: string, runId: string, state: WorkflowState): void {
    if (state.queue.some((q) => q.runId === runId)) return;
-    const triggerPayload = logStore.getTriggerPayload(runId);
-    state.queue.push({ runId, payload: triggerPayload });
+    const launch = readLaunchFromTriggerPayload(logStore.getTriggerPayload(runId), config.maxRounds);
+    state.queue.push({ runId, prompt: launch.prompt, maxRounds: launch.maxRounds });
    process.stderr.write(
      `[workflow-manager] crash-recovery: re-queued thread "${runId}" for "${workflowName}"\n`,
    );
@@ -274,18 +322,19 @@ export function createWorkflowManager(
    worker: WorkerEntry,
  ): void {
    if (state.active.has(runId)) return;
-    const events = logStore.getThreadEvents(runId);
-    const triggerPayload = logStore.getTriggerPayload(runId);
+    const rawMessages = logStore.getThreadMessages(runId);
+    const launch = readLaunchFromTriggerPayload(logStore.getTriggerPayload(runId), config.maxRounds);
+    const messages = ensureThreadMessagesWithStart(rawMessages, launch.prompt, launch.maxRounds);
    state.active.add(runId);
    const msg: ResumeThreadMessage = {
      type: "resume-thread",
      runId,
-      events,
-      triggerPayload,
+      messages,
+      maxRounds: launch.maxRounds,
    };
    sendResumeThread(worker.process, msg);
    process.stderr.write(
-      `[workflow-manager] crash-recovery: resuming thread "${runId}" for "${workflowName}" (${events.length} events)\n`,
+      `[workflow-manager] crash-recovery: resuming thread "${runId}" for "${workflowName}" (${messages.length} messages)\n`,
    );
  }

@@ -363,12 +412,12 @@ export function createWorkflowManager(
      return;
    }

-    if (msg.type === "thread-command-event") {
+    if (msg.type === "thread-workflow-message") {
      logStore.append({
        source: "workflow",
-        type: "thread_command_event",
+        type: "thread_workflow_message",
        refId: msg.runId,
-        payload: JSON.stringify(msg.event),
+        payload: JSON.stringify(msg.message),
        ts: Date.now(),
      });
      return;
@@ -464,7 +513,7 @@ export function createWorkflowManager(
    return entry;
  }

-  function startWorkflow(workflowName: string, payload: unknown): void {
+  function startWorkflow(workflowName: string, launch: WorkflowLaunchParams): void {
    if (stopped) return;

    const wfConfig = workflowConfig(workflowName);
@@ -477,9 +526,10 @@ export function createWorkflowManager(

    const state = getOrCreateState(workflowName);
    const runId = crypto.randomUUID();
+    const { prompt, maxRounds } = launch;

    if (state.active.size < wfConfig.concurrency) {
-      dispatchThread(workflowName, runId, payload);
+      dispatchThread(workflowName, runId, prompt, maxRounds);
      return;
    }

@@ -504,7 +554,7 @@ export function createWorkflowManager(
      }
    }

-    state.queue.push({ runId, payload });
+    state.queue.push({ runId, prompt, maxRounds });
    logWorkflowEvent(workflowName, runId, "queued");
    process.stderr.write(
      `[workflow-manager] queued thread for "${workflowName}" runId "${runId}" (queue length: ${state.queue.length})\n`,
@@ -12,14 +12,14 @@
 import { existsSync } from "node:fs";
 import { join, resolve } from "node:path";

-import type {
-  CommandEvent,
-  ThreadState,
-  WorkflowContext,
-  WorkflowDefinition,
-} from "@uncaged/nerve-core";
+import type { RoleMeta, WorkflowDefinition, WorkflowMessage } from "@uncaged/nerve-core";
+import { END, START } from "@uncaged/nerve-core";

-import type { ThreadCommandEventMessage, ThreadEventType, WorkerToParentMessage } from "./ipc.js";
+import type {
+  ThreadEventType,
+  ThreadWorkflowMessageMessage,
+  WorkerToParentMessage,
+} from "./ipc.js";
 import { parseParentMessage } from "./ipc.js";
 import { ignoreSessionBroadcastSignals } from "./worker-fork-support.js";

@@ -45,137 +45,121 @@ function sendWorkflowError(runId: string, error: string): void {
  send({ type: "workflow-error", runId, error });
 }

-function sendCommandEvent(runId: string, event: CommandEvent): void {
-  const msg: ThreadCommandEventMessage = {
-    type: "thread-command-event",
+function sendWorkflowMessage(runId: string, message: WorkflowMessage): void {
+  const msg: ThreadWorkflowMessageMessage = {
+    type: "thread-workflow-message",
    runId,
-    event: event as { type: string; [key: string]: unknown },
+    message: {
+      role: message.role,
+      content: message.content,
+      meta: message.meta,
+      timestamp: message.timestamp,
+    },
  };
  send(msg);
 }

 // ---------------------------------------------------------------------------
-// Thread loop (RFC-002 §5.4)
+// Thread loop (signal-driven automaton, issue #80)
 // ---------------------------------------------------------------------------

-/**
- * Replay persisted events through moderate() to reconstruct ThreadState,
- * then execute the next role and return the resulting CommandEvent.
- * Returns null if the thread is already complete (moderate returned null).
- */
-async function replayAndResume(
-  def: WorkflowDefinition,
-  runId: string,
-  ctx: WorkflowContext,
-  state: ThreadState,
-  resumeEvents: CommandEvent[],
-): Promise<CommandEvent | null> {
-  let lastNext: ReturnType<typeof def.moderate> = null;
-  for (const ev of resumeEvents) {
-    state.events.push(ev);
-    lastNext = def.moderate(state, ev);
-    if (lastNext === null) {
-      sendThreadEvent(runId, "completed", null);
-      return null;
-    }
-  }
-
-  const next = lastNext;
-  if (next === null) {
-    sendThreadEvent(runId, "completed", null);
-    return null;
-  }
-
-  const role = def.roles[next.role];
-  if (!role) {
-    sendWorkflowError(runId, `Unknown role: ${next.role}`);
-    return null;
-  }
-
-  try {
-    const event = await role.execute(next.prompt, ctx);
-    sendCommandEvent(runId, event);
-    return event;
-  } catch (e: unknown) {
-    const errMsg = e instanceof Error ? e.message : String(e);
-    sendThreadEvent(runId, "failed", { error: errMsg });
-    return null;
-  }
-}
-
 async function runThread(
-  def: WorkflowDefinition,
-  workflowName: string,
+  def: WorkflowDefinition<RoleMeta>,
  runId: string,
-  triggerPayload: unknown,
-  /** Pre-existing event history for crash-recovery resume. Empty for a fresh thread. */
-  resumeEvents: CommandEvent[] = [],
+  maxRounds: number,
+  resumeMessages: WorkflowMessage[] = [],
+  freshPrompt: string | null = null,
 ): Promise<void> {
-  const state: ThreadState = { runId, events: [] };
-  const ctx: WorkflowContext = {
-    runId,
-    workflowName,
-    log: (msg) => sendThreadEvent(runId, "step_complete", { message: msg }),
-  };
+  let chain: WorkflowMessage[];

-  const initialEvent: CommandEvent = {
-    type: "thread_start",
-    triggerPayload:
-      triggerPayload != null && typeof triggerPayload === "object" ? triggerPayload : {},
-  };
+  if (resumeMessages.length > 0) {
+    chain = [...resumeMessages];
+  } else {
+    const prompt = freshPrompt ?? "";
+    const startMsg: WorkflowMessage = {
+      role: START,
+      content: prompt,
+      meta: { maxRounds },
+      timestamp: Date.now(),
+    };
+    chain = [startMsg];
+    sendWorkflowMessage(runId, startMsg);
+  }

-  // On resume: replay persisted events, run the next un-executed role, then continue.
-  if (resumeEvents.length > 0) {
-    const nextEvent = await replayAndResume(def, runId, ctx, state, resumeEvents);
-    if (nextEvent === null) return;
-    await continueThread(def, runId, ctx, state, nextEvent);
+  let roleRound = chain.filter((m) => m.role !== START).length;
+  const lastMsg = chain[chain.length - 1];
+  if (lastMsg === undefined) {
+    sendWorkflowError(runId, "empty workflow message chain");
    return;
  }

-  // Fresh thread — send the initial command event and enter the loop.
-  sendCommandEvent(runId, initialEvent);
-  await continueThread(def, runId, ctx, state, initialEvent);
-}
+  const lastSignal =
+    lastMsg.role === START
+      ? {
+          role: START,
+          content: lastMsg.content,
+          meta: lastMsg.meta as { maxRounds: number },
+          timestamp: lastMsg.timestamp,
+        }
+      : { role: lastMsg.role, meta: lastMsg.meta as Record<string, unknown> };

-async function continueThread(
-  def: WorkflowDefinition,
-  runId: string,
-  ctx: WorkflowContext,
-  state: ThreadState,
-  firstEvent: CommandEvent,
-): Promise<void> {
-  let event = firstEvent;
+  let nextRole = def.moderator(
+    lastSignal as Parameters<typeof def.moderator>[0],
+    roleRound,
+    maxRounds,
+  );

-  const MAX_STEPS = 1000;
-  let step = 0;
-  while (step < MAX_STEPS) {
-    step++;
-    state.events.push(event);
-    const next = def.moderate(state, event);
+  if (nextRole === END) {
+    sendThreadEvent(runId, "completed", null);
+    return;
+  }

-    if (next === null) {
-      sendThreadEvent(runId, "completed", null);
-      return;
-    }
-
-    const role = def.roles[next.role];
+  while (roleRound < maxRounds) {
+    const role = def.roles[nextRole];
    if (!role) {
-      sendWorkflowError(runId, `Unknown role: ${next.role}`);
+      sendWorkflowError(runId, `Unknown role: ${nextRole}`);
      return;
    }

+    let result: { content: string; meta: Record<string, unknown> };
    try {
-      event = await role.execute(next.prompt, ctx);
+      result = await role(chain);
    } catch (e: unknown) {
      const errMsg = e instanceof Error ? e.message : String(e);
      sendThreadEvent(runId, "failed", { error: errMsg });
      return;
    }
-    sendCommandEvent(runId, event);
-  }
-  if (step >= MAX_STEPS) {
-    sendWorkflowError(runId, `Thread exceeded maximum steps (${MAX_STEPS})`);
+
+    if (typeof result.content !== "string") {
+      sendWorkflowError(runId, `Role "${nextRole}" returned non-string content`);
+      return;
+    }
+    if (result.meta === null || typeof result.meta !== "object" || Array.isArray(result.meta)) {
+      sendWorkflowError(runId, `Role "${nextRole}" returned invalid meta (must be a plain object)`);
+      return;
+    }
+
+    const message: WorkflowMessage = {
+      role: nextRole,
+      content: result.content,
+      meta: result.meta,
+      timestamp: Date.now(),
+    };
+    chain.push(message);
+    sendWorkflowMessage(runId, message);
+
+    roleRound += 1;
+
+    const signal = { role: nextRole, meta: result.meta };
+    nextRole = def.moderator(signal as Parameters<typeof def.moderator>[0], roleRound, maxRounds);
+
+    if (nextRole === END) {
+      sendThreadEvent(runId, "completed", null);
+      return;
+    }
  }
+
+  sendWorkflowError(runId, `Thread exceeded maximum rounds (${maxRounds})`);
 }

 // ---------------------------------------------------------------------------
@@ -185,7 +169,7 @@ async function continueThread(
 async function loadWorkflowDefinition(
  nerveRoot: string,
  workflowName: string,
-): Promise<WorkflowDefinition> {
+): Promise<WorkflowDefinition<RoleMeta>> {
  const candidates = [
    resolve(join(nerveRoot, "workflows", workflowName, "index.ts")),
    resolve(join(nerveRoot, "workflows", workflowName, "index.js")),
@@ -205,15 +189,16 @@ async function loadWorkflowDefinition(
  if (
    def === null ||
    typeof def !== "object" ||
-    typeof (def as WorkflowDefinition).moderate !== "function" ||
-    typeof (def as WorkflowDefinition).roles !== "object"
+    typeof (def as WorkflowDefinition<RoleMeta>).moderator !== "function" ||
+    typeof (def as WorkflowDefinition<RoleMeta>).roles !== "object" ||
+    typeof (def as WorkflowDefinition<RoleMeta>).name !== "string"
  ) {
    throw new Error(
-      `Workflow "${workflowName}" must export a WorkflowDefinition with "roles" and "moderate".`,
+      `Workflow "${workflowName}" must export a WorkflowDefinition with "name", "roles", and "moderator".`,
    );
  }

-  return def as WorkflowDefinition;
+  return def as WorkflowDefinition<RoleMeta>;
 }

 // ---------------------------------------------------------------------------
@@ -222,8 +207,7 @@ async function loadWorkflowDefinition(

 function handleMessage(
  raw: unknown,
-  def: WorkflowDefinition,
-  workflowName: string,
+  def: WorkflowDefinition<RoleMeta>,
  inFlight: Map<string, Promise<void>>,
  shuttingDown: { value: boolean },
 ): void {
@@ -246,11 +230,11 @@ function handleMessage(

  if (msg.type === "start-thread") {
    if (shuttingDown.value) return;
-    const { runId, triggerPayload } = msg;
+    const { runId, prompt, maxRounds } = msg;

    const previous = inFlight.get(runId) ?? Promise.resolve();
    const next = previous
-      .then(() => runThread(def, workflowName, runId, triggerPayload))
+      .then(() => runThread(def, runId, maxRounds, [], prompt))
      .catch((e: unknown) => {
        const errMsg = e instanceof Error ? e.message : String(e);
        sendWorkflowError(runId, errMsg);
@@ -265,11 +249,11 @@ function handleMessage(

  if (msg.type === "resume-thread") {
    if (shuttingDown.value) return;
-    const { runId, events, triggerPayload } = msg;
+    const { runId, messages, maxRounds } = msg;

    const previous = inFlight.get(runId) ?? Promise.resolve();
    const next = previous
-      .then(() => runThread(def, workflowName, runId, triggerPayload, events as CommandEvent[]))
+      .then(() => runThread(def, runId, maxRounds, messages as WorkflowMessage[], null))
      .catch((e: unknown) => {
        const errMsg = e instanceof Error ? e.message : String(e);
        sendWorkflowError(runId, errMsg);
@@ -288,7 +272,7 @@ function handleMessage(
 // ---------------------------------------------------------------------------

 async function bootstrap(nerveRoot: string, workflowName: string): Promise<void> {
-  let def: WorkflowDefinition;
+  let def: WorkflowDefinition<RoleMeta>;
  try {
    def = await loadWorkflowDefinition(nerveRoot, workflowName);
  } catch (e: unknown) {
@@ -303,7 +287,7 @@ async function bootstrap(nerveRoot: string, workflowName: string): Promise<void>
  sendReady();

  process.on("message", (raw: unknown) => {
-    handleMessage(raw, def, workflowName, inFlight, shuttingDown);
+    handleMessage(raw, def, inFlight, shuttingDown);
  });
 }

@@ -1,8 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts", "src/sense-worker.ts"],
-  format: ["esm"],
-  dts: true,
-  clean: true,
-});
Author	SHA1	Message	Date
xiaoju	9bf0b2abb8	fix: PR #81 review follow-ups (closes #83 ) - Filter __start__ messages in getThreadRoundCount SQL to fix round offset - Remove duplicate parseWorkflowField, use parseSenseWorkflowDirective - Remove unnecessary double casts in workflow CLI - Add runtime validation for Role meta in workflow-worker - Export DEFAULT_ENGINE_MAX_ROUNDS from types.ts 小橘 🍊（NEKO Team）	2026-04-24 11:09:31 +00:00
xiaomo	d93f5c8fa2	Merge pull request 'refactor(core): restore type-safe workflow automaton from Pulse design' (#81 ) from refactor/workflow-type-safety into main	2026-04-24 11:02:23 +00:00
xiaoju	fa210ec3e0	refactor: restore Pulse-style workflow type safety - Replace loose payload types with WorkflowLaunchParams { prompt, maxRounds } - Add SenseResult.workflow field with pipe-separated format (name\|rounds\|prompt) - Add parseWorkflowField utility and routeSenseComputeOutput in @nerve/core - Integrate sense→workflow routing in kernel - Remove deprecated workflow reflex kind from ReflexScheduler - Update all test files to use new type-safe interfaces 小橘 🍊（NEKO Team）	2026-04-24 10:58:48 +00:00
xiaoju	f72b64d481	refactor(core): restore type-safe workflow automaton from Pulse design (closes #80 )	2026-04-24 09:50:28 +00:00
xiaoju	b033a98553	chore: bump version to 0.3.0 小橘 <xiaoju@shazhou.work>	2026-04-24 06:08:11 +00:00
xiaomo	68071ffa1e	Merge pull request 'feat(cli): add nerve workflow thread <runId> command — closes #77 ' (#78 ) from feat/workflow-thread-77 into main	2026-04-24 06:04:32 +00:00
xiaoju	f08ad802b0	fix: remove accidentally committed tgz and add to .gitignore 小橘 <xiaoju@shazhou.work>	2026-04-24 06:03:00 +00:00
xiaoju	dcfb00128d	feat(cli): add nerve workflow thread <runId> command — closes #77 Implements the workflow thread CLI command that retrieves workflow execution context (logs, events, state) for a given run. - Add 'nerve workflow thread <runId>' subcommand - Add log-store query API in daemon - Add tests for CLI and log-store - Export new daemon types for thread data 小橘 <xiaoju@shazhou.work>	2026-04-24 05:59:53 +00:00
xiaomo	9cdac05f2c	Merge pull request 'docs: add coding agent rules (.cursor/rules + CLAUDE.md)' (#76 ) from chore/cursor-rules-from-conventions into main	2026-04-23 12:12:08 +00:00
xiaomo	24a8ec927d	docs: add core concepts (sense, signal, reflex, workflow) to agent rules	2026-04-23 12:05:31 +00:00
xiaomo	554a79775c	docs: add .github/copilot-instructions.md for GitHub Copilot	2026-04-23 12:03:15 +00:00
xiaomo	ceb5998fa3	docs: add cursor rules and CLAUDE.md from coding conventions - .cursor/rules/global.mdc: coding conventions as Cursor agent rules - CLAUDE.md: same conventions for Claude Code / Hermes agents - Content derived from docs/coding-conventions.md - Includes no-dynamic-import rule in CLAUDE.md for completeness	2026-04-23 12:01:03 +00:00
xiaomo	49b5099065	Merge pull request 'fix(daemon): accept string triggerPayload in workflow thread' (#75 ) from fix/trigger-payload-string-support into main	2026-04-23 11:50:48 +00:00
xiaoju	01d2185495	fix(daemon): accept string triggerPayload in workflow thread The original code only accepted object-type triggerPayload, silently discarding string values by replacing them with {}. This meant `nerve workflow trigger <name> --payload '"some string"'` would lose the payload entirely. Changed to `triggerPayload ?? {}` so strings (and other non-null values) pass through correctly. 小橘 🍊（NEKO Team）	2026-04-23 11:48:05 +00:00
xiaoju	5cedc6a33d	release: v0.2.0 — core, daemon, cli	2026-04-23 10:58:49 +00:00
xiaomo	c291d3a69a	Merge pull request 'feat(cli): add nerve init --from to clone workspace from git' (#74 ) from feat/init-from-git into main	2026-04-23 10:56:17 +00:00
xiaomo	7960f5af8b	Merge pull request 'docs: add comprehensive README for root and all packages' (#73 ) from docs/readme-update into main	2026-04-23 10:54:43 +00:00
xiaomo	5be14d0d8b	docs: add comprehensive README for root and all packages	2026-04-23 10:53:45 +00:00
xiaoju	0e0eb4eec6	feat(cli): add nerve init --from to clone workspace from git Made-with: Cursor	2026-04-23 10:53:06 +00:00
xiaomo	cf2b0ac223	Merge pull request 'build: migrate from tsup to rslib' (#71 ) from build/tsup-to-rslib into main	2026-04-23 09:50:55 +00:00
xiaoju	1b5a52ea4d	build: migrate from tsup to rslib Replace tsup (esbuild-based) with rslib (rspack-based) across all packages. tsup's built-in nodeProtocolPlugin strips the 'node:' prefix from all Node.js builtins. Unlike node:fs etc., node:sqlite has no unprefixed form, causing ERR_MODULE_NOT_FOUND at runtime. rslib handles node: imports correctly without any workarounds. Changes: - Replace tsup.config.ts with rslib.config.ts in core, daemon, cli - Swap tsup → @rslib/core in devDependencies - Fix log-store.ts params type (Record<string, unknown> → Record<string, string \| number>) - Fix logStream.fd type cast in start.ts - Exclude __tests__ from CLI tsconfig to avoid DTS errors - All 356 tests pass, nerve init works correctly Closes #70 小橘 🍊（NEKO Team）	2026-04-23 09:48:45 +00:00
xiaoju	a084205b47	Revert "fix: restore node:sqlite prefix stripped by tsup bundler" This reverts commit `57550ccfdb`.	2026-04-23 09:41:28 +00:00
xiaoju	57550ccfdb	fix: restore node:sqlite prefix stripped by tsup bundler tsup's built-in node-protocol-plugin strips the 'node:' prefix from all builtins. Unlike node:fs etc., node:sqlite has no unprefixed form, causing ERR_MODULE_NOT_FOUND at runtime. - Add onSuccess hook to both cli and daemon tsup configs to restore 'node:sqlite' imports in bundled output - Fix log-store params type to Record<string, string \| number> 小橘 🍊（NEKO Team）	2026-04-23 09:32:20 +00:00
xiaomo	37588df402	Merge pull request 'refactor(daemon): upgrade Drizzle v1.0-beta + migrate better-sqlite3 → node:sqlite' (#69 ) from refactor/drizzle-v1-node-sqlite into main	2026-04-23 09:20:15 +00:00